lnwire: patch unit tests for encoding/decoding

This commit adds unit tests for `AnnounceSignatures1`,
`AnnounceSignatures2`, and `ChannelAnnouncement1`. This further assures
all the encoding and decoding methods are behaved as expected.

Author: yyforyongyu

lnwire/announcement_signatures_2_test.go

@@ -0,0 +1,59 @@
+package lnwire
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestAnnounceSignatures2EncodeDecode tests the encode and decode methods for
+// the AnnounceSignatures2 message.
+func TestAnnounceSignatures2EncodeDecode(t *testing.T) {
+	t.Parallel()
+
+	// We'll create a raw byte stream that represents a valid
+	// AnnounceSignatures2 message. This includes the fixed-size fields and
+	// a TLV stream with both known and unknown records.
+	var rawBytes []byte
+
+	// ChannelID.
+	rawBytes = append(rawBytes, make([]byte, 32)...)
+
+	// ShortChannelID.
+	rawBytes = append(rawBytes, []byte{0, 0, 1, 0, 0, 2, 0, 3}...)
+
+	// PartialSignature.
+	rawBytes = append(rawBytes, make([]byte, 32)...)
+
+	// Extra Opaque Data.
+	rawBytes = append(rawBytes, []byte{
+		// Unknown odd-type TLV record.
+		0x3,        // type
+		0x2,        // length
+		0xab, 0xcd, // value
+	}...)
+
+	// Extra Opaque Data.
+	rawBytes = append(rawBytes, []byte{
+		// Unknown odd-type TLV record.
+		0x6f,       // type
+		0x2,        // length
+		0x79, 0x79, // value
+	}...)
+
+	// Now, create a new empty message and decode the raw bytes into it.
+	msg := &AnnounceSignatures2{}
+	r := bytes.NewReader(rawBytes)
+	err := msg.Decode(r, 0)
+	require.NoError(t, err)
+
+	// Next, encode the message back into a new byte buffer.
+	var b bytes.Buffer
+	err = msg.Encode(&b, 0)
+	require.NoError(t, err)
+
+	// The re-encoded bytes should be exactly the same as the original raw
+	// bytes.
+	require.Equal(t, rawBytes, b.Bytes())
+}

lnwire/announcement_signatures_test.go

@@ -0,0 +1,62 @@
+package lnwire
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestAnnounceSignatures1EncodeDecode tests the encode and decode methods for
+// the AnnounceSignatures1 message.
+func TestAnnounceSignatures1EncodeDecode(t *testing.T) {
+	t.Parallel()
+
+	// We'll create a raw byte stream that represents a valid
+	// AnnounceSignatures1 message. This includes the fixed-size fields and
+	// a TLV stream with both known and unknown records.
+	var rawBytes []byte
+
+	// ChannelID.
+	rawBytes = append(rawBytes, make([]byte, 32)...)
+
+	// ShortChannelID.
+	rawBytes = append(rawBytes, []byte{0, 0, 1, 0, 0, 2, 0, 3}...)
+
+	// NodeSignature.
+	rawBytes = append(rawBytes, make([]byte, 64)...)
+
+	// BitcoinSignature.
+	rawBytes = append(rawBytes, make([]byte, 64)...)
+
+	// Extra Opaque Data.
+	rawBytes = append(rawBytes, []byte{
+		// Unknown odd-type TLV record.
+		0x3,        // type
+		0x2,        // length
+		0xab, 0xcd, // value
+	}...)
+
+	// Extra Opaque Data.
+	rawBytes = append(rawBytes, []byte{
+		// Unknown odd-type TLV record.
+		0x6f,       // type
+		0x2,        // length
+		0x79, 0x79, // value
+	}...)
+
+	// Now, create a new empty message and decode the raw bytes into it.
+	msg := &AnnounceSignatures1{}
+	r := bytes.NewReader(rawBytes)
+	err := msg.Decode(r, 0)
+	require.NoError(t, err)
+
+	// Next, encode the message back into a new byte buffer.
+	var b bytes.Buffer
+	err = msg.Encode(&b, 0)
+	require.NoError(t, err)
+
+	// The re-encoded bytes should be exactly the same as the original raw
+	// bytes.
+	require.Equal(t, rawBytes, b.Bytes())
+}

lnwire/channel_announcement_test.go

@@ -0,0 +1,64 @@
+package lnwire
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// TestChannelAnnouncement1EncodeDecode asserts that a raw byte stream can be
+// decoded, then re-encoded to the same exact byte stream.
+func TestChannelAnnouncement1EncodeDecode(t *testing.T) {
+	t.Parallel()
+
+	// We'll create a raw byte stream that represents a valid
+	// ChannelAnnouncement1 message. This includes valid values for all
+	// fields and some extra opaque data to test for forward-compatibility.
+	// The exact values are not important, only that they are of the
+	// correct size.
+	var rawBytes []byte
+	rawBytes = append(rawBytes, make([]byte, 64)...) // NodeSig1
+	rawBytes = append(rawBytes, make([]byte, 64)...) // NodeSig2
+	rawBytes = append(rawBytes, make([]byte, 64)...) // BitcoinSig1
+	rawBytes = append(rawBytes, make([]byte, 64)...) // BitcoinSig2
+	rawBytes = append(rawBytes, []byte{
+		0x0, 0x1, 0x2, // Features
+	}...)
+	rawBytes = append(rawBytes, make([]byte, 32)...) // ChainHash
+	rawBytes = append(rawBytes, []byte{
+		0x0, 0x0, 0x1, // BlockHeight
+		0x0, 0x0, 0x2, // TxIndex
+		0x0, 0x3, // TxPosition
+	}...)
+	rawBytes = append(rawBytes, make([]byte, 33)...) // NodeID1
+	rawBytes = append(rawBytes, make([]byte, 33)...) // NodeID2
+	rawBytes = append(rawBytes, make([]byte, 33)...) // BitcoinKey1
+	rawBytes = append(rawBytes, make([]byte, 33)...) // BitcoinKey2
+	rawBytes = append(rawBytes, []byte{
+		// Extra Opaque Data - Unknown Record 1
+		0x6d,       // type
+		0x2,        // length
+		0xab, 0xcd, // value
+
+		// Extra Opaque Data - Unknown Record 2
+		0x6f,       // type
+		0x2,        // length
+		0x79, 0x79, // value
+	}...)
+
+	// Now, create a new empty message and decode the raw bytes into it.
+	msg := &ChannelAnnouncement1{}
+	r := bytes.NewReader(rawBytes)
+	err := msg.Decode(r, 0)
+	require.NoError(t, err)
+
+	// Next, encode the message back into a new byte buffer.
+	var b bytes.Buffer
+	err = msg.Encode(&b, 0)
+	require.NoError(t, err)
+
+	// The re-encoded bytes should be exactly the same as the original raw
+	// bytes.
+	require.Equal(t, rawBytes, b.Bytes())
+}