1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
module Path = ImportDataTypes.Path
open Test_migration
let result_testable =
Alcotest.result Test_migration.expression_testable Alcotest.string
(** Helper used to test the equality between the litteral expression and it’s
AST *)
let test : string -> Path.t ImportExpression.T.t -> unit =
fun expr result ->
let expression = ImportConf.expression_from_string expr in
Alcotest.check result_testable "" (Ok result) expression
let path_column =
"column as path" >:: fun () ->
test ":A" (Path { Path.alias = None; column = 1 })
let path_table =
"path with table" >:: fun () ->
test ":table.A" (Path { Path.alias = Some "table"; column = 1 })
let path_subtable =
"path with table" >:: fun () ->
test ":table.Name.A" (Path { Path.alias = Some "table.Name"; column = 1 })
let parse_dquoted =
"parse_dquoted" >:: fun _ ->
test "match(\"\\(..\\)\", :B)"
(Function
("match", [ Literal "\\(..\\)"; Path { alias = None; column = 2 } ]))
let parse_quoted =
"parse_quoted" >:: fun _ ->
test "match('\\(..\\)', :B)"
(Function
("match", [ Literal "\\(..\\)"; Path { alias = None; column = 2 } ]))
let concat =
"concat" >:: fun _ ->
test ":A ^ :B"
(Concat
[ Path { alias = None; column = 1 }; Path { alias = None; column = 2 } ])
let concat2 =
"concat2" >:: fun _ ->
test "'A' ^ '_' ^ 'B'" (Concat [ Literal "A"; Literal "_"; Literal "B" ])
let litteral =
"litteral" >:: fun _ ->
(* The text is quoted in shall not be considered as a path *)
test "':A'" (Literal ":A")
let empty = "empty" >:: fun _ -> test "" Empty
let upper_nvl =
"upper_nvl" >:: fun _ -> test "NVL('','')" (Nvl [ Empty; Empty ])
let lower_nvl =
"lower_nvl" >:: fun _ -> test "nvl('','')" (Nvl [ Empty; Empty ])
let numeric = "numeric" >:: fun _ -> test "123" (Integer "123")
let numeric_neg = "numeric_neg" >:: fun _ -> test "-123" (Integer "-123")
let op_priority =
"operator_priority" >:: fun _ ->
test "1 + 2 > 2"
(BOperator (GT, BOperator (Add, Integer "1", Integer "2"), Integer "2"))
let op_priority2 =
"operator_priority" >:: fun _ ->
test "1 ^ 2 = 2"
(BOperator (Equal, Concat [ Integer "1"; Integer "2" ], Integer "2"))
let join =
"join" >:: fun _ ->
let expr = "join('sep', :A, :B)" in
let result = ImportConf.expression_from_string expr in
Alcotest.check result_testable ""
(Ok
(Join
( "sep",
[
Path { alias = None; column = 1 };
Path { alias = None; column = 2 };
] )))
result
let join_empty =
"join" >:: fun _ ->
test "join('', :A, :B)"
(Join
( "",
[
Path { alias = None; column = 1 }; Path { alias = None; column = 2 };
] ))
let upper = "upper" >:: fun _ -> test "upper('')" (Function' (Upper, [ Empty ]))
let trim = "trim" >:: fun _ -> test "trim('')" (Function' (Trim, [ Empty ]))
(** Extract the columns from a window function *)
let fold_values =
"fold_values" >:: fun _ ->
let open Path in
(* The expression we want to test *)
let expr =
ImportExpression.T.Window
( Previous (Path { alias = None; column = 1 }),
[ Path { alias = None; column = 2 } ],
[ Path { alias = None; column = 3 } ] )
in
let result =
ImportExpression.T.fold_values ~init:[] ~f:(fun acc v -> v :: acc) expr
|> List.rev
in
let expected =
[
{ alias = None; column = 1 };
{ alias = None; column = 2 };
{ alias = None; column = 3 };
]
in
Alcotest.check
(Alcotest.list @@ Test_migration.make_test (module Path))
"" expected result
let bad_quote =
"bad_quote" >:: fun _ ->
let expr = "':source.A" in
let result = ImportConf.expression_from_string expr in
Alcotest.check result_testable ""
(Error "Unclosed quote at line 1 : \"':source.A\"") result
let nested_expression =
"nested_expression" >:: fun _ ->
test "1 = (1 = 0)"
(BOperator
(Equal, Integer "1", Expr (BOperator (Equal, Integer "1", Integer "0"))))
let priority_equality =
"priority_equality" >:: fun _ ->
test "1 = 1 = 0"
(BOperator (Equal, Integer "1", BOperator (Equal, Integer "1", Integer "0")))
let priority_operator_and =
"priority_equality" >:: fun _ ->
test "1 and 1 = 0"
(BOperator (And, Integer "1", BOperator (Equal, Integer "1", Integer "0")))
let priority_operator_or =
"priority_equality" >:: fun _ ->
test "1 <> 1 or 0"
(BOperator (Or, BOperator (Different, Integer "1", Integer "1"), Integer "0"))
let unknown_function =
"unknown function" >:: fun _ ->
let expr = "function()" in
let result = ImportConf.expression_from_string expr in
Alcotest.check result_testable ""
(Error "Unknown function or wrong number of arguments for 'function'")
result
let wrong_arguments =
"unknown function" >:: fun _ ->
let expr = "if()" in
let result = ImportConf.expression_from_string expr in
Alcotest.check result_testable ""
(Error "Unknown function or wrong number of arguments for 'if'") result
let test_suit =
[
path_column;
path_table;
path_subtable;
parse_dquoted;
parse_quoted;
concat;
concat2;
litteral;
empty;
upper_nvl;
lower_nvl;
numeric;
numeric_neg;
op_priority;
op_priority2;
join;
upper;
trim;
join_empty;
fold_values;
bad_quote;
nested_expression;
priority_equality;
priority_operator_and;
priority_operator_or;
unknown_function;
wrong_arguments;
]
let tests = "configuration_expression" >::: test_suit
|
