{

void SetUp() override

{

_mockService = today::mock_service();

}

void TearDown() override

{

_mockService.reset();

}

std::unique_ptr<today::TodayMockService> _mockService;

{

auto query = R"(

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(1);

auto result =

_mockService->service

->resolve({ query, "Everything"sv, std::move(variables), std::launch::async, state })

.get();

EXPECT_EQ(size_t { 1 }, _mockService->getAppointmentsCount)

<< "today service lazy loads the appointments and caches the result";

EXPECT_EQ(size_t { 1 }, _mockService->getTasksCount)

<< "today service lazy loads the tasks and caches the result";

EXPECT_EQ(size_t { 1 }, _mockService->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

{

ASSERT_TRUE(result.type() == response::Type::Map);

auto errorsItr = result.find("errors");

if (errorsItr != result.get<response::MapType>().cend())

{

FAIL() << response::toJSON(response::Value(errorsItr->second));

}

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(size_t { 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(today::getFakeAppointmentId(),

service::IdArgument::require("id", 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";

EXPECT_EQ("Appointment", service::StringArgument::require("__typename", appointmentNode))

<< "__typename should match";

const auto tasks = service::ScalarArgument::require("tasks", data);

const auto taskEdges =

service::ScalarArgument::require<service::TypeModifier::List>("edges", tasks);

ASSERT_EQ(size_t { 1 }, taskEdges.size()) << "tasks should have 1 entry";

ASSERT_TRUE(taskEdges[0].type() == response::Type::Map) << "task should be an object";

const auto taskNode = service::ScalarArgument::require("node", taskEdges[0]);

EXPECT_EQ(today::getFakeTaskId(), service::IdArgument::require("id", 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";

EXPECT_EQ("Task", service::StringArgument::require("__typename", taskNode))

<< "__typename should match";

const auto unreadCounts = service::ScalarArgument::require("unreadCounts", data);

const auto unreadCountEdges =

service::ScalarArgument::require<service::TypeModifier::List>("edges", unreadCounts);

ASSERT_EQ(size_t { 1 }, unreadCountEdges.size()) << "unreadCounts should have 1 entry";

ASSERT_TRUE(unreadCountEdges[0].type() == response::Type::Map)

<< "unreadCount should be an object";

const auto unreadCountNode = service::ScalarArgument::require("node", unreadCountEdges[0]);

EXPECT_EQ(today::getFakeFolderId(), service::IdArgument::require("id", unreadCountNode))

<< "id should match in base64 encoding";

EXPECT_EQ("\"Fake\" Inbox", service::StringArgument::require("name", unreadCountNode))

<< "name should match";

EXPECT_EQ(3, service::IntArgument::require("unreadCount", unreadCountNode))

<< "unreadCount should match";

EXPECT_EQ("Folder", service::StringArgument::require("__typename", unreadCountNode))

<< "__typename should match";

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(2);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

EXPECT_EQ(size_t { 1 }, _mockService->getAppointmentsCount)

<< "today service lazy loads the appointments and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->getTasksCount)

<< "today service lazy loads the tasks and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->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(errorsItr->second));

}

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(size_t { 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(today::getFakeAppointmentId(),

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());

}

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(2);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

EXPECT_EQ(size_t { 1 }, _mockService->getAppointmentsCount)

<< "today service lazy loads the appointments and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->getTasksCount)

<< "today service lazy loads the tasks and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->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(size_t { 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(today::getFakeAppointmentId(),

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());

}

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(2);

auto result = _mockService->service

->resolve({ query, {}, std::move(variables), std::launch::async, state })

.get();

EXPECT_EQ(size_t { 1 }, _mockService->getAppointmentsCount)

<< "today service lazy loads the appointments and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->getTasksCount)

<< "today service lazy loads the tasks and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->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(size_t { 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(today::getFakeAppointmentId(),

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());

}

{

auto query = R"gql({

})gql"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(3);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

EXPECT_GE(size_t { 1 }, _mockService->getAppointmentsCount)

<< "today service lazy loads the appointments and caches the result";

EXPECT_EQ(size_t { 1 }, _mockService->getTasksCount)

<< "today service lazy loads the tasks and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->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

{

ASSERT_TRUE(result.type() == response::Type::Map);

auto errorsItr = result.find("errors");

if (errorsItr != result.get<response::MapType>().cend())

{

FAIL() << response::toJSON(response::Value(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto tasks = service::ScalarArgument::require("tasks", data);

const auto taskEdges =

service::ScalarArgument::require<service::TypeModifier::List>("edges", tasks);

ASSERT_EQ(size_t { 1 }, taskEdges.size()) << "tasks should have 1 entry";

ASSERT_TRUE(taskEdges[0].type() == response::Type::Map) << "task should be an object";

const auto taskNode = service::ScalarArgument::require("node", taskEdges[0]);

EXPECT_EQ(today::getFakeTaskId(), service::IdArgument::require("taskId", 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 (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(4);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

EXPECT_GE(size_t { 1 }, _mockService->getAppointmentsCount)

<< "today service lazy loads the appointments and caches the result";

EXPECT_GE(size_t { 1 }, _mockService->getTasksCount)

<< "today service lazy loads the tasks and caches the result";

EXPECT_EQ(size_t { 1 }, _mockService->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

{

ASSERT_TRUE(result.type() == response::Type::Map);

auto errorsItr = result.find("errors");

if (errorsItr != result.get<response::MapType>().cend())

{

FAIL() << response::toJSON(response::Value(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto unreadCounts = service::ScalarArgument::require("unreadCounts", data);

const auto unreadCountEdges =

service::ScalarArgument::require<service::TypeModifier::List>("edges", unreadCounts);

ASSERT_EQ(size_t { 1 }, unreadCountEdges.size()) << "unreadCounts should have 1 entry";

ASSERT_TRUE(unreadCountEdges[0].type() == response::Type::Map)

<< "unreadCount should be an object";

const auto unreadCountNode = service::ScalarArgument::require("node", unreadCountEdges[0]);

EXPECT_EQ(today::getFakeFolderId(),

service::IdArgument::require("folderId", unreadCountNode))

<< "id should match in base64 encoding";

EXPECT_EQ("\"Fake\" Inbox", service::StringArgument::require("name", unreadCountNode))

<< "name should match";

EXPECT_EQ(3, service::IntArgument::require("unreadCount", unreadCountNode))

<< "unreadCount should match";

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = R"(mutation {

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(5);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto completedTask = service::ScalarArgument::require("completedTask", data);

ASSERT_TRUE(completedTask.type() == response::Type::Map) << "payload should be an object";

const auto task = service::ScalarArgument::require("completedTask", completedTask);

EXPECT_TRUE(task.type() == response::Type::Map) << "should get back a task";

EXPECT_EQ(today::getFakeTaskId(), service::IdArgument::require("completedTaskId", task))

<< "id should match in base64 encoding";

EXPECT_EQ("Mutated Task!", service::StringArgument::require("title", task))

<< "title should match";

EXPECT_TRUE(service::BooleanArgument::require("isComplete", task))

<< "isComplete should match";

const auto clientMutationId =

service::StringArgument::require("clientMutationId", completedTask);

EXPECT_EQ("Hi There!", clientMutationId) << "clientMutationId should match";

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = peg::parseString(R"(subscription TestSubscription {

})");

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(6);

response::Value result;

auto key = _mockService->service

->subscribe({ [&result](response::Value&& response) {

result = std::move(response);

},

std::move(query),

"TestSubscription"s,

std::move(variables),

{},

state })

.get();

_mockService->service->deliver({ "nextAppointmentChange"sv }).get();

_mockService->service->unsubscribe({ key }).get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto appointmentNode = service::ScalarArgument::require("nextAppointment", data);

EXPECT_EQ(today::getFakeAppointmentId(),

service::IdArgument::require("nextAppointmentId", 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_TRUE(service::BooleanArgument::require("isNow", appointmentNode))

<< "isNow should match";

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = peg::parseString(R"(subscription TestSubscription {

})");

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(7);

auto subscriptionObject = std::make_shared<today::NextAppointmentChange>(

[](const std::shared_ptr<service::RequestState>& state)

-> std::shared_ptr<today::Appointment> {

EXPECT_EQ(size_t { 7 }, std::static_pointer_cast<today::RequestState>(state)->requestId)

<< "should pass the RequestState to the subscription resolvers";

return std::make_shared<today::Appointment>(

response::IdType(today::getFakeAppointmentId()),

"today",

"Dinner Time!",

true);

});

response::Value result;

auto key = _mockService->service

->subscribe({ [&result](response::Value&& response) {

result = std::move(response);

},

std::move(query),

"TestSubscription"s,

std::move(variables),

{},

state })

.get();

_mockService->service

->deliver({ "nextAppointmentChange"sv,

{}, // filter

{}, // launch

std::make_shared<today::object::Subscription>(std::move(subscriptionObject)) })

.get();

_mockService->service->unsubscribe({ key }).get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto appointmentNode = service::ScalarArgument::require("nextAppointment", data);

EXPECT_EQ(today::getFakeAppointmentId(),

service::IdArgument::require("nextAppointmentId", appointmentNode))

<< "id should match in base64 encoding";

EXPECT_EQ("Dinner Time!", service::StringArgument::require("subject", appointmentNode))

<< "subject should match";

EXPECT_EQ("today", service::StringArgument::require("when", appointmentNode))

<< "when should match";

EXPECT_TRUE(service::BooleanArgument::require("isNow", appointmentNode))

<< "isNow should match";

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto service = std::make_shared<today::Operations>(nullptr, nullptr, nullptr);

bool exception = false;

try

{

service->deliver({ "nextAppointmentChange"sv }).get();

}

catch (const std::invalid_argument& ex)

{

EXPECT_TRUE(ex.what() == "Missing subscriptionObject"sv) << "exception should match";

exception = true;

}

ASSERT_TRUE(exception) << "expected an exception";

{

auto service = std::make_shared<today::EmptyOperations>();

bool exception = false;

try

{

service->deliver({ "nextAppointmentChange"sv }).get();

}

catch (const std::logic_error& ex)

{

EXPECT_TRUE(ex.what() == "Subscriptions not supported"sv) << "exception should match";

exception = true;

}

ASSERT_TRUE(exception) << "expected an exception";

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(8);

auto result = _mockService->service

->resolve({ query, {}, std::move(variables), std::launch::async, state })

.get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto schema = service::ScalarArgument::require("__schema", data);

const auto types =

service::ScalarArgument::require<service::TypeModifier::List>("types", schema);

const auto queryType = service::ScalarArgument::require("queryType", schema);

const auto mutationType = service::ScalarArgument::require("mutationType", schema);

ASSERT_FALSE(types.empty());

ASSERT_TRUE(queryType.type() == response::Type::Map);

ASSERT_TRUE(mutationType.type() == response::Type::Map);

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(9);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto schema = service::ScalarArgument::require("__schema", data);

const auto types =

service::ScalarArgument::require<service::TypeModifier::List>("types", schema);

const auto queryType = service::ScalarArgument::require("queryType", schema);

const auto mutationType = service::ScalarArgument::find("mutationType", schema);

ASSERT_FALSE(types.empty());

ASSERT_TRUE(queryType.type() == response::Type::Map);

ASSERT_FALSE(mutationType.second);

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = R"({

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(10);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto schema = service::ScalarArgument::require("__schema", data);

const auto types =

service::ScalarArgument::require<service::TypeModifier::List>("types", schema);

const auto queryType = service::ScalarArgument::find("queryType", schema);

const auto mutationType = service::ScalarArgument::require("mutationType", schema);

ASSERT_FALSE(types.empty());

ASSERT_FALSE(queryType.second);

ASSERT_TRUE(mutationType.type() == response::Type::Map);

}

catch (service::schema_exception& ex)

{

FAIL() << response::toJSON(ex.getErrors());

}

{

auto query = R"(

})"_graphql;

response::Value variables(response::Type::Map);

auto state = std::make_shared<today::RequestState>(11);

auto result =

_mockService->service->resolve({ query, {}, std::move(variables), {}, state }).get();

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(errorsItr->second));

}

const auto data = service::ScalarArgument::require("data", result);

const auto nested1 = service::ScalarArgument::require("nested", data);

const auto depth1 = service::IntArgument::require("depth", nested1);

const auto nested2 = service::ScalarArgument::require("fragmentDefinitionNested", nested1);

const auto depth2 = service::IntArgument::require("depth", nested2);

const auto nested3 = service::ScalarArgument::require("inlineFragmentNested", nested2);

const auto depth3 = service::IntArgument::require("depth", nested3);

const auto nested4 = service::ScalarArgument::require("inlineFragmentNested", nested3);

const auto depth4 = service::IntArgument::require("depth", nested4);

auto capturedParams = today::NestedType::getCapturedParams();

const auto params4 = std::move(capturedParams.top());

capturedParams.pop();

const auto params3 = std::move(capturedParams.top());

capturedParams.pop();

const auto params2 = std::move(capturedParams.top());

capturedParams.pop();

const auto params1 = std::move(capturedParams.top());

capturedParams.pop();

ASSERT_EQ(size_t { 1 }, params1.operationDirectives.size())

<< "missing operation directive";

const auto itrQueryTag1 = params1.operationDirectives.cbegin();

ASSERT_TRUE(itrQueryTag1->first == "queryTag"sv) << "missing required directive";

const auto& queryTag1 = itrQueryTag1->second;

const auto query1 = service::StringArgument::require("query", queryTag1);

const auto fragmentDefinitionCount1 = params1.fragmentDefinitionDirectives.size();

const auto fragmentSpreadCount1 = params1.fragmentSpreadDirectives.size();

const auto inlineFragmentCount1 = params1.inlineFragmentDirectives.size();

ASSERT_EQ(size_t { 1 }, params1.fieldDirectives.size()) << "missing operation directive";

const auto itrFieldTag1 = params1.fieldDirectives.cbegin();

ASSERT_TRUE(itrFieldTag1->first == "fieldTag"sv) << "missing required directive";

const auto& fieldTag1 = itrFieldTag1->second;

const auto field1 = service::StringArgument::require("field", fieldTag1);

ASSERT_EQ(size_t { 1 }, params2.operationDirectives.size())

<< "missing operation directive";

const auto itrQueryTag2 = params2.operationDirectives.cbegin();

ASSERT_TRUE(itrQueryTag2->first == "queryTag"sv) << "missing required directive";

const auto& queryTag2 = itrQueryTag2->second;

const auto query2 = service::StringArgument::require("query", queryTag2);

ASSERT_EQ(size_t { 1 }, params2.fragmentDefinitionDirectives.size())

<< "missing fragment definition directive";

const auto itrFragmentDefinitionTag2 = params2.fragmentDefinitionDirectives.cbegin();

ASSERT_TRUE(itrFragmentDefinitionTag2->first == "fragmentDefinitionTag"sv)

<< "missing fragment definition directive";

const auto& fragmentDefinitionTag2 = itrFragmentDefinitionTag2->second;

const auto fragmentDefinition2 =

service::StringArgument::require("fragmentDefinition", fragmentDefinitionTag2);

ASSERT_EQ(size_t { 1 }, params2.fragmentSpreadDirectives.size())

<< "missing fragment spread directive";

const auto itrFragmentSpreadTag2 = params2.fragmentSpreadDirectives.cbegin();

ASSERT_TRUE(itrFragmentSpreadTag2->first == "fragmentSpreadTag"sv)

<< "missing fragment spread directive";

const auto& fragmentSpreadTag2 = itrFragmentSpreadTag2->second;

const auto fragmentSpread2 =