dex/pkg/api/jsonrpc_test.go at main

lux/dex

mirror of https://github.com/luxfi/dex.git synced 2026-09-24 00:26:31 +00:00

Files

T

zeekayandHanzo Dev 10a084c0b2 refactor(dex): fold pkg/lx into pkg/dex — one matcher, one package

The matching engine (pkg/lx, 45.5K LOC incl. tests) and the deterministic
core layered on it (pkg/dex) are one matcher spread across two packages
(dex imported lx in 12 files; lx imported neither). Fold lx into dex and
drop the "lx" name entirely — pkg/dex is now the single matcher package.

Pure rename/fold, ZERO logic change. Behavior proven identical: the merged
pkg/dex runs 457 top-level tests (431 former-lx + 26 former-dex) and 489
test funcs (468 + 21), all green — matching, batch (BatchMatchEqualsSequential,
run-to-run determinism, tile boundary), GPU/CPU parity, truncation, and CL
swap math all pass unchanged.

What moved:
- git mv all 101 pkg/lx/*.go + 1 .c into pkg/dex/ (package lx -> package dex).
- lx's swap_test.go -> swap_math_test.go (only filename collision with dex's
  existing swap_test.go).
- Rewrote imports repo-wide: 54 pkg/lx import lines removed; 42 external
  importers (api, client, consensus, dchain, dpdk, lxgpu, marketdata, test/,
  tests/) repointed to pkg/dex with lx.X -> dex.X; the 12 in-package dex files
  had lx.X -> bare X. 717 selector lines rewritten. Stale pkg/lx comment refs
  updated (pkg/lxgpu left intact).

Collisions resolved (2, both package-level vars):
- ErrNoLiquidity: lx's pool-level error (dexError, used only in swap.go, never
  referenced via qualifier) renamed ErrPoolNoLiquidity to match the existing
  ErrPool* convention; dex's router-level ErrNoLiquidity (public, has errors.Is
  tests) kept.
- priceMultiplierBig: identical after fold (both big.NewInt(PriceMultiplier));
  deduped by deleting dex's copy.

Not folded — pkg/orderbook: it is NOT the GPU seam (that is orderbook_gpu.go,
which lives in the engine and folded in here). pkg/orderbook is a zero-importer,
placeholder-cgo island whose 13 core domain identifiers (Order, OrderBook, Trade,
OrderType, OrderStatus, PriceLevel, Buy, Sell, Market, Limit, Filled,
PartiallyFilled, NewOrderBook) collide incompatibly with the engine's. Folding
it verbatim breaks the build; folding via rename reintroduces the exact parallel
duplication this fold removes. Left for owner decision (recommend deletion as
dead code) — see refactor notes.

Follow-on (separate repos, not touched): 19 files under luxfi/dex import
pkg/lx externally — lux/precompile/dex, lux/precompile-dex/dex,
lux/consensus/examples/01-simple-bridge, lux/_consensus-v12537/examples,
lux/cex/pkg/engine — repoint to pkg/dex after this lands.

Verified: CGO_ENABLED=0 GOWORK=off go build ./... clean; go vet ./... clean;
go test ./... -count=1 all green (22 ok / 0 fail).

Co-authored-by: Hanzo Dev <[email protected]>

2026-07-02 00:57:08 -07:00

270 lines

7.0 KiB

Go

Raw Permalink Blame History

 package api
 import (
 	"bytes"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"testing"
 	"time"
 	"github.com/luxfi/dex/pkg/dex"
 	"github.com/luxfi/log"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 func TestJSONRPCServer_GetBestBid(t *testing.T) {
 	// Create test orderbook
 	orderBook := dex.NewOrderBook("TEST")
 	orderBook.AddOrder(&dex.Order{
 		ID:        1,
 		Type:      dex.Limit,
 		Side:      dex.Buy,
 		Price:     100,
 		Size:      10,
 		User:      "test",
 		Timestamp: time.Now(),
 	})
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create test request
 	reqBody := `{"jsonrpc":"2.0","method":"orderbook.getBestBid","params":{},"id":1}`
 	req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusOK, w.Code)
 	var resp map[string]interface{}
 	err := json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.Equal(t, "2.0", resp["jsonrpc"])
 	assert.Equal(t, float64(100), resp["result"])
 	assert.Equal(t, float64(1), resp["id"])
 }
 func TestJSONRPCServer_GetBestAsk(t *testing.T) {
 	// Create test orderbook
 	orderBook := dex.NewOrderBook("TEST")
 	orderBook.AddOrder(&dex.Order{
 		ID:        1,
 		Type:      dex.Limit,
 		Side:      dex.Sell,
 		Price:     101,
 		Size:      10,
 		User:      "test",
 		Timestamp: time.Now(),
 	})
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create test request
 	reqBody := `{"jsonrpc":"2.0","method":"orderbook.getBestAsk","params":{},"id":2}`
 	req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusOK, w.Code)
 	var resp map[string]interface{}
 	err := json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.Equal(t, "2.0", resp["jsonrpc"])
 	assert.Equal(t, float64(101), resp["result"])
 	assert.Equal(t, float64(2), resp["id"])
 }
 func TestJSONRPCServer_GetStats(t *testing.T) {
 	// Create test orderbook with some data
 	orderBook := dex.NewOrderBook("TEST")
 	orderBook.AddOrder(&dex.Order{
 		ID:        1,
 		Type:      dex.Limit,
 		Side:      dex.Buy,
 		Price:     100,
 		Size:      10,
 		User:      "buyer",
 		Timestamp: time.Now(),
 	})
 	orderBook.AddOrder(&dex.Order{
 		ID:        2,
 		Type:      dex.Limit,
 		Side:      dex.Sell,
 		Price:     100,
 		Size:      10,
 		User:      "seller",
 		Timestamp: time.Now(),
 	})
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create test request
 	reqBody := `{"jsonrpc":"2.0","method":"orderbook.getStats","params":{},"id":3}`
 	req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusOK, w.Code)
 	var resp map[string]interface{}
 	err := json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.Equal(t, "2.0", resp["jsonrpc"])
 	assert.NotNil(t, resp["result"])
 	result := resp["result"].(map[string]interface{})
 	assert.Equal(t, "TEST", result["symbol"])
 	assert.NotNil(t, result["orders"])
 	assert.NotNil(t, result["trades"])
 }
 func TestJSONRPCServer_InvalidMethod(t *testing.T) {
 	orderBook := dex.NewOrderBook("TEST")
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create test request with invalid method
 	reqBody := `{"jsonrpc":"2.0","method":"invalid.method","params":{},"id":4}`
 	req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusOK, w.Code)
 	var resp map[string]interface{}
 	err := json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.Equal(t, "2.0", resp["jsonrpc"])
 	assert.NotNil(t, resp["error"])
 	assert.Nil(t, resp["result"])
 	errorObj := resp["error"].(map[string]interface{})
 	assert.Equal(t, float64(-32601), errorObj["code"])
 	assert.Equal(t, "Method not found", errorObj["message"])
 }
 func TestJSONRPCServer_InvalidJSON(t *testing.T) {
 	orderBook := dex.NewOrderBook("TEST")
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create test request with invalid JSON
 	reqBody := `{invalid json}`
 	req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusOK, w.Code)
 	var resp map[string]interface{}
 	err := json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.NotNil(t, resp["error"])
 	errorObj := resp["error"].(map[string]interface{})
 	assert.Equal(t, float64(-32700), errorObj["code"])
 	assert.Equal(t, "Parse error", errorObj["message"])
 }
 func TestJSONRPCServer_InvalidVersion(t *testing.T) {
 	orderBook := dex.NewOrderBook("TEST")
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create test request with wrong JSON-RPC version
 	reqBody := `{"jsonrpc":"1.0","method":"orderbook.getBestBid","params":{},"id":5}`
 	req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusOK, w.Code)
 	var resp map[string]interface{}
 	err := json.Unmarshal(w.Body.Bytes(), &resp)
 	require.NoError(t, err)
 	assert.NotNil(t, resp["error"])
 	errorObj := resp["error"].(map[string]interface{})
 	assert.Equal(t, float64(-32600), errorObj["code"])
 	assert.Equal(t, "Invalid Request", errorObj["message"])
 }
 func TestJSONRPCServer_GET_NotAllowed(t *testing.T) {
 	orderBook := dex.NewOrderBook("TEST")
 	level, _ := log.ToLevel("debug")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	// Create GET request (should be rejected)
 	req := httptest.NewRequest("GET", "/rpc", nil)
 	w := httptest.NewRecorder()
 	// Handle request
 	server.ServeHTTP(w, req)
 	// Check response
 	assert.Equal(t, http.StatusMethodNotAllowed, w.Code)
 }
 func BenchmarkJSONRPCServer_GetBestBid(b *testing.B) {
 	// Setup
 	orderBook := dex.NewOrderBook("BENCH")
 	for i := 0; i < 1000; i++ {
 		orderBook.AddOrder(&dex.Order{
 			ID:        uint64(i),
 			Type:      dex.Limit,
 			Side:      dex.Buy,
 			Price:     float64(100 - i%10),
 			Size:      10,
 			User:      "bench",
 			Timestamp: time.Now(),
 		})
 	}
 	level, _ := log.ToLevel("error")
 	logger := log.NewTestLogger(level)
 	server := NewJSONRPCServer(orderBook, logger)
 	reqBody := `{"jsonrpc":"2.0","method":"orderbook.getBestBid","params":{},"id":1}`
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
 		req := httptest.NewRequest("POST", "/rpc", bytes.NewBufferString(reqBody))
 		w := httptest.NewRecorder()
 		server.ServeHTTP(w, req)
 	}
 }

270 lines 7.0 KiB Go Raw Permalink Blame History

270 lines

7.0 KiB

Go

Raw Permalink Blame History