1 | 'use strict';
|
2 |
|
3 | var testUtils = require('../test-utils');
|
4 | var should = testUtils.should;
|
5 |
|
6 | module.exports = function (dbType, context) {
|
7 |
|
8 | describe(dbType + ': eq', function () {
|
9 | it('does eq queries', function () {
|
10 | var db = context.db;
|
11 | var index = {
|
12 | "index": {
|
13 | "fields": ["foo"]
|
14 | },
|
15 | "name": "foo-index",
|
16 | "type": "json"
|
17 | };
|
18 |
|
19 | return db.createIndex(index).then(function () {
|
20 | return db.bulkDocs([
|
21 | { _id: '1', foo: 'eyo'},
|
22 | { _id: '2', foo: 'ebb'},
|
23 | { _id: '3', foo: 'eba'},
|
24 | { _id: '4', foo: 'abo'}
|
25 | ]);
|
26 | }).then(function () {
|
27 | return db.find({
|
28 | selector: {foo: "eba"},
|
29 | fields: ["_id", "foo"],
|
30 | sort: [{foo: "asc"}]
|
31 | });
|
32 | }).then(function (resp) {
|
33 | resp.should.deep.equal({
|
34 | docs: [
|
35 | {_id: '3', foo: 'eba'}
|
36 | ]
|
37 | });
|
38 | });
|
39 | });
|
40 |
|
41 | it('does explicit $eq queries', function () {
|
42 | var db = context.db;
|
43 | var index = {
|
44 | "index": {
|
45 | "fields": ["foo"]
|
46 | },
|
47 | "name": "foo-index",
|
48 | "type": "json"
|
49 | };
|
50 |
|
51 | return db.createIndex(index).then(function () {
|
52 | return db.bulkDocs([
|
53 | { _id: '1', foo: 'eyo'},
|
54 | { _id: '2', foo: 'ebb'},
|
55 | { _id: '3', foo: 'eba'},
|
56 | { _id: '4', foo: 'abo'}
|
57 | ]);
|
58 | }).then(function () {
|
59 | return db.find({
|
60 | selector: {foo: {$eq: "eba"}},
|
61 | fields: ["_id", "foo"],
|
62 | sort: [{foo: "asc"}]
|
63 | });
|
64 | }).then(function (resp) {
|
65 | resp.should.deep.equal({
|
66 | docs: [
|
67 | { _id: '3', foo: 'eba'}
|
68 | ]
|
69 | });
|
70 | });
|
71 | });
|
72 |
|
73 | it('does eq queries, no fields', function () {
|
74 | var db = context.db;
|
75 | var index = {
|
76 | "index": {
|
77 | "fields": ["foo"]
|
78 | },
|
79 | "name": "foo-index",
|
80 | "type": "json"
|
81 | };
|
82 |
|
83 | return db.createIndex(index).then(function () {
|
84 | return db.bulkDocs([
|
85 | { _id: '1', foo: 'eyo'},
|
86 | { _id: '2', foo: 'ebb'},
|
87 | { _id: '3', foo: 'eba'},
|
88 | { _id: '4', foo: 'abo'}
|
89 | ]);
|
90 | }).then(function () {
|
91 | return db.find({
|
92 | selector: {foo: "eba"},
|
93 | sort: [{foo: "asc"}]
|
94 | });
|
95 | }).then(function (resp) {
|
96 | should.exist(resp.docs[0]._rev);
|
97 | delete resp.docs[0]._rev;
|
98 | resp.should.deep.equal({
|
99 | docs: [
|
100 | {_id: '3', foo: 'eba'}
|
101 | ]
|
102 | });
|
103 | });
|
104 | });
|
105 |
|
106 | it('does eq queries, no fields or sort', function () {
|
107 | var db = context.db;
|
108 | var index = {
|
109 | "index": {
|
110 | "fields": ["foo"]
|
111 | },
|
112 | "name": "foo-index",
|
113 | "type": "json"
|
114 | };
|
115 |
|
116 | return db.createIndex(index).then(function () {
|
117 | return db.bulkDocs([
|
118 | { _id: '1', foo: 'eyo'},
|
119 | { _id: '2', foo: 'ebb'},
|
120 | { _id: '3', foo: 'eba'},
|
121 | { _id: '4', foo: 'abo'}
|
122 | ]);
|
123 | }).then(function () {
|
124 | return db.find({
|
125 | selector: {foo: "eba"}
|
126 | });
|
127 | }).then(function (resp) {
|
128 | should.exist(resp.docs[0]._rev);
|
129 | delete resp.docs[0]._rev;
|
130 | resp.should.deep.equal({
|
131 | docs: [
|
132 | {_id: '3', foo: 'eba'}
|
133 | ]
|
134 | });
|
135 | });
|
136 | });
|
137 |
|
138 | it('does eq queries, no index name', function () {
|
139 | var db = context.db;
|
140 | var index = {
|
141 | "index": {
|
142 | "fields": ["foo"]
|
143 | }
|
144 | };
|
145 |
|
146 | return db.createIndex(index).then(function () {
|
147 | return db.bulkDocs([
|
148 | { _id: '1', foo: 'eyo'},
|
149 | { _id: '2', foo: 'ebb'},
|
150 | { _id: '3', foo: 'eba'},
|
151 | { _id: '4', foo: 'abo'}
|
152 | ]);
|
153 | }).then(function () {
|
154 | return db.getIndexes();
|
155 | }).then(function (resp) {
|
156 |
|
157 | resp.indexes[1].ddoc.should.match(/_design\/.*/);
|
158 | var ddocName = resp.indexes[1].ddoc.split('/')[1];
|
159 | resp.indexes[1].name.should.equal(ddocName);
|
160 | delete resp.indexes[1].ddoc;
|
161 | delete resp.indexes[1].name;
|
162 | resp.should.deep.equal({
|
163 | "total_rows":2,
|
164 | "indexes": [
|
165 | {
|
166 | "ddoc": null,
|
167 | "name": "_all_docs",
|
168 | "type": "special",
|
169 | "def": {
|
170 | "fields": [
|
171 | {
|
172 | "_id": "asc"
|
173 | }
|
174 | ]
|
175 | }
|
176 | },
|
177 | {
|
178 | "type": "json",
|
179 | "def": {
|
180 | "fields": [
|
181 | {
|
182 | "foo": "asc"
|
183 | }
|
184 | ]
|
185 | }
|
186 | }
|
187 | ]
|
188 | });
|
189 | return db.get('_design/' + ddocName);
|
190 | }).then(function (ddoc) {
|
191 | var ddocId = ddoc._id.split('/')[1];
|
192 |
|
193 | Object.keys(ddoc.views).should.deep.equal([ddocId]);
|
194 | delete ddoc._id;
|
195 | delete ddoc._rev;
|
196 | ddoc.views.theView = ddoc.views[ddocId];
|
197 | delete ddoc.views[ddocId];
|
198 | delete ddoc.views.theView.options.w;
|
199 |
|
200 | ddoc.should.deep.equal({
|
201 | "language": "query",
|
202 | "views": {
|
203 | theView: {
|
204 | "map": {
|
205 | "fields": {
|
206 | "foo": "asc"
|
207 | }
|
208 | },
|
209 | "reduce": "_count",
|
210 | "options": {
|
211 | "def": {
|
212 | "fields": [
|
213 | "foo"
|
214 | ]
|
215 | }
|
216 | }
|
217 | }
|
218 | }
|
219 | });
|
220 |
|
221 | return db.find({
|
222 | selector: {foo: "eba"}
|
223 | });
|
224 | }).then(function (resp) {
|
225 | should.exist(resp.docs[0]._rev);
|
226 | delete resp.docs[0]._rev;
|
227 | resp.should.deep.equal({
|
228 | docs: [
|
229 | {_id: '3', foo: 'eba'}
|
230 | ]
|
231 | });
|
232 | });
|
233 | });
|
234 |
|
235 | it('#7 does eq queries 1', function () {
|
236 | var db = context.db;
|
237 | var index = {
|
238 | "index": {
|
239 | "fields": ["foo"]
|
240 | }
|
241 | };
|
242 |
|
243 | return db.createIndex(index).then(function () {
|
244 | return db.bulkDocs([
|
245 | { _id: '1', foo: 'eyo', bar: 'zxy'},
|
246 | { _id: '2', foo: 'ebb', bar: 'zxy'},
|
247 | { _id: '3', foo: 'eba', bar: 'zxz'},
|
248 | { _id: '4', foo: 'abo', bar: 'zxz'}
|
249 | ]);
|
250 | }).then(function () {
|
251 | return db.find({
|
252 | selector: {foo: {$gt: "a"}, bar: {$eq: 'zxy'}},
|
253 | fields: ["_id"],
|
254 | sort: [{foo: "asc"}]
|
255 | });
|
256 | }).then(function (resp) {
|
257 | resp.should.deep.equal({
|
258 | docs: [
|
259 | { _id: '2'},
|
260 | { _id: '1'}
|
261 | ]
|
262 | });
|
263 | });
|
264 | });
|
265 |
|
266 | it('#7 does eq queries 2', function () {
|
267 | var db = context.db;
|
268 | var index = {
|
269 | "index": {
|
270 | "fields": ["foo", "bar"]
|
271 | }
|
272 | };
|
273 |
|
274 | return db.createIndex(index).then(function () {
|
275 | return db.bulkDocs([
|
276 | {_id: '1', foo: 'eyo', bar: 'zxy'},
|
277 | {_id: '2', foo: 'ebb', bar: 'zxy'},
|
278 | {_id: '3', foo: 'eba', bar: 'zxz'},
|
279 | {_id: '4', foo: 'abo', bar: 'zxz'}
|
280 | ]);
|
281 | }).then(function () {
|
282 | return db.find({
|
283 | selector: {foo: {$gt: "a"}, bar: {$eq: 'zxy'}},
|
284 | fields: ["_id"],
|
285 | sort: [{foo: "asc"}]
|
286 | });
|
287 | }).then(function (resp) {
|
288 | resp.should.deep.equal({
|
289 | docs: [
|
290 | {_id: '2'},
|
291 | {_id: '1'}
|
292 | ]
|
293 | });
|
294 | });
|
295 | });
|
296 |
|
297 | it('#170 does queries with a null value', function () {
|
298 | var db = context.db;
|
299 | var index = {
|
300 | "index": {
|
301 | "fields": ["field1"]
|
302 | }
|
303 | };
|
304 |
|
305 | return db.createIndex(index).then(function () {
|
306 | return db.bulkDocs([
|
307 | {_id: '1', field1: null, field2: null },
|
308 | {_id: '2', field1: null, field2: "1" },
|
309 | {_id: '3', field1: "1", field2: null },
|
310 | ]);
|
311 | }).then(function () {
|
312 | return db.find({
|
313 | selector: {field1: null},
|
314 | fields: ["_id"]
|
315 | });
|
316 | }).then(function (resp) {
|
317 | resp.should.deep.equal({
|
318 | docs: [
|
319 | {_id: '1'},
|
320 | {_id: '2'}
|
321 | ]
|
322 | });
|
323 | });
|
324 | });
|
325 |
|
326 | it('#170 does queries with a null value (explicit $eq)', function () {
|
327 | var db = context.db;
|
328 | var index = {
|
329 | "index": {
|
330 | "fields": ["field1"]
|
331 | }
|
332 | };
|
333 |
|
334 | return db.createIndex(index).then(function () {
|
335 | return db.bulkDocs([
|
336 | {_id: '1', field1: null, field2: null },
|
337 | {_id: '2', field1: null, field2: "1" },
|
338 | {_id: '3', field1: "1", field2: null },
|
339 | ]);
|
340 | }).then(function () {
|
341 | return db.find({
|
342 | selector: {field1: {$eq: null}},
|
343 | fields: ["_id"]
|
344 | });
|
345 | }).then(function (resp) {
|
346 | resp.should.deep.equal({
|
347 | docs: [
|
348 | {_id: '1'},
|
349 | {_id: '2'}
|
350 | ]
|
351 | });
|
352 | });
|
353 | });
|
354 |
|
355 | it('#170 does queries with multiple null values', function () {
|
356 | var db = context.db;
|
357 | var index = {
|
358 | "index": {
|
359 | "fields": ["field1"]
|
360 | }
|
361 | };
|
362 |
|
363 | return db.createIndex(index).then(function () {
|
364 | return db.bulkDocs([
|
365 | {_id: '1', field1: null, field2: null },
|
366 | {_id: '2', field1: null, field2: "1" },
|
367 | {_id: '3', field1: "1", field2: null },
|
368 | ]);
|
369 | }).then(function () {
|
370 | return db.find({
|
371 | selector: {field1: null, field2: null},
|
372 | fields: ["_id"]
|
373 | });
|
374 | }).then(function (resp) {
|
375 | resp.should.deep.equal({
|
376 | docs: [
|
377 | {_id: '1'}
|
378 | ]
|
379 | });
|
380 | });
|
381 | });
|
382 |
|
383 | it('#170 does queries with multiple null values - $lte', function () {
|
384 | var db = context.db;
|
385 | var index = {
|
386 | "index": {
|
387 | "fields": ["field1"]
|
388 | }
|
389 | };
|
390 |
|
391 | return db.createIndex(index).then(function () {
|
392 | return db.bulkDocs([
|
393 | {_id: '1', field1: null, field2: null },
|
394 | {_id: '2', field1: null, field2: "1" },
|
395 | {_id: '3', field1: "1", field2: null },
|
396 | ]);
|
397 | }).then(function () {
|
398 | return db.find({
|
399 | selector: {field1: null, field2: {$lte: null}},
|
400 | fields: ["_id"]
|
401 | });
|
402 | }).then(function (resp) {
|
403 | resp.should.deep.equal({
|
404 | docs: [
|
405 | {_id: '1'}
|
406 | ]
|
407 | });
|
408 | });
|
409 | });
|
410 |
|
411 |
|
412 |
|
413 | it.skip('#170 does queries with multiple null values - $gte', function () {
|
414 | var db = context.db;
|
415 | var index = {
|
416 | "index": {
|
417 | "fields": ["field1"]
|
418 | }
|
419 | };
|
420 |
|
421 | return db.createIndex(index).then(function () {
|
422 | return db.bulkDocs([
|
423 | {_id: '1', field1: null, field2: null },
|
424 | {_id: '2', field1: null, field2: "1" },
|
425 | {_id: '3', field1: "1", field2: null },
|
426 | ]);
|
427 | }).then(function () {
|
428 | return db.find({
|
429 | selector: {field1: null, field2: {$gte: null}},
|
430 | fields: ["_id"]
|
431 | });
|
432 | }).then(function (resp) {
|
433 | resp.should.deep.equal({
|
434 | docs: [
|
435 | {_id: '1'}
|
436 | ]
|
437 | });
|
438 | });
|
439 | });
|
440 |
|
441 | it('#170 does queries with multiple null values - $ne', function () {
|
442 | var db = context.db;
|
443 | var index = {
|
444 | "index": {
|
445 | "fields": ["field1"]
|
446 | }
|
447 | };
|
448 |
|
449 | return db.createIndex(index).then(function () {
|
450 | return db.bulkDocs([
|
451 | {_id: '1', field1: null, field2: null },
|
452 | {_id: '2', field1: null, field2: "1" },
|
453 | {_id: '3', field1: "1", field2: null },
|
454 | ]);
|
455 | }).then(function () {
|
456 | return db.find({
|
457 | selector: {field1: null, field2: {$ne: null}},
|
458 | fields: ["_id"]
|
459 | });
|
460 | }).then(function (resp) {
|
461 | resp.should.deep.equal({
|
462 | docs: [
|
463 | {_id: '2'}
|
464 | ]
|
465 | });
|
466 | });
|
467 | });
|
468 |
|
469 | it('#170 does queries with multiple null values - $mod', function () {
|
470 | var db = context.db;
|
471 | var index = {
|
472 | "index": {
|
473 | "fields": ["field1"]
|
474 | }
|
475 | };
|
476 |
|
477 | return db.createIndex(index).then(function () {
|
478 | return db.bulkDocs([
|
479 | {_id: '1', field1: null, field2: null },
|
480 | {_id: '2', field1: null, field2: 1 },
|
481 | {_id: '3', field1: 1, field2: null },
|
482 | ]);
|
483 | }).then(function () {
|
484 | return db.find({
|
485 | selector: {field1: null, field2: {$mod: [1, 0]}},
|
486 | fields: ["_id"]
|
487 | });
|
488 | }).then(function (resp) {
|
489 | resp.should.deep.equal({
|
490 | docs: [
|
491 | {_id: '2'}
|
492 | ]
|
493 | });
|
494 | });
|
495 | });
|
496 |
|
497 | it('#170 does queries with multiple null values - $mod', function () {
|
498 | var db = context.db;
|
499 | var index = {
|
500 | "index": {
|
501 | "fields": ["field1"]
|
502 | }
|
503 | };
|
504 |
|
505 | return db.createIndex(index).then(function () {
|
506 | return db.bulkDocs([
|
507 | {_id: '1', field1: null, field2: null },
|
508 | {_id: '2', field1: null, field2: null },
|
509 | {_id: '3', field1: null, field2: null },
|
510 | ]);
|
511 | }).then(function () {
|
512 | return db.find({
|
513 | selector: {field1: null, field2: {$mod: [1, 0]}},
|
514 | fields: ["_id"]
|
515 | });
|
516 | }).then(function (resp) {
|
517 | resp.should.deep.equal({
|
518 | docs: [
|
519 | ]
|
520 | });
|
521 | });
|
522 | });
|
523 | });
|
524 | };
|