Add unit tests with matching/non-matching args

Author: wravery

GraphQLResponse.cpp

@@ -153,7 +153,7 @@ bool Value::operator==(const Value& rhs) const noexcept
 
 		case Type::String:
 		case Type::EnumValue:
-			return _string == rhs._string;
+			return *_string == *rhs._string;
 
 		case Type::Null:
 			return true;

include/Today.h

@@ -487,6 +487,11 @@ class Subscription : public object::Subscription
 	{
 		throw std::runtime_error("Unexpected call to getNextAppointmentChange");
 	}
+
+	std::future<std::shared_ptr<service::Object>> getNodeChange(service::FieldParams&&, std::vector<uint8_t>&&) const override
+	{
+		throw std::runtime_error("Unexpected call to getNodeChange");
+	}
 };
 
 class NextAppointmentChange : public object::Subscription
@@ -508,10 +513,43 @@ class NextAppointmentChange : public object::Subscription
 		return promise.get_future();
 	}
 
+	std::future<std::shared_ptr<service::Object>> getNodeChange(service::FieldParams&&, std::vector<uint8_t>&&) const override
+	{
+		throw std::runtime_error("Unexpected call to getNodeChange");
+	}
+
 private:
 	nextAppointmentChange _changeNextAppointment;
 };
 
+class NodeChange : public object::Subscription
+{
+public:
+	using nodeChange = std::function<std::shared_ptr<service::Object>(const std::shared_ptr<service::RequestState>&, std::vector<uint8_t>&&)>;
+
+	explicit NodeChange(nodeChange&& changeNode)
+		: _changeNode(std::move(changeNode))
+	{
+	}
+
+	std::future<std::shared_ptr<object::Appointment>> getNextAppointmentChange(service::FieldParams&&) const override
+	{
+		throw std::runtime_error("Unexpected call to getNextAppointmentChange");
+	}
+
+	std::future<std::shared_ptr<service::Object>> getNodeChange(service::FieldParams&& params, std::vector<uint8_t>&& idArg) const override
+	{
+		std::promise<std::shared_ptr<service::Object>> promise;
+
+		promise.set_value(std::static_pointer_cast<service::Object>(_changeNode(params.state, std::move(idArg))));
+
+		return promise.get_future();
+	}
+
+private:
+	nodeChange _changeNode;
+};
+
 struct CapturedParams
 {
 	// Copied in the constructor

samples/TodaySchema.cpp

@@ -540,6 +540,7 @@ Subscription::Subscription()
 		"Subscription"
 	}, {
 		{ "nextAppointmentChange", [this](service::ResolverParams&& params) { return resolveNextAppointmentChange(std::move(params)); } },
+		{ "nodeChange", [this](service::ResolverParams&& params) { return resolveNodeChange(std::move(params)); } },
 		{ "__typename", [this](service::ResolverParams&& params) { return resolve__typename(std::move(params)); } }
 	})
 {
@@ -552,6 +553,14 @@ std::future<response::Value> Subscription::resolveNextAppointmentChange(service:
 	return service::ModifiedResult<Appointment>::convert<service::TypeModifier::Nullable>(std::move(result), std::move(params));
 }
 
+std::future<response::Value> Subscription::resolveNodeChange(service::ResolverParams&& params)
+{
+	auto argId = service::ModifiedArgument<std::vector<uint8_t>>::require("id", params.arguments);
+	auto result = getNodeChange(service::FieldParams(params, std::move(params.fieldDirectives)), std::move(argId));
+
+	return service::ModifiedResult<service::Object>::convert(std::move(result), std::move(params));
+}
+
 std::future<response::Value> Subscription::resolve__typename(service::ResolverParams&&)
 {
 	std::promise<response::Value> promise;
@@ -883,7 +892,10 @@ void AddTypesToSchema(std::shared_ptr<introspection::Schema> schema)
 		}), schema->WrapType(introspection::__TypeKind::NON_NULL, schema->LookupType("CompleteTaskPayload")))
 	});
 	typeSubscription->AddFields({
-		std::make_shared<introspection::Field>("nextAppointmentChange", R"md()md", std::unique_ptr<std::string>(new std::string(R"md(Need to deprecate a [field](https://facebook.github.io/graphql/June2018/#sec-Deprecation))md")), std::vector<std::shared_ptr<introspection::InputValue>>(), schema->LookupType("Appointment"))
+		std::make_shared<introspection::Field>("nextAppointmentChange", R"md()md", std::unique_ptr<std::string>(new std::string(R"md(Need to deprecate a [field](https://facebook.github.io/graphql/June2018/#sec-Deprecation))md")), std::vector<std::shared_ptr<introspection::InputValue>>(), schema->LookupType("Appointment")),
+		std::make_shared<introspection::Field>("nodeChange", R"md()md", std::unique_ptr<std::string>(nullptr), std::vector<std::shared_ptr<introspection::InputValue>>({
+			std::make_shared<introspection::InputValue>("id", R"md()md", schema->WrapType(introspection::__TypeKind::NON_NULL, schema->LookupType("ID")), R"gql()gql")
+		}), schema->WrapType(introspection::__TypeKind::NON_NULL, schema->LookupType("Node")))
 	});
 	typeAppointment->AddInterfaces({
 		typeNode

samples/TodaySchema.h

@@ -253,9 +253,11 @@ class Subscription
 
 public:
 	virtual std::future<std::shared_ptr<Appointment>> getNextAppointmentChange(service::FieldParams&& params) const = 0;
+	virtual std::future<std::shared_ptr<service::Object>> getNodeChange(service::FieldParams&& params, std::vector<uint8_t>&& idArg) const = 0;
 
 private:
 	std::future<response::Value> resolveNextAppointmentChange(service::ResolverParams&& params);
+	std::future<response::Value> resolveNodeChange(service::ResolverParams&& params);
 
 	std::future<response::Value> resolve__typename(service::ResolverParams&& params);
 };

samples/schema.today.graphql

@@ -85,6 +85,7 @@ type Mutation {
 
 type Subscription {
     nextAppointmentChange : Appointment @deprecated(reason:"""Need to deprecate a [field](https://facebook.github.io/graphql/June2018/#sec-Deprecation)""")
+	nodeChange(id: ID!): Node!
 }
 
 directive @subscriptionTag(field: String) on SUBSCRIPTION

tests.cpp

@@ -833,6 +833,95 @@ TEST_F(TodayServiceCase, QueryAppointmentsById)
 	}
 }
 
+TEST_F(TodayServiceCase, SubscribeNodeChangeMatchingId)
+{
+	auto ast = peg::parseString(R"(subscription TestSubscription {
+			changedNode: nodeChange(id: "ZmFrZVRhc2tJZA==") {
+				changedId: id
+				...on Task {
+					title
+					isComplete
+				}
+			}
+		})");
+	response::Value variables(response::Type::Map);
+	auto state = std::make_shared<today::RequestState>(13);
+	auto subscriptionObject = std::make_shared<today::NodeChange>(
+		[this](const std::shared_ptr<service::RequestState>& state, std::vector<uint8_t>&& idArg) -> std::shared_ptr<service::Object>
+	{
+		EXPECT_EQ(13, std::static_pointer_cast<today::RequestState>(state)->requestId) << "should pass the RequestState to the subscription resolvers";
+		EXPECT_EQ(_fakeTaskId, idArg);
+		return std::static_pointer_cast<service::Object>(std::make_shared<today::Task>(std::vector<uint8_t>(_fakeTaskId), "Don't forget", true));
+	});
+	response::Value result;
+	auto key = _service->subscribe(service::SubscriptionParams { state, std::move(ast), "TestSubscription", std::move(std::move(variables)) },
+		[&result](std::future<response::Value> response)
+	{
+		result = response.get();
+	});
+	_service->deliver("nodeChange", { {"id", response::Value(std::string("ZmFrZVRhc2tJZA==")) } }, std::static_pointer_cast<service::Object>(subscriptionObject));
+	_service->unsubscribe(key);
+
+	try
+	{
+		ASSERT_TRUE(result.type() == response::Type::Map);
+		auto errorsItr = result.find("errors");
+		if (errorsItr != result.get<const response::MapType&>().cend())
+		{
+			FAIL() << response::toJSON(response::Value(errorsItr->second));
+		}
+		const auto data = service::ScalarArgument::require("data", result);
+
+		const auto taskNode = service::ScalarArgument::require("changedNode", data);
+		EXPECT_EQ(_fakeTaskId, service::IdArgument::require("changedId", taskNode)) << "id should match in base64 encoding";
+		EXPECT_EQ("Don't forget", service::StringArgument::require("title", taskNode)) << "title should match";
+		EXPECT_TRUE(service::BooleanArgument::require("isComplete", taskNode)) << "isComplete should match";
+	}
+	catch (const service::schema_exception& ex)
+	{
+		FAIL() << response::toJSON(response::Value(ex.getErrors()));
+	}
+}
+
+TEST_F(TodayServiceCase, SubscribeNodeChangeMismatchedId)
+{
+	auto ast = peg::parseString(R"(subscription TestSubscription {
+			changedNode: nodeChange(id: "ZmFrZVRhc2tJZA==") {
+				changedId: id
+				...on Task {
+					title
+					isComplete
+				}
+			}
+		})");
+	response::Value variables(response::Type::Map);
+	bool calledResolver = false;
+	auto subscriptionObject = std::make_shared<today::NodeChange>(
+		[this, &calledResolver](const std::shared_ptr<service::RequestState>& state, std::vector<uint8_t>&& idArg) -> std::shared_ptr<service::Object>
+	{
+		calledResolver = true;
+		return nullptr;
+	});
+	bool calledGet = false;
+	auto key = _service->subscribe(service::SubscriptionParams { nullptr, std::move(ast), "TestSubscription", std::move(std::move(variables)) },
+		[&calledGet](std::future<response::Value>)
+	{
+		calledGet = true;
+	});
+	_service->deliver("nodeChange", { {"id", response::Value(std::string("ZmFrZUFwcG9pbnRtZW50SWQ=")) } }, std::static_pointer_cast<service::Object>(subscriptionObject));
+	_service->unsubscribe(key);
+
+	try
+	{
+		ASSERT_FALSE(calledResolver);
+		ASSERT_FALSE(calledGet);
+	}
+	catch (const service::schema_exception& ex)
+	{
+		FAIL() << response::toJSON(response::Value(ex.getErrors()));
+	}
+}
+
 TEST(ArgumentsCase, ListArgumentStrings)
 {
 	auto parsed = response::parseJSON(R"js({"value":[