blitz_query_cpp

1
#include <gtest/gtest.h>
2
#include <gmock/gmock.h>
3
#include "parser/parser.hpp"
4
#include <format>
5

6
using namespace blitz_query_cpp;
7

8
TEST(Parser_t, ParseArgumentDefinitions)
9
{
10
  document_t doc("(stringVal: String = \"foo\", intVal :Int)");
11
  doc.all_nodes.reserve(10);
12
  parser_t parser(doc);
13
  EXPECT_TRUE(parser.parse_argument_definitions());
14
  ASSERT_EQ(doc.children.size(), 2u);
15
  ASSERT_EQ(doc.arguments.size(), doc.children.size());
16

17
  ASSERT_EQ(doc.children[0]->type, syntax_node_type::InputValueDefinition);
18
  ASSERT_EQ(doc.children[1]->type, syntax_node_type::InputValueDefinition);
19

20
  ASSERT_EQ(doc.children[0]->name, "stringVal");
21
  ASSERT_EQ(doc.children[1]->name, "intVal");
22

23
  ASSERT_NE(doc.children[0]->definition_type, nullptr);
24
  ASSERT_NE(doc.children[1]->definition_type, nullptr);
25

26
  ASSERT_EQ(doc.children[0]->definition_type->name, "String");
27
  ASSERT_EQ(doc.children[1]->definition_type->name, "Int");
28
}
29

30
TEST(Parser_t, ParseArguments)
31
{
32
  document_t doc("(stringVal: \"foo\", intVal :42, objVal: {foo:10 bar:null} boolVal: true enumVal: Hello, floatVal : 3.14e2)");
33
  doc.all_nodes.reserve(20);
34
  parser_t parser(doc);
35
  EXPECT_TRUE(parser.parse_arguments(false));
36
  ASSERT_EQ(doc.children.size(), 6u);
37
  ASSERT_EQ(doc.arguments.size(), doc.children.size());
38

39
  EXPECT_EQ(doc.children[0]->type, syntax_node_type::Argument);
40
  EXPECT_EQ(doc.children[1]->type, syntax_node_type::Argument);
41
  EXPECT_EQ(doc.children[2]->type, syntax_node_type::Argument);
42
  EXPECT_EQ(doc.children[3]->type, syntax_node_type::Argument);
43
  EXPECT_EQ(doc.children[4]->type, syntax_node_type::Argument);
44
  EXPECT_EQ(doc.children[5]->type, syntax_node_type::Argument);
45

46
  EXPECT_EQ(doc.children[0]->name, "stringVal");
47
  EXPECT_EQ(doc.children[1]->name, "intVal");
48
  EXPECT_EQ(doc.children[2]->name, "objVal");
49
  EXPECT_EQ(doc.children[3]->name, "boolVal");
50
  EXPECT_EQ(doc.children[4]->name, "enumVal");
51
  EXPECT_EQ(doc.children[5]->name, "floatVal");
52

53
  EXPECT_EQ(doc.arguments[0]->children[0]->content, "foo");
54
  EXPECT_EQ(doc.arguments[1]->children[0]->intValue, 42);
55
  EXPECT_EQ(doc.arguments[2]->children[0]->children[0]->children[0]->intValue, 10);
56
  EXPECT_EQ(doc.arguments[3]->children[0]->boolValue, true);
57
  EXPECT_EQ(doc.arguments[4]->children[0]->content, "Hello");
58
  EXPECT_EQ(doc.arguments[5]->children[0]->floatValue, 314.0);
59
}
60

61
TEST(Parser_t, ParseDirectives)
62
{
63
  document_t doc("@include(if:$foo) @custom");
64
  doc.all_nodes.reserve(20);
65
  parser_t parser(doc);
66
  EXPECT_TRUE(parser.parse_directives(false));
67
  ASSERT_EQ(doc.children.size(), 2u);
68
  ASSERT_EQ(doc.directives.size(), doc.children.size());
69

70
  EXPECT_EQ(doc.directives[0]->type, syntax_node_type::Directive);
71
  EXPECT_EQ(doc.directives[1]->type, syntax_node_type::Directive);
72

73
  EXPECT_EQ(doc.directives[0]->name, "@include");
74
  EXPECT_EQ(doc.directives[1]->name, "@custom");
75

76
  ASSERT_EQ(doc.directives[0]->arguments.size(), 1u);
77
  EXPECT_EQ(doc.directives[0]->arguments[0]->name, "if");
78
  ASSERT_EQ(doc.directives[0]->arguments[0]->children.size(), 1u);
79
  EXPECT_EQ(doc.directives[0]->arguments[0]->children[0]->type, syntax_node_type::Variable);
80
  EXPECT_EQ(doc.directives[0]->arguments[0]->children[0]->name, "$foo");
81
}
82

83
TEST(Parser_t, ParseField)
84
{
85
  document_t doc("my_pic :\tpicture(size:128)@include(if:$foo){type data}");
86
  doc.all_nodes.reserve(20);
87
  parser_t parser(doc);
88
  EXPECT_TRUE(parser.parse_field());
89
  ASSERT_EQ(doc.children.size(), 1u);
90
  ASSERT_NE(doc.children[0]->selection_set, nullptr);
91
  ASSERT_EQ(doc.children[0]->directives.size(), 1u);
92
  ASSERT_EQ(doc.children[0]->arguments.size(), 1u);
93
  ASSERT_EQ(doc.children[0]->selection_set->children.size(), 2u);
94
}
95

96
TEST(Parser_t, ShortQuery)
97
{
98
  document_t doc("{file(skip:0,take:10){items{name Id}totalCount}}");
99
  doc.all_nodes.reserve(20);
100
  parser_t parser(doc);
101
  EXPECT_TRUE(parser.parse());
102
  ASSERT_EQ(doc.children.size(), 1u);
103
  EXPECT_EQ(doc.children[0]->type, syntax_node_type::OperationDefinition);
104
  ASSERT_NE(doc.children[0]->selection_set, nullptr);
105
  EXPECT_EQ(doc.children[0]->directives.size(), 0u);
106
  EXPECT_EQ(doc.children[0]->arguments.size(), 0u);
107
  ASSERT_EQ(doc.children[0]->selection_set->children.size(), 1u);
108
  EXPECT_EQ(doc.children[0]->selection_set->children[0]->arguments.size(), 2u);
109
}
110

111
TEST(Parser_t, FragmentQuery)
112
{
113
  document_t doc("query withFragments{file{items{...fileFields}}} fragment fileFields on File{id name}");
114
  doc.all_nodes.reserve(20);
115
  parser_t parser(doc);
116
  EXPECT_TRUE(parser.parse());
117
  ASSERT_EQ(doc.children.size(), 2u);
118
  EXPECT_EQ(doc.children[0]->type, syntax_node_type::OperationDefinition);
119
  EXPECT_EQ(doc.children[0]->name, "withFragments");
120
  ASSERT_NE(doc.children[0]->selection_set, nullptr);
121
  EXPECT_EQ(doc.children[0]->directives.size(), 0u);
122
  EXPECT_EQ(doc.children[0]->arguments.size(), 0u);
123
  ASSERT_EQ(doc.children[0]->selection_set->children.size(), 1u);
124
  EXPECT_EQ(doc.children[0]->selection_set->children[0]->arguments.size(), 0u);
125

126
  EXPECT_EQ(doc.children[1]->type, syntax_node_type::FragmentDefinition);
127
  EXPECT_EQ(doc.children[1]->name, "fileFields");
128
  
129
}
130

131
TEST(Parser_t, Query)
132
{
133
  std::string query = "query files($pattern: String = \"\\\"\"){\r\n\
134
  file(skip: 0, take : 10 where:{name:{contains: $pattern}}) {\r\n\
135
    pageInfo {\r\n\
136
      hasNextPage\r\n\
137
      # hasPreviousPage\r\n\
138
    }\r\n\
139
    items{\r\n\
140
      filename : name,\r\n\
141
      Id,\r\n\
142
      bucket_id,\r\n\
143
      bucket @skip_if(bucket_id:null),\r\n\
144
      {\r\n\
145
        name\r\n\
146
      }\r\n\
147
    }\r\n\
148
    totalCount\r\n\
149
  }\r\n\
150
}";
151

152
  document_t doc{std::string(query)};
153
  parser_t parser(doc);
154
  EXPECT_TRUE(parser.parse());
155

156
  // for(auto& node : doc.all_nodes)
157
  // {
158
  //   std::cout << enum_name(node.type) << "\t(" << node.pos << ", " << node.size << "): '" << node.content << "'" << std::endl;
159
  // }
160
}
161