Differential D4436 Diff 16320 src/seeder/test/seeder_tests.cpp

Changeset View

Standalone View

src/seeder/test/seeder_tests.cpp

	// Copyright (c) 2019 The Bitcoin developers			// Copyright (c) 2019 The Bitcoin developers
	// Distributed under the MIT software license, see the accompanying			// Distributed under the MIT software license, see the accompanying
	// file COPYING or http://www.opensource.org/licenses/mit-license.php.			// file COPYING or http://www.opensource.org/licenses/mit-license.php.

	#define BOOST_TEST_MODULE Bitcoin Seeder Test Suite			#define BOOST_TEST_MODULE Bitcoin Seeder Test Suite

				#include <chainparams.h>
				#include <protocol.h>
				#include <seeder/bitcoin.h>
				#include <seeder/db.h>
				#include <serialize.h>
				#include <streams.h>
				#include <util/system.h>
				#include <version.h>

				#include <string>
				#include <vector>

				const std::function<std::string(const char *)> G_TRANSLATION_FUN = nullptr;

	#include <boost/test/unit_test.hpp>			#include <boost/test/unit_test.hpp>

	BOOST_AUTO_TEST_SUITE(seeder_tests)			BOOST_AUTO_TEST_SUITE(seeder_tests)

	BOOST_AUTO_TEST_CASE(test_stub) {			static const unsigned short SERVICE_PORT = 18444;
	BOOST_CHECK_EQUAL(true, true);			static const uint32_t VERACK_PAYLOAD = 0;
				// After the 1000th addr, the seeder will only add one more address from an addr
				// message.
				static const int VADDR_SOFT_CAP = 1000;

				static const CService CreateDummyService(std::vector<CAddress> &vAddr) {
				CNetAddr ip;
				ip.SetInternal("foo.com");
				const CService service(ip, SERVICE_PORT);
				CAddress addr(service, ServiceFlags());
				vAddr.clear();
				vAddr.push_back(addr);
				return service;
				}

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

				bool TestProcessMessage(const std::string &strCommand,
				CDataStream message) {
				return CSeederNode::ProcessMessage(strCommand, message);
				}
				};

				static CDataStream
				CreateVersionMessage(int64_t now, CAddress addrTo, CAddress addrFrom,
				int32_t start_height, uint64_t nonce = 0,
				uint16_t user_agent = 0,
				FabienUnsubmitted Not Done Inline Actions User agent is a string, not an integer Fabien: User agent is a string, not an integer
				uint32_t nVersion = INIT_PROTO_VERSION) {
				CDataStream payload(SER_NETWORK, 0);
				payload.SetVersion(nVersion);
				ServiceFlags service = ServiceFlags(NODE_NETWORK);
				payload << nVersion << uint64_t(service) << now << addrTo << addrFrom
				<< nonce << user_agent << start_height;
				return payload;
				}

				// Verack message consists of only the header with NetMsgType::VERACK as the
				// command string.
				static CDataStream CreateVerackMessage(uint32_t nVersion = INIT_PROTO_VERSION) {
				CDataStream payload(SER_NETWORK, 0);
				payload.SetVersion(nVersion);
				payload << VERACK_PAYLOAD;
				return payload;
				}

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

				BOOST_AUTO_TEST_CASE(seeder_node_version_test) {
				std::vector<CAddress> vAddr;
				const CService service = CreateDummyService(vAddr);
				TestCSeederNode testNode(service, &vAddr);

				CService serviceFrom;
				CAddress addrFrom(serviceFrom,
				ServiceFlags(NODE_NETWORK \| NODE_BITCOIN_CASH));
				CDataStream versionMessage = CreateVersionMessage(
				time(nullptr), vAddr[0], addrFrom, GetRequireHeight());

				bool ret = testNode.TestProcessMessage(NetMsgType::VERSION, versionMessage);
				BOOST_CHECK_EQUAL(ret, false);
				}

				BOOST_AUTO_TEST_CASE(seeder_node_verack_test) {
				std::vector<CAddress> vAddr;
				const CService service = CreateDummyService(vAddr);
				TestCSeederNode testNode(service, &vAddr);

				CDataStream verackMessage = CreateVerackMessage();

				bool ret = testNode.TestProcessMessage(NetMsgType::VERACK, verackMessage);
				BOOST_CHECK_EQUAL(ret, false);
				}

				BOOST_AUTO_TEST_CASE(seeder_node_addr_test_happy_path) {
				std::vector<CAddress> vAddr;
				const CService service = CreateDummyService(vAddr);
				TestCSeederNode testNode(service, &vAddr);

				CDataStream addrMessage = CreateAddrMessage(vAddr);

				bool ret = testNode.TestProcessMessage(NetMsgType::ADDR, addrMessage);
				BOOST_CHECK_EQUAL(ret, false);
				BOOST_CHECK_EQUAL(2, vAddr.size());
				}

				BOOST_AUTO_TEST_CASE(seeder_node_addr_test_soft_cap) {
				std::vector<CAddress> vAddr;
				const CService service = CreateDummyService(vAddr);
				TestCSeederNode testNode(service, &vAddr);

				// vAddr starts with 1 entry. Only need to add VADDR_SOFT_CAP - 1
				std::vector<CAddress> sendAddrs(VADDR_SOFT_CAP - 1, vAddr[0]);
				CDataStream addrMessage = CreateAddrMessage(sendAddrs);

				// Maximum number of addrs is VADDR_SOFT_CAP. All addrs are added until the
				// VADDR_SOFT_CAPth.
				BOOST_CHECK_EQUAL(1, vAddr.size());
				bool ret = testNode.TestProcessMessage(NetMsgType::ADDR, addrMessage);
				BOOST_CHECK_EQUAL(ret, false);
				BOOST_CHECK_EQUAL(VADDR_SOFT_CAP, vAddr.size());

				// After the VADDR_SOFT_CAPth, only one is added and the rest are ignored
				ret = testNode.TestProcessMessage(NetMsgType::ADDR, addrMessage);
				BOOST_CHECK_EQUAL(ret, true);
				BOOST_CHECK_EQUAL(VADDR_SOFT_CAP + 1, vAddr.size());
	}			}

	BOOST_AUTO_TEST_SUITE_END()			BOOST_AUTO_TEST_SUITE_END()