Differential D8624 Diff 26293 src/seeder/test/p2p_messaging_tests.cpp

Changeset View

Standalone View

src/seeder/test/p2p_messaging_tests.cpp

	Show All 18 Lines
	#include <string>			#include <string>
	#include <vector>			#include <vector>

	std::ostream &operator<<(std::ostream &os, const PeerMessagingState &state) {			std::ostream &operator<<(std::ostream &os, const PeerMessagingState &state) {
	os << to_integral(state);			os << to_integral(state);
	return os;			return os;
	}			}

	class TestCSeederNode : public CSeederNode {			namespace {
				class CSeederNodeTest : public CSeederNode {
	public:			public:
	TestCSeederNode(const CService &service, std::vector<CAddress> *vAddrIn)			CSeederNodeTest(const CService &service, std::vector<CAddress> *vAddrIn)
	: CSeederNode(service, vAddrIn) {			: CSeederNode(service, vAddrIn) {}
	SelectParams(CBaseChainParams::REGTEST);
	}

	void TestProcessMessage(const std::string &strCommand, CDataStream &message,			void TestProcessMessage(const std::string &strCommand, CDataStream &message,
	PeerMessagingState expectedState) {			PeerMessagingState expectedState) {
	PeerMessagingState ret =			PeerMessagingState ret = ProcessMessage(strCommand, message);
	CSeederNode::ProcessMessage(strCommand, message);
	BOOST_CHECK_EQUAL(ret, expectedState);			BOOST_CHECK_EQUAL(ret, expectedState);
	}			}

				CDataStream getSendBuffer() { return vSend; }
	};			};
				} // namespace

	static const unsigned short SERVICE_PORT = 18444;			static const unsigned short SERVICE_PORT = 18444;

	struct SeederTestingSetup {			struct SeederTestingSetup {
	SeederTestingSetup() {			SeederTestingSetup() {
				SelectParams(CBaseChainParams::REGTEST);
	CNetAddr ip;			CNetAddr ip;
	ip.SetInternal("bitcoin.test");			ip.SetInternal("bitcoin.test");
	CService service = {ip, SERVICE_PORT};			CService service = {ip, SERVICE_PORT};
	vAddr.emplace_back(service, ServiceFlags());			vAddr.emplace_back(service, ServiceFlags());
	testNode = std::make_unique<TestCSeederNode>(service, &vAddr);			testNode = std::make_unique<CSeederNodeTest>(service, &vAddr);
	}			}

	std::vector<CAddress> vAddr;			std::vector<CAddress> vAddr;
	std::unique_ptr<TestCSeederNode> testNode;			std::unique_ptr<CSeederNodeTest> testNode;
	};			};

	BOOST_FIXTURE_TEST_SUITE(p2p_messaging_tests, SeederTestingSetup)			BOOST_FIXTURE_TEST_SUITE(p2p_messaging_tests, SeederTestingSetup)

	static CDataStream			static CDataStream
	CreateVersionMessage(int64_t now, CAddress addrTo, CAddress addrFrom,			CreateVersionMessage(int64_t now, CAddress addrTo, CAddress addrFrom,
	int32_t start_height, uint32_t nVersion,			int32_t start_height, uint32_t nVersion,
	uint64_t nonce = 0,			uint64_t nonce = 0,
	std::string user_agent = "/bitcoin-cash-seeder:0.15/") {			std::string user_agent = "/bitcoin-cash-seeder:0.15/") {
	CDataStream payload(SER_NETWORK, 0);			CDataStream payload(SER_NETWORK, 0);
	payload.SetVersion(nVersion);			payload.SetVersion(nVersion);
	ServiceFlags serviceflags = ServiceFlags(NODE_NETWORK);			ServiceFlags serviceflags = ServiceFlags(NODE_NETWORK);
	payload << nVersion << uint64_t(serviceflags) << now << addrTo << addrFrom			payload << nVersion << uint64_t(serviceflags) << now << addrTo << addrFrom
	<< nonce << user_agent << start_height;			<< nonce << user_agent << start_height;
	return payload;			return payload;
	}			}

	static const int SEEDER_INIT_VERSION = 0;			static const int SEEDER_INIT_VERSION = 0;

	BOOST_AUTO_TEST_CASE(seeder_node_version_test) {			BOOST_AUTO_TEST_CASE(process_version_msg) {
	CService serviceFrom;			CService serviceFrom;
	CAddress addrFrom(serviceFrom, ServiceFlags(NODE_NETWORK));			CAddress addrFrom(serviceFrom, ServiceFlags(NODE_NETWORK));

	CDataStream versionMessage =			CDataStream versionMessage =
	CreateVersionMessage(time(nullptr), vAddr[0], addrFrom,			CreateVersionMessage(time(nullptr), vAddr[0], addrFrom,
	GetRequireHeight(), INIT_PROTO_VERSION);			GetRequireHeight(), INIT_PROTO_VERSION);

	// Verify the version is set as the initial value			// Verify the version is set as the initial value
	BOOST_CHECK_EQUAL(testNode->CSeederNode::GetClientVersion(),			BOOST_CHECK_EQUAL(testNode->CSeederNode::GetClientVersion(),
	SEEDER_INIT_VERSION);			SEEDER_INIT_VERSION);
	testNode->TestProcessMessage(NetMsgType::VERSION, versionMessage,			testNode->TestProcessMessage(NetMsgType::VERSION, versionMessage,
	PeerMessagingState::AwaitingMessages);			PeerMessagingState::AwaitingMessages);
	// Verify the version has been updated			// Verify the version has been updated
	BOOST_CHECK_EQUAL(testNode->CSeederNode::GetClientVersion(),			BOOST_CHECK_EQUAL(testNode->CSeederNode::GetClientVersion(),
	versionMessage.GetVersion());			versionMessage.GetVersion());
	}			}

				BOOST_AUTO_TEST_CASE(process_verack_msg) {
				CDataStream verackMessage(SER_NETWORK, 0);
				verackMessage.SetVersion(INIT_PROTO_VERSION);
				testNode->TestProcessMessage(NetMsgType::VERACK, verackMessage,
				PeerMessagingState::AwaitingMessages);

				// Seeder should respond with an ADDR message
				const CMessageHeader::MessageMagic netMagic = Params().NetMagic();
				CMessageHeader header(netMagic);
				testNode->getSendBuffer() >> header;
				BOOST_CHECK(header.IsValidWithoutConfig(netMagic));
				BOOST_CHECK_EQUAL(header.GetCommand(), NetMsgType::GETADDR);
				}

	static CDataStream CreateAddrMessage(std::vector<CAddress> sendAddrs,			static CDataStream CreateAddrMessage(std::vector<CAddress> sendAddrs,
	uint32_t nVersion = INIT_PROTO_VERSION) {			uint32_t nVersion = INIT_PROTO_VERSION) {
	CDataStream payload(SER_NETWORK, 0);			CDataStream payload(SER_NETWORK, 0);
	payload.SetVersion(nVersion);			payload.SetVersion(nVersion);
	payload << sendAddrs;			payload << sendAddrs;
	return payload;			return payload;
	}			}

	BOOST_AUTO_TEST_CASE(seeder_node_addr_test) {			BOOST_AUTO_TEST_CASE(process_addr_msg) {
	// vAddrs starts with 1 entry.			// vAddrs starts with 1 entry.
	std::vector<CAddress> sendAddrs(ADDR_SOFT_CAP - 1, vAddr[0]);			std::vector<CAddress> sendAddrs(ADDR_SOFT_CAP - 1, vAddr[0]);

	// Happy path			// Happy path
	// addrs are added normally to vAddr until ADDR_SOFT_CAP is reached.			// addrs are added normally to vAddr until ADDR_SOFT_CAP is reached.
	// Add addrs up to the soft cap.			// Add addrs up to the soft cap.
	CDataStream addrMessage = CreateAddrMessage(sendAddrs);			CDataStream addrMessage = CreateAddrMessage(sendAddrs);
	BOOST_CHECK_EQUAL(1, vAddr.size());			BOOST_CHECK_EQUAL(1, vAddr.size());
	Show All 25 Lines