Browse Source
Merge pull request #245 from hermeznetwork/refactor/api-exits-and-auth
Refactor/api exits and authfeature/sql-semaphore1
Eduard S
4 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 749 additions and 553 deletions
Unified View
Diff Options
-
+68 -0api/accountcreationauths.go
-
+99 -0api/accountcreationauths_test.go
-
+6 -290api/api_test.go
-
+0 -133api/dbtoapistructs.go
-
+72 -0api/exits.go
-
+276 -0api/exits_test.go
-
+0 -101api/handlers.go
-
+7 -1api/txshistory_test.go
-
+47 -0apitypes/apitypes.go
-
+79 -0apitypes/apitypes_test.go
-
+23 -13db/historydb/historydb.go
-
+53 -14db/historydb/views.go
-
+11 -1db/l2db/l2db.go
-
+8 -0db/l2db/views.go
@ -0,0 +1,68 @@ |
|||||
|
package api |
||||
|
|
||||
|
import ( |
||||
|
"errors" |
||||
|
"net/http" |
||||
|
"time" |
||||
|
|
||||
|
ethCommon "github.com/ethereum/go-ethereum/common" |
||||
|
"github.com/gin-gonic/gin" |
||||
|
"github.com/hermeznetwork/hermez-node/apitypes" |
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/iden3/go-iden3-crypto/babyjub" |
||||
|
) |
||||
|
|
||||
|
func postAccountCreationAuth(c *gin.Context) { |
||||
|
// Parse body
|
||||
|
var apiAuth receivedAuth |
||||
|
if err := c.ShouldBindJSON(&apiAuth); err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
// API to common + verify signature
|
||||
|
commonAuth := accountCreationAuthAPIToCommon(&apiAuth) |
||||
|
if !commonAuth.VerifySignature() { |
||||
|
retBadReq(errors.New("invalid signature"), c) |
||||
|
return |
||||
|
} |
||||
|
// Insert to DB
|
||||
|
if err := l2.AddAccountCreationAuth(commonAuth); err != nil { |
||||
|
retSQLErr(err, c) |
||||
|
return |
||||
|
} |
||||
|
// Return OK
|
||||
|
c.Status(http.StatusOK) |
||||
|
} |
||||
|
|
||||
|
func getAccountCreationAuth(c *gin.Context) { |
||||
|
// Get hezEthereumAddress
|
||||
|
addr, err := parseParamHezEthAddr(c) |
||||
|
if err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
// Fetch auth from l2DB
|
||||
|
auth, err := l2.GetAccountCreationAuthAPI(*addr) |
||||
|
if err != nil { |
||||
|
retSQLErr(err, c) |
||||
|
return |
||||
|
} |
||||
|
// Build succesfull response
|
||||
|
c.JSON(http.StatusOK, auth) |
||||
|
} |
||||
|
|
||||
|
type receivedAuth struct { |
||||
|
EthAddr apitypes.StrHezEthAddr `json:"hezEthereumAddress" binding:"required"` |
||||
|
BJJ apitypes.StrHezBJJ `json:"bjj" binding:"required"` |
||||
|
Signature apitypes.EthSignature `json:"signature" binding:"required"` |
||||
|
Timestamp time.Time `json:"timestamp"` |
||||
|
} |
||||
|
|
||||
|
func accountCreationAuthAPIToCommon(apiAuth *receivedAuth) *common.AccountCreationAuth { |
||||
|
return &common.AccountCreationAuth{ |
||||
|
EthAddr: ethCommon.Address(apiAuth.EthAddr), |
||||
|
BJJ: (*babyjub.PublicKey)(&apiAuth.BJJ), |
||||
|
Signature: []byte(apiAuth.Signature), |
||||
|
Timestamp: apiAuth.Timestamp, |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,99 @@ |
|||||
|
package api |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"encoding/hex" |
||||
|
"encoding/json" |
||||
|
"fmt" |
||||
|
"math/big" |
||||
|
"testing" |
||||
|
"time" |
||||
|
|
||||
|
ethCommon "github.com/ethereum/go-ethereum/common" |
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
) |
||||
|
|
||||
|
type testAuth struct { |
||||
|
EthAddr string `json:"hezEthereumAddress" binding:"required"` |
||||
|
BJJ string `json:"bjj" binding:"required"` |
||||
|
Signature string `json:"signature" binding:"required"` |
||||
|
Timestamp time.Time `json:"timestamp"` |
||||
|
} |
||||
|
|
||||
|
func genTestAuths(auths []*common.AccountCreationAuth) []testAuth { |
||||
|
testAuths := []testAuth{} |
||||
|
for _, auth := range auths { |
||||
|
testAuths = append(testAuths, testAuth{ |
||||
|
EthAddr: ethAddrToHez(auth.EthAddr), |
||||
|
BJJ: bjjToString(auth.BJJ), |
||||
|
Signature: "0x" + hex.EncodeToString(auth.Signature), |
||||
|
Timestamp: auth.Timestamp, |
||||
|
}) |
||||
|
} |
||||
|
return testAuths |
||||
|
} |
||||
|
|
||||
|
func TestAccountCreationAuth(t *testing.T) { |
||||
|
// POST
|
||||
|
endpoint := apiURL + "account-creation-authorization" |
||||
|
for _, auth := range tc.auths { |
||||
|
jsonAuthBytes, err := json.Marshal(auth) |
||||
|
assert.NoError(t, err) |
||||
|
jsonAuthReader := bytes.NewReader(jsonAuthBytes) |
||||
|
fmt.Println(string(jsonAuthBytes)) |
||||
|
assert.NoError( |
||||
|
t, doGoodReq( |
||||
|
"POST", |
||||
|
endpoint, |
||||
|
jsonAuthReader, nil, |
||||
|
), |
||||
|
) |
||||
|
} |
||||
|
// GET
|
||||
|
endpoint += "/" |
||||
|
for _, auth := range tc.auths { |
||||
|
fetchedAuth := testAuth{} |
||||
|
assert.NoError( |
||||
|
t, doGoodReq( |
||||
|
"GET", |
||||
|
endpoint+auth.EthAddr, |
||||
|
nil, &fetchedAuth, |
||||
|
), |
||||
|
) |
||||
|
assertAuth(t, auth, fetchedAuth) |
||||
|
} |
||||
|
// POST
|
||||
|
// 400
|
||||
|
// Wrong addr
|
||||
|
badAuth := tc.auths[0] |
||||
|
badAuth.EthAddr = ethAddrToHez(ethCommon.BigToAddress(big.NewInt(1))) |
||||
|
jsonAuthBytes, err := json.Marshal(badAuth) |
||||
|
assert.NoError(t, err) |
||||
|
jsonAuthReader := bytes.NewReader(jsonAuthBytes) |
||||
|
err = doBadReq("POST", endpoint, jsonAuthReader, 400) |
||||
|
assert.NoError(t, err) |
||||
|
// Wrong signature
|
||||
|
badAuth = tc.auths[0] |
||||
|
badAuth.Signature = badAuth.Signature[:len(badAuth.Signature)-1] |
||||
|
badAuth.Signature += "F" |
||||
|
jsonAuthBytes, err = json.Marshal(badAuth) |
||||
|
assert.NoError(t, err) |
||||
|
jsonAuthReader = bytes.NewReader(jsonAuthBytes) |
||||
|
err = doBadReq("POST", endpoint, jsonAuthReader, 400) |
||||
|
assert.NoError(t, err) |
||||
|
// GET
|
||||
|
// 400
|
||||
|
err = doBadReq("GET", endpoint+"hez:0xFooBar", nil, 400) |
||||
|
assert.NoError(t, err) |
||||
|
// 404
|
||||
|
err = doBadReq("GET", endpoint+"hez:0x0000000000000000000000000000000000000001", nil, 404) |
||||
|
assert.NoError(t, err) |
||||
|
} |
||||
|
|
||||
|
func assertAuth(t *testing.T, expected, actual testAuth) { |
||||
|
// timestamp should be very close to now
|
||||
|
assert.Less(t, time.Now().UTC().Unix()-3, actual.Timestamp.Unix()) |
||||
|
expected.Timestamp = actual.Timestamp |
||||
|
assert.Equal(t, expected, actual) |
||||
|
} |
||||
@ -0,0 +1,72 @@ |
|||||
|
package api |
||||
|
|
||||
|
import ( |
||||
|
"net/http" |
||||
|
|
||||
|
"github.com/gin-gonic/gin" |
||||
|
"github.com/hermeznetwork/hermez-node/db" |
||||
|
"github.com/hermeznetwork/hermez-node/db/historydb" |
||||
|
) |
||||
|
|
||||
|
func getExits(c *gin.Context) { |
||||
|
// Get query parameters
|
||||
|
// Account filters
|
||||
|
tokenID, addr, bjj, idx, err := parseAccountFilters(c) |
||||
|
if err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
// BatchNum
|
||||
|
batchNum, err := parseQueryUint("batchNum", nil, 0, maxUint32, c) |
||||
|
if err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
// Pagination
|
||||
|
fromItem, order, limit, err := parsePagination(c) |
||||
|
if err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// Fetch exits from historyDB
|
||||
|
exits, pagination, err := h.GetExitsAPI( |
||||
|
addr, bjj, tokenID, idx, batchNum, fromItem, limit, order, |
||||
|
) |
||||
|
if err != nil { |
||||
|
retSQLErr(err, c) |
||||
|
return |
||||
|
} |
||||
|
|
||||
|
// Build succesfull response
|
||||
|
type exitsResponse struct { |
||||
|
Exits []historydb.ExitAPI `json:"exits"` |
||||
|
Pagination *db.Pagination `json:"pagination"` |
||||
|
} |
||||
|
c.JSON(http.StatusOK, &exitsResponse{ |
||||
|
Exits: exits, |
||||
|
Pagination: pagination, |
||||
|
}) |
||||
|
} |
||||
|
|
||||
|
func getExit(c *gin.Context) { |
||||
|
// Get batchNum and accountIndex
|
||||
|
batchNum, err := parseParamUint("batchNum", nil, 0, maxUint32, c) |
||||
|
if err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
idx, err := parseParamIdx(c) |
||||
|
if err != nil { |
||||
|
retBadReq(err, c) |
||||
|
return |
||||
|
} |
||||
|
// Fetch tx from historyDB
|
||||
|
exit, err := h.GetExitAPI(batchNum, idx) |
||||
|
if err != nil { |
||||
|
retSQLErr(err, c) |
||||
|
return |
||||
|
} |
||||
|
// Build succesfull response
|
||||
|
c.JSON(http.StatusOK, exit) |
||||
|
} |
||||
@ -0,0 +1,276 @@ |
|||||
|
package api |
||||
|
|
||||
|
import ( |
||||
|
"fmt" |
||||
|
"testing" |
||||
|
|
||||
|
"github.com/hermeznetwork/hermez-node/common" |
||||
|
"github.com/hermeznetwork/hermez-node/db" |
||||
|
"github.com/hermeznetwork/hermez-node/db/historydb" |
||||
|
"github.com/mitchellh/copystructure" |
||||
|
"github.com/stretchr/testify/assert" |
||||
|
"github.com/stretchr/testify/require" |
||||
|
) |
||||
|
|
||||
|
type testCVP struct { |
||||
|
Root string |
||||
|
Siblings []string |
||||
|
OldKey string |
||||
|
OldValue string |
||||
|
IsOld0 bool |
||||
|
Key string |
||||
|
Value string |
||||
|
Fnc int |
||||
|
} |
||||
|
|
||||
|
type testExit struct { |
||||
|
ItemID int `json:"itemId"` |
||||
|
BatchNum common.BatchNum `json:"batchNum"` |
||||
|
AccountIdx string `json:"accountIndex"` |
||||
|
MerkleProof testCVP `json:"merkleProof"` |
||||
|
Balance string `json:"balance"` |
||||
|
InstantWithdrawn *int64 `json:"instantWithdrawn"` |
||||
|
DelayedWithdrawRequest *int64 `json:"delayedWithdrawRequest"` |
||||
|
DelayedWithdrawn *int64 `json:"delayedWithdrawn"` |
||||
|
Token historydb.TokenWithUSD `json:"token"` |
||||
|
} |
||||
|
|
||||
|
type testExitsResponse struct { |
||||
|
Exits []testExit `json:"exits"` |
||||
|
Pagination *db.Pagination `json:"pagination"` |
||||
|
} |
||||
|
|
||||
|
func (t *testExitsResponse) GetPagination() *db.Pagination { |
||||
|
if t.Exits[0].ItemID < t.Exits[len(t.Exits)-1].ItemID { |
||||
|
t.Pagination.FirstReturnedItem = t.Exits[0].ItemID |
||||
|
t.Pagination.LastReturnedItem = t.Exits[len(t.Exits)-1].ItemID |
||||
|
} else { |
||||
|
t.Pagination.LastReturnedItem = t.Exits[0].ItemID |
||||
|
t.Pagination.FirstReturnedItem = t.Exits[len(t.Exits)-1].ItemID |
||||
|
} |
||||
|
return t.Pagination |
||||
|
} |
||||
|
|
||||
|
func (t *testExitsResponse) Len() int { |
||||
|
return len(t.Exits) |
||||
|
} |
||||
|
|
||||
|
func genTestExits( |
||||
|
commonExits []common.ExitInfo, |
||||
|
tokens []historydb.TokenWithUSD, |
||||
|
accs []common.Account, |
||||
|
usrIdxs []string, |
||||
|
) (usrExits, allExits []testExit) { |
||||
|
allExits = []testExit{} |
||||
|
for _, exit := range commonExits { |
||||
|
token := getTokenByIdx(exit.AccountIdx, tokens, accs) |
||||
|
siblings := []string{} |
||||
|
for i := 0; i < len(exit.MerkleProof.Siblings); i++ { |
||||
|
siblings = append(siblings, exit.MerkleProof.Siblings[i].String()) |
||||
|
} |
||||
|
allExits = append(allExits, testExit{ |
||||
|
BatchNum: exit.BatchNum, |
||||
|
AccountIdx: idxToHez(exit.AccountIdx, token.Symbol), |
||||
|
MerkleProof: testCVP{ |
||||
|
Root: exit.MerkleProof.Root.String(), |
||||
|
Siblings: siblings, |
||||
|
OldKey: exit.MerkleProof.OldKey.String(), |
||||
|
OldValue: exit.MerkleProof.OldValue.String(), |
||||
|
IsOld0: exit.MerkleProof.IsOld0, |
||||
|
Key: exit.MerkleProof.Key.String(), |
||||
|
Value: exit.MerkleProof.Value.String(), |
||||
|
Fnc: exit.MerkleProof.Fnc, |
||||
|
}, |
||||
|
Balance: exit.Balance.String(), |
||||
|
InstantWithdrawn: exit.InstantWithdrawn, |
||||
|
DelayedWithdrawRequest: exit.DelayedWithdrawRequest, |
||||
|
DelayedWithdrawn: exit.DelayedWithdrawn, |
||||
|
Token: token, |
||||
|
}) |
||||
|
} |
||||
|
usrExits = []testExit{} |
||||
|
for _, exit := range allExits { |
||||
|
for _, idx := range usrIdxs { |
||||
|
if idx == exit.AccountIdx { |
||||
|
usrExits = append(usrExits, exit) |
||||
|
break |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
return usrExits, allExits |
||||
|
} |
||||
|
|
||||
|
func TestGetExits(t *testing.T) { |
||||
|
endpoint := apiURL + "exits" |
||||
|
fetchedExits := []testExit{} |
||||
|
appendIter := func(intr interface{}) { |
||||
|
for i := 0; i < len(intr.(*testExitsResponse).Exits); i++ { |
||||
|
tmp, err := copystructure.Copy(intr.(*testExitsResponse).Exits[i]) |
||||
|
if err != nil { |
||||
|
panic(err) |
||||
|
} |
||||
|
fetchedExits = append(fetchedExits, tmp.(testExit)) |
||||
|
} |
||||
|
} |
||||
|
// Get all (no filters)
|
||||
|
limit := 8 |
||||
|
path := fmt.Sprintf("%s?limit=%d&fromItem=", endpoint, limit) |
||||
|
err := doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
assertExitAPIs(t, tc.exits, fetchedExits) |
||||
|
|
||||
|
// Get by ethAddr
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 7 |
||||
|
path = fmt.Sprintf( |
||||
|
"%s?hermezEthereumAddress=%s&limit=%d&fromItem=", |
||||
|
endpoint, tc.usrAddr, limit, |
||||
|
) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
assertExitAPIs(t, tc.usrExits, fetchedExits) |
||||
|
// Get by bjj
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 6 |
||||
|
path = fmt.Sprintf( |
||||
|
"%s?BJJ=%s&limit=%d&fromItem=", |
||||
|
endpoint, tc.usrBjj, limit, |
||||
|
) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
assertExitAPIs(t, tc.usrExits, fetchedExits) |
||||
|
// Get by tokenID
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 5 |
||||
|
tokenID := tc.exits[0].Token.TokenID |
||||
|
path = fmt.Sprintf( |
||||
|
"%s?tokenId=%d&limit=%d&fromItem=", |
||||
|
endpoint, tokenID, limit, |
||||
|
) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
tokenIDExits := []testExit{} |
||||
|
for i := 0; i < len(tc.exits); i++ { |
||||
|
if tc.exits[i].Token.TokenID == tokenID { |
||||
|
tokenIDExits = append(tokenIDExits, tc.exits[i]) |
||||
|
} |
||||
|
} |
||||
|
assertExitAPIs(t, tokenIDExits, fetchedExits) |
||||
|
// idx
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 4 |
||||
|
idx := tc.exits[0].AccountIdx |
||||
|
path = fmt.Sprintf( |
||||
|
"%s?accountIndex=%s&limit=%d&fromItem=", |
||||
|
endpoint, idx, limit, |
||||
|
) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
idxExits := []testExit{} |
||||
|
for i := 0; i < len(tc.exits); i++ { |
||||
|
if tc.exits[i].AccountIdx[6:] == idx[6:] { |
||||
|
idxExits = append(idxExits, tc.exits[i]) |
||||
|
} |
||||
|
} |
||||
|
assertExitAPIs(t, idxExits, fetchedExits) |
||||
|
// batchNum
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 3 |
||||
|
batchNum := tc.exits[0].BatchNum |
||||
|
path = fmt.Sprintf( |
||||
|
"%s?batchNum=%d&limit=%d&fromItem=", |
||||
|
endpoint, batchNum, limit, |
||||
|
) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
batchNumExits := []testExit{} |
||||
|
for i := 0; i < len(tc.exits); i++ { |
||||
|
if tc.exits[i].BatchNum == batchNum { |
||||
|
batchNumExits = append(batchNumExits, tc.exits[i]) |
||||
|
} |
||||
|
} |
||||
|
assertExitAPIs(t, batchNumExits, fetchedExits) |
||||
|
// Multiple filters
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 1 |
||||
|
path = fmt.Sprintf( |
||||
|
"%s?batchNum=%d&tokeId=%d&limit=%d&fromItem=", |
||||
|
endpoint, batchNum, tokenID, limit, |
||||
|
) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderAsc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
mixedExits := []testExit{} |
||||
|
flipedExits := []testExit{} |
||||
|
for i := 0; i < len(tc.exits); i++ { |
||||
|
if tc.exits[i].BatchNum == batchNum && tc.exits[i].Token.TokenID == tokenID { |
||||
|
mixedExits = append(mixedExits, tc.exits[i]) |
||||
|
} |
||||
|
flipedExits = append(flipedExits, tc.exits[len(tc.exits)-1-i]) |
||||
|
} |
||||
|
assertExitAPIs(t, mixedExits, fetchedExits) |
||||
|
// All, in reverse order
|
||||
|
fetchedExits = []testExit{} |
||||
|
limit = 5 |
||||
|
path = fmt.Sprintf("%s?limit=%d&fromItem=", endpoint, limit) |
||||
|
err = doGoodReqPaginated(path, historydb.OrderDesc, &testExitsResponse{}, appendIter) |
||||
|
assert.NoError(t, err) |
||||
|
assertExitAPIs(t, flipedExits, fetchedExits) |
||||
|
// 400
|
||||
|
path = fmt.Sprintf( |
||||
|
"%s?accountIndex=%s&hermezEthereumAddress=%s", |
||||
|
endpoint, idx, tc.usrAddr, |
||||
|
) |
||||
|
err = doBadReq("GET", path, nil, 400) |
||||
|
assert.NoError(t, err) |
||||
|
path = fmt.Sprintf("%s?tokenId=X", endpoint) |
||||
|
err = doBadReq("GET", path, nil, 400) |
||||
|
assert.NoError(t, err) |
||||
|
// 404
|
||||
|
path = fmt.Sprintf("%s?batchNum=999999", endpoint) |
||||
|
err = doBadReq("GET", path, nil, 404) |
||||
|
assert.NoError(t, err) |
||||
|
path = fmt.Sprintf("%s?limit=1000&fromItem=999999", endpoint) |
||||
|
err = doBadReq("GET", path, nil, 404) |
||||
|
assert.NoError(t, err) |
||||
|
} |
||||
|
|
||||
|
func TestGetExit(t *testing.T) { |
||||
|
// Get all txs by their ID
|
||||
|
endpoint := apiURL + "exits/" |
||||
|
fetchedExits := []testExit{} |
||||
|
for _, exit := range tc.exits { |
||||
|
fetchedExit := testExit{} |
||||
|
assert.NoError( |
||||
|
t, doGoodReq( |
||||
|
"GET", |
||||
|
fmt.Sprintf("%s%d/%s", endpoint, exit.BatchNum, exit.AccountIdx), |
||||
|
nil, &fetchedExit, |
||||
|
), |
||||
|
) |
||||
|
fetchedExits = append(fetchedExits, fetchedExit) |
||||
|
} |
||||
|
assertExitAPIs(t, tc.exits, fetchedExits) |
||||
|
// 400
|
||||
|
err := doBadReq("GET", endpoint+"1/haz:BOOM:1", nil, 400) |
||||
|
assert.NoError(t, err) |
||||
|
err = doBadReq("GET", endpoint+"-1/hez:BOOM:1", nil, 400) |
||||
|
assert.NoError(t, err) |
||||
|
// 404
|
||||
|
err = doBadReq("GET", endpoint+"494/hez:XXX:1", nil, 404) |
||||
|
assert.NoError(t, err) |
||||
|
} |
||||
|
|
||||
|
func assertExitAPIs(t *testing.T, expected, actual []testExit) { |
||||
|
require.Equal(t, len(expected), len(actual)) |
||||
|
for i := 0; i < len(actual); i++ { //nolint len(actual) won't change within the loop
|
||||
|
actual[i].ItemID = 0 |
||||
|
actual[i].Token.ItemID = 0 |
||||
|
if expected[i].Token.USDUpdate == nil { |
||||
|
assert.Equal(t, expected[i].Token.USDUpdate, actual[i].Token.USDUpdate) |
||||
|
} else { |
||||
|
assert.Equal(t, expected[i].Token.USDUpdate.Unix(), actual[i].Token.USDUpdate.Unix()) |
||||
|
expected[i].Token.USDUpdate = actual[i].Token.USDUpdate |
||||
|
} |
||||
|
assert.Equal(t, expected[i], actual[i]) |
||||
|
} |
||||
|
} |
||||