GlcoinCore/pool
1
0
Fork 0
mirror of https://github.com/lightninglabs/pool.git synced 2026-08-17 13:06:52 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #58 from guggero/flake-unit

Browse source 
test: fix flake in race and unit tests
This commit is contained in:
Olaoluwa Osuntokun 2020-04-09 19:31:37 -07:00 • committed by GitHub
commit da5a56b037
2 changed files with 87 additions and 52 deletions
Download patch file Download diff file Expand all files Collapse all files

14
order/batch_verifier.go
View file

@ -88,7 +88,7 @@ func (v *batchVerifier) Verify(batch *Batch) error {
// Find our order in the database.
ourOrder, err := v.orderStore.GetOrder(nonce)
if err != nil {
return fmt.Errorf("order %x not found: %v", nonce, err)
return fmt.Errorf("order %v not found: %v", nonce, err)
}
// We'll index our account tallies by the serialized form of
@ -98,7 +98,7 @@ func (v *batchVerifier) Verify(batch *Batch) error {
acctKeyRaw [33]byte
)
if acctKey == nil {
return fmt.Errorf("account for order %x invalid", nonce)
return fmt.Errorf("account for order %v invalid", nonce)
}
copy(acctKeyRaw[:], acctKey.SerializeCompressed())
@ -130,7 +130,7 @@ func (v *batchVerifier) Verify(batch *Batch) error {
)
if err != nil {
return newMismatchErr(
err, "error matching against order %x",
err, "error matching against order %v",
theirOrder.Order.Nonce(),
)
}
@ -144,7 +144,7 @@ func (v *batchVerifier) Verify(batch *Batch) error {
if err != nil {
return newMismatchErr(
err, "error finding channel output "+
"for matched order %x",
"for matched order %v",
theirOrder.Order.Nonce(),
)
}
@ -160,7 +160,7 @@ func (v *batchVerifier) Verify(batch *Batch) error {
if unitsFilled > ourOrder.Details().UnitsUnfulfilled {
return &MismatchErr{
msg: fmt.Sprintf("invalid units to be filled "+
"for order %x. currently unfulfilled "+
"for order %v. currently unfulfilled "+
"%d, matched with %d in total",
ourOrder.Nonce(),
ourOrder.Details().UnitsUnfulfilled,
@ -233,7 +233,7 @@ func (v *batchVerifier) validateMatchedOrder(tally *AccountTally,
// Order type must be opposite.
if otherOrder.Order.Type() == ourOrder.Type() {
return fmt.Errorf("order %x matched same type "+
return fmt.Errorf("order %v matched same type "+
"orders", ourOrder.Nonce())
}
@ -327,7 +327,7 @@ func (v *batchVerifier) validateChannelOutput(batchTx *wire.MsgTx,
}
return fmt.Errorf("no channel output found in batch tx for matched "+
"order %x", otherOrder.Order.Nonce())
"order %v", otherOrder.Order.Nonce())
}
// A compile-time constraint to ensure batchVerifier implements BatchVerifier.

125
order/batch_verifier_test.go
View file

@ -32,11 +32,7 @@ func TestBatchVerifier(t *testing.T) {
t.Parallel()
var (
lnd = test.NewMockLnd()
verifier = &batchVerifier{
wallet: lnd.WalletKit,
ourNodePubkey: nodePubkey,
}
lnd = test.NewMockLnd()
batchID BatchID
acctIDBig [33]byte
acctIDSmall [33]byte
@ -52,156 +48,191 @@ func TestBatchVerifier(t *testing.T) {
testCases := []struct {
name string
expectedErr string
doVerify func(*Ask, *Bid, *Bid, *Batch) error
doVerify func(BatchVerifier, *Ask, *Bid, *Bid, *Batch) error
}{
{
name: "version mismatch",
expectedErr: ErrVersionMismatch.Error(),
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
return verifier.Verify(&Batch{Version: 999})
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
return v.Verify(&Batch{Version: 999})
},
},
{
name: "invalid order",
expectedErr: "not found",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
arr := make([]*MatchedOrder, 0)
b.MatchedOrders[Nonce{99, 99}] = arr
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid order type",
expectedErr: "matched same type orders",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.MatchedOrders[a.nonce] = append(
b.MatchedOrders[a.nonce],
&MatchedOrder{
Order: a,
},
)
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid node pubkey",
expectedErr: "other order is an order from our node",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.MatchedOrders[a.nonce][0].NodeKey = nodePubkey
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "ask max duration larger than bid",
expectedErr: "duration not overlapping for our ask",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
expectedErr: "duration not overlapping",
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
a.MaxDuration = 100
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "ask fixed rate larger than bid",
expectedErr: "ask price greater than bid price",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
a.FixedRate = 20
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "bid min duration larger than ask",
expectedErr: "duration not overlapping for our bid",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
expectedErr: "duration not overlapping",
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
delete(b.MatchedOrders, a.nonce)
b2.MinDuration = 5000
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "bid fixed rate smaller than ask",
expectedErr: "ask price greater than bid price",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
delete(b.MatchedOrders, a.nonce)
b1.FixedRate = 5
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "channel output not found, wrong value",
expectedErr: "no channel output found in batch tx for",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.BatchTX.TxOut[0].Value = 123
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "channel output not found, wrong script",
expectedErr: "no channel output found in batch tx for",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.BatchTX.TxOut[0].PkScript = []byte{99, 88}
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid units filled",
expectedErr: "invalid units to be filled for order",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.BatchTX.TxOut[0].Value = 900_000
b.MatchedOrders[a.nonce][0].UnitsFilled = 9
return verifier.Verify(b)
b.MatchedOrders[b1.nonce][0].UnitsFilled = 9
return v.Verify(b)
},
},
{
name: "invalid funding TX fee rate",
expectedErr: "server sent unexpected ending balance",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.BatchTxFeeRate *= 2
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid clearing price",
expectedErr: "server sent unexpected ending balance",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.ClearingPrice *= 2
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid execution fee rate",
expectedErr: "server sent unexpected ending balance",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.ExecutionFee = NewLinearFeeSchedule(1, 1)
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid ending state",
expectedErr: "diff is incorrect: unexpected state",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.ExecutionFee = NewLinearFeeSchedule(0, 0)
b.BatchTX.TxOut[2].Value += 2220
b.AccountDiffs[0].EndingBalance += 2220
b.AccountDiffs[1].EndingBalance += 2220
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "invalid ending output",
expectedErr: "diff is incorrect: outpoint index",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
b.ExecutionFee = NewLinearFeeSchedule(0, 0)
b.BatchTX.TxOut[2].Value += 2220
b.AccountDiffs[0].EndingBalance += 2220
b.AccountDiffs[1].EndingBalance += 2220
b.AccountDiffs[1].EndingState = stateRecreated
return verifier.Verify(b)
return v.Verify(b)
},
},
{
name: "happy path",
expectedErr: "",
doVerify: func(a *Ask, b1, b2 *Bid, b *Batch) error {
return verifier.Verify(b)
doVerify: func(v BatchVerifier, a *Ask, b1, b2 *Bid,
b *Batch) error {
return v.Verify(b)
},
},
}
@ -375,8 +406,12 @@ func TestBatchVerifier(t *testing.T) {
// Create the starting database state now.
storeMock := newMockStore()
verifier.orderStore = storeMock
verifier.getAccount = storeMock.getAccount
verifier := &batchVerifier{
wallet: lnd.WalletKit,
orderStore: storeMock,
ourNodePubkey: nodePubkey,
getAccount: storeMock.getAccount,
}
storeMock.accounts = map[*btcec.PublicKey]*account.Account{
acctKeyBig: bigAcct,
acctKeySmall: smallAcct,
@ -389,7 +424,7 @@ func TestBatchVerifier(t *testing.T) {
// Finally run the test case itself.
t.Run(tc.name, func(t *testing.T) {
err := tc.doVerify(ask, bid1, bid2, batch)
err := tc.doVerify(verifier, ask, bid1, bid2, batch)
if (err == nil && tc.expectedErr != "") ||
(err != nil && !strings.Contains(
err.Error(), tc.expectedErr,