toki
ec938475e0
- Add backtest and market socket handlers for API and Worker - Add proto definitions for backtest and market services - Update client socket integration and tests - Generate protobuf code for Go and Dart - Archive completed agent tasks under agent-task/archive/2026/05/
271 lines
9.1 KiB
Go
271 lines
9.1 KiB
Go
package socket
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
altv1 "git.toki-labs.com/toki/alt/packages/contracts/gen/go/alt/v1"
|
|
"git.toki-labs.com/toki/alt/packages/domain/market"
|
|
"git.toki-labs.com/toki/alt/services/worker/internal/storage"
|
|
protoSocket "git.toki-labs.com/toki/proto-socket/go"
|
|
)
|
|
|
|
type fakeInstrumentStore struct {
|
|
listCalled bool
|
|
insts []market.Instrument
|
|
err error
|
|
}
|
|
|
|
func (f *fakeInstrumentStore) UpsertInstrument(ctx context.Context, inst market.Instrument) error {
|
|
return nil
|
|
}
|
|
|
|
func (f *fakeInstrumentStore) GetInstrument(ctx context.Context, id market.InstrumentID) (market.Instrument, error) {
|
|
return market.Instrument{}, nil
|
|
}
|
|
|
|
func (f *fakeInstrumentStore) ListInstruments(ctx context.Context) ([]market.Instrument, error) {
|
|
f.listCalled = true
|
|
return f.insts, f.err
|
|
}
|
|
|
|
type fakeBarStore struct {
|
|
gotID market.InstrumentID
|
|
gotTimeframe market.Timeframe
|
|
gotFrom time.Time
|
|
gotTo time.Time
|
|
bars []market.Bar
|
|
err error
|
|
}
|
|
|
|
func (f *fakeBarStore) UpsertBar(ctx context.Context, bar market.Bar) error { return nil }
|
|
|
|
func (f *fakeBarStore) GetBars(ctx context.Context, id market.InstrumentID, timeframe market.Timeframe, from, to time.Time) ([]market.Bar, error) {
|
|
f.gotID = id
|
|
f.gotTimeframe = timeframe
|
|
f.gotFrom = from
|
|
f.gotTo = to
|
|
return f.bars, f.err
|
|
}
|
|
|
|
func validListBarsRequest() *altv1.ListBarsRequest {
|
|
return &altv1.ListBarsRequest{
|
|
InstrumentId: "KRX:005930",
|
|
Timeframe: altv1.Timeframe_TIMEFRAME_DAILY,
|
|
FromUnixMs: time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC).UnixMilli(),
|
|
ToUnixMs: time.Date(2026, 5, 15, 0, 0, 0, 0, time.UTC).UnixMilli(),
|
|
}
|
|
}
|
|
|
|
func TestHandleListInstrumentsFiltersMarketAndProvider(t *testing.T) {
|
|
store := &fakeInstrumentStore{insts: []market.Instrument{
|
|
{ID: "KRX:005930", Market: market.MarketKR, Symbol: "005930", ProviderSymbols: map[string]string{"kis": "005930"}},
|
|
{ID: "KRX:000660", Market: market.MarketKR, Symbol: "000660", ProviderSymbols: map[string]string{"other": "000660"}},
|
|
{ID: "NASDAQ:AAPL", Market: market.MarketUS, Symbol: "AAPL", ProviderSymbols: map[string]string{"kis": "AAPL"}},
|
|
}}
|
|
|
|
resp, err := handleListInstruments(Deps{Instruments: store}, &altv1.ListInstrumentsRequest{
|
|
Market: altv1.Market_MARKET_KR,
|
|
Provider: "kis",
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if !store.listCalled {
|
|
t.Fatal("expected instrument store to be called")
|
|
}
|
|
if len(resp.GetInstruments()) != 1 {
|
|
t.Fatalf("expected one filtered instrument, got %d", len(resp.GetInstruments()))
|
|
}
|
|
if resp.GetInstruments()[0].GetId() != "KRX:005930" {
|
|
t.Errorf("unexpected instrument: %+v", resp.GetInstruments()[0])
|
|
}
|
|
}
|
|
|
|
func TestHandleListInstrumentsEmpty(t *testing.T) {
|
|
resp, err := handleListInstruments(Deps{Instruments: &fakeInstrumentStore{}}, &altv1.ListInstrumentsRequest{})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(resp.GetInstruments()) != 0 {
|
|
t.Errorf("expected empty instruments, got %d", len(resp.GetInstruments()))
|
|
}
|
|
}
|
|
|
|
func TestHandleListInstrumentsInvalidMarket(t *testing.T) {
|
|
store := &fakeInstrumentStore{}
|
|
resp, err := handleListInstruments(Deps{Instruments: store}, &altv1.ListInstrumentsRequest{Market: altv1.Market(99)})
|
|
if err != nil {
|
|
t.Fatalf("expected typed validation response, got error: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorInvalidRequest)
|
|
if store.listCalled {
|
|
t.Error("store must not be called when validation fails")
|
|
}
|
|
}
|
|
|
|
func TestHandleListInstrumentsUnavailable(t *testing.T) {
|
|
resp, err := handleListInstruments(Deps{}, &altv1.ListInstrumentsRequest{})
|
|
if err != nil {
|
|
t.Fatalf("expected typed unavailable response, got error: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorUnavailable)
|
|
}
|
|
|
|
func TestHandleListInstrumentsStoreError(t *testing.T) {
|
|
resp, err := handleListInstruments(Deps{Instruments: &fakeInstrumentStore{err: errors.New("boom")}}, &altv1.ListInstrumentsRequest{})
|
|
if err != nil {
|
|
t.Fatalf("expected typed internal response, got error: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorInternal)
|
|
}
|
|
|
|
func TestHandleListBarsSuccess(t *testing.T) {
|
|
req := validListBarsRequest()
|
|
store := &fakeBarStore{bars: []market.Bar{{
|
|
InstrumentID: "KRX:005930",
|
|
Timeframe: market.TimeframeDaily,
|
|
Timestamp: time.UnixMilli(req.GetFromUnixMs()).UTC(),
|
|
}}}
|
|
|
|
resp, err := handleListBars(Deps{Bars: store}, req)
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if store.gotID != "KRX:005930" {
|
|
t.Errorf("instrument id mismatch: %q", store.gotID)
|
|
}
|
|
if store.gotTimeframe != market.TimeframeDaily {
|
|
t.Errorf("timeframe mismatch: %q", store.gotTimeframe)
|
|
}
|
|
if !store.gotFrom.Equal(time.UnixMilli(req.GetFromUnixMs()).UTC()) || !store.gotTo.Equal(time.UnixMilli(req.GetToUnixMs()).UTC()) {
|
|
t.Errorf("time range mismatch: got %v..%v", store.gotFrom, store.gotTo)
|
|
}
|
|
if len(resp.GetBars()) != 1 {
|
|
t.Errorf("expected 1 bar, got %d", len(resp.GetBars()))
|
|
}
|
|
}
|
|
|
|
func TestHandleListBarsValidation(t *testing.T) {
|
|
valid := validListBarsRequest()
|
|
tests := []struct {
|
|
name string
|
|
req *altv1.ListBarsRequest
|
|
}{
|
|
{"missing instrument", &altv1.ListBarsRequest{Timeframe: valid.GetTimeframe(), FromUnixMs: valid.GetFromUnixMs(), ToUnixMs: valid.GetToUnixMs()}},
|
|
{"unknown timeframe", &altv1.ListBarsRequest{InstrumentId: valid.GetInstrumentId(), Timeframe: altv1.Timeframe(99), FromUnixMs: valid.GetFromUnixMs(), ToUnixMs: valid.GetToUnixMs()}},
|
|
{"missing from", &altv1.ListBarsRequest{InstrumentId: valid.GetInstrumentId(), Timeframe: valid.GetTimeframe(), ToUnixMs: valid.GetToUnixMs()}},
|
|
{"missing to", &altv1.ListBarsRequest{InstrumentId: valid.GetInstrumentId(), Timeframe: valid.GetTimeframe(), FromUnixMs: valid.GetFromUnixMs()}},
|
|
{"inverted range", &altv1.ListBarsRequest{InstrumentId: valid.GetInstrumentId(), Timeframe: valid.GetTimeframe(), FromUnixMs: valid.GetToUnixMs(), ToUnixMs: valid.GetFromUnixMs()}},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
store := &fakeBarStore{}
|
|
resp, err := handleListBars(Deps{Bars: store}, tt.req)
|
|
if err != nil {
|
|
t.Fatalf("expected typed validation response, got error: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorInvalidRequest)
|
|
if store.gotID != "" {
|
|
t.Error("store must not be called when validation fails")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHandleListBarsUnavailable(t *testing.T) {
|
|
resp, err := handleListBars(Deps{}, validListBarsRequest())
|
|
if err != nil {
|
|
t.Fatalf("expected typed unavailable response, got error: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorUnavailable)
|
|
}
|
|
|
|
func TestHandleListBarsNotFound(t *testing.T) {
|
|
resp, err := handleListBars(Deps{Bars: &fakeBarStore{err: storage.ErrInstrumentNotFound}}, validListBarsRequest())
|
|
if err != nil {
|
|
t.Fatalf("expected typed not_found response, got error: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorNotFound)
|
|
}
|
|
|
|
func TestMarketHandlersCoverAllRequests(t *testing.T) {
|
|
registered := make(map[string]bool)
|
|
for _, h := range marketHandlers(Deps{}) {
|
|
if h.requestType == "" {
|
|
t.Error("handler has empty request type")
|
|
}
|
|
if h.register == nil {
|
|
t.Errorf("handler %q has nil register", h.requestType)
|
|
}
|
|
registered[h.requestType] = true
|
|
}
|
|
|
|
required := []string{
|
|
"alt.v1.ListInstrumentsRequest",
|
|
"alt.v1.ListBarsRequest",
|
|
}
|
|
for _, req := range required {
|
|
if !registered[req] {
|
|
t.Errorf("missing handler for %q", req)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWorkerMarketSocketValidationReturnsTypedError(t *testing.T) {
|
|
client := startBacktestWorkerTestClient(t, Deps{Bars: &fakeBarStore{}})
|
|
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.ListBarsRequest, *altv1.ListBarsResponse](
|
|
&client.Communicator,
|
|
&altv1.ListBarsRequest{},
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return typed error response without timeout: %v", err)
|
|
}
|
|
requireMarketError(t, resp.GetError(), marketErrorInvalidRequest)
|
|
}
|
|
|
|
func TestWorkerMarketSocketListBarsSuccess(t *testing.T) {
|
|
req := validListBarsRequest()
|
|
store := &fakeBarStore{bars: []market.Bar{{
|
|
InstrumentID: "KRX:005930",
|
|
Timeframe: market.TimeframeDaily,
|
|
Timestamp: time.UnixMilli(req.GetFromUnixMs()).UTC(),
|
|
}}}
|
|
client := startBacktestWorkerTestClient(t, Deps{Bars: store})
|
|
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.ListBarsRequest, *altv1.ListBarsResponse](
|
|
&client.Communicator,
|
|
req,
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return market response without timeout: %v", err)
|
|
}
|
|
if resp.GetError() != nil {
|
|
t.Fatalf("unexpected market error: %+v", resp.GetError())
|
|
}
|
|
if len(resp.GetBars()) != 1 {
|
|
t.Fatalf("expected one bar, got %d", len(resp.GetBars()))
|
|
}
|
|
if store.gotID != "KRX:005930" {
|
|
t.Fatalf("expected request to reach store, got id %q", store.gotID)
|
|
}
|
|
}
|
|
|
|
func requireMarketError(t *testing.T, errInfo *altv1.ErrorInfo, code string) {
|
|
t.Helper()
|
|
if errInfo == nil {
|
|
t.Fatalf("expected ErrorInfo code %q, got nil", code)
|
|
}
|
|
if errInfo.GetCode() != code {
|
|
t.Fatalf("expected ErrorInfo code %q, got %q (%s)", code, errInfo.GetCode(), errInfo.GetMessage())
|
|
}
|
|
if errInfo.GetMessage() == "" {
|
|
t.Fatalf("expected ErrorInfo message for code %q", code)
|
|
}
|
|
}
|