From a4978ba4c8a272c8a0dd710f5ddc797967113dba Mon Sep 17 00:00:00 2001 From: Dave Collins Date: Mon, 23 Dec 2013 23:25:17 -0600 Subject: [PATCH] Add tests for the new MsgReject message. This commit adds a full suite tests for the new reject message added in protocol version 70002 to bring the overall test coverage of btcwire back up to 100%. Closes #9. --- message_test.go | 4 +- msgreject_test.go | 384 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 386 insertions(+), 2 deletions(-) create mode 100644 msgreject_test.go diff --git a/message_test.go b/message_test.go index bfbc8e1e..567533ac 100644 --- a/message_test.go +++ b/message_test.go @@ -71,10 +71,9 @@ func TestMessage(t *testing.T) { msgFilterAdd := btcwire.NewMsgFilterAdd([]byte{0x01}) msgFilterClear := btcwire.NewMsgFilterClear() msgFilterLoad := btcwire.NewMsgFilterLoad([]byte{0x01}, 10, 0, btcwire.BloomUpdateNone) - - // bh := btcwire.NewBlockHeader(&btcwire.ShaHash{}, &btcwire.ShaHash{}, 0, 0) msgMerkleBlock := btcwire.NewMsgMerkleBlock(bh) + msgReject := btcwire.NewMsgReject("block", btcwire.RejectDuplicate, "duplicate block") tests := []struct { in btcwire.Message // Value to encode @@ -103,6 +102,7 @@ func TestMessage(t *testing.T) { {msgFilterClear, msgFilterClear, pver, btcwire.MainNet, 24}, {msgFilterLoad, msgFilterLoad, pver, btcwire.MainNet, 35}, {msgMerkleBlock, msgMerkleBlock, pver, btcwire.MainNet, 110}, + {msgReject, msgReject, pver, btcwire.MainNet, 79}, } t.Logf("Running %d tests", len(tests)) diff --git a/msgreject_test.go b/msgreject_test.go new file mode 100644 index 00000000..33d3165c --- /dev/null +++ b/msgreject_test.go @@ -0,0 +1,384 @@ +// Copyright (c) 2014 Conformal Systems LLC. +// Use of this source code is governed by an ISC +// license that can be found in the LICENSE file. + +package btcwire_test + +import ( + "bytes" + "github.com/conformal/btcwire" + "github.com/davecgh/go-spew/spew" + "io" + "reflect" + "testing" +) + +// TestRejectCodeStringer tests the stringized output for the reject code type. +func TestRejectCodeStringer(t *testing.T) { + tests := []struct { + in btcwire.RejectCode + want string + }{ + {btcwire.RejectMalformed, "REJECT_MALFORMED"}, + {btcwire.RejectInvalid, "REJECT_INVALID"}, + {btcwire.RejectObsolete, "REJECT_OBSOLETE"}, + {btcwire.RejectDuplicate, "REJECT_DUPLICATE"}, + {btcwire.RejectNonstandard, "REJECT_NONSTANDARD"}, + {btcwire.RejectDust, "REJECT_DUST"}, + {btcwire.RejectInsufficientFee, "REJECT_INSUFFICIENTFEE"}, + {btcwire.RejectCheckpoint, "REJECT_CHECKPOINT"}, + {0xff, "Unknown RejectCode (255)"}, + } + + t.Logf("Running %d tests", len(tests)) + for i, test := range tests { + result := test.in.String() + if result != test.want { + t.Errorf("String #%d\n got: %s want: %s", i, result, + test.want) + continue + } + } + +} + +// TestRejectLatest tests the MsgPong API against the latest protocol version. +func TestRejectLatest(t *testing.T) { + pver := btcwire.ProtocolVersion + + // Create reject message data. + rejCommand := (&btcwire.MsgBlock{}).Command() + rejCode := btcwire.RejectDuplicate + rejReason := "duplicate block" + rejHash := btcwire.GenesisHash + + // Ensure we get the correct data back out. + msg := btcwire.NewMsgReject(rejCommand, rejCode, rejReason) + msg.Hash = rejHash + if msg.Cmd != rejCommand { + t.Errorf("NewMsgReject: wrong rejected command - got %v, "+ + "want %v", msg.Cmd, rejCommand) + } + if msg.Code != rejCode { + t.Errorf("NewMsgReject: wrong rejected code - got %v, "+ + "want %v", msg.Code, rejCode) + } + if msg.Reason != rejReason { + t.Errorf("NewMsgReject: wrong rejected reason - got %v, "+ + "want %v", msg.Reason, rejReason) + } + + // Ensure the command is expected value. + wantCmd := "reject" + if cmd := msg.Command(); cmd != wantCmd { + t.Errorf("NewMsgReject: wrong command - got %v want %v", + cmd, wantCmd) + } + + // Ensure max payload is expected value for latest protocol version. + wantPayload := btcwire.MaxMessagePayload + maxPayload := msg.MaxPayloadLength(pver) + if maxPayload != wantPayload { + t.Errorf("MaxPayloadLength: wrong max payload length for "+ + "protocol version %d - got %v, want %v", pver, + maxPayload, wantPayload) + } + + // Test encode with latest protocol version. + var buf bytes.Buffer + err := msg.BtcEncode(&buf, pver) + if err != nil { + t.Errorf("encode of MsgReject failed %v err <%v>", msg, err) + } + + // Test decode with latest protocol version. + readMsg := btcwire.MsgReject{} + err = readMsg.BtcDecode(&buf, pver) + if err != nil { + t.Errorf("decode of MsgReject failed %v err <%v>", buf.Bytes(), + err) + } + + // Ensure decoded data is the same. + if msg.Cmd != readMsg.Cmd { + t.Errorf("Should get same reject command - got %v, want %v", + readMsg.Cmd, msg.Cmd) + } + if msg.Code != readMsg.Code { + t.Errorf("Should get same reject code - got %v, want %v", + readMsg.Code, msg.Code) + } + if msg.Reason != readMsg.Reason { + t.Errorf("Should get same reject reason - got %v, want %v", + readMsg.Reason, msg.Reason) + } + if msg.Hash != readMsg.Hash { + t.Errorf("Should get same reject hash - got %v, want %v", + readMsg.Hash, msg.Hash) + } +} + +// TestRejectBeforeAdded tests the MsgReject API against a protocol version +// before the version which introduced it (RejectVersion). +func TestRejectBeforeAdded(t *testing.T) { + // Use the protocol version just prior to RejectVersion. + pver := btcwire.RejectVersion - 1 + + // Create reject message data. + rejCommand := (&btcwire.MsgBlock{}).Command() + rejCode := btcwire.RejectDuplicate + rejReason := "duplicate block" + rejHash := btcwire.GenesisHash + + msg := btcwire.NewMsgReject(rejCommand, rejCode, rejReason) + msg.Hash = rejHash + + // Ensure max payload is expected value for old protocol version. + size := msg.MaxPayloadLength(pver) + if size != 0 { + t.Errorf("Max length should be 0 for reject protocol version %d.", + pver) + } + + // Test encode with old protocol version. + var buf bytes.Buffer + err := msg.BtcEncode(&buf, pver) + if err == nil { + t.Errorf("encode of MsgReject succeeded when it shouldn't "+ + "have %v", msg) + } + + // // Test decode with old protocol version. + readMsg := btcwire.MsgReject{} + err = readMsg.BtcDecode(&buf, pver) + if err == nil { + t.Errorf("decode of MsgReject succeeded when it shouldn't "+ + "have %v", spew.Sdump(buf.Bytes())) + } + + // Since this protocol version doesn't support reject, make sure various + // fields didn't get encoded and decoded back out. + if msg.Cmd == readMsg.Cmd { + t.Errorf("Should not get same reject command for protocol "+ + "version %d", pver) + } + if msg.Code == readMsg.Code { + t.Errorf("Should not get same reject code for protocol "+ + "version %d", pver) + } + if msg.Reason == readMsg.Reason { + t.Errorf("Should not get same reject reason for protocol "+ + "version %d", pver) + } + if msg.Hash == readMsg.Hash { + t.Errorf("Should not get same reject hash for protocol "+ + "version %d", pver) + } +} + +// TestRejectCrossProtocol tests the MsgReject API when encoding with the latest +// protocol version and decoded with a version before the version which +// introduced it (RejectVersion). +func TestRejectCrossProtocol(t *testing.T) { + // Create reject message data. + rejCommand := (&btcwire.MsgBlock{}).Command() + rejCode := btcwire.RejectDuplicate + rejReason := "duplicate block" + rejHash := btcwire.GenesisHash + + msg := btcwire.NewMsgReject(rejCommand, rejCode, rejReason) + msg.Hash = rejHash + + // Encode with latest protocol version. + var buf bytes.Buffer + err := msg.BtcEncode(&buf, btcwire.ProtocolVersion) + if err != nil { + t.Errorf("encode of MsgReject failed %v err <%v>", msg, err) + } + + // Decode with old protocol version. + readMsg := btcwire.MsgReject{} + err = readMsg.BtcDecode(&buf, btcwire.RejectVersion-1) + if err == nil { + t.Errorf("encode of MsgReject succeeded when it shouldn't "+ + "have %v", msg) + } + + // Since one of the protocol versions doesn't support the reject + // message, make sure the various fields didn't get encoded and decoded + // back out. + if msg.Cmd == readMsg.Cmd { + t.Errorf("Should not get same reject command for cross protocol") + } + if msg.Code == readMsg.Code { + t.Errorf("Should not get same reject code for cross protocol") + } + if msg.Reason == readMsg.Reason { + t.Errorf("Should not get same reject reason for cross protocol") + } + if msg.Hash == readMsg.Hash { + t.Errorf("Should not get same reject hash for cross protocol") + } +} + +// TestRejectWire tests the MsgReject wire encode and decode for various +// protocol versions. +func TestRejectWire(t *testing.T) { + tests := []struct { + msg btcwire.MsgReject // Message to encode + buf []byte // Wire encoding + pver uint32 // Protocol version for wire encoding + }{ + // Latest protocol version rejected command version (no hash). + { + btcwire.MsgReject{ + Cmd: "version", + Code: btcwire.RejectDuplicate, + Reason: "duplicate version", + }, + []byte{ + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, // "version" + 0x12, // btcwire.RejectDuplicate + 0x11, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, // "duplicate version" + }, + btcwire.ProtocolVersion, + }, + // Latest protocol version rejected command block (has hash). + { + btcwire.MsgReject{ + Cmd: "block", + Code: btcwire.RejectDuplicate, + Reason: "duplicate block", + Hash: btcwire.GenesisHash, + }, + []byte{ + 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, // "block" + 0x12, // btcwire.RejectDuplicate + 0x0f, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, // "duplicate block" + 0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, + 0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f, + 0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c, + 0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, // btcwire.GenesisHash + }, + btcwire.ProtocolVersion, + }, + } + + t.Logf("Running %d tests", len(tests)) + for i, test := range tests { + // Encode the message to wire format. + var buf bytes.Buffer + err := test.msg.BtcEncode(&buf, test.pver) + if err != nil { + t.Errorf("BtcEncode #%d error %v", i, err) + continue + } + if !bytes.Equal(buf.Bytes(), test.buf) { + t.Errorf("BtcEncode #%d\n got: %s want: %s", i, + spew.Sdump(buf.Bytes()), spew.Sdump(test.buf)) + continue + } + + // Decode the message from wire format. + var msg btcwire.MsgReject + rbuf := bytes.NewBuffer(test.buf) + err = msg.BtcDecode(rbuf, test.pver) + if err != nil { + t.Errorf("BtcDecode #%d error %v", i, err) + continue + } + if !reflect.DeepEqual(msg, test.msg) { + t.Errorf("BtcDecode #%d\n got: %s want: %s", i, + spew.Sdump(msg), spew.Sdump(test.msg)) + continue + } + } +} + +// TestRejectWireErrors performs negative tests against wire encode and decode +// of MsgReject to confirm error paths work correctly. +func TestRejectWireErrors(t *testing.T) { + pver := btcwire.ProtocolVersion + pverNoReject := btcwire.RejectVersion - 1 + btcwireErr := &btcwire.MessageError{} + + baseReject := btcwire.NewMsgReject("block", btcwire.RejectDuplicate, + "duplicate block") + baseReject.Hash = btcwire.GenesisHash + baseRejectEncoded := []byte{ + 0x05, 0x62, 0x6c, 0x6f, 0x63, 0x6b, // "block" + 0x12, // btcwire.RejectDuplicate + 0x0f, 0x64, 0x75, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x20, 0x62, 0x6c, 0x6f, 0x63, 0x6b, // "duplicate block" + 0x6f, 0xe2, 0x8c, 0x0a, 0xb6, 0xf1, 0xb3, 0x72, + 0xc1, 0xa6, 0xa2, 0x46, 0xae, 0x63, 0xf7, 0x4f, + 0x93, 0x1e, 0x83, 0x65, 0xe1, 0x5a, 0x08, 0x9c, + 0x68, 0xd6, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, // btcwire.GenesisHash + } + + tests := []struct { + in *btcwire.MsgReject // Value to encode + buf []byte // Wire encoding + pver uint32 // Protocol version for wire encoding + max int // Max size of fixed buffer to induce errors + writeErr error // Expected write error + readErr error // Expected read error + }{ + // Latest protocol version with intentional read/write errors. + // Force error in reject command. + {baseReject, baseRejectEncoded, pver, 0, io.ErrShortWrite, io.EOF}, + // Force error in reject code. + {baseReject, baseRejectEncoded, pver, 6, io.ErrShortWrite, io.EOF}, + // Force error in reject reason. + {baseReject, baseRejectEncoded, pver, 7, io.ErrShortWrite, io.EOF}, + // Force error in reject hash. + {baseReject, baseRejectEncoded, pver, 23, io.ErrShortWrite, io.EOF}, + // Force error due to unsupported protocol version. + {baseReject, baseRejectEncoded, pverNoReject, 6, btcwireErr, btcwireErr}, + } + + t.Logf("Running %d tests", len(tests)) + for i, test := range tests { + // Encode to wire format. + w := newFixedWriter(test.max) + err := test.in.BtcEncode(w, test.pver) + if reflect.TypeOf(err) != reflect.TypeOf(test.writeErr) { + t.Errorf("BtcEncode #%d wrong error got: %v, want: %v", + i, err, test.writeErr) + continue + } + + // For errors which are not of type btcwire.MessageError, check + // them for equality. + if _, ok := err.(*btcwire.MessageError); !ok { + if err != test.writeErr { + t.Errorf("BtcEncode #%d wrong error got: %v, "+ + "want: %v", i, err, test.writeErr) + continue + } + } + + // Decode from wire format. + var msg btcwire.MsgReject + r := newFixedReader(test.max, test.buf) + err = msg.BtcDecode(r, test.pver) + if reflect.TypeOf(err) != reflect.TypeOf(test.readErr) { + t.Errorf("BtcDecode #%d wrong error got: %v, want: %v", + i, err, test.readErr) + continue + } + + // For errors which are not of type btcwire.MessageError, check + // them for equality. + if _, ok := err.(*btcwire.MessageError); !ok { + if err != test.readErr { + t.Errorf("BtcDecode #%d wrong error got: %v, "+ + "want: %v", i, err, test.readErr) + continue + } + } + } +}