sorla-db 1.0.0

package/test/feature_collection.test.js

@@ -0,0 +1,73 @@
+const chai = require('chai')
+const expect = chai.expect
+const faker = require('faker')
+const sorla = require('../src/sorla.js')
+
+describe('SORLA Collection Feature Test', () => {
+    beforeAll(() => {
+        this.srla = new sorla();
+        this.dbname = faker.random.word();
+        this.srla.createDb(this.dbname);
+        this.srla.useDb(this.dbname);
+    });
+
+    beforeEach(() => {
+        this.collectionName = faker.random.word();
+        this.srla.db.createCollection(this.collectionName);
+    });
+
+    it('Create a single document inside of a collection and check by length', () => {
+        this.srla.db[this.collectionName].insertOne({name: 'Anderson'});
+        expect(this.srla.db[this.collectionName].count()).to.equal(1);
+    });
+
+    it('create multiple documents and check by length', () => {
+        this.srla.db[this.collectionName].insertMany([
+            {name: 'Anderson'},
+            {name: 'Arruda'},
+            {name: 'Sorla'}
+        ]);
+        expect(this.srla.db[this.collectionName].count()).to.equal(3);
+    });
+
+    it('create a document with prohibited character $', () => {
+        expect(() => this.srla.db[this.collectionName].insertOne({name: 'Anderson', $test: '123'})).to.throw();
+    });
+
+    it('create a document with prohibited character .', () => {
+        expect(() => this.srla.db[this.collectionName].insertOne({"name.name": 'Anderson', test: {test: '123'}})).to.throw();
+    });
+
+    it('create a document with prohibited character . inside of an array', () => {
+        expect(() => this.srla.db[this.collectionName].insertOne({name: 'Anderson', test: [{"test.number": '123'}, {"test.number": '123'}]})).to.throw();
+    });
+
+    it('create a document with prohibited character . inside of an object', () => {
+        expect(() => this.srla.db[this.collectionName].insertOne({name: 'Anderson', test: {"test.number": '123'}})).to.throw();
+    });
+
+    /*it('get a document by his subfield using test.inscription', () => {
+        this.srla.db[this.collectionName].insertMany([
+            {name: 'Anderson', test: {inscription: 123}},
+            {name: 'Arruda', test: {inscription: 321}},
+            {name: 'Sorla', test: {inscription: 213}}
+        ]);
+        expect(this.srla.db[this.collectionName].findOne({'test.inscription': 123}).length).to.equal(1);
+    });
+
+    it('Try to create a document without beeing a valid object', () => {
+        expect(() => this.srla.db[this.collectionName].insertOne('Anderson')).to.throw();
+    });
+
+    it('Try to create a document with array', () => {
+        expect(() => this.srla.db[this.collectionName].insertOne(['Anderson'])).to.throw();
+    });
+
+    it('Try to create many documents without beeing a valid array', () => {
+        expect(() => this.srla.db[this.collectionName].insertMany('Anderson')).to.throw();
+    });
+
+    it('Try to create many documents without having valid object', () => {
+        expect(() => this.srla.db[this.collectionName].insertMany([{test: '123', }, 'anderson'])).to.throw();
+    });*/
+});

package/test/feature_collection_queries.test.js

@@ -0,0 +1,269 @@
+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);
+    });
+});

package/test/unit_database.test.js

@@ -0,0 +1,36 @@
+const chai = require('chai')
+const expect = chai.expect
+const faker = require('faker')
+const sorla = require('../src/sorla.js')
+const collection = require('../src/collections/collection.js');
+
+describe('SORLA Database Unit Test', () => {
+    beforeAll(() => {
+        this.srla = new sorla();
+        this.dbname = faker.random.word();
+        this.srla.createDb(this.dbname);
+        this.srla.useDb(this.dbname);
+    });
+
+    it('Should create a new collection with specified name', () => {
+        this.srla.db.createCollection('collection1');
+        expect(this.srla.db.countCollections()).to.equal(1);
+        expect(this.srla.db.collection1).to.not.be.undefined;
+        expect(this.srla.db.collection1).to.be.an.instanceof(collection);
+    });
+
+    it('Should create a new collection with specified name, second collection', () => {
+        this.srla.db.createCollection('collection2');
+        expect(this.srla.db.countCollections()).to.equal(2);
+        expect(this.srla.db.collection2).to.not.be.undefined;
+        expect(this.srla.db.collection2).to.be.an.instanceof(collection);
+    });
+
+    it('Should return a collection undefined when not exists', () => {
+        expect(this.srla.db.collection3).to.be.undefined;
+    });
+
+    it('Should avoid create a collection with name that exists in database class', () => {
+        expect(() => this.srla.db.createCollection('_name')).to.throw();
+    });
+});

package/test/unit_document_test.js

@@ -0,0 +1,39 @@
+const chai = require('chai');
+const expect = chai.expect;
+const faker = require('faker');
+const documents = require('../src/documents/document.js');
+
+describe('testing document capabilities', () => {
+    it('checking capabilities of getting a field inside a object', () => {
+        const doc = new documents({
+            name: 'Anderson',
+            test: {
+                inscription: 123
+            }
+        });
+        
+        expect(doc.name).to.equal('Anderson');
+    });
+
+    it('checking capabilities of getting a field inside a object', () => {
+        const doc = new documents({
+            name: 'Anderson',
+            test: {
+                inscription: 123
+            }
+        });
+        
+        expect(doc.test.inscription).to.equal(123);
+    });
+
+    it('checking capabilities of getting a field inside a object', () => {
+        const doc = new documents({
+            name: 'Anderson',
+            test: {
+                inscription: 123
+            }
+        });
+        
+        expect(doc['test.inscription']).to.equal(123);
+    });
+});

package/test/unit_sorla.test.js

@@ -0,0 +1,42 @@
+const chai = require('chai')
+const expect = chai.expect
+const faker = require('faker')
+
+const sorla = require('../src/sorla.js')
+
+describe('SORLA Unit Test', () => {
+    it('Should create a new database with random name', () => {
+        const srla = new sorla();
+        const dbname = faker.random.word();
+        srla.createDb(dbname);
+        srla.useDb(dbname);
+
+        expect(srla.countDb()).to.equal(1);
+        expect(srla.dbExists(dbname)).to.equal(true);
+        expect(srla.db.name).to.equal(dbname);
+    });
+
+    it('Should not create a new database with the same name', () => {
+        const srla = new sorla();
+        const dbname = faker.random.word();
+        srla.createDb(dbname);
+
+        expect(srla.createDb(dbname)).to.equal(false);
+    });
+
+    it('Should created more than one database', () => {
+        const srla = new sorla();
+        for(let i=0; i<2; i++)
+        {
+            const dbname = faker.random.word();
+            srla.createDb(dbname);
+        }
+
+        expect(srla.countDb()).to.equal(2);
+    });
+
+    it('Should not have any database created', () => {
+        const srla = new sorla();
+        expect(srla.countDb()).to.equal(0);
+    });
+});

package/test/unit_test.test.js

@@ -0,0 +1,25 @@
+const chai = require('chai');
+const expect = chai.expect;
+
+const sorla = require('../src/sorla.js');
+
+describe('Sorla Class', () => {
+    it('should create a new database', () => {
+        const srla = new sorla();
+        srla.createDb('test');
+        expect(srla.countDb()).to.equal(1);
+    });
+
+    it('should not create a new database with the same name', () => {
+        const srla = new sorla();
+        srla.createDb('test');
+        expect(srla.createDb('test')).to.equal(false);
+    });
+
+    it('should created a new database and select it', () => {
+        const srla = new sorla();
+        const dbname = 'test';
+        srla.useDb(dbname);
+        expect(srla.db.name).to.equal(dbname);
+    });
+});

package/webpack.config.js

@@ -0,0 +1,11 @@
+const path = require('path');
+
+module.exports = {
+    mode: "production",
+    target: "web",
+    entry: './src/sorla.js',
+    output: {
+        path: path.resolve(__dirname, 'dist'),
+        filename: 'sorla.min.js'
+    }
+}