lnd.xprv/lnwire/reply_channel_range_test.go

107 lines
2.7 KiB
Go
Raw Normal View History

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())
}
})
}
}