blitz_query_cpp

1
#include <type_system/type_system_classes.hpp>
2
#include <gtest/gtest.h>
3
#include <gmock/gmock.h>
4
#include <type_system/schema.hpp>
5
#include <type_system/schema_parser.hpp>
6
#include <type_system/builtin_types.hpp>
7

8
#include <filesystem>
9
#include <fstream>
10
#include <string>
11

12
using namespace blitz_query_cpp;
13

14
TEST(Schema, ParseSchemaDef)
15
{
16
   std::string scm = "schema { query: Query mutation: Mutation }";
17
   schema_t my_schema;
18
   schema_parser_t parser;
19
   bool res = parser.parse(my_schema, scm);
20
   EXPECT_EQ(res, true);
21
   EXPECT_EQ(my_schema.query_type_name, "Query");
22
   EXPECT_EQ(my_schema.mutation_type_name, "Mutation");
23
}
24

25
TEST(Schema, ParseScalarDef)
26
{
27
   std::string scm = "\"scalar description\" scalar UUID @specifiedBy(url: \"https://tools.ietf.org/html/rfc4122\" foo: {bar: 1 baz: false}, param: null)";
28
   schema_t my_schema;
29
   schema_parser_t parser;
30
   bool res = parser.parse(my_schema, scm);
31
   ASSERT_EQ(res, true);
32
   ASSERT_EQ(my_schema.types.size(), 1u);
33
   auto &type = *my_schema.types.begin();
34
   EXPECT_EQ(type.description, "scalar description");
35
   EXPECT_EQ(type.kind, type_kind::Scalar);
36
   ASSERT_EQ(type.directives.size(), 1u);
37
   EXPECT_EQ(type.directives[0].name, "@specifiedBy");
38
}
39

40
TEST(Schema, ParseEnumDef)
41
{
42
   std::string scm = "\"enum description\" enum BookGenre @foo {ART CHILDREN_BOOK SCIENCE}";
43
   schema_t my_schema;
44
   schema_parser_t parser;
45
   bool res = parser.parse(my_schema, scm);
46
   ASSERT_EQ(res, true);
47
   ASSERT_EQ(my_schema.types.size(), 1u);
48
   auto &type = *my_schema.types.begin();
49
   EXPECT_EQ(type.directives.size(), 1u);
50

51
   EXPECT_EQ(type.description, "enum description");
52
   ASSERT_EQ(type.kind, type_kind::Enum);
53
   ASSERT_EQ(type.fields.size(), 3u);
54
   ASSERT_EQ(type.fields.contains("ART"), true);
55
   ASSERT_EQ(type.fields.contains("CHILDREN_BOOK"), true);
56
   ASSERT_EQ(type.fields.contains("SCIENCE"), true);
57
}
58

59
TEST(Schema, ParseDirectiveDef)
60
{
61
   std::string scm = "\"directive description\" directive @foo (\"param descr\" param: String!, foo :Foo = {bar: 1 buz: true}) repeatable on SCALAR | ENUM";
62
   schema_t my_schema;
63
   schema_parser_t parser;
64
   bool res = parser.parse(my_schema, scm);
65
   ASSERT_EQ(res, true);
66
   ASSERT_EQ(my_schema.directive_types.size(), 1u);
67
   auto &type = *my_schema.directive_types.begin();
68
   EXPECT_EQ(type.description, "directive description");
69
   EXPECT_EQ(type.name, "@foo");
70
   EXPECT_EQ(type.target, directive_target_t::Scalar | directive_target_t::Enum | directive_target_t::IsRepeatable);
71

72
   EXPECT_EQ(type.arguments.size(), 2u);
73
   ASSERT_EQ(type.arguments.contains("param"), true);
74
   ASSERT_EQ(type.arguments.contains("foo"), true);
75

76
   auto param = *type.arguments.find("param");
77
   EXPECT_EQ(param.field_type.name, "String");
78
   EXPECT_EQ(param.field_type.not_nullable, 1u);
79
   EXPECT_EQ(param.description, "param descr");
80
   EXPECT_EQ(param.default_value.value_type, value_kind::None);
81

82
   auto foo = *type.arguments.find("foo");
83
   EXPECT_EQ(foo.field_type.name, "Foo");
84
   EXPECT_EQ(foo.field_type.not_nullable, 0u);
85
   EXPECT_EQ(foo.description, "");
86
   EXPECT_EQ(foo.default_value.value_type, value_kind::Object);
87
}
88

89
TEST(Schema, ParseUnionDef)
90
{
91
   std::string scm = "\"union description\" union MyUnion @foo = User | Group";
92
   schema_t my_schema;
93
   schema_parser_t parser;
94
   bool res = parser.parse(my_schema, scm);
95
   ASSERT_EQ(res, true);
96

97
   auto &type = *my_schema.types.begin();
98
   EXPECT_EQ(type.directives.size(), 1u);
99

100
   EXPECT_EQ(type.description, "union description");
101
   ASSERT_EQ(type.kind, type_kind::Union);
102
   ASSERT_EQ(type.implements.size(), 2u);
103
   ASSERT_EQ(type.implements.contains("User"), true);
104
   ASSERT_EQ(type.implements.contains("Group"), true);
105
}
106

107
TEST(Schema, ParseInputDef)
108
{
109
   std::string scm = "\"input description\" input fileInput @foo { \"file is deleted\" deleted: Boolean! = true @bar name: String Id: UUID }";
110
   schema_t my_schema;
111
   schema_parser_t parser;
112
   bool res = parser.parse(my_schema, scm);
113
   ASSERT_EQ(res, true);
114

115
   auto &type = *my_schema.types.begin();
116
   EXPECT_EQ(type.directives.size(), 1u);
117
   EXPECT_EQ(type.directives[0].name, "@foo");
118

119
   EXPECT_EQ(type.description, "input description");
120
   EXPECT_EQ(type.kind, type_kind::InputObject);
121
   EXPECT_EQ(type.fields.size(), 3u);
122
   ASSERT_EQ(type.fields.contains("deleted"), true);
123
   ASSERT_EQ(type.fields.contains("name"), true);
124
   ASSERT_EQ(type.fields.contains("Id"), true);
125

126
   auto deleted = *type.fields.find("deleted");
127
   EXPECT_EQ(deleted.description, "file is deleted");
128
   EXPECT_EQ(deleted.declaring_type.name, "fileInput");
129
   EXPECT_EQ(deleted.field_type.name, "Boolean");
130
   EXPECT_EQ(deleted.field_type.not_nullable, 1u);
131
   EXPECT_EQ(deleted.field_type.list_nesting_depth, 0);
132
   EXPECT_EQ(deleted.default_value.value_type, value_kind::Boolean);
133
   EXPECT_EQ(deleted.default_value.bool_value, true);
134
   EXPECT_EQ(deleted.directives.size(), 1u);
135
   EXPECT_EQ(deleted.directives[0].name, "@bar");
136
   EXPECT_EQ(deleted.index, 0);
137
   EXPECT_EQ(deleted.is_optional(), true);
138
}
139

140
TEST(Schema, ParseTypeDef)
141
{
142
   std::string scm = "\"files descr\" type Files implements FileSystem @foo(bar:\"baz\") { \"file descr\" file(skip: Int take: Int where: fileFilterInput order: [fileSortInput!]): fileCollectionSegment @bar }";
143
   schema_t my_schema;
144
   schema_parser_t parser;
145
   bool res = parser.parse(my_schema, scm);
146
   EXPECT_EQ(parser.get_error_msg(), "");
147
   ASSERT_EQ(res, true);
148

149
   auto &type = *my_schema.types.begin();
150
   EXPECT_EQ(type.directives.size(), 1u);
151
   EXPECT_EQ(type.directives[0].name, "@foo");
152
   EXPECT_EQ(type.directives[0].parameters.contains("bar"), true);
153

154
   EXPECT_EQ(type.description, "files descr");
155
   EXPECT_EQ(type.kind, type_kind::Object);
156
   EXPECT_EQ(type.fields.size(), 1u);
157
   ASSERT_EQ(type.fields.contains("file"), true);
158

159
   auto file = *type.fields.find("file");
160
   EXPECT_EQ(file.description, "file descr");
161
   EXPECT_EQ(file.declaring_type.name, "Files");
162
   EXPECT_EQ(file.field_type.name, "fileCollectionSegment");
163
   EXPECT_EQ(file.field_type.not_nullable, 0u);
164
   EXPECT_EQ(file.field_type.list_nesting_depth, 0);
165
   EXPECT_EQ(file.directives.size(), 1u);
166
   EXPECT_EQ(file.directives[0].name, "@bar");
167
   EXPECT_EQ(file.index, 0);
168
   EXPECT_EQ(file.is_optional(), true);
169
}
170

171
TEST(Schema, ParseInterfaceDef)
172
{
173
   std::string scm = "\"interface descr\" interface FileSystem @foo(bar:\"baz\") { \"file descr\" file(skip: Int take: Int where: fileFilterInput order: [fileSortInput!]): fileCollectionSegment @bar }";
174
   schema_t my_schema;
175
   schema_parser_t parser;
176
   bool res = parser.parse(my_schema, scm);
177
   EXPECT_EQ(parser.get_error_msg(), "");
178
   ASSERT_EQ(res, true);
179

180
   auto &type = *my_schema.types.begin();
181
   EXPECT_EQ(type.directives.size(), 1u);
182
   EXPECT_EQ(type.directives[0].name, "@foo");
183
   EXPECT_EQ(type.directives[0].parameters.contains("bar"), true);
184

185
   EXPECT_EQ(type.description, "interface descr");
186
   EXPECT_EQ(type.kind, type_kind::Object);
187
   EXPECT_EQ(type.fields.size(), 1u);
188
   ASSERT_EQ(type.fields.contains("file"), true);
189

190
   auto file = *type.fields.find("file");
191
   EXPECT_EQ(file.description, "file descr");
192
   EXPECT_EQ(file.declaring_type.name, "FileSystem");
193
   EXPECT_EQ(file.field_type.name, "fileCollectionSegment");
194
   EXPECT_EQ(file.field_type.not_nullable, 0u);
195
   EXPECT_EQ(file.field_type.list_nesting_depth, 0);
196
   EXPECT_EQ(file.directives.size(), 1u);
197
   EXPECT_EQ(file.directives[0].name, "@bar");
198
   EXPECT_EQ(file.index, 0);
199
   EXPECT_EQ(file.is_optional(), true);
200
}
201

202
namespace fs = std::filesystem;
203

204
std::string readFile(fs::path path)
205
{
206
   std::ifstream f(path, std::ios::in | std::ios::binary);
207
   const auto sz = fs::file_size(path);
208
   std::string result(sz, '\0');
209
   f.read(result.data(), sz);
210
   return result;
211
}
212

213
TEST(Schema, LoadSchema)
214
{
215
   std::string scm = readFile("test_data/schema.graphql");
216
   schema_t my_schema;
217
   schema_parser_t parser;
218
   bool res = parser.parse(my_schema, scm);
219
   EXPECT_EQ(parser.get_error_msg(), "");
220
   ASSERT_EQ(res, true);
221
}
222

223
TEST(Schema, SchemaIntrospectionTypes)
224
{
225
   schema_t my_schema;
226
   bool res = add_introspection_types(my_schema);
227
   ASSERT_EQ(res, true);
228
}
229

230

231
TEST(Schema, ParseObjectExt)
232
{
233
   std::string scm = "type Foo{bar:Int} extend type Foo{baz:Int} ";
234
   schema_t my_schema;
235
   schema_parser_t parser;
236
   bool res = parser.parse(my_schema, scm);
237
   EXPECT_EQ(parser.get_error_msg(), "");
238
   ASSERT_EQ(res, true);
239

240
}