decred.org/dcrdex@v1.0.5/server/db/driver/pg/orders_test.go (about)

     1  //go:build !pgonline
     2  
     3  // This code is available on the terms of the project LICENSE.md file,
     4  // also available online at https://blueoakcouncil.org/license/1.0.0.
     5  
     6  package pg
     7  
     8  import (
     9  	"database/sql"
    10  	"database/sql/driver"
    11  	"fmt"
    12  	"os"
    13  	"regexp"
    14  	"testing"
    15  
    16  	"decred.org/dcrdex/dex"
    17  	"decred.org/dcrdex/dex/order"
    18  )
    19  
    20  func TestMain(m *testing.M) {
    21  	startLogger()
    22  
    23  	mktInfo, err := dex.NewMarketInfoFromSymbols("dcr", "btc", LotSize, RateStep, EpochDuration, 0, MarketBuyBuffer)
    24  	if err != nil {
    25  		fmt.Println(err)
    26  		os.Exit(1)
    27  	}
    28  
    29  	AssetDCR = mktInfo.Base
    30  	AssetBTC = mktInfo.Quote
    31  
    32  	sql.Register("stub", &dbStub{})
    33  
    34  	os.Exit(m.Run())
    35  }
    36  
    37  // driver.Driver
    38  type dbStub struct{}
    39  
    40  var _ driver.Driver = (*dbStub)(nil)
    41  
    42  func (db *dbStub) Open(name string) (driver.Conn, error) {
    43  	return &dbStubConn{}, nil
    44  }
    45  
    46  // driver.Conn
    47  type dbStubConn struct{}
    48  
    49  var _ driver.Conn = (*dbStubConn)(nil)
    50  
    51  func (dbc *dbStubConn) Prepare(query string) (driver.Stmt, error) {
    52  	re := regexp.MustCompile(`\$\d+`)
    53  	matches := re.FindAllStringIndex(query, -1)
    54  	return &dbStubStmt{len(matches)}, nil
    55  }
    56  func (dbc *dbStubConn) Close() error              { return nil }
    57  func (dbc *dbStubConn) Begin() (driver.Tx, error) { return &dbStubTx{}, nil }
    58  
    59  // driver.Tx
    60  type dbStubTx struct{}
    61  
    62  var _ driver.Tx = (*dbStubTx)(nil)
    63  
    64  func (dbt *dbStubTx) Commit() error   { return nil }
    65  func (dbt *dbStubTx) Rollback() error { return nil }
    66  
    67  // driver.Stmt
    68  type dbStubStmt struct {
    69  	numPlaceholders int
    70  }
    71  
    72  var _ driver.Stmt = (*dbStubStmt)(nil)
    73  
    74  func (dbs *dbStubStmt) Close() error  { return nil }
    75  func (dbs *dbStubStmt) NumInput() int { return dbs.numPlaceholders }
    76  func (dbs *dbStubStmt) Exec(args []driver.Value) (driver.Result, error) {
    77  	return &dbStubResult{args}, nil
    78  }
    79  func (dbs *dbStubStmt) Query(args []driver.Value) (driver.Rows, error) {
    80  	return &dbStubRows{}, nil
    81  }
    82  
    83  // driver.Rows
    84  type dbStubRows struct{}
    85  
    86  var _ driver.Rows = (*dbStubRows)(nil)
    87  
    88  func (dbr *dbStubRows) Columns() []string {
    89  	return nil
    90  }
    91  func (dbr *dbStubRows) Close() error                   { return nil }
    92  func (dbr *dbStubRows) Next(dest []driver.Value) error { return nil }
    93  
    94  // driver.Result
    95  type dbStubResult struct {
    96  	values []driver.Value
    97  }
    98  
    99  var _ driver.Result = (*dbStubResult)(nil)
   100  
   101  func (dbs *dbStubResult) LastInsertId() (int64, error) {
   102  	return 0, nil
   103  }
   104  func (dbs *dbStubResult) RowsAffected() (int64, error) {
   105  	return 1, nil
   106  }
   107  
   108  // Values is not required for driver.Result
   109  func (dbs *dbStubResult) Values() []driver.Value {
   110  	return dbs.values
   111  }
   112  
   113  // Test_storeLimitOrder simply exercises the Valuers (OrderID, AccountID,
   114  // OrderType, Commitment). Since the DB is a stub, there should never be an
   115  // error with storeLimitOrder in this test. The Valuers may be tested
   116  // independently in the order and account packages.
   117  func Test_storeLimitOrder(t *testing.T) {
   118  	stub, err := sql.Open("stub", "discardedConnectString")
   119  	if err != nil {
   120  		t.Fatal(err)
   121  	}
   122  
   123  	type args struct {
   124  		lo     *order.LimitOrder
   125  		status order.OrderStatus
   126  	}
   127  	tests := []struct {
   128  		name    string
   129  		args    args
   130  		wantErr bool
   131  	}{
   132  		{
   133  			name: "ok",
   134  			args: args{
   135  				lo:     newLimitOrder(false, 4500000, 1, order.StandingTiF, 0),
   136  				status: order.OrderStatusBooked,
   137  			},
   138  			wantErr: false,
   139  		},
   140  	}
   141  	for _, tt := range tests {
   142  		t.Run(tt.name, func(t *testing.T) {
   143  			N, err := storeLimitOrder(stub, "dcrdex", tt.args.lo, marketToPgStatus(tt.args.status), 123456, 6000)
   144  			if (err != nil) != tt.wantErr {
   145  				t.Errorf("storeLimitOrder() error = %v, wantErr %v", err, tt.wantErr)
   146  			}
   147  			if N != 1 {
   148  				t.Errorf("Expected 1 row affected, got %d", N)
   149  			}
   150  		})
   151  	}
   152  }