Debian Codegraph @

packages/search/lib/commands/CREATE.spec.ts

raw
1 import { strict as assert } from 'assert';
2 import testUtils, { GLOBAL } from '../test-utils';
3 import { transformArguments } from './CREATE';
4 import { SchemaFieldTypes, SchemaTextFieldPhonetics, RedisSearchLanguages, VectorAlgorithms } from '.';
5
6 describe('CREATE', () => {
7 describe('transformArguments', () => {
8 it('simple', () => {
9 assert.deepEqual(
10 transformArguments('index', {}),
11 ['FT.CREATE', 'index', 'SCHEMA']
12 );
13 });
14
15 describe('with fields', () => {
16 describe('TEXT', () => {
17 it('without options', () => {
18 assert.deepEqual(
19 transformArguments('index', {
20 field: SchemaFieldTypes.TEXT
21 }),
22 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT']
23 );
24 });
25
26 it('with NOSTEM', () => {
27 assert.deepEqual(
28 transformArguments('index', {
29 field: {
30 type: SchemaFieldTypes.TEXT,
31 NOSTEM: true
32 }
33 }),
34 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOSTEM']
35 );
36 });
37
38 it('with WEIGHT', () => {
39 assert.deepEqual(
40 transformArguments('index', {
41 field: {
42 type: SchemaFieldTypes.TEXT,
43 WEIGHT: 1
44 }
45 }),
46 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WEIGHT', '1']
47 );
48 });
49
50 it('with PHONETIC', () => {
51 assert.deepEqual(
52 transformArguments('index', {
53 field: {
54 type: SchemaFieldTypes.TEXT,
55 PHONETIC: SchemaTextFieldPhonetics.DM_EN
56 }
57 }),
58 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'PHONETIC', SchemaTextFieldPhonetics.DM_EN]
59 );
60 });
61
62 it('with WITHSUFFIXTRIE', () => {
63 assert.deepEqual(
64 transformArguments('index', {
65 field: {
66 type: SchemaFieldTypes.TEXT,
67 WITHSUFFIXTRIE: true
68 }
69 }),
70 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'WITHSUFFIXTRIE']
71 );
72 });
73 });
74
75 it('NUMERIC', () => {
76 assert.deepEqual(
77 transformArguments('index', {
78 field: SchemaFieldTypes.NUMERIC
79 }),
80 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'NUMERIC']
81 );
82 });
83
84 it('GEO', () => {
85 assert.deepEqual(
86 transformArguments('index', {
87 field: SchemaFieldTypes.GEO
88 }),
89 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'GEO']
90 );
91 });
92
93 describe('TAG', () => {
94 describe('without options', () => {
95 it('SchemaFieldTypes.TAG', () => {
96 assert.deepEqual(
97 transformArguments('index', {
98 field: SchemaFieldTypes.TAG
99 }),
100 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
101 );
102 });
103
104 it('{ type: SchemaFieldTypes.TAG }', () => {
105 assert.deepEqual(
106 transformArguments('index', {
107 field: {
108 type: SchemaFieldTypes.TAG
109 }
110 }),
111 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG']
112 );
113 });
114 });
115
116 it('with SEPARATOR', () => {
117 assert.deepEqual(
118 transformArguments('index', {
119 field: {
120 type: SchemaFieldTypes.TAG,
121 SEPARATOR: 'separator'
122 }
123 }),
124 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'SEPARATOR', 'separator']
125 );
126 });
127
128 it('with CASESENSITIVE', () => {
129 assert.deepEqual(
130 transformArguments('index', {
131 field: {
132 type: SchemaFieldTypes.TAG,
133 CASESENSITIVE: true
134 }
135 }),
136 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'CASESENSITIVE']
137 );
138 });
139
140 it('with WITHSUFFIXTRIE', () => {
141 assert.deepEqual(
142 transformArguments('index', {
143 field: {
144 type: SchemaFieldTypes.TAG,
145 WITHSUFFIXTRIE: true
146 }
147 }),
148 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TAG', 'WITHSUFFIXTRIE']
149 );
150 });
151 });
152
153 describe('VECTOR', () => {
154 it('Flat algorithm', () => {
155 assert.deepEqual(
156 transformArguments('index', {
157 field: {
158 type: SchemaFieldTypes.VECTOR,
159 ALGORITHM: VectorAlgorithms.FLAT,
160 TYPE: 'FLOAT32',
161 DIM: 2,
162 DISTANCE_METRIC: 'L2',
163 INITIAL_CAP: 1000000,
164 BLOCK_SIZE: 1000
165 }
166 }),
167 [
168 'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'FLAT', '10', 'TYPE',
169 'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
170 'BLOCK_SIZE', '1000'
171 ]
172 );
173 });
174
175 it('HNSW algorithm', () => {
176 assert.deepEqual(
177 transformArguments('index', {
178 field: {
179 type: SchemaFieldTypes.VECTOR,
180 ALGORITHM: VectorAlgorithms.HNSW,
181 TYPE: 'FLOAT32',
182 DIM: 2,
183 DISTANCE_METRIC: 'L2',
184 INITIAL_CAP: 1000000,
185 M: 40,
186 EF_CONSTRUCTION: 250,
187 EF_RUNTIME: 20
188 }
189 }),
190 [
191 'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'HNSW', '14', 'TYPE',
192 'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
193 'M', '40', 'EF_CONSTRUCTION', '250', 'EF_RUNTIME', '20'
194 ]
195 );
196 });
197 });
198
199 describe('with generic options', () => {
200 it('with AS', () => {
201 assert.deepEqual(
202 transformArguments('index', {
203 field: {
204 type: SchemaFieldTypes.TEXT,
205 AS: 'as'
206 }
207 }),
208 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'AS', 'as', 'TEXT']
209 );
210 });
211
212 describe('with SORTABLE', () => {
213 it('true', () => {
214 assert.deepEqual(
215 transformArguments('index', {
216 field: {
217 type: SchemaFieldTypes.TEXT,
218 SORTABLE: true
219 }
220 }),
221 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'SORTABLE']
222 );
223 });
224
225 it('UNF', () => {
226 assert.deepEqual(
227 transformArguments('index', {
228 field: {
229 type: SchemaFieldTypes.TEXT,
230 SORTABLE: 'UNF'
231 }
232 }),
233 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'SORTABLE', 'UNF']
234 );
235 });
236 });
237
238 it('with NOINDEX', () => {
239 assert.deepEqual(
240 transformArguments('index', {
241 field: {
242 type: SchemaFieldTypes.TEXT,
243 NOINDEX: true
244 }
245 }),
246 ['FT.CREATE', 'index', 'SCHEMA', 'field', 'TEXT', 'NOINDEX']
247 );
248 });
249 });
250 });
251
252 it('with ON', () => {
253 assert.deepEqual(
254 transformArguments('index', {}, {
255 ON: 'HASH'
256 }),
257 ['FT.CREATE', 'index', 'ON', 'HASH', 'SCHEMA']
258 );
259 });
260
261 describe('with PREFIX', () => {
262 it('string', () => {
263 assert.deepEqual(
264 transformArguments('index', {}, {
265 PREFIX: 'prefix'
266 }),
267 ['FT.CREATE', 'index', 'PREFIX', '1', 'prefix', 'SCHEMA']
268 );
269 });
270
271 it('Array', () => {
272 assert.deepEqual(
273 transformArguments('index', {}, {
274 PREFIX: ['1', '2']
275 }),
276 ['FT.CREATE', 'index', 'PREFIX', '2', '1', '2', 'SCHEMA']
277 );
278 });
279 });
280
281 it('with FILTER', () => {
282 assert.deepEqual(
283 transformArguments('index', {}, {
284 FILTER: '@field != ""'
285 }),
286 ['FT.CREATE', 'index', 'FILTER', '@field != ""', 'SCHEMA']
287 );
288 });
289
290 it('with LANGUAGE', () => {
291 assert.deepEqual(
292 transformArguments('index', {}, {
293 LANGUAGE: RedisSearchLanguages.ARABIC
294 }),
295 ['FT.CREATE', 'index', 'LANGUAGE', RedisSearchLanguages.ARABIC, 'SCHEMA']
296 );
297 });
298
299 it('with LANGUAGE_FIELD', () => {
300 assert.deepEqual(
301 transformArguments('index', {}, {
302 LANGUAGE_FIELD: '@field'
303 }),
304 ['FT.CREATE', 'index', 'LANGUAGE_FIELD', '@field', 'SCHEMA']
305 );
306 });
307
308 it('with SCORE', () => {
309 assert.deepEqual(
310 transformArguments('index', {}, {
311 SCORE: 1
312 }),
313 ['FT.CREATE', 'index', 'SCORE', '1', 'SCHEMA']
314 );
315 });
316
317 it('with SCORE_FIELD', () => {
318 assert.deepEqual(
319 transformArguments('index', {}, {
320 SCORE_FIELD: '@field'
321 }),
322 ['FT.CREATE', 'index', 'SCORE_FIELD', '@field', 'SCHEMA']
323 );
324 });
325
326 it('with MAXTEXTFIELDS', () => {
327 assert.deepEqual(
328 transformArguments('index', {}, {
329 MAXTEXTFIELDS: true
330 }),
331 ['FT.CREATE', 'index', 'MAXTEXTFIELDS', 'SCHEMA']
332 );
333 });
334
335 it('with TEMPORARY', () => {
336 assert.deepEqual(
337 transformArguments('index', {}, {
338 TEMPORARY: 1
339 }),
340 ['FT.CREATE', 'index', 'TEMPORARY', '1', 'SCHEMA']
341 );
342 });
343
344 it('with NOOFFSETS', () => {
345 assert.deepEqual(
346 transformArguments('index', {}, {
347 NOOFFSETS: true
348 }),
349 ['FT.CREATE', 'index', 'NOOFFSETS', 'SCHEMA']
350 );
351 });
352
353 it('with NOHL', () => {
354 assert.deepEqual(
355 transformArguments('index', {}, {
356 NOHL: true
357 }),
358 ['FT.CREATE', 'index', 'NOHL', 'SCHEMA']
359 );
360 });
361
362 it('with NOFIELDS', () => {
363 assert.deepEqual(
364 transformArguments('index', {}, {
365 NOFIELDS: true
366 }),
367 ['FT.CREATE', 'index', 'NOFIELDS', 'SCHEMA']
368 );
369 });
370
371 it('with NOFREQS', () => {
372 assert.deepEqual(
373 transformArguments('index', {}, {
374 NOFREQS: true
375 }),
376 ['FT.CREATE', 'index', 'NOFREQS', 'SCHEMA']
377 );
378 });
379
380 it('with SKIPINITIALSCAN', () => {
381 assert.deepEqual(
382 transformArguments('index', {}, {
383 SKIPINITIALSCAN: true
384 }),
385 ['FT.CREATE', 'index', 'SKIPINITIALSCAN', 'SCHEMA']
386 );
387 });
388
389 describe('with STOPWORDS', () => {
390 it('string', () => {
391 assert.deepEqual(
392 transformArguments('index', {}, {
393 STOPWORDS: 'stopword'
394 }),
395 ['FT.CREATE', 'index', 'STOPWORDS', '1', 'stopword', 'SCHEMA']
396 );
397 });
398
399 it('Array', () => {
400 assert.deepEqual(
401 transformArguments('index', {}, {
402 STOPWORDS: ['1', '2']
403 }),
404 ['FT.CREATE', 'index', 'STOPWORDS', '2', '1', '2', 'SCHEMA']
405 );
406 });
407 });
408 });
409
410 testUtils.testWithClient('client.ft.create', async client => {
411 assert.equal(
412 await client.ft.create('index', {
413 field: SchemaFieldTypes.TEXT
414 }),
415 'OK'
416 );
417 }, GLOBAL.SERVERS.OPEN);
418 });