toki
620ca92e2e
- parser_map.go 업데이트하여 market status 파싱 로직 통일 - protobuf market.proto 변경사항 적용 (market.pb.go, market.pb.dart) - socket handlers, market, backtest 관련 테스트 및 런타임 코드 개선 - workerclient와 alt-worker main.go 변경사항 반영 - agent-task archive 이동 (01_import_contract_worker_api → archive/2026/06/)
495 lines
16 KiB
Go
495 lines
16 KiB
Go
package socket
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
altv1 "git.toki-labs.com/toki/alt/packages/contracts/gen/go/alt/v1"
|
|
"git.toki-labs.com/toki/alt/services/api/internal/config"
|
|
apiContracts "git.toki-labs.com/toki/alt/services/api/internal/contracts"
|
|
"git.toki-labs.com/toki/alt/services/api/internal/workerclient"
|
|
protoSocket "git.toki-labs.com/toki/proto-socket/go"
|
|
)
|
|
|
|
// fakeWorkerClient is a controllable WorkerClient for handler tests. It records
|
|
// the last forwarded request and returns canned responses/errors.
|
|
type fakeWorkerClient struct {
|
|
startReq *altv1.StartBacktestRequest
|
|
listReq *altv1.ListBacktestRunsRequest
|
|
detailReq *altv1.GetBacktestRunDetailRequest
|
|
resultReq *altv1.GetBacktestResultRequest
|
|
compareReq *altv1.CompareBacktestRunsRequest
|
|
instReq *altv1.ListInstrumentsRequest
|
|
barsReq *altv1.ListBarsRequest
|
|
importReq *altv1.ImportDailyBarsRequest
|
|
|
|
startRes *altv1.StartBacktestResponse
|
|
listRes *altv1.ListBacktestRunsResponse
|
|
detailRes *altv1.GetBacktestRunDetailResponse
|
|
resultRes *altv1.GetBacktestResultResponse
|
|
compareRes *altv1.CompareBacktestRunsResponse
|
|
instRes *altv1.ListInstrumentsResponse
|
|
barsRes *altv1.ListBarsResponse
|
|
importRes *altv1.ImportDailyBarsResponse
|
|
|
|
err error
|
|
connectErr error
|
|
isConnected bool
|
|
connectCount int
|
|
}
|
|
|
|
func (f *fakeWorkerClient) IsConnected() bool { return f.isConnected }
|
|
func (f *fakeWorkerClient) Connect(ctx context.Context) error {
|
|
f.connectCount++
|
|
if f.connectErr != nil {
|
|
return f.connectErr
|
|
}
|
|
f.isConnected = true
|
|
return nil
|
|
}
|
|
func (f *fakeWorkerClient) Close() error {
|
|
f.isConnected = false
|
|
return nil
|
|
}
|
|
func (f *fakeWorkerClient) Hello(ctx context.Context, req *altv1.HelloRequest) (*altv1.HelloResponse, error) {
|
|
return &altv1.HelloResponse{}, f.err
|
|
}
|
|
func (f *fakeWorkerClient) StartBacktest(ctx context.Context, req *altv1.StartBacktestRequest) (*altv1.StartBacktestResponse, error) {
|
|
f.startReq = req
|
|
return f.startRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) ListBacktestRuns(ctx context.Context, req *altv1.ListBacktestRunsRequest) (*altv1.ListBacktestRunsResponse, error) {
|
|
f.listReq = req
|
|
return f.listRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) GetBacktestRunDetail(ctx context.Context, req *altv1.GetBacktestRunDetailRequest) (*altv1.GetBacktestRunDetailResponse, error) {
|
|
f.detailReq = req
|
|
return f.detailRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) GetBacktestResult(ctx context.Context, req *altv1.GetBacktestResultRequest) (*altv1.GetBacktestResultResponse, error) {
|
|
f.resultReq = req
|
|
return f.resultRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) CompareBacktestRuns(ctx context.Context, req *altv1.CompareBacktestRunsRequest) (*altv1.CompareBacktestRunsResponse, error) {
|
|
f.compareReq = req
|
|
return f.compareRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) ListInstruments(ctx context.Context, req *altv1.ListInstrumentsRequest) (*altv1.ListInstrumentsResponse, error) {
|
|
f.instReq = req
|
|
return f.instRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) ListBars(ctx context.Context, req *altv1.ListBarsRequest) (*altv1.ListBarsResponse, error) {
|
|
f.barsReq = req
|
|
return f.barsRes, f.err
|
|
}
|
|
func (f *fakeWorkerClient) ImportDailyBars(ctx context.Context, req *altv1.ImportDailyBarsRequest) (*altv1.ImportDailyBarsResponse, error) {
|
|
f.importReq = req
|
|
return f.importRes, f.err
|
|
}
|
|
|
|
func validStart() *altv1.StartBacktestRequest {
|
|
return &altv1.StartBacktestRequest{Spec: &altv1.BacktestRunSpec{StrategyId: "strat-abc"}}
|
|
}
|
|
|
|
func TestHandleStartBacktestForwards(t *testing.T) {
|
|
fake := &fakeWorkerClient{startRes: &altv1.StartBacktestResponse{Run: &altv1.BacktestRun{Id: "run-1"}}}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if fake.startReq == nil {
|
|
t.Fatal("expected request to be forwarded to worker")
|
|
}
|
|
if resp.GetRun().GetId() != "run-1" {
|
|
t.Errorf("unexpected response run id: %q", resp.GetRun().GetId())
|
|
}
|
|
}
|
|
|
|
func TestHandleStartBacktestRejectsMissingSpec(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleStartBacktest(fake, &altv1.StartBacktestRequest{})
|
|
if err != nil {
|
|
t.Fatalf("expected typed validation response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInvalidRequest)
|
|
if fake.startReq != nil {
|
|
t.Error("worker must not be called when validation fails")
|
|
}
|
|
}
|
|
|
|
func TestHandleStartBacktestNilWorker(t *testing.T) {
|
|
resp, err := handleStartBacktest(nil, validStart())
|
|
if err != nil {
|
|
t.Fatalf("expected typed unavailable response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorUnavailable)
|
|
}
|
|
|
|
func TestHandleStartBacktestMapsUnavailable(t *testing.T) {
|
|
fake := &fakeWorkerClient{err: workerclient.ErrUnavailable}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("expected typed unavailable response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorUnavailable)
|
|
}
|
|
|
|
func TestHandleStartBacktestMapsTimeout(t *testing.T) {
|
|
fake := &fakeWorkerClient{err: workerclient.ErrTimeout}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("expected typed timeout response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorTimeout)
|
|
}
|
|
|
|
func TestHandleStartBacktestMapsUnexpectedWorkerError(t *testing.T) {
|
|
fake := &fakeWorkerClient{err: context.Canceled}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("expected typed internal response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInternal)
|
|
}
|
|
|
|
func TestHandleStartBacktestNilWorkerResponseForwardsRequest(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("expected typed internal response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInternal)
|
|
if fake.startReq == nil {
|
|
t.Error("expected worker to be called before nil response was detected")
|
|
}
|
|
}
|
|
|
|
func TestHandleListBacktestRunsNilWorkerResponse(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleListBacktestRuns(fake, &altv1.ListBacktestRunsRequest{})
|
|
if err != nil {
|
|
t.Fatalf("expected typed internal response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInternal)
|
|
if fake.listReq == nil {
|
|
t.Error("expected request to be forwarded before nil response was detected")
|
|
}
|
|
}
|
|
|
|
func TestHandleListBacktestRunsForwards(t *testing.T) {
|
|
fake := &fakeWorkerClient{listRes: &altv1.ListBacktestRunsResponse{Runs: []*altv1.BacktestRun{{Id: "run-1"}}}}
|
|
|
|
resp, err := handleListBacktestRuns(fake, &altv1.ListBacktestRunsRequest{Status: altv1.BacktestRunStatus_BACKTEST_RUN_STATUS_SUCCEEDED})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if fake.listReq.GetStatus() != altv1.BacktestRunStatus_BACKTEST_RUN_STATUS_SUCCEEDED {
|
|
t.Error("status filter was not forwarded unchanged")
|
|
}
|
|
if len(resp.GetRuns()) != 1 {
|
|
t.Errorf("expected 1 run, got %d", len(resp.GetRuns()))
|
|
}
|
|
}
|
|
|
|
func TestHandleGetBacktestRunDetailRequiresRunID(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleGetBacktestRunDetail(fake, &altv1.GetBacktestRunDetailRequest{})
|
|
if err != nil {
|
|
t.Fatalf("expected typed validation response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInvalidRequest)
|
|
if fake.detailReq != nil {
|
|
t.Error("worker must not be called when validation fails")
|
|
}
|
|
}
|
|
|
|
func TestHandleGetBacktestRunDetailNilWorkerResponse(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleGetBacktestRunDetail(fake, &altv1.GetBacktestRunDetailRequest{RunId: "run-1"})
|
|
if err != nil {
|
|
t.Fatalf("expected typed internal response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInternal)
|
|
if fake.detailReq == nil {
|
|
t.Error("expected request to be forwarded before nil response was detected")
|
|
}
|
|
}
|
|
|
|
func TestHandleGetBacktestRunDetailForwards(t *testing.T) {
|
|
fake := &fakeWorkerClient{detailRes: &altv1.GetBacktestRunDetailResponse{Run: &altv1.BacktestRun{Id: "run-1"}}}
|
|
|
|
resp, err := handleGetBacktestRunDetail(fake, &altv1.GetBacktestRunDetailRequest{RunId: "run-1"})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if resp.GetRun().GetId() != "run-1" {
|
|
t.Errorf("unexpected run id: %q", resp.GetRun().GetId())
|
|
}
|
|
}
|
|
|
|
func TestHandleGetBacktestResultRequiresRunID(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleGetBacktestResult(fake, &altv1.GetBacktestResultRequest{})
|
|
if err != nil {
|
|
t.Fatalf("expected typed validation response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInvalidRequest)
|
|
if fake.resultReq != nil {
|
|
t.Error("worker must not be called when validation fails")
|
|
}
|
|
}
|
|
|
|
func TestHandleCompareBacktestRunsEmptyIsNoOp(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleCompareBacktestRuns(fake, &altv1.CompareBacktestRunsRequest{})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if resp.GetError() != nil {
|
|
t.Fatalf("expected no error for empty no-op compare, got %+v", resp.GetError())
|
|
}
|
|
if len(resp.GetResults()) != 0 {
|
|
t.Errorf("expected empty results, got %d", len(resp.GetResults()))
|
|
}
|
|
if fake.compareReq != nil {
|
|
t.Error("worker must not be called for empty no-op compare")
|
|
}
|
|
}
|
|
|
|
func TestHandleCompareBacktestRunsValidation(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
|
|
resp, err := handleCompareBacktestRuns(fake, &altv1.CompareBacktestRunsRequest{RunIds: []string{"run-1", ""}})
|
|
if err != nil {
|
|
t.Fatalf("expected typed validation response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorInvalidRequest)
|
|
if fake.compareReq != nil {
|
|
t.Error("worker must not be called when validation fails")
|
|
}
|
|
}
|
|
|
|
func TestHandleCompareBacktestRunsForwards(t *testing.T) {
|
|
fake := &fakeWorkerClient{compareRes: &altv1.CompareBacktestRunsResponse{Results: []*altv1.BacktestResult{{RunId: "run-1"}, {RunId: "run-2"}}}}
|
|
|
|
resp, err := handleCompareBacktestRuns(fake, &altv1.CompareBacktestRunsRequest{RunIds: []string{"run-1", "run-2"}})
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if len(resp.GetResults()) != 2 {
|
|
t.Errorf("expected 2 results, got %d", len(resp.GetResults()))
|
|
}
|
|
}
|
|
|
|
func TestBacktestSocketValidationReturnsTypedErrors(t *testing.T) {
|
|
fake := &fakeWorkerClient{}
|
|
client := startBacktestAPITestClient(t, fake)
|
|
|
|
cases := []struct {
|
|
name string
|
|
run func(*testing.T) *altv1.ErrorInfo
|
|
}{
|
|
{
|
|
name: "start missing spec",
|
|
run: func(t *testing.T) *altv1.ErrorInfo {
|
|
t.Helper()
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.StartBacktestRequest, *altv1.StartBacktestResponse](
|
|
&client.Communicator,
|
|
&altv1.StartBacktestRequest{},
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return typed error response without timeout: %v", err)
|
|
}
|
|
return resp.GetError()
|
|
},
|
|
},
|
|
{
|
|
name: "detail missing run id",
|
|
run: func(t *testing.T) *altv1.ErrorInfo {
|
|
t.Helper()
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.GetBacktestRunDetailRequest, *altv1.GetBacktestRunDetailResponse](
|
|
&client.Communicator,
|
|
&altv1.GetBacktestRunDetailRequest{},
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return typed error response without timeout: %v", err)
|
|
}
|
|
return resp.GetError()
|
|
},
|
|
},
|
|
{
|
|
name: "result missing run id",
|
|
run: func(t *testing.T) *altv1.ErrorInfo {
|
|
t.Helper()
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.GetBacktestResultRequest, *altv1.GetBacktestResultResponse](
|
|
&client.Communicator,
|
|
&altv1.GetBacktestResultRequest{},
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return typed error response without timeout: %v", err)
|
|
}
|
|
return resp.GetError()
|
|
},
|
|
},
|
|
{
|
|
name: "compare empty id",
|
|
run: func(t *testing.T) *altv1.ErrorInfo {
|
|
t.Helper()
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.CompareBacktestRunsRequest, *altv1.CompareBacktestRunsResponse](
|
|
&client.Communicator,
|
|
&altv1.CompareBacktestRunsRequest{RunIds: []string{"run-1", ""}},
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return typed error response without timeout: %v", err)
|
|
}
|
|
return resp.GetError()
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range cases {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
requireBacktestError(t, tt.run(t), backtestErrorInvalidRequest)
|
|
})
|
|
}
|
|
if fake.startReq != nil || fake.detailReq != nil || fake.resultReq != nil || fake.compareReq != nil {
|
|
t.Fatal("worker must not be called for socket-level validation failures")
|
|
}
|
|
}
|
|
|
|
func TestBacktestSocketWorkerUnavailableReturnsTypedError(t *testing.T) {
|
|
fake := &fakeWorkerClient{err: workerclient.ErrUnavailable}
|
|
client := startBacktestAPITestClient(t, fake)
|
|
|
|
resp, err := protoSocket.SendRequestTyped[*altv1.StartBacktestRequest, *altv1.StartBacktestResponse](
|
|
&client.Communicator,
|
|
validStart(),
|
|
500*time.Millisecond,
|
|
)
|
|
if err != nil {
|
|
t.Fatalf("request should return typed error response without timeout: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorUnavailable)
|
|
if fake.startReq == nil {
|
|
t.Fatal("valid start request should be forwarded before worker error is mapped")
|
|
}
|
|
}
|
|
|
|
func startBacktestAPITestClient(t *testing.T, fake workerclient.WorkerClient) *protoSocket.WsClient {
|
|
t.Helper()
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
t.Cleanup(cancel)
|
|
|
|
cfg := config.Config{
|
|
Host: "127.0.0.1",
|
|
Port: freeTCPPort(t),
|
|
SocketPath: "/socket",
|
|
HeartbeatIntervalSec: 0,
|
|
HeartbeatWaitSec: 0,
|
|
}
|
|
server := NewServerWithWorker(cfg, fake)
|
|
if err := server.Start(ctx); err != nil {
|
|
t.Fatalf("failed to start API socket server: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = server.Stop() })
|
|
|
|
client, err := protoSocket.DialWsWithHeartbeat(ctx, cfg.Host, cfg.Port, cfg.SocketPath, 0, 0, apiContracts.ParserMap())
|
|
if err != nil {
|
|
t.Fatalf("failed to dial API socket server: %v", err)
|
|
}
|
|
t.Cleanup(func() { _ = client.Close() })
|
|
|
|
return client
|
|
}
|
|
|
|
func requireBacktestError(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)
|
|
}
|
|
}
|
|
|
|
func TestBacktestHandlersRegisteredInSession(t *testing.T) {
|
|
registered := make(map[string]bool)
|
|
for _, h := range sessionHandlers(nil) {
|
|
registered[h.requestType] = true
|
|
}
|
|
required := []string{
|
|
protoSocket.TypeNameOf(&altv1.StartBacktestRequest{}),
|
|
protoSocket.TypeNameOf(&altv1.ListBacktestRunsRequest{}),
|
|
protoSocket.TypeNameOf(&altv1.GetBacktestRunDetailRequest{}),
|
|
protoSocket.TypeNameOf(&altv1.GetBacktestResultRequest{}),
|
|
protoSocket.TypeNameOf(&altv1.CompareBacktestRunsRequest{}),
|
|
}
|
|
for _, req := range required {
|
|
if !registered[req] {
|
|
t.Errorf("missing API handler registration for %q", req)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestHandleStartBacktest_ConnectFailure(t *testing.T) {
|
|
fake := &fakeWorkerClient{
|
|
connectErr: workerclient.ErrUnavailable,
|
|
isConnected: false,
|
|
}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("expected typed unavailable response, got error: %v", err)
|
|
}
|
|
requireBacktestError(t, resp.GetError(), backtestErrorUnavailable)
|
|
if fake.startReq != nil {
|
|
t.Error("expected request not to be forwarded to worker on connect failure")
|
|
}
|
|
if fake.connectCount != 1 {
|
|
t.Errorf("expected connectCount to be 1, got %d", fake.connectCount)
|
|
}
|
|
}
|
|
|
|
func TestHandleStartBacktest_ReconnectBehavior(t *testing.T) {
|
|
fake := &fakeWorkerClient{
|
|
startRes: &altv1.StartBacktestResponse{Run: &altv1.BacktestRun{Id: "run-1"}},
|
|
isConnected: false,
|
|
}
|
|
|
|
resp, err := handleStartBacktest(fake, validStart())
|
|
if err != nil {
|
|
t.Fatalf("unexpected error: %v", err)
|
|
}
|
|
if resp.GetError() != nil {
|
|
t.Fatalf("unexpected handler error: %+v", resp.GetError())
|
|
}
|
|
if fake.connectCount != 1 {
|
|
t.Errorf("expected Connect to be called once, got %d", fake.connectCount)
|
|
}
|
|
if fake.startReq == nil {
|
|
t.Error("expected request to be forwarded to worker")
|
|
}
|
|
if !fake.isConnected {
|
|
t.Error("expected fake worker state to be connected")
|
|
}
|
|
}
|