Differential D2616 Diff 7577 src/test/rpc_server_tests.cpp

Changeset View

Standalone View

src/test/rpc_server_tests.cpp

	// Copyright (c) 2018-2019 The Bitcoin developers			// Copyright (c) 2018-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.

	#include "chainparams.h"			#include "chainparams.h"
	#include "config.h"			#include "config.h"
				#include "rpc/commandwithargscontext.h"
	#include "rpc/jsonrpcrequest.h"			#include "rpc/jsonrpcrequest.h"
	#include "rpc/server.h"			#include "rpc/server.h"
	#include "util.h"			#include "util.h"

	#include "test/test_bitcoin.h"			#include "test/test_bitcoin.h"

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

	#include <string>			#include <string>

	BOOST_FIXTURE_TEST_SUITE(rpc_server_tests, TestingSetup)			BOOST_FIXTURE_TEST_SUITE(rpc_server_tests, TestingSetup)

	class ArgsTestRPCCommand : public RPCCommand {			class ArgsTestRPCCommand : public RPCCommandWithArgsContext {
	public:			public:
	ArgsTestRPCCommand(std::string nameIn) : RPCCommand(nameIn) {}			ArgsTestRPCCommand(std::string nameIn)
				: RPCCommandWithArgsContext(nameIn) {}

	UniValue Execute(const UniValue &args) const override {			UniValue Execute(const UniValue &args) const override {
	BOOST_CHECK_EQUAL(args["arg1"].get_str(), "value1");			BOOST_CHECK_EQUAL(args["arg1"].get_str(), "value1");
	return UniValue("testing");			return UniValue("testing1");
	}			}
	};			};

	static bool isRpcMethodNotFound(const UniValue &u) {			static bool isRpcMethodNotFound(const UniValue &u) {
	return find_value(u, "code").get_int() == int(RPC_METHOD_NOT_FOUND);			return find_value(u, "code").get_int() == int(RPC_METHOD_NOT_FOUND);
	}			}

	BOOST_AUTO_TEST_CASE(rpc_server_execute_command) {			BOOST_AUTO_TEST_CASE(rpc_server_execute_command) {
	DummyConfig config;			DummyConfig config;
	RPCServer rpcServer;			RPCServer rpcServer;
	const std::string commandName = "testcommand";			const std::string commandName = "testcommand1";
	rpcServer.RegisterCommand(MakeUnique<ArgsTestRPCCommand>(commandName));			rpcServer.RegisterCommand(MakeUnique<ArgsTestRPCCommand>(commandName));

	UniValue args(UniValue::VOBJ);			UniValue args(UniValue::VOBJ);
	args.pushKV("arg1", "value1");			args.pushKV("arg1", "value1");

	// Registered commands execute and return values correctly			// Registered commands execute and return values correctly
	JSONRPCRequest request;			JSONRPCRequest request;
	request.strMethod = commandName;			request.strMethod = commandName;
	request.params = args;			request.params = args;
	UniValue output = rpcServer.ExecuteCommand(config, request);			UniValue output = rpcServer.ExecuteCommand(config, request);
	BOOST_CHECK_EQUAL(output.get_str(), "testing");			BOOST_CHECK_EQUAL(output.get_str(), "testing1");

	// Not-registered commands throw an exception as expected			// Not-registered commands throw an exception as expected
	JSONRPCRequest badCommandRequest;			JSONRPCRequest badCommandRequest;
	badCommandRequest.strMethod = "this-command-does-not-exist";			badCommandRequest.strMethod = "this-command-does-not-exist";
	BOOST_CHECK_EXCEPTION(rpcServer.ExecuteCommand(config, badCommandRequest),			BOOST_CHECK_EXCEPTION(rpcServer.ExecuteCommand(config, badCommandRequest),
	UniValue, isRpcMethodNotFound);			UniValue, isRpcMethodNotFound);
	}			}

				class RequestContextRPCCommand : public RPCCommandWithRequestContext {
				public:
				RequestContextRPCCommand(std::string nameIn)
				: RPCCommandWithRequestContext(nameIn) {}

				// Sanity check that Execute(JSONRPCRequest) is called correctly from
				// RPCServer
				UniValue Execute(const JSONRPCRequest &request) const override {
				const UniValue args = request.params;
				BOOST_CHECK_EQUAL(request.strMethod, "testcommand2");
				BOOST_CHECK_EQUAL(args["arg2"].get_str(), "value2");
				return UniValue("testing2");
				}
				};

				BOOST_AUTO_TEST_CASE(rpc_server_execute_command_from_request_context) {
				DummyConfig config;
				RPCServer rpcServer;
				const std::string commandName = "testcommand2";
				rpcServer.RegisterCommand(
				MakeUnique<RequestContextRPCCommand>(commandName));

				UniValue args(UniValue::VOBJ);
				args.pushKV("arg2", "value2");

				// Registered commands execute and return values correctly
				JSONRPCRequest request;
				request.strMethod = commandName;
				request.params = args;
				UniValue output = rpcServer.ExecuteCommand(config, request);
				BOOST_CHECK_EQUAL(output.get_str(), "testing2");
				}

	BOOST_AUTO_TEST_SUITE_END()			BOOST_AUTO_TEST_SUITE_END()