New query condition support to match all strings that starts with some other given strings (#3864)

* feat: Convert $regex value to RegExp object

* feat: Add lib folder

* Revert "feat: Add lib folder"

This reverts commit c9dfbcbf699ff220baeb2df5586a944d19808e5e.

* feat: Add $regex test in $all array

* test: Test regex with $all only in MongoDB

* Revert "test: Test regex with $all only in MongoDB"

This reverts commit d7194c7869dee98d924fbc2502593a198385dba1.

* feat: Add tests for containsAllStartingWith

* feat: Add postgres support

Thanks to @dplewis

* feat: Check that all values in $all must be regex or none

* test: Check that $all vaules must be regex or none

* feat: Update tests to use only REST API

* refactor: Move $all regex check to adapter

* feat: Check for valid $all values in progres

* refactor: Update function name

* fix:  Postgres $all values regex checking

* fix: Check starts with as string

* fix: Define contains all regex sql function

* fix: Wrong value check

* fix: Check valid data

* fix: Check regex when there is only one value

* fix: Constains all starting with string returns empty with bad params

* fix: Pass correct regex value

* feat: Add missing tests

* feat: Add missing tests

* feat: Add more tests

* fix: Unify MongoDB and PostgreSQL functionality

* fix: Lint checks

* fix: Test broken

$regex in $all list must be { $regex: "string" }

* test for empty $all
This commit is contained in:
Eduard Bosch Bertran
2018-05-16 03:42:32 +02:00
committed by Diamond Lewis
parent 2c357df33e
commit c0e3672e32
7 changed files with 395 additions and 2 deletions

View File

@@ -353,6 +353,41 @@ describe('parseObjectToMongoObjectForCreate', () => {
expect(output.ts.iso).toEqual('2017-01-18T00:00:00.000Z');
done();
});
it('$regex in $all list', (done) => {
const input = {
arrayField: {'$all': [{$regex: '^\\Qone\\E'}, {$regex: '^\\Qtwo\\E'}, {$regex: '^\\Qthree\\E'}]},
};
const outputValue = {
arrayField: {'$all': [/^\Qone\E/, /^\Qtwo\E/, /^\Qthree\E/]},
};
const output = transform.transformWhere(null, input);
jequal(outputValue.arrayField, output.arrayField);
done();
});
it('$regex in $all list must be { $regex: "string" }', (done) => {
const input = {
arrayField: {'$all': [{$regex: 1}]},
};
expect(() => {
transform.transformWhere(null, input)
}).toThrow();
done();
});
it('all values in $all must be $regex (start with string) or non $regex (start with string)', (done) => {
const input = {
arrayField: {'$all': [{$regex: '^\\Qone\\E'}, {$unknown: '^\\Qtwo\\E'}]},
};
expect(() => {
transform.transformWhere(null, input)
}).toThrow();
done();
});
});
describe('transformUpdate', () => {

View File

@@ -509,6 +509,251 @@ describe('Parse.Query testing', () => {
});
});
it('containsAllStartingWith should match all strings that starts with string', (done) => {
const object = new Parse.Object('Object');
object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']);
const object2 = new Parse.Object('Object');
object2.set('strings', ['the', 'brown', 'fox', 'jumps']);
const object3 = new Parse.Object('Object');
object3.set('strings', ['over', 'the', 'lazy', 'dog']);
const objectList = [object, object2, object3];
Parse.Object.saveAll(objectList).then((results) => {
equal(objectList.length, results.length);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [
{$regex: '\^\\Qthe\\E'},
{$regex: '\^\\Qfox\\E'},
{$regex: '\^\\Qlazy\\E'}
]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
})
.then(function (results) {
equal(results.results.length, 1);
arrayContains(results.results, object);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [
{$regex: '\^\\Qthe\\E'},
{$regex: '\^\\Qlazy\\E'}
]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function (results) {
equal(results.results.length, 2);
arrayContains(results.results, object);
arrayContains(results.results, object3);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [
{$regex: '\^\\Qhe\\E'},
{$regex: '\^\\Qlazy\\E'}
]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function (results) {
equal(results.results.length, 0);
done();
});
});
});
it('containsAllStartingWith values must be all of type starting with regex', (done) => {
const object = new Parse.Object('Object');
object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']);
object.save().then(() => {
equal(object.isNew(), false);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [
{$regex: '\^\\Qthe\\E'},
{$regex: '\^\\Qlazy\\E'},
{$regex: '\^\\Qfox\\E'},
{$unknown: /unknown/}
]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function () {
}, function () {
done();
});
});
it('containsAllStartingWith empty array values should return empty results', (done) => {
const object = new Parse.Object('Object');
object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']);
object.save().then(() => {
equal(object.isNew(), false);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: []
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function (results) {
equal(results.results.length, 0);
done();
}, function () {
});
});
it('containsAllStartingWith single empty value returns empty results', (done) => {
const object = new Parse.Object('Object');
object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']);
object.save().then(() => {
equal(object.isNew(), false);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [ {} ]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function (results) {
equal(results.results.length, 0);
done();
}, function () {
});
});
it('containsAllStartingWith single regex value should return corresponding matching results', (done) => {
const object = new Parse.Object('Object');
object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']);
const object2 = new Parse.Object('Object');
object2.set('strings', ['the', 'brown', 'fox', 'jumps']);
const object3 = new Parse.Object('Object');
object3.set('strings', ['over', 'the', 'lazy', 'dog']);
const objectList = [object, object2, object3];
Parse.Object.saveAll(objectList).then((results) => {
equal(objectList.length, results.length);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [ {$regex: '\^\\Qlazy\\E'} ]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function (results) {
equal(results.results.length, 2);
done();
}, function () {
});
});
it('containsAllStartingWith single invalid regex returns empty results', (done) => {
const object = new Parse.Object('Object');
object.set('strings', ['the', 'brown', 'lazy', 'fox', 'jumps']);
object.save().then(() => {
equal(object.isNew(), false);
return require('request-promise').get({
url: Parse.serverURL + "/classes/Object",
json: {
where: {
strings: {
$all: [ {$unknown: '\^\\Qlazy\\E'} ]
}
}
},
headers: {
'X-Parse-Application-Id': Parse.applicationId,
'X-Parse-Javascript-Key': Parse.javaScriptKey
}
});
})
.then(function (results) {
equal(results.results.length, 0);
done();
}, function () {
});
});
const BoxedNumber = Parse.Object.extend({
className: "BoxedNumber"
});