Add test asserts to verify RequestState handling

wravery · wravery · commit 7aa17d2a9df5 · 2018-12-16T12:11:27.000-08:00
diff --git a/Today.cpp b/Today.cpp
@@ -39,8 +39,16 @@ Query::Query(appointmentsLoader&& getAppointments, tasksLoader&& getTasks, unrea
 {
 }
 
-void Query::loadAppointments() const
+void Query::loadAppointments(const std::shared_ptr<service::RequestState>& state) const
 {
+	if (state)
+	{
+		auto todayState = std::static_pointer_cast<RequestState>(state);
+
+		todayState->appointmentsRequestId = todayState->requestId;
+		todayState->loadAppointmentsCount++;
+	}
+
 	if (_getAppointments)
 	{
 		_appointments = _getAppointments();
@@ -50,7 +58,7 @@ void Query::loadAppointments() const
 
 std::shared_ptr<Appointment> Query::findAppointment(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const
 {
-	loadAppointments();
+	loadAppointments(state);
 
 	for (const auto& appointment : _appointments)
 	{
@@ -65,8 +73,16 @@ std::shared_ptr<Appointment> Query::findAppointment(const std::shared_ptr<servic
 	return nullptr;
 }
 
-void Query::loadTasks() const
+void Query::loadTasks(const std::shared_ptr<service::RequestState>& state) const
 {
+	if (state)
+	{
+		auto todayState = std::static_pointer_cast<RequestState>(state);
+
+		todayState->tasksRequestId = todayState->requestId;
+		todayState->loadTasksCount++;
+	}
+
 	if (_getTasks)
 	{
 		_tasks = _getTasks();
@@ -76,7 +92,7 @@ void Query::loadTasks() const
 
 std::shared_ptr<Task> Query::findTask(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const
 {
-	loadTasks();
+	loadTasks(state);
 
 	for (const auto& task : _tasks)
 	{
@@ -91,8 +107,16 @@ std::shared_ptr<Task> Query::findTask(const std::shared_ptr<service::RequestStat
 	return nullptr;
 }
 
-void Query::loadUnreadCounts() const
+void Query::loadUnreadCounts(const std::shared_ptr<service::RequestState>& state) const
 {
+	if (state)
+	{
+		auto todayState = std::static_pointer_cast<RequestState>(state);
+
+		todayState->unreadCountsRequestId = todayState->requestId;
+		todayState->loadUnreadCountsCount++;
+	}
+
 	if (_getUnreadCounts)
 	{
 		_unreadCounts = _getUnreadCounts();
@@ -102,7 +126,7 @@ void Query::loadUnreadCounts() const
 
 std::shared_ptr<Folder> Query::findUnreadCount(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const
 {
-	loadUnreadCounts();
+	loadUnreadCounts(state);
 
 	for (const auto& folder : _unreadCounts)
 	{
@@ -248,7 +272,7 @@ std::future<std::shared_ptr<object::AppointmentConnection>> Query::getAppointmen
 	return std::async(std::launch::async,
 		[this, spThis](const std::shared_ptr<service::RequestState>& stateWrapped, std::unique_ptr<int>&& firstWrapped, std::unique_ptr<response::Value>&& afterWrapped, std::unique_ptr<int>&& lastWrapped, std::unique_ptr<response::Value>&& beforeWrapped)
 	{
-		loadAppointments();
+		loadAppointments(stateWrapped);
 
 		EdgeConstraints<Appointment, AppointmentConnection> constraints(stateWrapped, _appointments);
 		auto connection = constraints(firstWrapped.get(), afterWrapped.get(), lastWrapped.get(), beforeWrapped.get());
@@ -263,7 +287,7 @@ std::future<std::shared_ptr<object::TaskConnection>> Query::getTasks(const std::
 	return std::async(std::launch::async,
 		[this, spThis](const std::shared_ptr<service::RequestState>& stateWrapped, std::unique_ptr<int>&& firstWrapped, std::unique_ptr<response::Value>&& afterWrapped, std::unique_ptr<int>&& lastWrapped, std::unique_ptr<response::Value>&& beforeWrapped)
 	{
-		loadTasks();
+		loadTasks(stateWrapped);
 
 		EdgeConstraints<Task, TaskConnection> constraints(stateWrapped, _tasks);
 		auto connection = constraints(firstWrapped.get(), afterWrapped.get(), lastWrapped.get(), beforeWrapped.get());
@@ -278,7 +302,7 @@ std::future<std::shared_ptr<object::FolderConnection>> Query::getUnreadCounts(co
 	return std::async(std::launch::async,
 		[this, spThis](const std::shared_ptr<service::RequestState>& stateWrapped, std::unique_ptr<int>&& firstWrapped, std::unique_ptr<response::Value>&& afterWrapped, std::unique_ptr<int>&& lastWrapped, std::unique_ptr<response::Value>&& beforeWrapped)
 	{
-		loadUnreadCounts();
+		loadUnreadCounts(stateWrapped);
 
 		EdgeConstraints<Folder, FolderConnection> constraints(stateWrapped, _unreadCounts);
 		auto connection = constraints(firstWrapped.get(), afterWrapped.get(), lastWrapped.get(), beforeWrapped.get());
diff --git a/include/Today.h b/include/Today.h
@@ -9,6 +9,24 @@ namespace facebook {
 namespace graphql {
 namespace today {
 
+struct RequestState : service::RequestState
+{
+	RequestState(size_t id)
+		: requestId(id)
+	{
+	}
+
+	const size_t requestId;
+
+	size_t appointmentsRequestId = 0;
+	size_t tasksRequestId = 0;
+	size_t unreadCountsRequestId = 0;
+
+	size_t loadAppointmentsCount = 0;
+	size_t loadTasksCount = 0;
+	size_t loadUnreadCountsCount = 0;
+};
+
 class Appointment;
 class Task;
 class Folder;
@@ -36,9 +54,9 @@ class Query : public object::Query
 	std::shared_ptr<Folder> findUnreadCount(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const;
 
 	// Lazy load the fields in each query
-	void loadAppointments() const;
-	void loadTasks() const;
-	void loadUnreadCounts() const;
+	void loadAppointments(const std::shared_ptr<service::RequestState>& state) const;
+	void loadTasks(const std::shared_ptr<service::RequestState>& state) const;
+	void loadUnreadCounts(const std::shared_ptr<service::RequestState>& state) const;
 
 	mutable appointmentsLoader _getAppointments;
 	mutable tasksLoader _getTasks;
diff --git a/tests.cpp b/tests.cpp
@@ -90,17 +90,6 @@ size_t TodayServiceCase::_getAppointmentsCount = 0;
 size_t TodayServiceCase::_getTasksCount = 0;
 size_t TodayServiceCase::_getUnreadCountsCount = 0;
 
-struct TestRequestId
-	: service::RequestState
-{
-	TestRequestId(size_t id)
-		: _id(id)
-	{
-	}
-
-	size_t _id;
-};
-
 TEST_F(TodayServiceCase, QueryEverything)
 {
 	auto ast = R"(
@@ -135,11 +124,18 @@ TEST_F(TodayServiceCase, QueryEverything)
 			}
 		})"_graphql;
 	response::Value variables(response::Type::Map);
-	auto state = std::make_shared<TestRequestId>(0);
+	auto state = std::make_shared<today::RequestState>(1);
 	auto result = _service->resolve(state, *ast->root, "Everything", variables).get();
 	EXPECT_EQ(size_t(1), _getAppointmentsCount) << "today service lazy loads the appointments and caches the result";
 	EXPECT_EQ(size_t(1), _getTasksCount) << "today service lazy loads the tasks and caches the result";
 	EXPECT_EQ(size_t(1), _getUnreadCountsCount) << "today service lazy loads the unreadCounts and caches the result";
+	EXPECT_EQ(size_t(1), state->appointmentsRequestId) << "today service passed the same RequestState";
+	EXPECT_EQ(size_t(1), state->tasksRequestId) << "today service passed the same RequestState";
+	EXPECT_EQ(size_t(1), state->unreadCountsRequestId) << "today service passed the same RequestState";
+	EXPECT_EQ(size_t(1), state->loadAppointmentsCount) << "today service called the loader once";
+	EXPECT_EQ(size_t(1), state->loadTasksCount) << "today service called the loader once";
+	EXPECT_EQ(size_t(1), state->loadUnreadCountsCount) << "today service called the loader once";
+
 
 	try
 	{
@@ -210,11 +206,17 @@ TEST_F(TodayServiceCase, QueryAppointments)
 			}
 		})"_graphql;
 	response::Value variables(response::Type::Map);
-	auto state = std::make_shared<TestRequestId>(1);
+	auto state = std::make_shared<today::RequestState>(2);
 	auto result = _service->resolve(state, *ast->root, "", 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
 	{
@@ -266,11 +268,17 @@ TEST_F(TodayServiceCase, QueryTasks)
 			}
 		})gql"_graphql;
 	response::Value variables(response::Type::Map);
-	auto state = std::make_shared<TestRequestId>(2);
+	auto state = std::make_shared<today::RequestState>(3);
 	auto result = _service->resolve(state, *ast->root, "", variables).get();
 	EXPECT_GE(size_t(1), _getAppointmentsCount) << "today service lazy loads the appointments and caches the result";
 	EXPECT_EQ(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(0), state->appointmentsRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(3), state->tasksRequestId) << "today service passed the same RequestState";
+	EXPECT_EQ(size_t(0), state->unreadCountsRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->loadAppointmentsCount) << "today service did not call the loader";
+	EXPECT_EQ(size_t(1), state->loadTasksCount) << "today service called the loader once";
+	EXPECT_EQ(size_t(0), state->loadUnreadCountsCount) << "today service did not call the loader";
 
 	try
 	{
@@ -321,11 +329,17 @@ TEST_F(TodayServiceCase, QueryUnreadCounts)
 			}
 		})"_graphql;
 	response::Value variables(response::Type::Map);
-	auto state = std::make_shared<TestRequestId>(3);
+	auto state = std::make_shared<today::RequestState>(4);
 	auto result = _service->resolve(state, *ast->root, "", variables).get();
 	EXPECT_GE(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_EQ(size_t(1), _getUnreadCountsCount) << "today service lazy loads the unreadCounts and caches the result";
+	EXPECT_EQ(size_t(0), state->appointmentsRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->tasksRequestId) << "today service did not call the loader";
+	EXPECT_EQ(size_t(4), state->unreadCountsRequestId) << "today service passed the same RequestState";
+	EXPECT_EQ(size_t(0), state->loadAppointmentsCount) << "today service did not call the loader";
+	EXPECT_EQ(size_t(0), state->loadTasksCount) << "today service did not call the loader";
+	EXPECT_EQ(size_t(1), state->loadUnreadCountsCount) << "today service called the loader once"; 
 
 	try
 	{
@@ -375,7 +389,7 @@ TEST_F(TodayServiceCase, MutateCompleteTask)
 			}
 		})"_graphql;
 	response::Value variables(response::Type::Map);
-	auto state = std::make_shared<TestRequestId>(4);
+	auto state = std::make_shared<today::RequestState>(5);
 	auto result = _service->resolve(state, *ast->root, "", variables).get();
 
 	try
@@ -451,7 +465,7 @@ TEST_F(TodayServiceCase, Introspection)
 			}
 		})"_graphql;
 	response::Value variables(response::Type::Map);
-	auto state = std::make_shared<TestRequestId>(5);
+	auto state = std::make_shared<today::RequestState>(6);
 	auto result = _service->resolve(state, *ast->root, "", variables).get();
 
 	try

Original file line number	Diff line number	Diff line change
`@@ -39,8 +39,16 @@ Query::Query(appointmentsLoader&& getAppointments, tasksLoader&& getTasks, unrea`
`39`	`39`	`{`
`40`	`40`	`}`
`41`	`41`
`42`		`-void Query::loadAppointments() const`
	`42`	`+void Query::loadAppointments(const std::shared_ptr<service::RequestState>& state) const`
`43`	`43`	`{`
	`44`	`+ if (state)`
	`45`	`+ {`
	`46`	`+ auto todayState = std::static_pointer_cast<RequestState>(state);`
	`47`	`+`
	`48`	`+ todayState->appointmentsRequestId = todayState->requestId;`
	`49`	`+ todayState->loadAppointmentsCount++;`
	`50`	`+ }`
	`51`	`+`
`44`	`52`	`if (_getAppointments)`
`45`	`53`	`{`
`46`	`54`	`_appointments = _getAppointments();`
`@@ -50,7 +58,7 @@ void Query::loadAppointments() const`
`50`	`58`
`51`	`59`	`std::shared_ptr<Appointment> Query::findAppointment(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const`
`52`	`60`	`{`
`53`		`- loadAppointments();`
	`61`	`+ loadAppointments(state);`
`54`	`62`
`55`	`63`	`for (const auto& appointment : _appointments)`
`56`	`64`	`{`
`@@ -65,8 +73,16 @@ std::shared_ptr<Appointment> Query::findAppointment(const std::shared_ptr<servic`
`65`	`73`	`return nullptr;`
`66`	`74`	`}`
`67`	`75`
`68`		`-void Query::loadTasks() const`
	`76`	`+void Query::loadTasks(const std::shared_ptr<service::RequestState>& state) const`
`69`	`77`	`{`
	`78`	`+ if (state)`
	`79`	`+ {`
	`80`	`+ auto todayState = std::static_pointer_cast<RequestState>(state);`
	`81`	`+`
	`82`	`+ todayState->tasksRequestId = todayState->requestId;`
	`83`	`+ todayState->loadTasksCount++;`
	`84`	`+ }`
	`85`	`+`
`70`	`86`	`if (_getTasks)`
`71`	`87`	`{`
`72`	`88`	`_tasks = _getTasks();`
`@@ -76,7 +92,7 @@ void Query::loadTasks() const`
`76`	`92`
`77`	`93`	`std::shared_ptr<Task> Query::findTask(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const`
`78`	`94`	`{`
`79`		`- loadTasks();`
	`95`	`+ loadTasks(state);`
`80`	`96`
`81`	`97`	`for (const auto& task : _tasks)`
`82`	`98`	`{`
`@@ -91,8 +107,16 @@ std::shared_ptr<Task> Query::findTask(const std::shared_ptr<service::RequestStat`
`91`	`107`	`return nullptr;`
`92`	`108`	`}`
`93`	`109`
`94`		`-void Query::loadUnreadCounts() const`
	`110`	`+void Query::loadUnreadCounts(const std::shared_ptr<service::RequestState>& state) const`
`95`	`111`	`{`
	`112`	`+ if (state)`
	`113`	`+ {`
	`114`	`+ auto todayState = std::static_pointer_cast<RequestState>(state);`
	`115`	`+`
	`116`	`+ todayState->unreadCountsRequestId = todayState->requestId;`
	`117`	`+ todayState->loadUnreadCountsCount++;`
	`118`	`+ }`
	`119`	`+`
`96`	`120`	`if (_getUnreadCounts)`
`97`	`121`	`{`
`98`	`122`	`_unreadCounts = _getUnreadCounts();`
`@@ -102,7 +126,7 @@ void Query::loadUnreadCounts() const`
`102`	`126`
`103`	`127`	`std::shared_ptr<Folder> Query::findUnreadCount(const std::shared_ptr<service::RequestState>& state, const std::vector<uint8_t>& id) const`
`104`	`128`	`{`
`105`		`- loadUnreadCounts();`
	`129`	`+ loadUnreadCounts(state);`
`106`	`130`
`107`	`131`	`for (const auto& folder : _unreadCounts)`
`108`	`132`	`{`
`@@ -248,7 +272,7 @@ std::future<std::shared_ptr<object::AppointmentConnection>> Query::getAppointmen`
`248`	`272`	`return std::async(std::launch::async,`
`249`	`273`	`[this, spThis](const std::shared_ptr<service::RequestState>& stateWrapped, std::unique_ptr<int>&& firstWrapped, std::unique_ptr<response::Value>&& afterWrapped, std::unique_ptr<int>&& lastWrapped, std::unique_ptr<response::Value>&& beforeWrapped)`
`250`	`274`	`{`
`251`		`- loadAppointments();`
	`275`	`+ loadAppointments(stateWrapped);`
`252`	`276`
`253`	`277`	`EdgeConstraints<Appointment, AppointmentConnection> constraints(stateWrapped, _appointments);`
`254`	`278`	`auto connection = constraints(firstWrapped.get(), afterWrapped.get(), lastWrapped.get(), beforeWrapped.get());`
`@@ -263,7 +287,7 @@ std::future<std::shared_ptr<object::TaskConnection>> Query::getTasks(const std::`
`263`	`287`	`return std::async(std::launch::async,`
`264`	`288`	`[this, spThis](const std::shared_ptr<service::RequestState>& stateWrapped, std::unique_ptr<int>&& firstWrapped, std::unique_ptr<response::Value>&& afterWrapped, std::unique_ptr<int>&& lastWrapped, std::unique_ptr<response::Value>&& beforeWrapped)`
`265`	`289`	`{`
`266`		`- loadTasks();`
	`290`	`+ loadTasks(stateWrapped);`
`267`	`291`
`268`	`292`	`EdgeConstraints<Task, TaskConnection> constraints(stateWrapped, _tasks);`
`269`	`293`	`auto connection = constraints(firstWrapped.get(), afterWrapped.get(), lastWrapped.get(), beforeWrapped.get());`
`@@ -278,7 +302,7 @@ std::future<std::shared_ptr<object::FolderConnection>> Query::getUnreadCounts(co`
`278`	`302`	`return std::async(std::launch::async,`
`279`	`303`	`[this, spThis](const std::shared_ptr<service::RequestState>& stateWrapped, std::unique_ptr<int>&& firstWrapped, std::unique_ptr<response::Value>&& afterWrapped, std::unique_ptr<int>&& lastWrapped, std::unique_ptr<response::Value>&& beforeWrapped)`
`280`	`304`	`{`
`281`		`- loadUnreadCounts();`
	`305`	`+ loadUnreadCounts(stateWrapped);`
`282`	`306`
`283`	`307`	`EdgeConstraints<Folder, FolderConnection> constraints(stateWrapped, _unreadCounts);`
`284`	`308`	`auto connection = constraints(firstWrapped.get(), afterWrapped.get(), lastWrapped.get(), beforeWrapped.get());`