sorla-db 1.1.0 → 1.2.0

package/test/feature_database.test.js

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

package/test/feature_insert.test.js

@@ -1,116 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-
-describe('SORLA inserting documents', () => {
-    let srla;
-    let counter = 0;
-    const fresh = () => {
-        const name = `insert${++counter}`;
-        srla.db.createCollection(name);
-        return srla.db[name];
-    };
-
-    beforeAll(() => {
-        srla = new sorla();
-        srla.useDb('inserts');
-        // insertMany logs the count of invalid documents on every call
-        jest.spyOn(console, 'info').mockImplementation(() => {});
-    });
-
-    afterAll(() => jest.restoreAllMocks());
-
-    it('generates a uuid v4 _id when the document has none', () => {
-        const collection = fresh();
-        collection.insertOne({ name: 'Ana' });
-        expect(collection.first._id).to.match(UUID_V4);
-    });
-
-    it('generates unique ids', () => {
-        const collection = fresh();
-        for(let i = 0; i < 500; i++) collection.insertOne({ i });
-        const ids = new Set(collection.all.map(doc => doc._id));
-        expect(ids.size).to.equal(500);
-    });
-
-    it('keeps a provided _id', () => {
-        const collection = fresh();
-        collection.insertOne({ _id: 'custom-1', name: 'Ana' });
-        expect(collection.findOne({ _id: 'custom-1' }).name).to.equal('Ana');
-    });
-
-    it('keeps values of every type', () => {
-        const collection = fresh();
-        collection.insertOne({ text: 'a', number: 1.5, flag: false, list: [1, 'b'], nested: { deep: { value: 3 } }, empty: '' });
-        const doc = collection.first;
-        expect(doc).to.include({ text: 'a', number: 1.5, flag: false, empty: '' });
-        expect(doc.list).to.deep.equal([1, 'b']);
-        expect(doc.nested.deep.value).to.equal(3);
-    });
-
-    it('insertMany inserts in order and counts', () => {
-        const collection = fresh();
-        collection.insertMany([{ n: 1 }, { n: 2 }, { n: 3 }]);
-        expect(collection.count()).to.equal(3);
-        expect(collection.all.map(doc => doc.n)).to.deep.equal([1, 2, 3]);
-        expect(collection.last.n).to.equal(3);
-    });
-
-    it('calls the callbacks', () => {
-        const collection = fresh();
-        let calls = 0;
-        collection.insertOne({ n: 1 }, () => calls++);
-        collection.insertMany([{ n: 2 }], () => calls++);
-        expect(calls).to.equal(2);
-    });
-
-    it('rejects documents that are not objects', () => {
-        const collection = fresh();
-        expect(() => collection.insertOne('text')).to.throw('Invalid document type');
-        expect(() => collection.insertOne(['a'])).to.throw('Invalid document type');
-        expect(() => collection.insertMany('text')).to.throw();
-        expect(() => collection.insertMany([{ a: 1 }, 'b'])).to.throw('Documents must be an array of objects');
-    });
-
-    it('rejects keys with $ or .', () => {
-        const collection = fresh();
-        expect(() => collection.insertOne({ $name: 'a' })).to.throw('Invalid document keys');
-        expect(() => collection.insertOne({ 'a.b': 1 })).to.throw('Invalid document keys');
-        expect(() => collection.insertOne({ nested: { 'a.b': 1 } })).to.throw('Invalid document keys');
-        expect(() => collection.insertOne({ list: [{ 'a.b': 1 }] })).to.throw('Invalid document keys');
-        expect(collection.count()).to.equal(0);
-    });
-
-    // ---- known bugs: these document current behavior and will start failing once fixed
-
-    it.failing('accepts null values (Object.keys(null) in _validateKeys)', () => {
-        const collection = fresh();
-        collection.insertOne({ name: 'Ana', nickname: null });
-        expect(collection.first.nickname).to.equal(null);
-    });
-
-    it.failing('validates every nested object, not only the first one', () => {
-        const collection = fresh();
-        expect(() => collection.insertOne({ first: { ok: 1 }, second: { 'a.b': 1 } })).to.throw('Invalid document keys');
-    });
-
-    it.failing('rejects a duplicated _id', () => {
-        const collection = fresh();
-        collection.insertOne({ _id: 'same' });
-        expect(() => collection.insertOne({ _id: 'same' })).to.throw();
-    });
-
-    it.failing('insertMany explains why a non array is rejected (it calls reduce before validating)', () => {
-        const collection = fresh();
-        expect(() => collection.insertMany('text')).to.throw('Documents must be an array of objects');
-    });
-
-    it.failing('does not mutate the inserted object', () => {
-        const collection = fresh();
-        const input = { name: 'Ana' };
-        collection.insertOne(input);
-        expect(input).to.not.have.property('_id');
-    });
-});

package/test/feature_nested_queries.test.js

@@ -1,94 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-describe('SORLA nested logical queries', () => {
-    let people;
-
-    beforeAll(() => {
-        const srla = new sorla();
-        srla.useDb('nestedQueries');
-        srla.db.createCollection('people');
-        srla.db.people.insertOne({ name: 'Ana', age: 25, city: 'A', tags: ['admin'] });
-        srla.db.people.insertOne({ name: 'Bruno', age: 31, city: 'B', tags: [] });
-        srla.db.people.insertOne({ name: 'Carla', age: 42, city: 'C', tags: ['admin', 'dev'] });
-        srla.db.people.insertOne({ name: 'Davi', age: 35, city: 'A' });
-        srla.db.people.insertOne({ name: 'Eva', age: 19, city: 'D', tags: ['dev'] });
-        people = srla.db.people;
-    });
-
-    const names = cursor => {
-        const result = [];
-        while(cursor.hasNext()) result.push(cursor.next()._data.name);
-        return result;
-    };
-
-    it('combines $and with a nested $or', () => {
-        const docs = people.find({
-            $and: [
-                { age: { $gte: 30 } },
-                { $or: [{ name: 'Carla' }, { city: { $in: ['A', 'B'] } }] }
-            ]
-        });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Carla', 'Davi']);
-    });
-
-    it('nests groups at any depth', () => {
-        const docs = people.find({
-            $or: [
-                { $and: [{ city: 'A' }, { $or: [{ age: { $lt: 30 } }, { name: 'Davi' }] }] },
-                { $and: [{ city: 'D' }, { age: { $lt: 20 } }] }
-            ]
-        });
-        expect(names(docs)).to.deep.equal(['Ana', 'Davi', 'Eva']);
-    });
-
-    it('evaluates every operator of a field inside $or', () => {
-        const docs = people.find({ $or: [{ age: { $gte: 30, $lte: 35 } }, { name: 'Eva' }] });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Davi', 'Eva']);
-    });
-
-    it('evaluates every operator of a field at the top level', () => {
-        expect(names(people.find({ age: { $gt: 20, $lt: 40, $ne: 31 } }))).to.deep.equal(['Ana', 'Davi']);
-    });
-
-    it('supports $nor with nested groups', () => {
-        const docs = people.find({ $nor: [{ city: 'A' }, { $and: [{ age: { $gt: 40 } }, { city: 'C' }] }] });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Eva']);
-    });
-
-    it('$not inverts the whole condition, with one or more operators', () => {
-        expect(names(people.find({ age: { $not: { $gte: 30 } } }))).to.deep.equal(['Ana', 'Eva']);
-        expect(names(people.find({ age: { $not: { $gte: 30, $lte: 35 } } }))).to.deep.equal(['Ana', 'Carla', 'Eva']);
-    });
-
-    it('$not can be combined with other operators and logical groups', () => {
-        const docs = people.find({ $and: [{ city: { $not: { $eq: 'A' } } }, { $or: [{ age: { $lt: 20 } }, { name: 'Bruno' }] }] });
-        expect(names(docs)).to.deep.equal(['Bruno', 'Eva']);
-    });
-
-    it('matches array fields with $in', () => {
-        expect(names(people.find({ $or: [{ tags: { $in: ['dev'] } }, { age: 31 }] }))).to.deep.equal(['Bruno', 'Carla', 'Eva']);
-    });
-
-    it('a field missing in the document matches $ne and $nin', () => {
-        expect(names(people.find({ tags: { $ne: 'x' }, city: 'A' }))).to.deep.equal(['Ana', 'Davi']);
-        expect(names(people.find({ name: { $nin: ['Ana', 'Bruno'] }, age: { $lt: 40 } }))).to.deep.equal(['Davi', 'Eva']);
-    });
-
-    it('accepts null values in conditions', () => {
-        expect(people.find({ name: null }).length).to.equal(0);
-        expect(people.find({ $or: [{ name: null }, { name: 'Ana' }] }).length).to.equal(1);
-    });
-
-    it('findOne works with nested queries', () => {
-        const doc = people.findOne({ $and: [{ $or: [{ city: 'C' }, { city: 'D' }] }, { age: { $gt: 40 } }] });
-        expect(doc.name).to.equal('Carla');
-    });
-
-    it('rejects invalid queries with a clear error', () => {
-        expect(() => people.find({ $or: { name: 'Ana' } })).to.throw('The $or operator must be an array');
-        expect(() => people.find({ age: { $between: [1, 2] } })).to.throw('Unknown operator $between');
-        expect(() => people.find({ $not: { age: 1 } })).to.throw('$not operator must be used inside a field condition');
-    });
-});

package/test/feature_query_equivalence.test.js

@@ -1,165 +0,0 @@
-/**
- * Compares find() against a straightforward reference implementation of the query semantics,
- * over hand written queries and hundreds of randomly generated nested ones (seeded, so a failure
- * always reproduces). This catches logic bugs, not just crashes.
- */
-const chai = require('chai')
-const expect = chai.expect
-const sorla = require('../src/sorla.js')
-
-// deterministic PRNG (mulberry32)
-function prng(seed) {
-    return () => {
-        seed |= 0; seed = seed + 0x6D2B79F5 | 0;
-        let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
-        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-        return ((t ^ t >>> 14) >>> 0) / 4294967296;
-    };
-}
-
-const NAMES = ['Ana', 'Bruno', 'Carla', 'Davi', 'Eva', 'Fábio'];
-const CITIES = ['A', 'B', 'C', 'D'];
-const TAGS = ['admin', 'dev', 'ops'];
-
-function buildDocuments(random, count) {
-    const pick = list => list[Math.floor(random() * list.length)];
-    return Array.from({ length: count }, (_, n) => {
-        const doc = { n, name: pick(NAMES), city: pick(CITIES), score: Math.round(random() * 1000) / 10, active: random() > 0.5 };
-        if(random() > 0.15) doc.age = 18 + Math.floor(random() * 50);          // sometimes missing
-        if(random() > 0.3) doc.tags = TAGS.filter(() => random() > 0.5);       // array, sometimes missing
-        // nickname is often missing; null values cannot be stored yet (see feature_insert.test.js)
-        if(random() > 0.5) doc.nickname = pick(NAMES);
-        return doc;
-    });
-}
-
-// ---- reference semantics, written independently of src/
-const compare = {
-    $eq: (v, q) => !Array.isArray(q) && v === q,
-    $ne: (v, q) => !Array.isArray(q) && v !== q,
-    $gt: (v, q) => !Array.isArray(q) && v > q,
-    $gte: (v, q) => !Array.isArray(q) && v >= q,
-    $lt: (v, q) => !Array.isArray(q) && v < q,
-    $lte: (v, q) => !Array.isArray(q) && v <= q,
-    $in: (v, q) => Array.isArray(v) ? v.some(item => q.includes(item)) : q.includes(v),
-    $nin: (v, q) => !(Array.isArray(v) ? v.some(item => q.includes(item)) : q.includes(v))
-};
-
-function refCondition(value, condition) {
-    const isOps = condition !== null && typeof condition === 'object' && !Array.isArray(condition)
-        && Object.keys(condition).length > 0 && Object.keys(condition).every(k => k.startsWith('$'));
-    if(!isOps) return value === condition;
-    return Object.entries(condition).every(([op, arg]) => op === '$not' ? !refCondition(value, arg) : compare[op](value, arg));
-}
-
-function refMatch(doc, query) {
-    return Object.entries(query).every(([key, value]) => {
-        if(key === '$and') return value.every(q => refMatch(doc, q));
-        if(key === '$or') return value.some(q => refMatch(doc, q));
-        if(key === '$nor') return !value.some(q => refMatch(doc, q));
-        return refCondition(doc[key], value);
-    });
-}
-
-// ---- random nested queries
-function randomQueryGenerator(random) {
-    const pick = list => list[Math.floor(random() * list.length)];
-    const fields = {
-        name: () => pick(NAMES),
-        city: () => pick(CITIES),
-        age: () => 18 + Math.floor(random() * 50),
-        score: () => Math.round(random() * 1000) / 10,
-        active: () => random() > 0.5,
-        tags: () => pick(TAGS),
-        nickname: () => random() > 0.3 ? pick(NAMES) : null
-    };
-
-    function condition(field) {
-        const value = fields[field];
-        const roll = random();
-        if(roll < 0.2) return value();                                            // plain equality
-        const ops = {};
-        const count = 1 + Math.floor(random() * 2);
-        for(let i = 0; i < count; i++) {
-            const op = pick(['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin']);
-            ops[op] = op === '$in' || op === '$nin' ? [value(), value()] : value();
-        }
-        return roll > 0.85 ? { $not: ops } : ops;
-    }
-
-    function node(depth) {
-        const query = {};
-        const fieldNames = Object.keys(fields).sort(() => random() - 0.5).slice(0, 1 + Math.floor(random() * 2));
-        for(const field of fieldNames) query[field] = condition(field);
-        if(depth < 3 && random() > 0.4) {
-            const logical = pick(['$and', '$or', '$nor']);
-            query[logical] = Array.from({ length: 1 + Math.floor(random() * 3) }, () => node(depth + 1));
-        }
-        return query;
-    }
-
-    return () => node(0);
-}
-
-describe('SORLA find() matches the reference query semantics', () => {
-    let collection;
-    let documents;
-
-    beforeAll(() => {
-        documents = buildDocuments(prng(2026), 120);
-        const srla = new sorla();
-        srla.useDb('equivalence');
-        srla.db.createCollection('people');
-        // insertOne mutates the object (adds _id), keep the reference documents clean
-        for(const doc of documents) srla.db.people.insertOne(structuredClone(doc));
-        collection = srla.db.people;
-    });
-
-    const found = query => {
-        const cursor = collection.find(query);
-        const ids = [];
-        while(cursor.hasNext()) ids.push(cursor.next()._data.n);
-        return ids;
-    };
-    const expected = query => documents.filter(doc => refMatch(doc, query)).map(doc => doc.n);
-
-    const handWritten = [
-        {},
-        { city: 'A' },
-        { age: { $gte: 30, $lt: 40 } },
-        { tags: { $in: ['ops'] } },
-        { nickname: null },
-        { nickname: { $ne: null } },
-        { age: { $nin: [20, 21, 22] }, active: true },
-        { $or: [{ city: 'A' }, { city: 'B', age: { $gt: 50 } }] },
-        { $and: [{ age: { $gte: 30 } }, { $or: [{ name: 'Ana' }, { city: { $in: ['A', 'B'] } }] }] },
-        { $nor: [{ active: true }, { score: { $lt: 50 } }] },
-        { score: { $not: { $gte: 20, $lte: 80 } } },
-        { $or: [{ $and: [{ city: 'C' }, { $nor: [{ age: { $lt: 30 } }] }] }, { tags: { $in: ['admin'] }, active: false }] }
-    ];
-
-    handWritten.forEach((query, i) => {
-        it(`hand written query #${i + 1}: ${JSON.stringify(query)}`, () => {
-            expect(found(query)).to.deep.equal(expected(query));
-        });
-    });
-
-    it('500 random nested queries give the same documents as the reference', () => {
-        const next = randomQueryGenerator(prng(42));
-        let nonEmpty = 0;
-        for(let i = 0; i < 500; i++) {
-            const query = next();
-            const want = expected(query);
-            if(want.length) nonEmpty++;
-            expect(found(query), JSON.stringify(query)).to.deep.equal(want);
-        }
-        // the generator must produce meaningful queries, not only empty results
-        expect(nonEmpty).to.be.greaterThan(100);
-    });
-
-    it('findOne returns the first matching document', () => {
-        const query = { $and: [{ city: 'B' }, { $or: [{ active: true }, { age: { $gt: 40 } }] }] };
-        const first = expected(query)[0];
-        expect(collection.findOne(query).n).to.equal(first);
-    });
-});

package/test/unit_database.test.js

@@ -1,36 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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_operators.test.js

@@ -1,78 +0,0 @@
-const chai = require('chai')
-const expect = chai.expect
-const operators = require('../src/query_language/operators.js')
-
-describe('SORLA comparison operators', () => {
-    const op = new operators();
-
-    it('recognizes logical and comparison operators', () => {
-        for(const name of ['$and', '$or', '$not', '$nor'])
-            expect(op.isLogicalOperator(name)).to.equal(true);
-        for(const name of ['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$nin'])
-            expect(op.isOperator(name)).to.equal(true);
-        expect(op.isAnyOperator('$regex')).to.equal(false);
-        expect(op.isAnyOperator('name')).to.equal(false);
-    });
-
-    it('$eq is strict', () => {
-        expect(op.$eq(1, 1)).to.equal(true);
-        expect(op.$eq('1', 1)).to.equal(false);
-        expect(op.$eq(null, null)).to.equal(true);
-        expect(op.$eq(undefined, null)).to.equal(false);
-        expect(op.$eq(true, 1)).to.equal(false);
-        expect(op.$eq([1], [1]), 'arrays are not compared').to.equal(false);
-    });
-
-    it('$ne is the negation of $eq for scalars', () => {
-        expect(op.$ne(1, 2)).to.equal(true);
-        expect(op.$ne(1, 1)).to.equal(false);
-        expect(op.$ne(undefined, 1), 'missing field').to.equal(true);
-    });
-
-    it('range operators compare numbers, strings and ISO dates', () => {
-        expect(op.$gt(5, 3)).to.equal(true);
-        expect(op.$gte(3, 3)).to.equal(true);
-        expect(op.$lt(2, 3)).to.equal(true);
-        expect(op.$lte(3, 3)).to.equal(true);
-        expect(op.$gt('b', 'a')).to.equal(true);
-        expect(op.$lt('2026-01-31', '2026-02-01')).to.equal(true);
-        expect(op.$gt(undefined, 0), 'missing field').to.equal(false);
-        expect(op.$lt(undefined, 10), 'missing field').to.equal(false);
-    });
-
-    it('range operators reject arrays as the operand', () => {
-        for(const name of ['$gt', '$gte', '$lt', '$lte', '$eq', '$ne'])
-            expect(op[name](1, [1, 2]), name).to.equal(false);
-    });
-
-    it('$in and $nin work with scalar and array fields', () => {
-        expect(op.$in('a', ['a', 'b'])).to.equal(true);
-        expect(op.$in('c', ['a', 'b'])).to.equal(false);
-        expect(op.$in(['x', 'b'], ['a', 'b']), 'array field shares a value').to.equal(true);
-        expect(op.$in(['x'], ['a', 'b'])).to.equal(false);
-        expect(op.$in(1, ['1']), 'strict').to.equal(false);
-        expect(op.$nin('c', ['a', 'b'])).to.equal(true);
-        expect(op.$nin(undefined, ['a']), 'missing field').to.equal(true);
-    });
-
-    it('$in and $nin require an array', () => {
-        expect(() => op.$in('a', 'a')).to.throw('$in operator must be an array');
-        expect(() => op.$nin('a', 'a')).to.throw('$nin operator must be an array');
-    });
-
-    it('matchesCondition treats plain values as equality and objects of operators as conditions', () => {
-        expect(op.matchesCondition(5, 5)).to.equal(true);
-        expect(op.matchesCondition(5, { $gt: 1, $lt: 10 })).to.equal(true);
-        expect(op.matchesCondition(5, { $gt: 1, $lt: 4 })).to.equal(false);
-        expect(op.matchesCondition(5, { $not: { $gt: 10 } })).to.equal(true);
-        expect(op.matchesCondition({ a: 1 }, { a: 1 }), 'objects are not deep compared').to.equal(false);
-    });
-
-    it('isOperatorObject only accepts non empty objects made of operators', () => {
-        expect(op.isOperatorObject({ $gt: 1 })).to.equal(true);
-        expect(op.isOperatorObject({ $gt: 1, name: 2 })).to.equal(false);
-        expect(op.isOperatorObject({})).to.equal(false);
-        expect(op.isOperatorObject(null)).to.equal(false);
-        expect(op.isOperatorObject([1])).to.equal(false);
-    });
-});

package/test/unit_sorla.test.js

@@ -1,42 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

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