Skip to content
This repository was archived by the owner on Jun 4, 2024. It is now read-only.

Commit 1732a03

Browse files
dmt0dmt0
committed
Tests
1 parent 9fe1ffb commit 1732a03

File tree

2 files changed

+155
-17
lines changed

2 files changed

+155
-17
lines changed

‎tests/cypress/tests/unit/query_syntactic_tree_test.ts

Lines changed: 90 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -589,5 +589,95 @@ describe('Query Syntax Tree', () => {
589589
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
590590
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
591591
});
592+
593+
it('can do case insensitive equality (i=) test', () => {
594+
const tree = new QuerySyntaxTree('{a} i= "abc v"');
595+
596+
expect(tree.isValid).to.equal(true);
597+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
598+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
599+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
600+
});
601+
602+
it('can do case insensitive equality (ieq) test', () => {
603+
const tree = new QuerySyntaxTree('{a} ieq "abc v"');
604+
605+
expect(tree.isValid).to.equal(true);
606+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
607+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
608+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
609+
});
610+
611+
it('can do case insensitive difference (ine) test', () => {
612+
const tree = new QuerySyntaxTree('{a} ine "abc v"');
613+
614+
expect(tree.isValid).to.equal(true);
615+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
616+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
617+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
618+
});
619+
620+
it('can do case insensitive difference (i!=) test', () => {
621+
const tree = new QuerySyntaxTree('{a} i!= "abc v"');
622+
623+
expect(tree.isValid).to.equal(true);
624+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
625+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
626+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
627+
});
628+
629+
it('can do case insensitive icontains (icontains) test', () => {
630+
const tree = new QuerySyntaxTree('{a} icontains v');
631+
632+
expect(tree.isValid).to.equal(true);
633+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
634+
expect(tree.evaluate({ a: 'abc V' })).to.equal(true);
635+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
636+
});
637+
638+
it('can do case sensitive equality (s=) test', () => {
639+
const tree = new QuerySyntaxTree('{a} s= "abc v"');
640+
641+
expect(tree.isValid).to.equal(true);
642+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
643+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
644+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
645+
});
646+
647+
it('can do case sensitive equality (seq) test', () => {
648+
const tree = new QuerySyntaxTree('{a} seq "abc v"');
649+
650+
expect(tree.isValid).to.equal(true);
651+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
652+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
653+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
654+
});
655+
656+
it('can do case sensitive difference (sne) test', () => {
657+
const tree = new QuerySyntaxTree('{a} sne "abc v"');
658+
659+
expect(tree.isValid).to.equal(true);
660+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
661+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
662+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
663+
});
664+
665+
it('can do case sensitive difference (s!=) test', () => {
666+
const tree = new QuerySyntaxTree('{a} s!= "abc v"');
667+
668+
expect(tree.isValid).to.equal(true);
669+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
670+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
671+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
672+
});
673+
674+
it('can do case sensitive scontains (scontains) test', () => {
675+
const tree = new QuerySyntaxTree('{a} scontains v');
676+
677+
expect(tree.isValid).to.equal(true);
678+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
679+
expect(tree.evaluate({ a: 'abc V' })).to.equal(false);
680+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
681+
});
592682
});
593683
});

‎tests/cypress/tests/unit/single_column_syntactic_tree_test.ts

Lines changed: 65 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -29,34 +29,46 @@ const COLUMN_UNDEFINED: SingleColumnConfig = {
2929
type: undefined
3030
};
3131

32+
const COLUMN_CASE_INSENSITIVE: SingleColumnConfig = {
33+
id: 'a',
34+
type: ColumnType.Text,
35+
filter_case_insensitive: true
36+
};
37+
38+
const COLUMN_CASE_SENSITIVE: SingleColumnConfig = {
39+
id: 'a',
40+
type: ColumnType.Text,
41+
filter_case_sensitive: true
42+
};
43+
3244
describe('Single Column Syntax Tree', () => {
3345
it('cannot have operand', () => {
34-
const tree = new SingleColumnSyntaxTree('{a} <= 1', COLUMN_UNDEFINED, Case.Insensitive);
46+
const tree = new SingleColumnSyntaxTree('{a} <= 1', COLUMN_UNDEFINED, Case.Sensitive);
3547

3648
expect(tree.isValid).to.equal(false);
3749
});
3850

3951
it('cannot have binary dangle', () => {
40-
const tree = new SingleColumnSyntaxTree('<=', COLUMN_UNDEFINED, Case.Insensitive);
52+
const tree = new SingleColumnSyntaxTree('<=', COLUMN_UNDEFINED, Case.Sensitive);
4153

4254
expect(tree.isValid).to.equal(false);
4355
});
4456

4557
it('cannot be unary + expression', () => {
46-
const tree = new SingleColumnSyntaxTree('is prime "a"', COLUMN_UNDEFINED, Case.Insensitive);
58+
const tree = new SingleColumnSyntaxTree('is prime "a"', COLUMN_UNDEFINED, Case.Sensitive);
4759

4860
expect(tree.isValid).to.equal(false);
4961
});
5062

5163
it('can be empty', () => {
52-
const tree = new SingleColumnSyntaxTree('', COLUMN_UNDEFINED, Case.Insensitive);
64+
const tree = new SingleColumnSyntaxTree('', COLUMN_UNDEFINED, Case.Sensitive);
5365

5466
expect(tree.isValid).to.equal(true);
5567
expect(tree.evaluate({ a: 0 })).to.equal(true);
5668
});
5769

5870
it('can be binary + expression', () => {
59-
const tree = new SingleColumnSyntaxTree('<= 1', COLUMN_UNDEFINED, Case.Insensitive);
71+
const tree = new SingleColumnSyntaxTree('<= 1', COLUMN_UNDEFINED, Case.Sensitive);
6072

6173
expect(tree.isValid).to.equal(true);
6274
expect(tree.evaluate({ a: 0 })).to.equal(true);
@@ -66,7 +78,7 @@ describe('Single Column Syntax Tree', () => {
6678
});
6779

6880
it('can be unary', () => {
69-
const tree = new SingleColumnSyntaxTree('is prime', COLUMN_UNDEFINED, Case.Insensitive);
81+
const tree = new SingleColumnSyntaxTree('is prime', COLUMN_UNDEFINED, Case.Sensitive);
7082

7183
expect(tree.isValid).to.equal(true);
7284
expect(tree.evaluate({ a: 5 })).to.equal(true);
@@ -76,7 +88,7 @@ describe('Single Column Syntax Tree', () => {
7688
});
7789

7890
it('can be expression with undefined column type', () => {
79-
const tree = new SingleColumnSyntaxTree('1', COLUMN_UNDEFINED, Case.Insensitive);
91+
const tree = new SingleColumnSyntaxTree('1', COLUMN_UNDEFINED, Case.Sensitive);
8092

8193
expect(tree.isValid).to.equal(true);
8294
expect(tree.evaluate({ a: '1' })).to.equal(true);
@@ -88,7 +100,7 @@ describe('Single Column Syntax Tree', () => {
88100
});
89101

90102
it('can be expression with numeric column type', () => {
91-
const tree = new SingleColumnSyntaxTree('1', COLUMN_NUMERIC, Case.Insensitive);
103+
const tree = new SingleColumnSyntaxTree('1', COLUMN_NUMERIC, Case.Sensitive);
92104

93105
expect(tree.isValid).to.equal(true);
94106
expect(tree.evaluate({ a: 1 })).to.equal(true);
@@ -98,7 +110,7 @@ describe('Single Column Syntax Tree', () => {
98110
});
99111

100112
it.only('can be permissive value expression', () => {
101-
const tree = new SingleColumnSyntaxTree('Hello world', COLUMN_TEXT, Case.Insensitive);
113+
const tree = new SingleColumnSyntaxTree('Hello world', COLUMN_TEXT, Case.Sensitive);
102114

103115
expect(tree.isValid).to.equal(true);
104116
expect(tree.evaluate({ a: 'Hello world' })).to.equal(true);
@@ -107,25 +119,25 @@ describe('Single Column Syntax Tree', () => {
107119
});
108120

109121
it('`undefined` column type can use `contains`', () => {
110-
const tree = new SingleColumnSyntaxTree('contains 1', COLUMN_UNDEFINED, Case.Insensitive);
122+
const tree = new SingleColumnSyntaxTree('contains 1', COLUMN_UNDEFINED, Case.Sensitive);
111123

112124
expect(tree.isValid).to.equal(true);
113125
});
114126

115127
it('`any` column type can use `contains`', () => {
116-
const tree = new SingleColumnSyntaxTree('contains 1', COLUMN_ANY, Case.Insensitive);
128+
const tree = new SingleColumnSyntaxTree('contains 1', COLUMN_ANY, Case.Sensitive);
117129

118130
expect(tree.isValid).to.equal(true);
119131
});
120132

121133
it('`numeric` column type can use `contains`', () => {
122-
const tree = new SingleColumnSyntaxTree('contains 1', COLUMN_NUMERIC, Case.Insensitive);
134+
const tree = new SingleColumnSyntaxTree('contains 1', COLUMN_NUMERIC, Case.Sensitive);
123135

124136
expect(tree.isValid).to.equal(true);
125137
});
126138

127139
it('can be expression with text column type', () => {
128-
const tree = new SingleColumnSyntaxTree('"1"', COLUMN_TEXT, Case.Insensitive);
140+
const tree = new SingleColumnSyntaxTree('"1"', COLUMN_TEXT, Case.Sensitive);
129141

130142
expect(tree.isValid).to.equal(true);
131143
expect(tree.evaluate({ a: 1 })).to.equal(true);
@@ -138,7 +150,7 @@ describe('Single Column Syntax Tree', () => {
138150

139151
['1975', '"1975"'].forEach(value => {
140152
it(`can be expression '${value}' with datetime column type`, () => {
141-
const tree = new SingleColumnSyntaxTree(value, COLUMN_DATE, Case.Insensitive);
153+
const tree = new SingleColumnSyntaxTree(value, COLUMN_DATE, Case.Sensitive);
142154

143155
expect(tree.evaluate({ a: 1975 })).to.equal(true);
144156
expect(tree.evaluate({ a: '1975' })).to.equal(true);
@@ -160,7 +172,7 @@ describe('Single Column Syntax Tree', () => {
160172
{ type: COLUMN_TEXT, name: 'text' }
161173
].forEach(({ type, name }) => {
162174
it(`returns the correct relational operator lexeme for '${name}' column type`, () => {
163-
const tree = new SingleColumnSyntaxTree('1', type, Case.Insensitive);
175+
const tree = new SingleColumnSyntaxTree('1', type, Case.Sensitive);
164176
const structure = tree.toStructure();
165177

166178
expect(tree.toQueryString()).to.equal('{a} contains 1');
@@ -189,7 +201,7 @@ describe('Single Column Syntax Tree', () => {
189201
});
190202

191203
it(`returns the correct relational operator lexeme for 'date' column type`, () => {
192-
const tree = new SingleColumnSyntaxTree('1975', COLUMN_DATE, Case.Insensitive);
204+
const tree = new SingleColumnSyntaxTree('1975', COLUMN_DATE, Case.Sensitive);
193205
const structure = tree.toStructure();
194206

195207
expect(tree.toQueryString()).to.equal('{a} datestartswith 1975');
@@ -217,7 +229,7 @@ describe('Single Column Syntax Tree', () => {
217229
});
218230

219231
it(`returns the correct relational operator lexeme for 'numeric' column type`, () => {
220-
const tree = new SingleColumnSyntaxTree('1', COLUMN_NUMERIC, Case.Insensitive);
232+
const tree = new SingleColumnSyntaxTree('1', COLUMN_NUMERIC, Case.Default);
221233
const structure = tree.toStructure();
222234

223235
expect(tree.toQueryString()).to.equal('{a} = 1');
@@ -243,4 +255,40 @@ describe('Single Column Syntax Tree', () => {
243255
}
244256
}
245257
});
258+
259+
it('can have case-insensitive column', () => {
260+
const tree = new SingleColumnSyntaxTree('= Hello world', COLUMN_CASE_INSENSITIVE, Case.Default);
261+
262+
expect(tree.isValid).to.equal(true);
263+
expect(tree.evaluate({ a: 'Hello world' })).to.equal(true);
264+
expect(tree.evaluate({ a: 'Helloworld' })).to.equal(false);
265+
expect(tree.toQueryString()).to.equal('{a} i= "Hello world"');
266+
});
267+
268+
it('can have forced case-sensitive column in case-insensitive table', () => {
269+
const tree = new SingleColumnSyntaxTree('= Hello world', COLUMN_CASE_SENSITIVE, Case.Insensitive);
270+
271+
expect(tree.isValid).to.equal(true);
272+
expect(tree.evaluate({ a: 'Hello world' })).to.equal(true);
273+
expect(tree.evaluate({ a: 'Helloworld' })).to.equal(false);
274+
expect(tree.toQueryString()).to.equal('{a} = "Hello world"');
275+
});
276+
277+
it('can have forced case-sensitive operator in case-insensitive column', () => {
278+
const tree = new SingleColumnSyntaxTree('c= Hello world', COLUMN_CASE_INSENSITIVE, Case.Default);
279+
280+
expect(tree.isValid).to.equal(true);
281+
expect(tree.evaluate({ a: 'Hello world' })).to.equal(true);
282+
expect(tree.evaluate({ a: 'Helloworld' })).to.equal(false);
283+
expect(tree.toQueryString()).to.equal('{a} = "Hello world"');
284+
});
285+
286+
it('can have forced case-sensitive operator in case-insensitive table', () => {
287+
const tree = new SingleColumnSyntaxTree('c= Hello world', COLUMN_CASE_SENSITIVE, Case.Insensitive);
288+
289+
expect(tree.isValid).to.equal(true);
290+
expect(tree.evaluate({ a: 'Hello world' })).to.equal(true);
291+
expect(tree.evaluate({ a: 'Helloworld' })).to.equal(false);
292+
expect(tree.toQueryString()).to.equal('{a} = "Hello world"');
293+
});
246294
});

0 commit comments

Comments
 (0)