mirror of
https://github.com/lightningnetwork/lnd.git
synced 2024-11-19 09:53:54 +01:00
9a6bb19770
Messages: - UpdateFulfillHTLC - UpdateFee - UpdateFailMalformedHTLC - UpdateFailHTLC - UpdateAddHTLC - Shutdown - RevokeAndAck - ReplyShortChanIDsEnd - ReplyChannelRange - QueryShortChanIDs - QueryChannelRange - NodeAnnouncement - Init - GossipTimestampRange - FundingSigned - FundingLocked - FundingCreated - CommitSig - ClosingSigned - ChannelUpdate - ChannelReestablish - ChannelAnnouncement - AnnounceSignatures lnwire: update quickcheck tests, use constant for Error multi: update unit tests to pass deep equal assertions with messages In this commit, we update a series of unit tests in the code base to now pass due to the new wire message encode/decode logic. In many instances, we'll now manually set the extra bytes to an empty byte slice to avoid comparisons that fail due to one message having an empty byte slice and the other having a nil pointer.
107 lines
2.7 KiB
Go
107 lines
2.7 KiB
Go
package lnwire
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/hex"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/davecgh/go-spew/spew"
|
|
)
|
|
|
|
// TestReplyChannelRangeUnsorted tests that decoding a ReplyChannelRange request
|
|
// that contains duplicate or unsorted ids returns an ErrUnsortedSIDs failure.
|
|
func TestReplyChannelRangeUnsorted(t *testing.T) {
|
|
for _, test := range unsortedSidTests {
|
|
test := test
|
|
t.Run(test.name, func(t *testing.T) {
|
|
req := &ReplyChannelRange{
|
|
EncodingType: test.encType,
|
|
ShortChanIDs: test.sids,
|
|
noSort: true,
|
|
}
|
|
|
|
var b bytes.Buffer
|
|
err := req.Encode(&b, 0)
|
|
if err != nil {
|
|
t.Fatalf("unable to encode req: %v", err)
|
|
}
|
|
|
|
var req2 ReplyChannelRange
|
|
err = req2.Decode(bytes.NewReader(b.Bytes()), 0)
|
|
if _, ok := err.(ErrUnsortedSIDs); !ok {
|
|
t.Fatalf("expected ErrUnsortedSIDs, got: %v",
|
|
err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestReplyChannelRangeEmpty tests encoding and decoding a ReplyChannelRange
|
|
// that doesn't contain any channel results.
|
|
func TestReplyChannelRangeEmpty(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
emptyChannelsTests := []struct {
|
|
name string
|
|
encType ShortChanIDEncoding
|
|
encodedHex string
|
|
}{
|
|
{
|
|
name: "empty plain encoding",
|
|
encType: EncodingSortedPlain,
|
|
encodedHex: "000000000000000000000000000000000000000" +
|
|
"00000000000000000000000000000000100000002" +
|
|
"01000100",
|
|
},
|
|
{
|
|
name: "empty zlib encoding",
|
|
encType: EncodingSortedZlib,
|
|
encodedHex: "00000000000000000000000000000000000000" +
|
|
"0000000000000000000000000000000001000000" +
|
|
"0201000101",
|
|
},
|
|
}
|
|
|
|
for _, test := range emptyChannelsTests {
|
|
test := test
|
|
t.Run(test.name, func(t *testing.T) {
|
|
req := ReplyChannelRange{
|
|
FirstBlockHeight: 1,
|
|
NumBlocks: 2,
|
|
Complete: 1,
|
|
EncodingType: test.encType,
|
|
ShortChanIDs: nil,
|
|
ExtraData: make([]byte, 0),
|
|
}
|
|
|
|
// First decode the hex string in the test case into a
|
|
// new ReplyChannelRange message. It should be
|
|
// identical to the one created above.
|
|
var req2 ReplyChannelRange
|
|
b, _ := hex.DecodeString(test.encodedHex)
|
|
err := req2.Decode(bytes.NewReader(b), 0)
|
|
if err != nil {
|
|
t.Fatalf("unable to decode req: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(req, req2) {
|
|
t.Fatalf("requests don't match: expected %v got %v",
|
|
spew.Sdump(req), spew.Sdump(req2))
|
|
}
|
|
|
|
// Next, we go in the reverse direction: encode the
|
|
// request created above, and assert that it matches
|
|
// the raw byte encoding.
|
|
var b2 bytes.Buffer
|
|
err = req.Encode(&b2, 0)
|
|
if err != nil {
|
|
t.Fatalf("unable to encode req: %v", err)
|
|
}
|
|
if !bytes.Equal(b, b2.Bytes()) {
|
|
t.Fatalf("encoded requests don't match: expected %x got %x",
|
|
b, b2.Bytes())
|
|
}
|
|
})
|
|
}
|
|
}
|