sorla-db 1.0.0 → 1.1.0

package/test/feature_collection_queries.test.js

@@ -1,269 +1,224 @@
-const chai = require('chai')
-const expect = chai.expect
-const faker = require('faker')
-const sorla = require('../src/sorla.js')
-const helper = require('../src/helper.js')
-
-describe('SORLA Collection Queries Feature Test', () => {
-    beforeAll(() => {
-        this.srla = new sorla();
-        this.dbname = faker.random.word();
-        this.srla.createDb(this.dbname);
-        this.srla.useDb(this.dbname);
-        this.collectionName = faker.random.word();
-        this.srla.db.createCollection(this.collectionName);
-        this.objects = helper.createFakeCollection(this.srla, this.collectionName, 30);
-    });
-
-    it('Test if the first document in the collection is the same first document on the objects array', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc).to.deep.equal(firstObj);
-    });
-
-    it('Takes the data field name from the document inside the collection', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc.name).to.be.a('string').equal(firstObj.name);
-    });
-
-    it('Takes the data field email from the document inside the collection', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc.email).to.be.a('string').equal(firstObj.email);
-    });
-
-    it('Takes the data field age from the document inside the collection', () => {
-        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
-        const firstObj = this.objects[0];
-        expect(firstDoc.age).to.be.a('number').equal(firstObj.age);
-    });
-
-    it('Creates a few documents and search for one of them', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const doc = this.srla.db[this.collectionName].findOne({ uuid: item1.uuid }, { _id: 0 });
-        expect(doc).to.deep.equal(item1);
-    });
-
-    it('Creates a few documents and search for some of them', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $or: [
-                { uuid: item1.uuid },
-                { uuid: item2.uuid }
-            ]
-        });
-
-        expect(docs.length).to.be.equal(2);
-    });
-
-    it('Creates a few documents and search using not', () => {
-        const [item1] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find(
-            {
-                uuid: { 
-                    $not: {
-                        $eq: item1.uuid 
-                    }
-                }
-            }
-        );
-
-        expect(docs.length).to.be.equal(this.objects.length - 1);
-    });
-
-    it('Creates a few documents and search using not with more than one expression', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find(
-            {
-                age: { 
-                    $not: {
-                        $eq: item1.age,
-                        $gt: 18
-                    }
-                }
-            }
-        );
-
-        expect(docs.length).to.be.equal(this.objects.length - 1);
-    });
-
-    it('Creates a few documents and search it using nor', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].findOne({
-            $nor: [
-                {name: item1.name},
-                {age: item1.age}
-            ]
-        });
-
-        expect(docs.name).to.not.be.equal(item1.name);
-        expect(docs.age).to.not.be.equal(item1.age);
-    });
-
-    it('Creates a few documents and search it using nor with more than one expression', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $nor: [
-                {name: item1.name},
-                {age: item1.age},
-                {name: item2.name},
-                {age: item2.age}
-            ]
-        });
-
-        expect(docs.length).to.be.equal(this.objects.length - 2);
-    });
-
-    it('Test sort number in ascending order', () => {
-        this.srla.db.createCollection('sortNumberAsc');
-        this.srla.db.sortNumberAsc.insertMany([
-            {
-                name: 'A',
-                age: 20
-            }, 
-            {
-                name: 'B',
-                age: 10
-            }, 
-            {
-                name: 'C',
-                age: 30
-            },
-            {
-                name: 'A',
-                age: 3
-            }, 
-            {
-                name: 'B',
-                age: 5
-            }, 
-            {
-                name: 'C',
-                age: 1
-            },
-        ]);
-    });
-
-    it('Test sort number in descending order', () => {
-    });
-
-    it('Test sort string in ascending order', () => {
-    });
-
-    it('Test sort string in descending order', () => {
-    });
-
-    it('Test sort date in ascending order', () => {
-    });
-
-    it('Test sort date in descending order', () => {
-    });
-
-    it('Test sort boolean in ascending order', () => {
-    });
-
-    it('Test sort boolean in descending order', () => {
-    });
-
-    it('Test equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const doc = this.srla.db[this.collectionName].findOne({ uuid: item1.uuid }, { _id: 0 });
-        expect(doc).to.deep.equal(item1);
-    });
-
-    it('Test not equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            uuid: { $ne: item1.uuid }
-        });
-
-        expect(docs.length).to.be.equal(this.objects.length - 1);
-    });
-
-    it('Test greater than comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $gt: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age > item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test greater than or equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $gte: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age >= item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test less than comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $lt: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age < item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test less than or equal comparison', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $lte: item1.age }
-        });
-
-        countAges = this.objects.filter(obj => obj.age <= item1.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test in comparison', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $in: [item1.age, item2.age] }
-        });
-
-        countAges = this.objects.filter(obj => obj.age === item1.age || obj.age === item2.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test not in comparison', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            age: { $nin: [item1.age, item2.age] }
-        });
-
-        countAges = this.objects.filter(obj => obj.age !== item1.age && obj.age !== item2.age).length;
-        expect(docs.length).to.be.equal(countAges);
-    });
-
-    it('Test mixed comparison with and', () => {
-        const [item1,] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $and: [
-                { name: item1.name },
-                { age: item1.age }
-            ]
-        });
-
-        const filtered = this.objects.filter(obj => obj.name === item1.name && obj.age === item1.age);
-        expect(docs.length).to.be.equal(filtered.length);
-    });
-
-    it('Test mixed comparison with or', () => {
-        const [item1, item2] = helper.getRandomComparisonData(this.objects);
-        const docs = this.srla.db[this.collectionName].find({
-            $or: [
-                { name: item1.name },
-                { age: item2.age }
-            ]
-        });
-
-        const filtered = this.objects.filter(obj => obj.name === item1.name || obj.age === item2.age);
-        expect(docs.length).to.be.equal(filtered.length);
-    });
+const chai = require('chai')
+const expect = chai.expect
+const faker = require('faker')
+const sorla = require('../src/sorla.js')
+const helper = require('../src/helper.js')
+
+describe('SORLA Collection Queries Feature Test', () => {
+    beforeAll(() => {
+        this.srla = new sorla();
+        this.dbname = faker.random.word();
+        this.srla.createDb(this.dbname);
+        this.srla.useDb(this.dbname);
+        this.collectionName = faker.random.word();
+        this.srla.db.createCollection(this.collectionName);
+        this.objects = helper.createFakeCollection(this.srla, this.collectionName, 30);
+    });
+
+    it('Test if the first document in the collection is the same first document on the objects array', () => {
+        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
+        const firstObj = this.objects[0];
+        expect(firstDoc).to.deep.equal(firstObj);
+    });
+
+    it('Takes the data field name from the document inside the collection', () => {
+        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
+        const firstObj = this.objects[0];
+        expect(firstDoc.name).to.be.a('string').equal(firstObj.name);
+    });
+
+    it('Takes the data field email from the document inside the collection', () => {
+        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
+        const firstObj = this.objects[0];
+        expect(firstDoc.email).to.be.a('string').equal(firstObj.email);
+    });
+
+    it('Takes the data field age from the document inside the collection', () => {
+        const firstDoc = this.srla.db[this.collectionName].findOne({}, { _id: 0 });
+        const firstObj = this.objects[0];
+        expect(firstDoc.age).to.be.a('number').equal(firstObj.age);
+    });
+
+    it('Creates a few documents and search for one of them', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const doc = this.srla.db[this.collectionName].findOne({ uuid: item1.uuid }, { _id: 0 });
+        expect(doc).to.deep.equal(item1);
+    });
+
+    it('Creates a few documents and search for some of them', () => {
+        const [item1, item2] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            $or: [
+                { uuid: item1.uuid },
+                { uuid: item2.uuid }
+            ]
+        });
+
+        expect(docs.length).to.be.equal(2);
+    });
+
+    it('Creates a few documents and search using not', () => {
+        const [item1] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find(
+            {
+                uuid: { 
+                    $not: {
+                        $eq: item1.uuid 
+                    }
+                }
+            }
+        );
+
+        expect(docs.length).to.be.equal(this.objects.length - 1);
+    });
+
+    it('Creates a few documents and search using not with more than one expression', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find(
+            {
+                age: { 
+                    $not: {
+                        $eq: item1.age,
+                        $gt: 18
+                    }
+                }
+            }
+        );
+
+        // $not negates the whole condition: excluded when age equals item1.age AND is over 18
+        const expected = this.objects.filter(obj => !(obj.age === item1.age && obj.age > 18));
+        expect(docs.length).to.be.equal(expected.length);
+    });
+
+    it('Creates a few documents and search it using nor', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].findOne({
+            $nor: [
+                {name: item1.name},
+                {age: item1.age}
+            ]
+        });
+
+        expect(docs.name).to.not.be.equal(item1.name);
+        expect(docs.age).to.not.be.equal(item1.age);
+    });
+
+    it('Creates a few documents and search it using nor with more than one expression', () => {
+        const [item1, item2] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            $nor: [
+                {name: item1.name},
+                {age: item1.age},
+                {name: item2.name},
+                {age: item2.age}
+            ]
+        });
+
+        // random names and ages can repeat, so count the expected documents instead of assuming 2
+        const expected = this.objects.filter(obj => obj.name !== item1.name && obj.age !== item1.age && obj.name !== item2.name && obj.age !== item2.age);
+        expect(docs.length).to.be.equal(expected.length);
+    });
+
+    // sorting is covered by test/feature_cursor.test.js
+
+    it('Test equal comparison', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const doc = this.srla.db[this.collectionName].findOne({ uuid: item1.uuid }, { _id: 0 });
+        expect(doc).to.deep.equal(item1);
+    });
+
+    it('Test not equal comparison', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            uuid: { $ne: item1.uuid }
+        });
+
+        expect(docs.length).to.be.equal(this.objects.length - 1);
+    });
+
+    it('Test greater than comparison', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            age: { $gt: item1.age }
+        });
+
+        countAges = this.objects.filter(obj => obj.age > item1.age).length;
+        expect(docs.length).to.be.equal(countAges);
+    });
+
+    it('Test greater than or equal comparison', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            age: { $gte: item1.age }
+        });
+
+        countAges = this.objects.filter(obj => obj.age >= item1.age).length;
+        expect(docs.length).to.be.equal(countAges);
+    });
+
+    it('Test less than comparison', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            age: { $lt: item1.age }
+        });
+
+        countAges = this.objects.filter(obj => obj.age < item1.age).length;
+        expect(docs.length).to.be.equal(countAges);
+    });
+
+    it('Test less than or equal comparison', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            age: { $lte: item1.age }
+        });
+
+        countAges = this.objects.filter(obj => obj.age <= item1.age).length;
+        expect(docs.length).to.be.equal(countAges);
+    });
+
+    it('Test in comparison', () => {
+        const [item1, item2] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            age: { $in: [item1.age, item2.age] }
+        });
+
+        countAges = this.objects.filter(obj => obj.age === item1.age || obj.age === item2.age).length;
+        expect(docs.length).to.be.equal(countAges);
+    });
+
+    it('Test not in comparison', () => {
+        const [item1, item2] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            age: { $nin: [item1.age, item2.age] }
+        });
+
+        countAges = this.objects.filter(obj => obj.age !== item1.age && obj.age !== item2.age).length;
+        expect(docs.length).to.be.equal(countAges);
+    });
+
+    it('Test mixed comparison with and', () => {
+        const [item1,] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            $and: [
+                { name: item1.name },
+                { age: item1.age }
+            ]
+        });
+
+        const filtered = this.objects.filter(obj => obj.name === item1.name && obj.age === item1.age);
+        expect(docs.length).to.be.equal(filtered.length);
+    });
+
+    it('Test mixed comparison with or', () => {
+        const [item1, item2] = helper.getRandomComparisonData(this.objects);
+        const docs = this.srla.db[this.collectionName].find({
+            $or: [
+                { name: item1.name },
+                { age: item2.age }
+            ]
+        });
+
+        const filtered = this.objects.filter(obj => obj.name === item1.name || obj.age === item2.age);
+        expect(docs.length).to.be.equal(filtered.length);
+    });
 });

package/test/feature_cursor.test.js

@@ -0,0 +1,84 @@
+const chai = require('chai')
+const expect = chai.expect
+const sorla = require('../src/sorla.js')
+
+describe('SORLA cursor', () => {
+    let people;
+
+    beforeAll(() => {
+        const srla = new sorla();
+        srla.useDb('cursor');
+        srla.db.createCollection('people');
+        people = srla.db.people;
+        for(const [name, age] of [['Carla', 42], ['Ana', 25], ['Bruno', 31]])
+            people.insertOne({ name, age, email: `${name.toLowerCase()}@mail.com` });
+        // projection logs every removed property
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+    });
+
+    afterAll(() => jest.restoreAllMocks());
+
+    it('iterates with hasNext/next and can be reset', () => {
+        const cursor = people.find({});
+        expect(cursor.length).to.equal(3);
+        const names = [];
+        while(cursor.hasNext()) names.push(cursor.next()._data.name);
+        expect(names).to.deep.equal(['Carla', 'Ana', 'Bruno']);
+        expect(() => cursor.next()).to.throw('No more item to the cursor');
+        cursor.reset();
+        expect(cursor.next()._data.name).to.equal('Carla');
+    });
+
+    it('first() returns the data of the first document', () => {
+        expect(people.find({ age: { $gt: 30 } }).first().name).to.equal('Carla');
+    });
+
+    it('returns copies: changing a result does not change the collection', () => {
+        const cursor = people.find({ name: 'Ana' });
+        cursor.next()._data.age = 99;
+        expect(people.findOne({ name: 'Ana' }).age).to.equal(25);
+    });
+
+    it('projection with 0 removes fields from the results only', () => {
+        const cursor = people.find({ name: 'Ana' }, { email: 0 });
+        expect(cursor.next()._data).to.not.have.property('email');
+        expect(people.findOne({ name: 'Ana' }).email).to.equal('ana@mail.com');
+    });
+
+    it('last() gives access to the fields of the last document', () => {
+        expect(people.find({}).last().name).to.equal('Bruno');
+    });
+
+    it('push only accepts objects', () => {
+        const cursor = people.find({});
+        expect(() => cursor.push('x')).to.throw('The element must be an object');
+        cursor.push({ name: 'Extra' });
+        expect(cursor.length).to.equal(4);
+    });
+
+    // ---- known bugs: these document current behavior and will start failing once fixed
+
+    it.failing('sorts by a number ascending (cursor.js/document.js circular require)', () => {
+        const cursor = people.find({});
+        cursor.sort({ age: 1 });
+        expect(cursor.first().name).to.equal('Ana');
+    });
+
+    it.failing('sorts by several fields descending', () => {
+        const cursor = people.find({});
+        cursor.sort({ age: -1, name: 1 });
+        expect(cursor.first().name).to.equal('Carla');
+    });
+
+    it.failing('toArray returns plain objects (structuredClone of a Proxy)', () => {
+        expect(people.find({}).toArray().map(doc => doc.name)).to.deep.equal(['Carla', 'Ana', 'Bruno']);
+    });
+
+    it.failing('findOne returns null when nothing matches', () => {
+        expect(people.findOne({ name: 'Nobody' })).to.equal(null);
+    });
+
+
+    it.todo('projection with 1 keeps only the listed fields');
+    it.todo('skip() and limit()');
+});

package/test/feature_database.test.js

@@ -0,0 +1,62 @@
+const chai = require('chai')
+const expect = chai.expect
+const sorla = require('../src/sorla.js')
+
+describe('SORLA databases and collections', () => {
+    it('useDb creates the database when needed and selects it', () => {
+        const srla = new sorla();
+        expect(srla.dbExists('shop')).to.equal(false);
+        srla.useDb('shop');
+        expect(srla.dbExists('shop')).to.equal(true);
+        expect(srla.db.name).to.equal('shop');
+        expect(srla.countDb()).to.equal(1);
+    });
+
+    it('createDb returns the position, or false when the name exists', () => {
+        const srla = new sorla();
+        expect(srla.createDb('a')).to.equal(0);
+        expect(srla.createDb('b')).to.equal(1);
+        expect(srla.createDb('a')).to.equal(false);
+    });
+
+    it('keeps databases and their collections isolated', () => {
+        const srla = new sorla();
+        srla.useDb('one');
+        srla.db.createCollection('items');
+        srla.db.items.insertOne({ n: 1 });
+        srla.useDb('two');
+        srla.db.createCollection('items');
+        expect(srla.db.items.count()).to.equal(0);
+        srla.useDb('one');
+        expect(srla.db.items.count()).to.equal(1);
+    });
+
+    it('instances do not share data', () => {
+        const a = new sorla();
+        const b = new sorla();
+        a.useDb('x');
+        expect(b.dbExists('x')).to.equal(false);
+    });
+
+    it('rejects duplicated collection names', () => {
+        const srla = new sorla();
+        srla.useDb('dupes');
+        srla.db.createCollection('items');
+        expect(() => srla.db.createCollection('items')).to.throw('Collection already exists');
+        expect(srla.db.countCollections()).to.equal(1);
+    });
+
+    it('collection count, first, last and all', () => {
+        const srla = new sorla();
+        srla.useDb('basics');
+        srla.db.createCollection('items');
+        const items = srla.db.items;
+        expect(items.count()).to.equal(0);
+        items.insertOne({ n: 1 });
+        items.insertOne({ n: 2 });
+        expect(items.count()).to.equal(2);
+        expect(items.first.n).to.equal(1);
+        expect(items.last.n).to.equal(2);
+        expect(items.all.length).to.equal(2);
+    });
+});