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

Commit b09272f

Browse files
dmt0dmt0
committed
Tests
1 parent b644487 commit b09272f

File tree

2 files changed

+154
-17
lines changed

2 files changed

+154
-17
lines changed

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

+89
Original file line numberDiff line numberDiff line change
@@ -599,7 +599,96 @@ describe('Query Syntax Tree', () => {
599599
const tree = new QuerySyntaxTree('{a}<=5');
600600
expect(tree.isValid).to.equal(true);
601601
expect(tree.evaluate({ a: 4 })).to.equal(true);
602+
});
603+
604+
it('can do case insensitive equality (i=) test', () => {
605+
const tree = new QuerySyntaxTree('{a} i= "abc v"');
606+
607+
expect(tree.isValid).to.equal(true);
608+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
609+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
610+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
611+
});
612+
613+
it('can do case insensitive equality (ieq) test', () => {
614+
const tree = new QuerySyntaxTree('{a} ieq "abc v"');
615+
616+
expect(tree.isValid).to.equal(true);
617+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
618+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
619+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
620+
});
602621

622+
it('can do case insensitive difference (ine) test', () => {
623+
const tree = new QuerySyntaxTree('{a} ine "abc v"');
624+
625+
expect(tree.isValid).to.equal(true);
626+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
627+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
628+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
629+
});
630+
631+
it('can do case insensitive difference (i!=) test', () => {
632+
const tree = new QuerySyntaxTree('{a} i!= "abc v"');
633+
634+
expect(tree.isValid).to.equal(true);
635+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
636+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
637+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
638+
});
639+
640+
it('can do case insensitive icontains (icontains) test', () => {
641+
const tree = new QuerySyntaxTree('{a} icontains v');
642+
643+
expect(tree.isValid).to.equal(true);
644+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
645+
expect(tree.evaluate({ a: 'abc V' })).to.equal(true);
646+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
647+
});
648+
649+
it('can do case sensitive equality (s=) test', () => {
650+
const tree = new QuerySyntaxTree('{a} s= "abc v"');
651+
652+
expect(tree.isValid).to.equal(true);
653+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
654+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
655+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
656+
});
657+
658+
it('can do case sensitive equality (seq) test', () => {
659+
const tree = new QuerySyntaxTree('{a} seq "abc v"');
660+
661+
expect(tree.isValid).to.equal(true);
662+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
663+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(false);
664+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
665+
});
666+
667+
it('can do case sensitive difference (sne) test', () => {
668+
const tree = new QuerySyntaxTree('{a} sne "abc v"');
669+
670+
expect(tree.isValid).to.equal(true);
671+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
672+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
673+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
674+
});
675+
676+
it('can do case sensitive difference (s!=) test', () => {
677+
const tree = new QuerySyntaxTree('{a} s!= "abc v"');
678+
679+
expect(tree.isValid).to.equal(true);
680+
expect(tree.evaluate({ a: 'abc v' })).to.equal(false);
681+
expect(tree.evaluate({ a: 'AbC V' })).to.equal(true);
682+
expect(tree.evaluate({ a: 'abc w' })).to.equal(true);
683+
});
684+
685+
it('can do case sensitive scontains (scontains) test', () => {
686+
const tree = new QuerySyntaxTree('{a} scontains v');
687+
688+
expect(tree.isValid).to.equal(true);
689+
expect(tree.evaluate({ a: 'abc v' })).to.equal(true);
690+
expect(tree.evaluate({ a: 'abc V' })).to.equal(false);
691+
expect(tree.evaluate({ a: 'abc w' })).to.equal(false);
603692
});
604693
});
605694
});

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

+65-17
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)