mirror of
https://github.com/luxfi/dex.git
synced 2026-09-24 00:26:31 +00:00
zeekay
b48ceaf847
ONE matching path: BackendGo (CPU). The pretend-acceleration cruft
is gone.
Removed (archive/lp108-2026-05-04/):
* pkg/engine/mlx_engine.go — claimed MLX-accelerated processing.
Real body was time.Sleep simulating GPU work + a hardcoded
597 ns/order constant. No Metal Performance Shaders, no MLX
device, no kernel.
* pkg/engine/mlx_engine_test.go — tested the stub.
* pkg/lx/fpga_accelerator.go — 484 LoC FPGA "accelerator". No
bitstream, no driver, interface-only.
* pkg/lx/fpga_accelerator_test.go — tested the stub itself
("DisabledFPGA returns error").
* pkg/fpga/* — 8 files, ~3K LoC of FPGA interfaces (amd_versal,
aws_f2, fpga_engine, fpga_interface, types, stubs + tests).
Interface-only. No hardware path.
Surgical edits to keep the rest of the test surface compiling:
* pkg/lx/orderbook.go::detectBestBackend — collapsed. Used to set
currentBackend to BackendGo/CGO/MLX/CUDA based on env probes;
nothing branched on the enum so the matching engine ran the Go
path regardless. Now: const Backend = BackendGo only. Removed
unused "os" + "runtime" imports.
* pkg/lx/critical_path_bench_test.go::BenchmarkFPGAAcceleration —
removed (called NewFPGAAccelerator).
* pkg/lx/coverage_improvement_test.go::TestFPGAAccelerator* —
removed (3 tests calling NewFPGAAccelerator).
* test/benchmark/orderbook_bench_test.go::BenchmarkMLXEngine —
removed. Called the standard CPU OrderBook then reported
b.ReportMetric(597, "ns/order") as a hardcoded literal.
* test/benchmark/orderbook_bench_test.go::BenchmarkPlanetScale —
removed. Entirely fabricated metrics (markets=5M, orders/sec=150M,
ns/order=597, watts=370, orders/watt=405405). No code in the
repo measured any of those.
What's left:
* BenchmarkOrderBook — real CPU path measurement
* BenchmarkOrderBookParallel — real CPU path measurement
* All match logic, order types, vault/margin/clearinghouse, etc.
Real measured numbers for the matching engine come from
luxcpp/dex/build/luxdex_bench (5.51 M orders/sec single-symbol on
Apple M1 Max). Anything labeled "GPU" or "FPGA" in benchmark
output of this repo is now removed because it didn't measure
GPU or FPGA work.
Verification on M1 Max:
* GOWORK=off go build ./pkg/lx/... ./test/benchmark/... — clean
* GOWORK=off go test -run='TestOrderBook$|TestNewOrderBook' ./pkg/lx/ — PASS
When real GPU/FPGA matching ships: add the variants back AND wire
through the match path AND a parity test vs BackendGo AND a
reproducible benchmark. LP-108 production gate applies.
1219 lines
33 KiB
Go
1219 lines
33 KiB
Go
package lx
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
// ============================================================================
|
|
// Tests for AlpacaSource.GetLatestPrice - Coverage target: 15.8% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestAlpacaSourceGetLatestPrice(t *testing.T) {
|
|
t.Run("CachedPrice", func(t *testing.T) {
|
|
source := NewAlpacaSource("test-key", "test-secret")
|
|
|
|
// Pre-populate cache
|
|
source.cache.Store("AAPL", 150.0)
|
|
|
|
price, err := source.GetLatestPrice("AAPL")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 150.0, price)
|
|
})
|
|
|
|
t.Run("FetchFromAPI_Success", func(t *testing.T) {
|
|
// Create mock server
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
// Verify headers
|
|
assert.Equal(t, "test-key", r.Header.Get("APCA-API-KEY-ID"))
|
|
assert.Equal(t, "test-secret", r.Header.Get("APCA-API-SECRET-KEY"))
|
|
|
|
response := struct {
|
|
Trade struct {
|
|
Price float64 `json:"p"`
|
|
} `json:"trade"`
|
|
}{
|
|
Trade: struct {
|
|
Price float64 `json:"p"`
|
|
}{Price: 155.50},
|
|
}
|
|
w.Header().Set("Content-Type", "application/json")
|
|
json.NewEncoder(w).Encode(response)
|
|
}))
|
|
defer server.Close()
|
|
|
|
source := NewAlpacaSource("test-key", "test-secret")
|
|
source.baseURL = server.URL
|
|
|
|
price, err := source.GetLatestPrice("AAPL")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 155.50, price)
|
|
|
|
// Verify cache was updated
|
|
cached, ok := source.cache.Load("AAPL")
|
|
assert.True(t, ok)
|
|
assert.Equal(t, 155.50, cached.(float64))
|
|
})
|
|
|
|
t.Run("FetchFromAPI_NetworkError", func(t *testing.T) {
|
|
source := NewAlpacaSource("test-key", "test-secret")
|
|
source.baseURL = "http://invalid-host-that-does-not-exist.local"
|
|
|
|
_, err := source.GetLatestPrice("AAPL")
|
|
assert.Error(t, err)
|
|
})
|
|
|
|
t.Run("FetchFromAPI_InvalidJSON", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.Write([]byte("invalid json"))
|
|
}))
|
|
defer server.Close()
|
|
|
|
source := NewAlpacaSource("test-key", "test-secret")
|
|
source.baseURL = server.URL
|
|
|
|
_, err := source.GetLatestPrice("AAPL")
|
|
assert.Error(t, err)
|
|
})
|
|
|
|
t.Run("CacheWithInvalidType", func(t *testing.T) {
|
|
source := NewAlpacaSource("test-key", "test-secret")
|
|
|
|
// Store invalid type in cache
|
|
source.cache.Store("AAPL", "not a float")
|
|
|
|
// Create mock server for fallback
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
response := struct {
|
|
Trade struct {
|
|
Price float64 `json:"p"`
|
|
} `json:"trade"`
|
|
}{
|
|
Trade: struct {
|
|
Price float64 `json:"p"`
|
|
}{Price: 160.0},
|
|
}
|
|
json.NewEncoder(w).Encode(response)
|
|
}))
|
|
defer server.Close()
|
|
source.baseURL = server.URL
|
|
|
|
price, err := source.GetLatestPrice("AAPL")
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 160.0, price)
|
|
})
|
|
}
|
|
|
|
// LP-108: TestFPGAAcceleratorProcessOrder/Batch/WireToWireLatency removed
|
|
// alongside the FPGAAccelerator stub
|
|
// (archive/lp108-2026-05-04/fpga_accelerator.go). The accelerator was
|
|
// interface-only; the "tests" exercised the stub itself, not any real
|
|
// hardware. Real FPGA matching belongs as a separate project with a
|
|
// working hardware driver and a parity test against the CPU path.
|
|
|
|
// ============================================================================
|
|
// Tests for FundingEngine.runFundingLoop - Coverage target: 38.5% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestFundingEngineRunFundingLoop(t *testing.T) {
|
|
t.Run("StartAndStop", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
config.Interval = 100 * time.Millisecond // Short interval for testing
|
|
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
// Start the engine
|
|
engine.Start()
|
|
|
|
// Let it run for a bit
|
|
time.Sleep(50 * time.Millisecond)
|
|
|
|
// Stop the engine
|
|
engine.Stop()
|
|
|
|
// Verify stopped
|
|
assert.True(t, engine.stopped)
|
|
})
|
|
|
|
t.Run("FundingTimeCheck", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
// Test funding times
|
|
fundingTime := time.Date(2024, 1, 1, 8, 0, 0, 0, time.UTC)
|
|
assert.True(t, engine.isFundingTime(fundingTime))
|
|
|
|
nonFundingTime := time.Date(2024, 1, 1, 9, 30, 0, 0, time.UTC)
|
|
assert.False(t, engine.isFundingTime(nonFundingTime))
|
|
})
|
|
|
|
t.Run("UpdatePredictedRates", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
// Setup TWAP trackers with values
|
|
engine.mu.Lock()
|
|
engine.premiumTWAP["BTC-PERP"] = &TWAPTracker{
|
|
Symbol: "BTC-PERP",
|
|
CurrentTWAP: 0.001,
|
|
}
|
|
engine.mu.Unlock()
|
|
|
|
// Update predicted rates - exercises the code path
|
|
// Note: clearinghouse returns 0 prices without proper initialization
|
|
engine.updatePredictedRates()
|
|
|
|
// The function should complete without panic even with zero prices
|
|
// GetPredictedFundingRate may return nil if indexPrice was 0
|
|
_ = engine.GetPredictedFundingRate("BTC-PERP")
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for PythPriceSource - Coverage target: 13.6%/18.8% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestPythPriceSourceHandlePriceUpdate(t *testing.T) {
|
|
t.Run("ValidPriceUpdate", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
source.priceIDs["BTC-USD"] = "test-price-id"
|
|
|
|
msg := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"price_id": "test-price-id",
|
|
"price": 50000.0,
|
|
"confidence": 50.0,
|
|
"publish_time": float64(time.Now().Unix()),
|
|
},
|
|
}
|
|
|
|
source.handlePriceUpdate(msg)
|
|
|
|
source.mu.RLock()
|
|
price, exists := source.prices["BTC-USD"]
|
|
source.mu.RUnlock()
|
|
|
|
assert.True(t, exists)
|
|
assert.NotNil(t, price)
|
|
assert.Equal(t, 50000.0, price.Price)
|
|
})
|
|
|
|
t.Run("InvalidData", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
// Missing data field
|
|
msg := map[string]interface{}{
|
|
"type": "price_update",
|
|
}
|
|
|
|
// Should not panic
|
|
source.handlePriceUpdate(msg)
|
|
})
|
|
|
|
t.Run("UnknownPriceID", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
msg := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"price_id": "unknown-id",
|
|
"price": 50000.0,
|
|
},
|
|
}
|
|
|
|
// Should not panic
|
|
source.handlePriceUpdate(msg)
|
|
})
|
|
|
|
t.Run("PriceWithExponent", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
source.priceIDs["BTC-USD"] = "test-price-id"
|
|
|
|
msg := map[string]interface{}{
|
|
"data": map[string]interface{}{
|
|
"price_id": "test-price-id",
|
|
"price": 50000000.0, // Price in smallest unit
|
|
"expo": -3.0, // 10^-3 adjustment
|
|
"confidence": 50.0,
|
|
"publish_time": float64(time.Now().Unix()),
|
|
},
|
|
}
|
|
|
|
source.handlePriceUpdate(msg)
|
|
|
|
source.mu.RLock()
|
|
price := source.prices["BTC-USD"]
|
|
source.mu.RUnlock()
|
|
|
|
assert.NotNil(t, price)
|
|
assert.InDelta(t, 50000.0, price.Price, 1.0)
|
|
})
|
|
}
|
|
|
|
func TestPythPriceSourceFetchPriceHTTP(t *testing.T) {
|
|
t.Run("SuccessfulFetch", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
response := []PythPriceFeed{
|
|
{
|
|
ID: "test-price-id",
|
|
Price: 50000.0,
|
|
ExponentPrice: 0,
|
|
Confidence: 50.0,
|
|
PublishTime: time.Now().Unix(),
|
|
},
|
|
}
|
|
json.NewEncoder(w).Encode(response)
|
|
}))
|
|
defer server.Close()
|
|
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", server.URL)
|
|
source.priceIDs["BTC-USD"] = "test-price-id"
|
|
|
|
price, err := source.fetchPriceHTTP("BTC-USD")
|
|
assert.NoError(t, err)
|
|
assert.NotNil(t, price)
|
|
assert.Equal(t, 50000.0, price.Price)
|
|
})
|
|
|
|
t.Run("UnknownSymbol", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
_, err := source.fetchPriceHTTP("UNKNOWN")
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "no price ID")
|
|
})
|
|
|
|
t.Run("EmptyResponse", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
json.NewEncoder(w).Encode([]PythPriceFeed{})
|
|
}))
|
|
defer server.Close()
|
|
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", server.URL)
|
|
source.priceIDs["BTC-USD"] = "test-price-id"
|
|
|
|
_, err := source.fetchPriceHTTP("BTC-USD")
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "no price data")
|
|
})
|
|
|
|
t.Run("NetworkError", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "http://invalid-host.local")
|
|
source.priceIDs["BTC-USD"] = "test-price-id"
|
|
|
|
_, err := source.fetchPriceHTTP("BTC-USD")
|
|
assert.Error(t, err)
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for AdvancedOrderBook.updateTrailingStops - Coverage target: 10% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestAdvancedOrderBookUpdateTrailingStops(t *testing.T) {
|
|
t.Run("SellTrailingStop_PriceIncrease", func(t *testing.T) {
|
|
book := NewAdvancedOrderBook("BTC-USDT")
|
|
book.lastPrice = 50000.0
|
|
|
|
// Add trailing stop order (sell)
|
|
order := &AdvancedOrder{
|
|
ID: 1,
|
|
Type: Bracket, // Bracket type for trailing stop
|
|
Side: Sell,
|
|
StopPrice: 49500.0, // Initial stop
|
|
TrailAmount: 500.0, // Trail by $500
|
|
}
|
|
book.stopOrders[order.ID] = order
|
|
|
|
// Price increases to 51000
|
|
book.updateTrailingStops(51000.0)
|
|
|
|
// Stop should have been raised to 50500
|
|
assert.Equal(t, 50500.0, order.StopPrice)
|
|
})
|
|
|
|
t.Run("SellTrailingStop_PriceDecrease", func(t *testing.T) {
|
|
book := NewAdvancedOrderBook("BTC-USDT")
|
|
book.lastPrice = 50000.0
|
|
|
|
order := &AdvancedOrder{
|
|
ID: 1,
|
|
Type: Bracket,
|
|
Side: Sell,
|
|
StopPrice: 49500.0,
|
|
TrailAmount: 500.0,
|
|
}
|
|
book.stopOrders[order.ID] = order
|
|
|
|
// Price decreases - stop should not change
|
|
book.updateTrailingStops(49000.0)
|
|
|
|
// Stop should remain the same
|
|
assert.Equal(t, 49500.0, order.StopPrice)
|
|
})
|
|
|
|
t.Run("BuyTrailingStop_PriceDecrease", func(t *testing.T) {
|
|
book := NewAdvancedOrderBook("BTC-USDT")
|
|
book.lastPrice = 50000.0
|
|
|
|
// Add trailing stop order (buy - for shorts)
|
|
order := &AdvancedOrder{
|
|
ID: 1,
|
|
Type: Bracket,
|
|
Side: Buy,
|
|
StopPrice: 50500.0, // Initial stop
|
|
TrailAmount: 500.0, // Trail by $500
|
|
}
|
|
book.stopOrders[order.ID] = order
|
|
|
|
// Price decreases to 49000
|
|
book.updateTrailingStops(49000.0)
|
|
|
|
// Stop should have been lowered to 49500
|
|
assert.Equal(t, 49500.0, order.StopPrice)
|
|
})
|
|
|
|
t.Run("NonTrailingStopIgnored", func(t *testing.T) {
|
|
book := NewAdvancedOrderBook("BTC-USDT")
|
|
|
|
// Regular stop order (not Bracket type)
|
|
order := &AdvancedOrder{
|
|
ID: 1,
|
|
Type: Stop, // Regular stop
|
|
Side: Sell,
|
|
StopPrice: 49500.0,
|
|
TrailAmount: 500.0,
|
|
}
|
|
book.stopOrders[order.ID] = order
|
|
|
|
// Price increases
|
|
book.updateTrailingStops(51000.0)
|
|
|
|
// Stop should not change
|
|
assert.Equal(t, 49500.0, order.StopPrice)
|
|
})
|
|
|
|
t.Run("MultipleTrailingStops", func(t *testing.T) {
|
|
book := NewAdvancedOrderBook("BTC-USDT")
|
|
|
|
order1 := &AdvancedOrder{
|
|
ID: 1,
|
|
Type: Bracket,
|
|
Side: Sell,
|
|
StopPrice: 49500.0,
|
|
TrailAmount: 500.0,
|
|
}
|
|
order2 := &AdvancedOrder{
|
|
ID: 2,
|
|
Type: Bracket,
|
|
Side: Sell,
|
|
StopPrice: 49000.0,
|
|
TrailAmount: 1000.0,
|
|
}
|
|
book.stopOrders[order1.ID] = order1
|
|
book.stopOrders[order2.ID] = order2
|
|
|
|
book.updateTrailingStops(51000.0)
|
|
|
|
assert.Equal(t, 50500.0, order1.StopPrice)
|
|
assert.Equal(t, 50000.0, order2.StopPrice)
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for ExtendedOrderBook.wouldSelfTrade - Coverage target: 27.3% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestExtendedOrderBookWouldSelfTrade(t *testing.T) {
|
|
t.Run("MarketOrderSelfTrade", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add existing buy order from user1
|
|
existingOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 50000.0,
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
book.Orders[existingOrder.ID] = existingOrder
|
|
book.UserOrders["user1"] = []uint64{existingOrder.ID}
|
|
|
|
// Try to add market sell from same user
|
|
newOrder := &Order{
|
|
ID: 2,
|
|
Type: Market,
|
|
Side: Sell,
|
|
Size: 0.5,
|
|
UserID: "user1",
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.True(t, result)
|
|
})
|
|
|
|
t.Run("LimitBuyOrderSelfTrade", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add existing sell order from user1
|
|
existingOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 50000.0,
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
book.Orders[existingOrder.ID] = existingOrder
|
|
book.UserOrders["user1"] = []uint64{existingOrder.ID}
|
|
|
|
// Buy order at higher price from same user
|
|
newOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 50100.0, // Higher than existing sell
|
|
Size: 0.5,
|
|
UserID: "user1",
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.True(t, result)
|
|
})
|
|
|
|
t.Run("LimitSellOrderSelfTrade", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add existing buy order from user1
|
|
existingOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 50000.0,
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
book.Orders[existingOrder.ID] = existingOrder
|
|
book.UserOrders["user1"] = []uint64{existingOrder.ID}
|
|
|
|
// Sell order at lower price from same user
|
|
newOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 49900.0, // Lower than existing buy
|
|
Size: 0.5,
|
|
UserID: "user1",
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.True(t, result)
|
|
})
|
|
|
|
t.Run("NoSelfTrade_DifferentUsers", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
existingOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 50000.0,
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
book.Orders[existingOrder.ID] = existingOrder
|
|
book.UserOrders["user1"] = []uint64{existingOrder.ID}
|
|
|
|
// Order from different user
|
|
newOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 49900.0,
|
|
Size: 0.5,
|
|
UserID: "user2", // Different user
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.False(t, result)
|
|
})
|
|
|
|
t.Run("NoSelfTrade_NoExistingOrders", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
newOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 50000.0,
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.False(t, result)
|
|
})
|
|
|
|
t.Run("NoSelfTrade_SameSide", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
existingOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 50000.0,
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
book.Orders[existingOrder.ID] = existingOrder
|
|
book.UserOrders["user1"] = []uint64{existingOrder.ID}
|
|
|
|
// Same side order
|
|
newOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Buy, // Same side
|
|
Price: 51000.0,
|
|
Size: 0.5,
|
|
UserID: "user1",
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.False(t, result)
|
|
})
|
|
|
|
t.Run("NoSelfTrade_PricesWouldNotMatch", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
existingOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 51000.0, // Higher sell price
|
|
Size: 1.0,
|
|
UserID: "user1",
|
|
}
|
|
book.Orders[existingOrder.ID] = existingOrder
|
|
book.UserOrders["user1"] = []uint64{existingOrder.ID}
|
|
|
|
// Buy at lower price - would not cross
|
|
newOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 50000.0, // Lower than existing sell
|
|
Size: 0.5,
|
|
UserID: "user1",
|
|
}
|
|
|
|
result := book.wouldSelfTrade(newOrder)
|
|
assert.False(t, result)
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for ExtendedOrderBook.CheckStopOrders - Coverage target: 27.8% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestExtendedOrderBookCheckStopOrders(t *testing.T) {
|
|
// Note: CheckStopOrders has a deadlock bug where it holds mu.Lock
|
|
// and calls AddOrder which tries to acquire the same lock.
|
|
// Tests below verify behavior when no trigger conditions are met.
|
|
|
|
t.Run("NoTrigger_StopBuyBelowPrice", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add stop buy order with price above current price
|
|
stopOrder := &Order{
|
|
ID: 1,
|
|
Type: Stop,
|
|
Side: Buy,
|
|
Price: 50500.0, // Stop price
|
|
Size: 1.0,
|
|
User: "user1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.stopBuyOrders[stopOrder.ID] = stopOrder
|
|
book.Orders[stopOrder.ID] = stopOrder
|
|
|
|
// Price is below stop price - should NOT trigger
|
|
book.CheckStopOrders(50000.0)
|
|
|
|
// Stop order should still exist (not triggered)
|
|
_, exists := book.stopBuyOrders[stopOrder.ID]
|
|
assert.True(t, exists, "Stop buy order should not be triggered when price < stop price")
|
|
})
|
|
|
|
t.Run("NoTrigger_StopSellAbovePrice", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add stop sell order with price below current price
|
|
stopOrder := &Order{
|
|
ID: 1,
|
|
Type: Stop,
|
|
Side: Sell,
|
|
Price: 49500.0, // Stop price
|
|
Size: 1.0,
|
|
User: "user1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.stopSellOrders[stopOrder.ID] = stopOrder
|
|
book.Orders[stopOrder.ID] = stopOrder
|
|
|
|
// Price is above stop price - should NOT trigger
|
|
book.CheckStopOrders(50000.0)
|
|
|
|
// Stop order should still exist (not triggered)
|
|
_, exists := book.stopSellOrders[stopOrder.ID]
|
|
assert.True(t, exists, "Stop sell order should not be triggered when price > stop price")
|
|
})
|
|
|
|
t.Run("NoTrigger_StopLimitSell_AbovePrice", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add stop-limit sell order
|
|
stopOrder := &Order{
|
|
ID: 1,
|
|
Type: StopLimit,
|
|
Side: Sell,
|
|
Price: 49500.0, // Stop price
|
|
LimitPrice: 49400.0, // Limit price after trigger
|
|
Size: 1.0,
|
|
User: "user1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.stopSellOrders[stopOrder.ID] = stopOrder
|
|
book.Orders[stopOrder.ID] = stopOrder
|
|
|
|
// Price is above stop price - should NOT trigger
|
|
book.CheckStopOrders(50000.0)
|
|
|
|
// Verify the order was NOT triggered
|
|
_, exists := book.stopSellOrders[stopOrder.ID]
|
|
assert.True(t, exists, "Stop-limit sell should not trigger when price > stop price")
|
|
})
|
|
|
|
t.Run("EmptyStopOrders", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// No stop orders - should not panic
|
|
book.CheckStopOrders(50000.0)
|
|
|
|
// Verify no errors
|
|
assert.Empty(t, book.stopBuyOrders)
|
|
assert.Empty(t, book.stopSellOrders)
|
|
})
|
|
|
|
t.Run("MultipleStopOrders_NoTrigger", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add multiple stop orders at different prices
|
|
stopOrder1 := &Order{
|
|
ID: 1,
|
|
Type: Stop,
|
|
Side: Sell,
|
|
Price: 49500.0,
|
|
Size: 1.0,
|
|
User: "user1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
stopOrder2 := &Order{
|
|
ID: 2,
|
|
Type: Stop,
|
|
Side: Sell,
|
|
Price: 49000.0,
|
|
Size: 1.0,
|
|
User: "user2",
|
|
Timestamp: time.Now(),
|
|
}
|
|
stopOrder3 := &Order{
|
|
ID: 3,
|
|
Type: Stop,
|
|
Side: Buy,
|
|
Price: 51000.0,
|
|
Size: 1.0,
|
|
User: "user3",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.stopSellOrders[stopOrder1.ID] = stopOrder1
|
|
book.stopSellOrders[stopOrder2.ID] = stopOrder2
|
|
book.stopBuyOrders[stopOrder3.ID] = stopOrder3
|
|
|
|
// Price doesn't trigger any stops (between all stop prices)
|
|
book.CheckStopOrders(50000.0)
|
|
|
|
// All stop orders should still exist (none triggered)
|
|
_, exists1 := book.stopSellOrders[stopOrder1.ID]
|
|
assert.True(t, exists1, "Stop sell 1 should not be triggered")
|
|
|
|
_, exists2 := book.stopSellOrders[stopOrder2.ID]
|
|
assert.True(t, exists2, "Stop sell 2 should not be triggered")
|
|
|
|
_, exists3 := book.stopBuyOrders[stopOrder3.ID]
|
|
assert.True(t, exists3, "Stop buy should not be triggered")
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for ExtendedOrderBook.GetVWAP - Coverage target: 28.6% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestExtendedOrderBookGetVWAP(t *testing.T) {
|
|
t.Run("InvalidSize", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
vwap, err := book.GetVWAP(Buy, 0)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid size")
|
|
assert.Equal(t, 0.0, vwap)
|
|
|
|
vwap, err = book.GetVWAP(Buy, -10)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid size")
|
|
})
|
|
|
|
t.Run("NoLiquidity", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
_, err := book.GetVWAP(Buy, 10.0)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "no liquidity")
|
|
})
|
|
|
|
t.Run("PartialFill", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add some liquidity
|
|
order := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 50000.0,
|
|
Size: 5.0,
|
|
User: "seller1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.AddOrder(order)
|
|
|
|
// Request more than available
|
|
vwap, err := book.GetVWAP(Buy, 10.0)
|
|
|
|
// Should return partial fill warning
|
|
if err != nil {
|
|
assert.Contains(t, err.Error(), "partial fill")
|
|
}
|
|
// VWAP should still be calculated for available liquidity
|
|
_ = vwap
|
|
})
|
|
|
|
t.Run("BuySide_MultipleLevel", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add sell orders at multiple levels
|
|
orders := []*Order{
|
|
{ID: 1, Type: Limit, Side: Sell, Price: 50000.0, Size: 2.0, User: "s1", Timestamp: time.Now()},
|
|
{ID: 2, Type: Limit, Side: Sell, Price: 50100.0, Size: 3.0, User: "s2", Timestamp: time.Now()},
|
|
{ID: 3, Type: Limit, Side: Sell, Price: 50200.0, Size: 5.0, User: "s3", Timestamp: time.Now()},
|
|
}
|
|
|
|
for _, o := range orders {
|
|
book.AddOrder(o)
|
|
}
|
|
|
|
// VWAP for buying 5 units
|
|
vwap, err := book.GetVWAP(Buy, 5.0)
|
|
if err == nil {
|
|
// VWAP should be between 50000 and 50100
|
|
assert.GreaterOrEqual(t, vwap, 50000.0)
|
|
assert.LessOrEqual(t, vwap, 50200.0)
|
|
}
|
|
})
|
|
|
|
t.Run("SellSide_VWAP", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add buy orders at multiple levels
|
|
orders := []*Order{
|
|
{ID: 1, Type: Limit, Side: Buy, Price: 49900.0, Size: 2.0, User: "b1", Timestamp: time.Now()},
|
|
{ID: 2, Type: Limit, Side: Buy, Price: 49800.0, Size: 3.0, User: "b2", Timestamp: time.Now()},
|
|
{ID: 3, Type: Limit, Side: Buy, Price: 49700.0, Size: 5.0, User: "b3", Timestamp: time.Now()},
|
|
}
|
|
|
|
for _, o := range orders {
|
|
book.AddOrder(o)
|
|
}
|
|
|
|
// VWAP for selling
|
|
vwap, err := book.GetVWAP(Sell, 5.0)
|
|
if err == nil {
|
|
// VWAP should be between levels
|
|
assert.GreaterOrEqual(t, vwap, 49700.0)
|
|
assert.LessOrEqual(t, vwap, 49900.0)
|
|
}
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for ExtendedOrderBook.GetMarketImpact - Coverage target: 30% -> 80%+
|
|
// ============================================================================
|
|
|
|
func TestExtendedOrderBookGetMarketImpact(t *testing.T) {
|
|
t.Run("NoLiquidity", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
impact, err := book.GetMarketImpact(Buy, 10.0)
|
|
assert.Error(t, err)
|
|
assert.Equal(t, 0.0, impact)
|
|
})
|
|
|
|
t.Run("NoMidPrice", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add only one side
|
|
order := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 50000.0,
|
|
Size: 10.0,
|
|
User: "seller1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.AddOrder(order)
|
|
|
|
impact, err := book.GetMarketImpact(Buy, 5.0)
|
|
// Should error due to missing mid price
|
|
assert.Error(t, err)
|
|
assert.Equal(t, 0.0, impact)
|
|
})
|
|
|
|
t.Run("BuySideImpact", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add both sides for mid price calculation
|
|
buyOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 49900.0,
|
|
Size: 10.0,
|
|
User: "buyer1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
sellOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 50100.0,
|
|
Size: 10.0,
|
|
User: "seller1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.AddOrder(buyOrder)
|
|
book.AddOrder(sellOrder)
|
|
|
|
impact, err := book.GetMarketImpact(Buy, 5.0)
|
|
// May or may not succeed depending on implementation
|
|
_ = impact
|
|
_ = err
|
|
})
|
|
|
|
t.Run("SellSideImpact", func(t *testing.T) {
|
|
book := NewExtendedOrderBook("BTC-USDT")
|
|
|
|
// Add both sides
|
|
buyOrder := &Order{
|
|
ID: 1,
|
|
Type: Limit,
|
|
Side: Buy,
|
|
Price: 49900.0,
|
|
Size: 10.0,
|
|
User: "buyer1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
sellOrder := &Order{
|
|
ID: 2,
|
|
Type: Limit,
|
|
Side: Sell,
|
|
Price: 50100.0,
|
|
Size: 10.0,
|
|
User: "seller1",
|
|
Timestamp: time.Now(),
|
|
}
|
|
book.AddOrder(buyOrder)
|
|
book.AddOrder(sellOrder)
|
|
|
|
impact, err := book.GetMarketImpact(Sell, 5.0)
|
|
// For sell side, impact should be negative (selling pushes price down)
|
|
_ = impact
|
|
_ = err
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Tests for Oracle.GetVWAP - Coverage target: ensure complete coverage
|
|
// ============================================================================
|
|
|
|
func TestOracleGetVWAP_Extended(t *testing.T) {
|
|
t.Run("ExistingVWAPMatch", func(t *testing.T) {
|
|
oracle := NewPriceOracle()
|
|
|
|
// Set up VWAP with matching window
|
|
oracle.VWAP["BTC-USDT"] = &VWAPData{
|
|
Symbol: "BTC-USDT",
|
|
Price: 50100.0,
|
|
Window: 5 * time.Minute,
|
|
}
|
|
|
|
vwap := oracle.GetVWAP("BTC-USDT", 5*time.Minute)
|
|
assert.Equal(t, 50100.0, vwap)
|
|
})
|
|
|
|
t.Run("ExistingVWAPNoMatch", func(t *testing.T) {
|
|
oracle := NewPriceOracle()
|
|
|
|
// Set up VWAP with different window
|
|
oracle.VWAP["BTC-USDT"] = &VWAPData{
|
|
Symbol: "BTC-USDT",
|
|
Price: 50100.0,
|
|
Window: 10 * time.Minute, // Different window
|
|
}
|
|
|
|
// Should calculate new VWAP
|
|
vwap := oracle.GetVWAP("BTC-USDT", 5*time.Minute)
|
|
// Will be 0 if no history
|
|
assert.GreaterOrEqual(t, vwap, 0.0)
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Additional concurrent tests for coverage
|
|
// ============================================================================
|
|
|
|
func TestConcurrentOperations(t *testing.T) {
|
|
t.Run("ConcurrentFundingEngineOperations", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
// Concurrent reads
|
|
for i := 0; i < 10; i++ {
|
|
wg.Add(1)
|
|
go func(symbol string) {
|
|
defer wg.Done()
|
|
_ = engine.GetCurrentFundingRate(symbol)
|
|
_ = engine.GetPredictedFundingRate(symbol)
|
|
_ = engine.GetFundingHistory(symbol, 10)
|
|
}("BTC-PERP")
|
|
}
|
|
|
|
wg.Wait()
|
|
})
|
|
|
|
t.Run("ConcurrentAlpacaCache", func(t *testing.T) {
|
|
source := NewAlpacaSource("test", "test")
|
|
|
|
var wg sync.WaitGroup
|
|
|
|
// Concurrent cache operations
|
|
for i := 0; i < 100; i++ {
|
|
wg.Add(2)
|
|
go func(i int) {
|
|
defer wg.Done()
|
|
source.cache.Store("AAPL", float64(150+i))
|
|
}(i)
|
|
go func() {
|
|
defer wg.Done()
|
|
source.cache.Load("AAPL")
|
|
}()
|
|
}
|
|
|
|
wg.Wait()
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Mock HTTP handler for testing error cases
|
|
// ============================================================================
|
|
|
|
func TestHTTPErrorCases(t *testing.T) {
|
|
t.Run("AlpacaTimeout", func(t *testing.T) {
|
|
// Create slow server
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
time.Sleep(200 * time.Millisecond) // Longer than client timeout
|
|
}))
|
|
defer server.Close()
|
|
|
|
source := NewAlpacaSource("test-key", "test-secret")
|
|
source.baseURL = server.URL
|
|
source.client = &http.Client{Timeout: 10 * time.Millisecond}
|
|
|
|
_, err := source.GetLatestPrice("AAPL")
|
|
assert.Error(t, err) // Should timeout
|
|
})
|
|
|
|
t.Run("PythInvalidResponse", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}))
|
|
defer server.Close()
|
|
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", server.URL)
|
|
source.priceIDs["BTC-USD"] = "test-id"
|
|
|
|
_, err := source.fetchPriceHTTP("BTC-USD")
|
|
assert.Error(t, err)
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Helper tests for edge cases
|
|
// ============================================================================
|
|
|
|
func TestEdgeCases(t *testing.T) {
|
|
t.Run("FundingEngine_ClampRate", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
// Test clamping
|
|
clamped := engine.clampRate(0.01) // Above max
|
|
assert.LessOrEqual(t, clamped, config.MaxFundingRate)
|
|
|
|
clamped = engine.clampRate(-0.01) // Below min
|
|
assert.GreaterOrEqual(t, clamped, config.MinFundingRate)
|
|
|
|
clamped = engine.clampRate(0.0001) // Within range
|
|
assert.Equal(t, 0.0001, clamped)
|
|
})
|
|
|
|
t.Run("FundingEngine_AddToHistory", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
// Add multiple rates to test history limit
|
|
for i := 0; i < 100; i++ {
|
|
rate := &FundingRate{
|
|
Symbol: "BTC-PERP",
|
|
Rate: 0.0001 * float64(i),
|
|
Timestamp: time.Now(),
|
|
}
|
|
engine.addToHistory("BTC-PERP", rate)
|
|
}
|
|
|
|
history := engine.GetFundingHistory("BTC-PERP", 100)
|
|
assert.NotNil(t, history)
|
|
assert.LessOrEqual(t, len(history), 90) // Max history is 90 periods (30 days)
|
|
})
|
|
|
|
t.Run("FundingEngine_GetNextFundingTime", func(t *testing.T) {
|
|
marginEngine := NewMarginEngine(nil, nil)
|
|
riskEngine := NewRiskEngine()
|
|
ch := NewClearingHouse(marginEngine, riskEngine)
|
|
|
|
config := DefaultFundingConfig()
|
|
engine := NewFundingEngine(ch, config)
|
|
|
|
// Test from different times
|
|
testTime := time.Date(2024, 1, 1, 10, 0, 0, 0, time.UTC)
|
|
nextTime := engine.getNextFundingTime(testTime)
|
|
assert.Equal(t, 16, nextTime.Hour())
|
|
|
|
// Test late in the day
|
|
lateTime := time.Date(2024, 1, 1, 20, 0, 0, 0, time.UTC)
|
|
nextTime = engine.getNextFundingTime(lateTime)
|
|
assert.Equal(t, 0, nextTime.Hour()) // Should be 00:00 next day
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// PythPriceSource handleMessage tests
|
|
// ============================================================================
|
|
|
|
func TestPythHandleMessage(t *testing.T) {
|
|
t.Run("HeartbeatMessage", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
msg := map[string]interface{}{
|
|
"type": "heartbeat",
|
|
}
|
|
|
|
source.handleMessage(msg)
|
|
|
|
source.mu.RLock()
|
|
assert.False(t, source.lastHeartbeat.IsZero())
|
|
source.mu.RUnlock()
|
|
})
|
|
|
|
t.Run("UnknownMessageType", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
msg := map[string]interface{}{
|
|
"type": "unknown_type",
|
|
}
|
|
|
|
// Should not panic
|
|
source.handleMessage(msg)
|
|
})
|
|
|
|
t.Run("MissingType", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
msg := map[string]interface{}{
|
|
"data": "some data",
|
|
}
|
|
|
|
// Should not panic
|
|
source.handleMessage(msg)
|
|
})
|
|
}
|
|
|
|
// ============================================================================
|
|
// Pyth context cancellation
|
|
// ============================================================================
|
|
|
|
func TestPythContextCancellation(t *testing.T) {
|
|
t.Run("CancelledContext", func(t *testing.T) {
|
|
source := NewPythPriceSource("wss://test.pyth.network/ws", "https://test.pyth.network")
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel() // Cancel immediately
|
|
|
|
// The internal methods should handle context properly
|
|
// This tests that operations don't hang on cancelled context
|
|
_ = ctx
|
|
_ = source
|
|
})
|
|
}
|