mirror of
https://github.com/d0zingcat/gocryptotrader.git
synced 2026-05-30 15:10:40 +00:00
db317a2447
* Added dispatch service * Added orderbook streaming capabilities * Assigned correct orderbook.base exchange name * Fixed Requested niterinos Add in cli orderbook QA tool to gctcli Add exchange orderbook streaming * Add ticker streaming support through dispatch package * Added in some more info on error returns for orderbook.go * fix linter issues * Fix some issues * Update * Fix requested * move dispatch out of exchanges folder to its own independant folder * Fix requested * change orderbook string to tickers * Limit orderbooks to 50 and made dispatch system more stateless in operation * lower cases for update/retrieve/sub exchange name * Adds in asset validation and lower case conversion on cli * Remove comment * Moved timer to a higher scope so its not constantly initialised just reset per instance and removed returning unused channel on error * Rm unused release function in dispatch.go Reset timer and bleed buffered timer chan if needed in dispatch.go Added in ticker.Stop() and timer.Stop() functions for worker routine return in dispatch.go Index aggregated bid and ask functions for orderbook.go Added in dummy slice for wsorderbook_test.go * Moved drain to above Reset so potential race would not occur in dispatch.go Fix various linter issues dispatch.go * Fix some issues * change to start/stop service, added in service state change via cli, updated logger * fix requested * Add worker amount init spawning * fix linter issues * Fix more linter issues * More fixes * Fix race issue on releasing pipe channel on a close after shutting down dispatcher system * Moved all types to dispatch_types.go && remove panic * Moved types into serperate file && improve test coverage * RM unnecessary select case for draining channel && fixed error string * Added orderbook_types file and improved code coverage * gofmt file * reinstated select cases on drain because I am silly * Remove error for drop worker * Added more test cases * not checking error issue fix * remove func causing race in test, this has required protection via an exported function * set Gemini websocket orderbook exchange name
609 lines
16 KiB
Go
609 lines
16 KiB
Go
package wsorderbook
|
|
|
|
import (
|
|
"fmt"
|
|
"math/rand"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/thrasher-corp/gocryptotrader/currency"
|
|
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
|
|
"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
|
|
)
|
|
|
|
var itemArray = [][]orderbook.Item{
|
|
{{Price: 1000, Amount: 1, ID: 1}},
|
|
{{Price: 2000, Amount: 1, ID: 2}},
|
|
{{Price: 3000, Amount: 1, ID: 3}},
|
|
{{Price: 3000, Amount: 2, ID: 4}},
|
|
{{Price: 4000, Amount: 0, ID: 6}},
|
|
{{Price: 5000, Amount: 1, ID: 5}},
|
|
}
|
|
|
|
const (
|
|
exchangeName = "exchangeTest"
|
|
)
|
|
|
|
func createSnapshot() (obl *WebsocketOrderbookLocal, curr currency.Pair, asks, bids []orderbook.Item, err error) {
|
|
var snapShot1 orderbook.Base
|
|
snapShot1.ExchangeName = exchangeName
|
|
curr = currency.NewPairFromString("BTCUSD")
|
|
asks = []orderbook.Item{
|
|
{Price: 4000, Amount: 1, ID: 6},
|
|
}
|
|
bids = []orderbook.Item{
|
|
{Price: 4000, Amount: 1, ID: 6},
|
|
}
|
|
snapShot1.Asks = asks
|
|
snapShot1.Bids = bids
|
|
snapShot1.AssetType = asset.Spot
|
|
snapShot1.Pair = curr
|
|
obl = &WebsocketOrderbookLocal{exchangeName: exchangeName}
|
|
err = obl.LoadSnapshot(&snapShot1)
|
|
return
|
|
}
|
|
|
|
// BenchmarkBufferPerformance demonstrates buffer more performant than multi
|
|
// process calls
|
|
func BenchmarkBufferPerformance(b *testing.B) {
|
|
obl, curr, asks, bids, err := createSnapshot()
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
obl.sortBuffer = true
|
|
cp := currency.NewPairFromString("BTCUSD")
|
|
// This is to ensure we do not send in zero orderbook info to our main book
|
|
// in orderbook.go, orderbooks should not be zero even after an update.
|
|
dummyItem := orderbook.Item{
|
|
Amount: 1333337,
|
|
Price: 1337.1337,
|
|
ID: 1337,
|
|
}
|
|
obl.ob[cp][asset.Spot].Bids = append(obl.ob[cp][asset.Spot].Bids, dummyItem)
|
|
update := &WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
}
|
|
for i := 0; i < b.N; i++ {
|
|
randomIndex := rand.Intn(5)
|
|
update.Asks = itemArray[randomIndex]
|
|
update.Bids = itemArray[randomIndex]
|
|
err = obl.Update(update)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// BenchmarkBufferSortingPerformance benchmark
|
|
func BenchmarkBufferSortingPerformance(b *testing.B) {
|
|
obl, curr, asks, bids, err := createSnapshot()
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
obl.sortBuffer = true
|
|
obl.bufferEnabled = true
|
|
obl.obBufferLimit = 5
|
|
update := &WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
}
|
|
for i := 0; i < b.N; i++ {
|
|
randomIndex := rand.Intn(5)
|
|
update.Asks = itemArray[randomIndex]
|
|
update.Bids = itemArray[randomIndex]
|
|
err = obl.Update(update)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// BenchmarkNoBufferPerformance demonstrates orderbook process less performant
|
|
// than buffer
|
|
func BenchmarkNoBufferPerformance(b *testing.B) {
|
|
obl, curr, asks, bids, err := createSnapshot()
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
cp := currency.NewPairFromString("BTCUSD")
|
|
// This is to ensure we do not send in zero orderbook info to our main book
|
|
// in orderbook.go, orderbooks should not be zero even after an update.
|
|
dummyItem := orderbook.Item{
|
|
Amount: 1333337,
|
|
Price: 1337.1337,
|
|
ID: 1337,
|
|
}
|
|
obl.ob[cp][asset.Spot].Bids = append(obl.ob[cp][asset.Spot].Bids, dummyItem)
|
|
update := &WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
}
|
|
for i := 0; i < b.N; i++ {
|
|
randomIndex := rand.Intn(5)
|
|
update.Asks = itemArray[randomIndex]
|
|
update.Bids = itemArray[randomIndex]
|
|
err = obl.Update(update)
|
|
if err != nil {
|
|
b.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestHittingTheBuffer logic test
|
|
func TestHittingTheBuffer(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
obl.bufferEnabled = true
|
|
obl.obBufferLimit = 5
|
|
for i := 0; i < len(itemArray); i++ {
|
|
asks := itemArray[i]
|
|
bids := itemArray[i]
|
|
err = obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Asks) != 3 {
|
|
t.Log(obl.ob[curr][asset.Spot])
|
|
t.Errorf("expected 3 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Asks))
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Bids) != 3 {
|
|
t.Errorf("expected 3 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Bids))
|
|
}
|
|
}
|
|
|
|
// TestInsertWithIDs logic test
|
|
func TestInsertWithIDs(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
obl.bufferEnabled = true
|
|
obl.updateEntriesByID = true
|
|
obl.obBufferLimit = 5
|
|
for i := 0; i < len(itemArray); i++ {
|
|
asks := itemArray[i]
|
|
bids := itemArray[i]
|
|
err = obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
Action: "insert",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Asks) != 6 {
|
|
t.Errorf("expected 6 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Asks))
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Bids) != 6 {
|
|
t.Errorf("expected 6 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Bids))
|
|
}
|
|
}
|
|
|
|
// TestSortIDs logic test
|
|
func TestSortIDs(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
obl.bufferEnabled = true
|
|
obl.sortBufferByUpdateIDs = true
|
|
obl.sortBuffer = true
|
|
obl.obBufferLimit = 5
|
|
for i := 0; i < len(itemArray); i++ {
|
|
asks := itemArray[i]
|
|
bids := itemArray[i]
|
|
err = obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateID: int64(i),
|
|
AssetType: asset.Spot,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Asks) != 3 {
|
|
t.Errorf("expected 3 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Asks))
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Bids) != 3 {
|
|
t.Errorf("expected 3 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Bids))
|
|
}
|
|
}
|
|
|
|
// TestDeleteWithIDs logic test
|
|
func TestDeleteWithIDs(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
cp := currency.NewPairFromString("BTCUSD")
|
|
// This is to ensure we do not send in zero orderbook info to our main book
|
|
// in orderbook.go, orderbooks should not be zero even after an update.
|
|
dummyItem := orderbook.Item{
|
|
Amount: 1333337,
|
|
Price: 1337.1337,
|
|
ID: 1337,
|
|
}
|
|
obl.ob[cp][asset.Spot].Bids = append(obl.ob[cp][asset.Spot].Bids, dummyItem)
|
|
obl.updateEntriesByID = true
|
|
for i := 0; i < len(itemArray); i++ {
|
|
asks := itemArray[i]
|
|
bids := itemArray[i]
|
|
err = obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
Action: "delete",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Asks) != 0 {
|
|
t.Errorf("expected 0 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Asks))
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Bids) != 1 {
|
|
t.Errorf("expected 1 entries, received: %v",
|
|
len(obl.ob[curr][asset.Spot].Bids))
|
|
}
|
|
}
|
|
|
|
// TestUpdateWithIDs logic test
|
|
func TestUpdateWithIDs(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
obl.updateEntriesByID = true
|
|
for i := 0; i < len(itemArray); i++ {
|
|
asks := itemArray[i]
|
|
bids := itemArray[i]
|
|
err = obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
Action: "update",
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Asks) != 1 {
|
|
t.Log(obl.ob[curr][asset.Spot])
|
|
t.Errorf("expected 1 entries, received: %v", len(obl.ob[curr][asset.Spot].Asks))
|
|
}
|
|
if len(obl.ob[curr][asset.Spot].Bids) != 1 {
|
|
t.Errorf("expected 1 entries, received: %v", len(obl.ob[curr][asset.Spot].Bids))
|
|
}
|
|
}
|
|
|
|
// TestOutOfOrderIDs logic test
|
|
func TestOutOfOrderIDs(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
outOFOrderIDs := []int64{2, 1, 5, 3, 4, 6, 7}
|
|
if itemArray[0][0].Price != 1000 {
|
|
t.Errorf("expected sorted price to be 3000, received: %v", itemArray[1][0].Price)
|
|
}
|
|
obl.bufferEnabled = true
|
|
obl.sortBuffer = true
|
|
obl.obBufferLimit = 5
|
|
for i := 0; i < len(itemArray); i++ {
|
|
asks := itemArray[i]
|
|
err = obl.Update(&WebsocketOrderbookUpdate{
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateID: outOFOrderIDs[i],
|
|
AssetType: asset.Spot,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
// Index 1 since index 0 is price 7000
|
|
if obl.ob[curr][asset.Spot].Asks[1].Price != 2000 {
|
|
t.Errorf("expected sorted price to be 3000, received: %v", obl.ob[curr][asset.Spot].Asks[1].Price)
|
|
}
|
|
}
|
|
|
|
// TestRunUpdateWithoutSnapshot logic test
|
|
func TestRunUpdateWithoutSnapshot(t *testing.T) {
|
|
var obl WebsocketOrderbookLocal
|
|
var snapShot1 orderbook.Base
|
|
curr := currency.NewPairFromString("BTCUSD")
|
|
asks := []orderbook.Item{
|
|
{Price: 4000, Amount: 1, ID: 8},
|
|
}
|
|
bids := []orderbook.Item{
|
|
{Price: 5999, Amount: 1, ID: 8},
|
|
{Price: 4000, Amount: 1, ID: 9},
|
|
}
|
|
snapShot1.Asks = asks
|
|
snapShot1.Bids = bids
|
|
snapShot1.AssetType = asset.Spot
|
|
snapShot1.Pair = curr
|
|
obl.exchangeName = exchangeName
|
|
err := obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: bids,
|
|
Asks: asks,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
})
|
|
if err == nil {
|
|
t.Fatal("expected an error running update with no snapshot loaded")
|
|
}
|
|
if err.Error() != "ob.Base could not be found for Exchange exchangeTest CurrencyPair: BTCUSD AssetType: spot" {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TestRunUpdateWithoutAnyUpdates logic test
|
|
func TestRunUpdateWithoutAnyUpdates(t *testing.T) {
|
|
var obl WebsocketOrderbookLocal
|
|
var snapShot1 orderbook.Base
|
|
curr := currency.NewPairFromString("BTCUSD")
|
|
snapShot1.Asks = []orderbook.Item{}
|
|
snapShot1.Bids = []orderbook.Item{}
|
|
snapShot1.AssetType = asset.Spot
|
|
snapShot1.Pair = curr
|
|
obl.exchangeName = exchangeName
|
|
err := obl.Update(&WebsocketOrderbookUpdate{
|
|
Bids: snapShot1.Asks,
|
|
Asks: snapShot1.Bids,
|
|
CurrencyPair: curr,
|
|
UpdateTime: time.Now(),
|
|
AssetType: asset.Spot,
|
|
})
|
|
if err == nil {
|
|
t.Fatal("expected an error running update with no snapshot loaded")
|
|
}
|
|
if err.Error() != fmt.Sprintf("%v cannot have bids and ask targets both nil",
|
|
exchangeName) {
|
|
t.Fatal("expected nil asks and bids error")
|
|
}
|
|
}
|
|
|
|
// TestRunSnapshotWithNoData logic test
|
|
func TestRunSnapshotWithNoData(t *testing.T) {
|
|
var obl WebsocketOrderbookLocal
|
|
var snapShot1 orderbook.Base
|
|
curr := currency.NewPairFromString("BTCUSD")
|
|
snapShot1.Asks = []orderbook.Item{}
|
|
snapShot1.Bids = []orderbook.Item{}
|
|
snapShot1.AssetType = asset.Spot
|
|
snapShot1.Pair = curr
|
|
snapShot1.ExchangeName = "test"
|
|
obl.exchangeName = "test"
|
|
err := obl.LoadSnapshot(&snapShot1)
|
|
if err == nil {
|
|
t.Fatal("expected an error loading a snapshot")
|
|
}
|
|
if err.Error() != "test snapshot ask and bids are nil" {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
// TestLoadSnapshot logic test
|
|
func TestLoadSnapshot(t *testing.T) {
|
|
var obl WebsocketOrderbookLocal
|
|
var snapShot1 orderbook.Base
|
|
snapShot1.ExchangeName = "SnapshotWithOverride"
|
|
curr := currency.NewPairFromString("BTCUSD")
|
|
asks := []orderbook.Item{
|
|
{Price: 4000, Amount: 1, ID: 8},
|
|
}
|
|
bids := []orderbook.Item{
|
|
{Price: 4000, Amount: 1, ID: 9},
|
|
}
|
|
snapShot1.Asks = asks
|
|
snapShot1.Bids = bids
|
|
snapShot1.AssetType = asset.Spot
|
|
snapShot1.Pair = curr
|
|
err := obl.LoadSnapshot(&snapShot1)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
// TestFlushCache logic test
|
|
func TestFlushCache(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if obl.ob[curr][asset.Spot] == nil {
|
|
t.Error("expected ob to have ask entries")
|
|
}
|
|
obl.FlushCache()
|
|
if obl.ob[curr][asset.Spot] != nil {
|
|
t.Error("expected ob be flushed")
|
|
}
|
|
|
|
}
|
|
|
|
// TestInsertingSnapShots logic test
|
|
func TestInsertingSnapShots(t *testing.T) {
|
|
var obl WebsocketOrderbookLocal
|
|
var snapShot1 orderbook.Base
|
|
snapShot1.ExchangeName = "WSORDERBOOKTEST1"
|
|
asks := []orderbook.Item{
|
|
{Price: 6000, Amount: 1, ID: 1},
|
|
{Price: 6001, Amount: 0.5, ID: 2},
|
|
{Price: 6002, Amount: 2, ID: 3},
|
|
{Price: 6003, Amount: 3, ID: 4},
|
|
{Price: 6004, Amount: 5, ID: 5},
|
|
{Price: 6005, Amount: 2, ID: 6},
|
|
{Price: 6006, Amount: 1.5, ID: 7},
|
|
{Price: 6007, Amount: 0.5, ID: 8},
|
|
{Price: 6008, Amount: 23, ID: 9},
|
|
{Price: 6009, Amount: 9, ID: 10},
|
|
{Price: 6010, Amount: 7, ID: 11},
|
|
}
|
|
|
|
bids := []orderbook.Item{
|
|
{Price: 5999, Amount: 1, ID: 12},
|
|
{Price: 5998, Amount: 0.5, ID: 13},
|
|
{Price: 5997, Amount: 2, ID: 14},
|
|
{Price: 5996, Amount: 3, ID: 15},
|
|
{Price: 5995, Amount: 5, ID: 16},
|
|
{Price: 5994, Amount: 2, ID: 17},
|
|
{Price: 5993, Amount: 1.5, ID: 18},
|
|
{Price: 5992, Amount: 0.5, ID: 19},
|
|
{Price: 5991, Amount: 23, ID: 20},
|
|
{Price: 5990, Amount: 9, ID: 21},
|
|
{Price: 5989, Amount: 7, ID: 22},
|
|
}
|
|
|
|
snapShot1.Asks = asks
|
|
snapShot1.Bids = bids
|
|
snapShot1.AssetType = asset.Spot
|
|
snapShot1.Pair = currency.NewPairFromString("BTCUSD")
|
|
err := obl.LoadSnapshot(&snapShot1)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var snapShot2 orderbook.Base
|
|
snapShot2.ExchangeName = "WSORDERBOOKTEST2"
|
|
asks = []orderbook.Item{
|
|
{Price: 51, Amount: 1, ID: 1},
|
|
{Price: 52, Amount: 0.5, ID: 2},
|
|
{Price: 53, Amount: 2, ID: 3},
|
|
{Price: 54, Amount: 3, ID: 4},
|
|
{Price: 55, Amount: 5, ID: 5},
|
|
{Price: 56, Amount: 2, ID: 6},
|
|
{Price: 57, Amount: 1.5, ID: 7},
|
|
{Price: 58, Amount: 0.5, ID: 8},
|
|
{Price: 59, Amount: 23, ID: 9},
|
|
{Price: 50, Amount: 9, ID: 10},
|
|
{Price: 60, Amount: 7, ID: 11},
|
|
}
|
|
|
|
bids = []orderbook.Item{
|
|
{Price: 49, Amount: 1, ID: 12},
|
|
{Price: 48, Amount: 0.5, ID: 13},
|
|
{Price: 47, Amount: 2, ID: 14},
|
|
{Price: 46, Amount: 3, ID: 15},
|
|
{Price: 45, Amount: 5, ID: 16},
|
|
{Price: 44, Amount: 2, ID: 17},
|
|
{Price: 43, Amount: 1.5, ID: 18},
|
|
{Price: 42, Amount: 0.5, ID: 19},
|
|
{Price: 41, Amount: 23, ID: 20},
|
|
{Price: 40, Amount: 9, ID: 21},
|
|
{Price: 39, Amount: 7, ID: 22},
|
|
}
|
|
|
|
snapShot2.Asks = asks
|
|
snapShot2.Bids = bids
|
|
snapShot2.AssetType = asset.Spot
|
|
snapShot2.Pair = currency.NewPairFromString("LTCUSD")
|
|
err = obl.LoadSnapshot(&snapShot2)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var snapShot3 orderbook.Base
|
|
snapShot3.ExchangeName = "WSORDERBOOKTEST3"
|
|
asks = []orderbook.Item{
|
|
{Price: 511, Amount: 1, ID: 1},
|
|
{Price: 52, Amount: 0.5, ID: 2},
|
|
{Price: 53, Amount: 2, ID: 3},
|
|
{Price: 54, Amount: 3, ID: 4},
|
|
{Price: 55, Amount: 5, ID: 5},
|
|
{Price: 56, Amount: 2, ID: 6},
|
|
{Price: 57, Amount: 1.5, ID: 7},
|
|
{Price: 58, Amount: 0.5, ID: 8},
|
|
{Price: 59, Amount: 23, ID: 9},
|
|
{Price: 50, Amount: 9, ID: 10},
|
|
{Price: 60, Amount: 7, ID: 11},
|
|
}
|
|
|
|
bids = []orderbook.Item{
|
|
{Price: 49, Amount: 1, ID: 12},
|
|
{Price: 48, Amount: 0.5, ID: 13},
|
|
{Price: 47, Amount: 2, ID: 14},
|
|
{Price: 46, Amount: 3, ID: 15},
|
|
{Price: 45, Amount: 5, ID: 16},
|
|
{Price: 44, Amount: 2, ID: 17},
|
|
{Price: 43, Amount: 1.5, ID: 18},
|
|
{Price: 42, Amount: 0.5, ID: 19},
|
|
{Price: 41, Amount: 23, ID: 20},
|
|
{Price: 40, Amount: 9, ID: 21},
|
|
{Price: 39, Amount: 7, ID: 22},
|
|
}
|
|
|
|
snapShot3.Asks = asks
|
|
snapShot3.Bids = bids
|
|
snapShot3.AssetType = "FUTURES"
|
|
snapShot3.Pair = currency.NewPairFromString("LTCUSD")
|
|
err = obl.LoadSnapshot(&snapShot3)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if obl.ob[snapShot1.Pair][snapShot1.AssetType].Asks[0] != snapShot1.Asks[0] {
|
|
t.Errorf("loaded data mismatch. Expected %v, received %v", snapShot1.Asks[0], obl.ob[snapShot1.Pair][snapShot1.AssetType].Asks[0])
|
|
}
|
|
if obl.ob[snapShot2.Pair][snapShot2.AssetType].Asks[0] != snapShot2.Asks[0] {
|
|
t.Errorf("loaded data mismatch. Expected %v, received %v", snapShot2.Asks[0], obl.ob[snapShot2.Pair][snapShot2.AssetType].Asks[0])
|
|
}
|
|
if obl.ob[snapShot3.Pair][snapShot3.AssetType].Asks[0] != snapShot3.Asks[0] {
|
|
t.Errorf("loaded data mismatch. Expected %v, received %v", snapShot3.Asks[0], obl.ob[snapShot3.Pair][snapShot3.AssetType].Asks[0])
|
|
}
|
|
}
|
|
|
|
func TestGetOrderbook(t *testing.T) {
|
|
obl, curr, _, _, err := createSnapshot()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ob := obl.GetOrderbook(curr, asset.Spot)
|
|
if obl.ob[curr][asset.Spot] != ob {
|
|
t.Error("Failed to get orderbook")
|
|
}
|
|
}
|
|
|
|
func TestSetup(t *testing.T) {
|
|
w := WebsocketOrderbookLocal{}
|
|
w.Setup(1, true, true, true, true, "hi")
|
|
if w.obBufferLimit != 1 || !w.bufferEnabled || !w.sortBuffer || !w.sortBufferByUpdateIDs || !w.updateEntriesByID || w.exchangeName != "hi" {
|
|
t.Errorf("Setup incorrectly loaded %s", w.exchangeName)
|
|
}
|
|
}
|