Cherry-pick new unit test to pin behavior

barbieri · wravery · commit b8fdb0f8205d · 2020-12-11T17:02:02.000-08:00
diff --git a/samples/schema.today.graphql b/samples/schema.today.graphql
@@ -115,6 +115,7 @@ type Appointment implements Node {
     when: DateTime
     subject: String
     isNow: Boolean!
+    forceError: String
 }
 
 type Task implements Node {
diff --git a/samples/separate/AppointmentObject.cpp b/samples/separate/AppointmentObject.cpp
@@ -23,6 +23,7 @@ Appointment::Appointment()
 		"Appointment"
 	}, {
 		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
+		{ R"gql(forceError)gql"sv, [this](service::ResolverParams&& params) { return resolveForceError(std::move(params)); } },
 		{ R"gql(id)gql"sv, [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
 		{ R"gql(isNow)gql"sv, [this](service::ResolverParams&& params) { return resolveIsNow(std::move(params)); } },
 		{ R"gql(subject)gql"sv, [this](service::ResolverParams&& params) { return resolveSubject(std::move(params)); } },
@@ -87,6 +88,20 @@ std::future<response::Value> Appointment::resolveIsNow(service::ResolverParams&&
 	return service::ModifiedResult<response::BooleanType>::convert(std::move(result), std::move(params));
 }
 
+service::FieldResult<std::optional<response::StringType>> Appointment::getForceError(service::FieldParams&&) const
+{
+	throw std::runtime_error(R"ex(Appointment::getForceError is not implemented)ex");
+}
+
+std::future<response::Value> Appointment::resolveForceError(service::ResolverParams&& params)
+{
+	std::unique_lock resolverLock(_resolverMutex);
+	auto result = getForceError(service::FieldParams(params, std::move(params.fieldDirectives)));
+	resolverLock.unlock();
+
+	return service::ModifiedResult<response::StringType>::convert<service::TypeModifier::Nullable>(std::move(result), std::move(params));
+}
+
 std::future<response::Value> Appointment::resolve_typename(service::ResolverParams&& params)
 {
 	return service::ModifiedResult<response::StringType>::convert(response::StringType{ R"gql(Appointment)gql" }, std::move(params));
@@ -103,7 +118,8 @@ void AddAppointmentDetails(std::shared_ptr<schema::ObjectType> typeAppointment,
 		std::make_shared<schema::Field>(R"gql(id)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("ID"))),
 		std::make_shared<schema::Field>(R"gql(when)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("DateTime")),
 		std::make_shared<schema::Field>(R"gql(subject)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String")),
-		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean")))
+		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean"))),
+		std::make_shared<schema::Field>(R"gql(forceError)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String"))
 	});
 }
 
diff --git a/samples/separate/AppointmentObject.h b/samples/separate/AppointmentObject.h
@@ -22,12 +22,14 @@ class Appointment
 	virtual service::FieldResult<std::optional<response::Value>> getWhen(service::FieldParams&& params) const;
 	virtual service::FieldResult<std::optional<response::StringType>> getSubject(service::FieldParams&& params) const;
 	virtual service::FieldResult<response::BooleanType> getIsNow(service::FieldParams&& params) const;
+	virtual service::FieldResult<std::optional<response::StringType>> getForceError(service::FieldParams&& params) const;
 
 private:
 	std::future<response::Value> resolveId(service::ResolverParams&& params);
 	std::future<response::Value> resolveWhen(service::ResolverParams&& params);
 	std::future<response::Value> resolveSubject(service::ResolverParams&& params);
 	std::future<response::Value> resolveIsNow(service::ResolverParams&& params);
+	std::future<response::Value> resolveForceError(service::ResolverParams&& params);
 
 	std::future<response::Value> resolve_typename(service::ResolverParams&& params);
 };
diff --git a/samples/separate_nointrospection/AppointmentObject.cpp b/samples/separate_nointrospection/AppointmentObject.cpp
@@ -23,6 +23,7 @@ Appointment::Appointment()
 		"Appointment"
 	}, {
 		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
+		{ R"gql(forceError)gql"sv, [this](service::ResolverParams&& params) { return resolveForceError(std::move(params)); } },
 		{ R"gql(id)gql"sv, [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
 		{ R"gql(isNow)gql"sv, [this](service::ResolverParams&& params) { return resolveIsNow(std::move(params)); } },
 		{ R"gql(subject)gql"sv, [this](service::ResolverParams&& params) { return resolveSubject(std::move(params)); } },
@@ -87,6 +88,20 @@ std::future<response::Value> Appointment::resolveIsNow(service::ResolverParams&&
 	return service::ModifiedResult<response::BooleanType>::convert(std::move(result), std::move(params));
 }
 
+service::FieldResult<std::optional<response::StringType>> Appointment::getForceError(service::FieldParams&&) const
+{
+	throw std::runtime_error(R"ex(Appointment::getForceError is not implemented)ex");
+}
+
+std::future<response::Value> Appointment::resolveForceError(service::ResolverParams&& params)
+{
+	std::unique_lock resolverLock(_resolverMutex);
+	auto result = getForceError(service::FieldParams(params, std::move(params.fieldDirectives)));
+	resolverLock.unlock();
+
+	return service::ModifiedResult<response::StringType>::convert<service::TypeModifier::Nullable>(std::move(result), std::move(params));
+}
+
 std::future<response::Value> Appointment::resolve_typename(service::ResolverParams&& params)
 {
 	return service::ModifiedResult<response::StringType>::convert(response::StringType{ R"gql(Appointment)gql" }, std::move(params));
@@ -103,7 +118,8 @@ void AddAppointmentDetails(std::shared_ptr<schema::ObjectType> typeAppointment,
 		std::make_shared<schema::Field>(R"gql(id)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("ID"))),
 		std::make_shared<schema::Field>(R"gql(when)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("DateTime")),
 		std::make_shared<schema::Field>(R"gql(subject)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String")),
-		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean")))
+		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean"))),
+		std::make_shared<schema::Field>(R"gql(forceError)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String"))
 	});
 }
 
diff --git a/samples/separate_nointrospection/AppointmentObject.h b/samples/separate_nointrospection/AppointmentObject.h
@@ -22,12 +22,14 @@ class Appointment
 	virtual service::FieldResult<std::optional<response::Value>> getWhen(service::FieldParams&& params) const;
 	virtual service::FieldResult<std::optional<response::StringType>> getSubject(service::FieldParams&& params) const;
 	virtual service::FieldResult<response::BooleanType> getIsNow(service::FieldParams&& params) const;
+	virtual service::FieldResult<std::optional<response::StringType>> getForceError(service::FieldParams&& params) const;
 
 private:
 	std::future<response::Value> resolveId(service::ResolverParams&& params);
 	std::future<response::Value> resolveWhen(service::ResolverParams&& params);
 	std::future<response::Value> resolveSubject(service::ResolverParams&& params);
 	std::future<response::Value> resolveIsNow(service::ResolverParams&& params);
+	std::future<response::Value> resolveForceError(service::ResolverParams&& params);
 
 	std::future<response::Value> resolve_typename(service::ResolverParams&& params);
 };
diff --git a/samples/today/TodayMock.h b/samples/today/TodayMock.h
@@ -154,6 +154,12 @@ class Appointment : public object::Appointment
 		return _isNow;
 	}
 
+	service::FieldResult<std::optional<response::StringType>> getForceError(
+		service::FieldParams&&) const final
+	{
+		throw std::runtime_error(R"ex(this error was forced)ex");
+	}
+
 private:
 	response::IdType _id;
 	std::string _when;
diff --git a/samples/unified/TodaySchema.cpp b/samples/unified/TodaySchema.cpp
@@ -760,6 +760,7 @@ Appointment::Appointment()
 		"Appointment"
 	}, {
 		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
+		{ R"gql(forceError)gql"sv, [this](service::ResolverParams&& params) { return resolveForceError(std::move(params)); } },
 		{ R"gql(id)gql"sv, [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
 		{ R"gql(isNow)gql"sv, [this](service::ResolverParams&& params) { return resolveIsNow(std::move(params)); } },
 		{ R"gql(subject)gql"sv, [this](service::ResolverParams&& params) { return resolveSubject(std::move(params)); } },
@@ -824,6 +825,20 @@ std::future<response::Value> Appointment::resolveIsNow(service::ResolverParams&&
 	return service::ModifiedResult<response::BooleanType>::convert(std::move(result), std::move(params));
 }
 
+service::FieldResult<std::optional<response::StringType>> Appointment::getForceError(service::FieldParams&&) const
+{
+	throw std::runtime_error(R"ex(Appointment::getForceError is not implemented)ex");
+}
+
+std::future<response::Value> Appointment::resolveForceError(service::ResolverParams&& params)
+{
+	std::unique_lock resolverLock(_resolverMutex);
+	auto result = getForceError(service::FieldParams(params, std::move(params.fieldDirectives)));
+	resolverLock.unlock();
+
+	return service::ModifiedResult<response::StringType>::convert<service::TypeModifier::Nullable>(std::move(result), std::move(params));
+}
+
 std::future<response::Value> Appointment::resolve_typename(service::ResolverParams&& params)
 {
 	return service::ModifiedResult<response::StringType>::convert(response::StringType{ R"gql(Appointment)gql" }, std::move(params));
@@ -1194,7 +1209,8 @@ void AddTypesToSchema(const std::shared_ptr<schema::Schema>& schema)
 		std::make_shared<schema::Field>(R"gql(id)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("ID"))),
 		std::make_shared<schema::Field>(R"gql(when)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("DateTime")),
 		std::make_shared<schema::Field>(R"gql(subject)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String")),
-		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean")))
+		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean"))),
+		std::make_shared<schema::Field>(R"gql(forceError)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String"))
 	});
 	typeTask->AddInterfaces({
 		typeNode
diff --git a/samples/unified/TodaySchema.h b/samples/unified/TodaySchema.h
@@ -278,12 +278,14 @@ class Appointment
 	virtual service::FieldResult<std::optional<response::Value>> getWhen(service::FieldParams&& params) const;
 	virtual service::FieldResult<std::optional<response::StringType>> getSubject(service::FieldParams&& params) const;
 	virtual service::FieldResult<response::BooleanType> getIsNow(service::FieldParams&& params) const;
+	virtual service::FieldResult<std::optional<response::StringType>> getForceError(service::FieldParams&& params) const;
 
 private:
 	std::future<response::Value> resolveId(service::ResolverParams&& params);
 	std::future<response::Value> resolveWhen(service::ResolverParams&& params);
 	std::future<response::Value> resolveSubject(service::ResolverParams&& params);
 	std::future<response::Value> resolveIsNow(service::ResolverParams&& params);
+	std::future<response::Value> resolveForceError(service::ResolverParams&& params);
 
 	std::future<response::Value> resolve_typename(service::ResolverParams&& params);
 };
diff --git a/samples/unified_nointrospection/TodaySchema.cpp b/samples/unified_nointrospection/TodaySchema.cpp
@@ -743,6 +743,7 @@ Appointment::Appointment()
 		"Appointment"
 	}, {
 		{ R"gql(__typename)gql"sv, [this](service::ResolverParams&& params) { return resolve_typename(std::move(params)); } },
+		{ R"gql(forceError)gql"sv, [this](service::ResolverParams&& params) { return resolveForceError(std::move(params)); } },
 		{ R"gql(id)gql"sv, [this](service::ResolverParams&& params) { return resolveId(std::move(params)); } },
 		{ R"gql(isNow)gql"sv, [this](service::ResolverParams&& params) { return resolveIsNow(std::move(params)); } },
 		{ R"gql(subject)gql"sv, [this](service::ResolverParams&& params) { return resolveSubject(std::move(params)); } },
@@ -807,6 +808,20 @@ std::future<response::Value> Appointment::resolveIsNow(service::ResolverParams&&
 	return service::ModifiedResult<response::BooleanType>::convert(std::move(result), std::move(params));
 }
 
+service::FieldResult<std::optional<response::StringType>> Appointment::getForceError(service::FieldParams&&) const
+{
+	throw std::runtime_error(R"ex(Appointment::getForceError is not implemented)ex");
+}
+
+std::future<response::Value> Appointment::resolveForceError(service::ResolverParams&& params)
+{
+	std::unique_lock resolverLock(_resolverMutex);
+	auto result = getForceError(service::FieldParams(params, std::move(params.fieldDirectives)));
+	resolverLock.unlock();
+
+	return service::ModifiedResult<response::StringType>::convert<service::TypeModifier::Nullable>(std::move(result), std::move(params));
+}
+
 std::future<response::Value> Appointment::resolve_typename(service::ResolverParams&& params)
 {
 	return service::ModifiedResult<response::StringType>::convert(response::StringType{ R"gql(Appointment)gql" }, std::move(params));
@@ -1177,7 +1192,8 @@ void AddTypesToSchema(const std::shared_ptr<schema::Schema>& schema)
 		std::make_shared<schema::Field>(R"gql(id)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("ID"))),
 		std::make_shared<schema::Field>(R"gql(when)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("DateTime")),
 		std::make_shared<schema::Field>(R"gql(subject)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String")),
-		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean")))
+		std::make_shared<schema::Field>(R"gql(isNow)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->WrapType(introspection::TypeKind::NON_NULL, schema->LookupType("Boolean"))),
+		std::make_shared<schema::Field>(R"gql(forceError)gql"sv, R"md()md"sv, std::nullopt, std::vector<std::shared_ptr<schema::InputValue>>(), schema->LookupType("String"))
 	});
 	typeTask->AddInterfaces({
 		typeNode
diff --git a/samples/unified_nointrospection/TodaySchema.h b/samples/unified_nointrospection/TodaySchema.h
@@ -274,12 +274,14 @@ class Appointment
 	virtual service::FieldResult<std::optional<response::Value>> getWhen(service::FieldParams&& params) const;
 	virtual service::FieldResult<std::optional<response::StringType>> getSubject(service::FieldParams&& params) const;
 	virtual service::FieldResult<response::BooleanType> getIsNow(service::FieldParams&& params) const;
+	virtual service::FieldResult<std::optional<response::StringType>> getForceError(service::FieldParams&& params) const;
 
 private:
 	std::future<response::Value> resolveId(service::ResolverParams&& params);
 	std::future<response::Value> resolveWhen(service::ResolverParams&& params);
 	std::future<response::Value> resolveSubject(service::ResolverParams&& params);
 	std::future<response::Value> resolveIsNow(service::ResolverParams&& params);
+	std::future<response::Value> resolveForceError(service::ResolverParams&& params);
 
 	std::future<response::Value> resolve_typename(service::ResolverParams&& params);
 };
diff --git a/test/TodayTests.cpp b/test/TodayTests.cpp
@@ -238,6 +238,64 @@ TEST_F(TodayServiceCase, QueryAppointments)
 	}
 }
 
+TEST_F(TodayServiceCase, QueryAppointmentsWithForceError)
+{
+	auto query = R"({
+			appointments {
+				edges {
+					node {
+						appointmentId: id
+						subject
+						when
+						isNow
+						forceError
+					}
+				}
+			}
+		})"_graphql;
+	response::Value variables(response::Type::Map);
+	auto state = std::make_shared<today::RequestState>(2);
+	auto result = _service->resolve(state, query, "", std::move(variables)).get();
+	EXPECT_EQ(size_t(1), _getAppointmentsCount) << "today service lazy loads the appointments and caches the result";
+	EXPECT_GE(size_t(1), _getTasksCount) << "today service lazy loads the tasks and caches the result";
+	EXPECT_GE(size_t(1), _getUnreadCountsCount) << "today service lazy loads the unreadCounts and caches the result";
+	EXPECT_EQ(size_t(2), state->appointmentsRequestId) << "today service passed the same RequestState";
+	EXPECT_EQ(size_t(0), state->tasksRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->unreadCountsRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(1), state->loadAppointmentsCount) << "today service called the loader once";
+	EXPECT_EQ(size_t(0), state->loadTasksCount) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->loadUnreadCountsCount) << "today service did not call the loader";
+
+	try
+	{
+		ASSERT_TRUE(result.type() == response::Type::Map);
+		auto errorsItr = result.find("errors");
+		if (errorsItr == result.get<response::MapType>().cend())
+		{
+			FAIL() << response::toJSON(response::Value(result)) << "no errors returned";
+		}
+
+		auto errorsString = response::toJSON(response::Value(errorsItr->second));
+		EXPECT_EQ(R"js([{"message":"Field error name: forceError unknown error: this error was forced","locations":[{"line":9,"column":7}],"path":["appointments","edges",0,"node","forceError"]}])js", errorsString) << "error should match";
+
+		const auto data = service::ScalarArgument::require("data", result);
+
+		const auto appointments = service::ScalarArgument::require("appointments", data);
+		const auto appointmentEdges = service::ScalarArgument::require<service::TypeModifier::List>("edges", appointments);
+		ASSERT_EQ(1, appointmentEdges.size()) << "appointments should have 1 entry";
+		ASSERT_TRUE(appointmentEdges[0].type() == response::Type::Map) << "appointment should be an object";
+		const auto appointmentNode = service::ScalarArgument::require("node", appointmentEdges[0]);
+		EXPECT_EQ(_fakeAppointmentId, service::IdArgument::require("appointmentId", appointmentNode)) << "id should match in base64 encoding";
+		EXPECT_EQ("Lunch?", service::StringArgument::require("subject", appointmentNode)) << "subject should match";
+		EXPECT_EQ("tomorrow", service::StringArgument::require("when", appointmentNode)) << "when should match";
+		EXPECT_FALSE(service::BooleanArgument::require("isNow", appointmentNode)) << "isNow should match";
+	}
+	catch (service::schema_exception & ex)
+	{
+		FAIL() << response::toJSON(ex.getErrors());
+	}
+}
+
 TEST_F(TodayServiceCase, QueryTasks)
 {
 	auto query = R"gql({

Original file line number	Diff line number	Diff line change
`@@ -115,6 +115,7 @@ type Appointment implements Node {`
`115`	`115`	`when: DateTime`
`116`	`116`	`subject: String`
`117`	`117`	`isNow: Boolean!`
	`118`	`+ forceError: String`
`118`	`119`	`}`
`119`	`120`
`120`	`121`	`type Task implements Node {`