@igojs/db 6.0.0-beta.1

package/test/ModelTest.js

@@ -0,0 +1,510 @@
+
+
+require('./init');
+
+const assert    = require('assert');
+const _         = require('lodash');
+
+const Model     = require('@igojs/db').Model;
+
+describe('db.Model', () => {
+
+  const schema = {
+    table:    'books',
+    primary: ['id'],
+    columns: [
+      'id',
+      'code',
+      'title',
+      {name: 'details_json', type: 'json', attr: 'details'},
+      {name:'is_available', type: 'boolean'},
+      'library_id',
+      'created_at'
+    ]
+  };
+
+  class Book extends Model(schema) {}
+
+  const schema2 = {
+    table:    'books',
+    primary: ['id'],
+    columns: [
+      'id',
+      'code',
+      'title',
+      {name: 'details_json', type: 'json', attr: 'details'},
+      {name:'is_available', type: 'boolean'},
+      'library_id',
+      'created_at'
+    ],
+    scopes: {
+      default:  query => query.limit(2)
+    }
+  };
+
+  class Book2 extends Model(schema2) {}
+
+  describe('standard crud operations', () => {
+
+    //
+    describe('insert', () => {
+
+      it('should insert a book', async () => {
+        const book = await Book.create();
+        assert(book && book.id);
+        assert.strictEqual(book.is_available, null);
+      });
+
+      it('should insert a book with values', async () => {
+        const book = await Book.create({code: 123});
+        assert(book && book.id);
+        assert.strictEqual(book.code, '123');
+      });
+
+      it('should insert a book with values and go through beforeCreate', async () => {
+        class BookWithTitle extends Model(schema) {
+          beforeCreate() {
+            this.title = this.title || this.code;
+          }
+        }
+
+        const book = await BookWithTitle.create({code: 123});
+        assert(book && book.id);
+        assert.strictEqual(book.code, '123');
+        assert.strictEqual(book.title, '123');
+      });
+
+    });
+
+    //
+    describe('find', () => {
+      it('should find book by id', async () => {
+        const first = await Book.create();
+        const book  = await Book.find(first.id);
+        assert.strictEqual(book.id, first.id);
+      });
+
+      it('should not find book if id is null', async () => {
+        await Book.create();
+        const book  = await Book.find(null);
+        assert.strictEqual(book, null);
+      });
+    });
+
+    //
+    describe('list', () => {
+
+      it('should handle empty arrays in where conditions', async () => {
+        const books = await Book.where({id: []}).list();
+        assert.strictEqual(0, books.length);
+      });
+
+      it('should handle 1k elements', async () => {
+        const nb = 1000;
+        const books = [];
+        for (let n = 0; n < nb; n++) {
+          const book = await Book.create();
+          books.push(book);
+        }
+        // const books = await Book.create(next)
+        assert.strictEqual(nb, books.length);
+        const books2 = await Book.list();
+        assert.strictEqual(nb, books2.length);
+      });
+
+      it('should handle a simple where condition as string', async () => {
+        const book1 = await Book.create();
+        const book2 = await Book.create();
+        const books = await Book.where('`id` > ' + book1.id).list();
+        assert.strictEqual(1, books.length);
+        assert.strictEqual(books[0].id, book2.id);
+      });
+
+      it('should handle a simple where condition with param', async () => {
+        const book1 = await Book.create();
+        const book2 = await Book.create();
+        const books = await Book.where('`id` > ?', book1.id).list();
+        assert.strictEqual(1, books.length);
+        assert.strictEqual(books[0].id, book2.id);
+      });
+
+      it('should handle where not condition with id', async () => {
+        const book1 = await Book.create();
+        const book2 = await Book.create();
+        const books = await Book.whereNot({id: book1.id}).list();
+        assert.strictEqual(1, books.length);
+        assert.strictEqual(books[0].id, book2.id);
+      });
+
+      it('should handle where not with array', async () => {
+        const book1 = await Book.create();
+        const book2 = await Book.create();
+        const books = await Book.whereNot({id: [book1.id, book2.id]}).list();
+        assert.strictEqual(0, books.length);
+      });
+
+      it('should handle where not with empty array', async () => {
+        await Book.create();
+        await Book.create();
+        const books = await Book.whereNot({id: []}).list();
+        assert.strictEqual(2, books.length);
+      });
+
+      it('should handle two where / whereNot conditions', async () => {
+        const book1 = await Book.create();
+        const book2 = await Book.create();
+        const books = await Book.where('`id` > ?', book1.id).whereNot({ id: book2.id }).list();
+        assert.strictEqual(0, books.length);
+      });
+
+      it('should handle two whereNoy / where conditions', async () => {
+        const book1 = await Book.create();
+        const book2 = await Book.create();
+        const books = await Book.whereNot({ id: book2.id }).where('`id` > ?', book1.id).list();
+        assert.strictEqual(0, books.length);
+      });
+
+      it.skip('should allow override default scope limit', async () => {
+        await Book2.create({ code: '123', title: 'title' });
+        await Book2.create({ code: '12345', title: 'title 2' });
+        const books = await Book2.list();
+        assert.strictEqual(books.length, 2);
+
+        const one = await Book2.limit(1).list();
+        assert.strictEqual(one.id, 1);
+      });
+
+    });
+
+    //
+    describe('first', () => {
+      it('should select first book', async () => {
+        const first   = await Book.create();
+        const hibook  = await Book.create({title: 'hi'});
+        await Book.create();
+        const book = await Book.unscoped().first();
+        assert.strictEqual(first.id, book.id);
+        assert.strictEqual('hi', hibook.title);
+      });
+
+      it('should allow a limit in the default scope and select first book', async () => {
+        const first   = await Book2.create();
+        const hibook  = await Book2.create({title: 'hi'});
+        await Book2.create();
+        const book = await Book2.first();
+        assert.strictEqual(first.id, book.id);
+        assert.strictEqual('hi', hibook.title);
+      });
+    });
+
+    //
+    describe('last', () => {
+      it('should select last book', async () => {
+        await Book.create();
+        await Book.create();
+        const last = await Book.create();
+        const book = await Book.unscoped().last();
+        assert.strictEqual(last.id, book.id);
+      });
+    });
+
+    //
+    describe('delete', () => {
+      it('should delete a book', async () => {
+        const first = await Book.create();
+        await Book.create();
+        await Book.create();
+        await Book.delete(first.id);
+        const book = await Book.find(first.id);
+        assert(!book);
+      });
+
+      it('should delete selected books', async () => {
+        await Book.create({ code: '123' });
+        await Book.create({ code: '123' });
+        await Book.create();
+        await Book.where({ code: '123' }).delete();
+        const books = await Book.list();
+        assert(books.length, 1);
+      });
+    });
+
+    //
+    describe('update', () => {
+      it('should update books', async () => {
+        await Book.create({ code: '123' });
+        await Book.create({ code: '123' });
+        await Book.create();
+        await Book.where({ code: '123' }).update({ title: 'undeuxtrois'});
+        const books = await Book.where({ title: 'undeuxtrois'}).list();
+        assert.strictEqual(books.length, 2);
+      });
+
+      it('should update all books', async () => {
+        await Book.create({ code: '123' });
+        await Book.create({ code: '123' });
+        await Book.create();
+        await Book.update({ title: 'undeuxtrois'});
+        const books = await Book.where({ title: 'undeuxtrois'}).list();
+        assert.strictEqual(books.length, 3);
+      });
+
+      it('should load distinct codes', async () => {
+        await Book.create({ code: '000' });
+        await Book.create({ code: '111' });
+        await Book.create({ code: '111' });
+        const codes = await Book.distinct('code').list();
+        assert.strictEqual(codes.length, 2);
+      });
+
+      it('should load distinct codes and titles', async () => {
+        await Book.create({ code: '000' });
+        await Book.create({ code: '111', title: '111' });
+        await Book.create({ code: '111', title: '111' });
+        await Book.create({ code: '222', title: '111' });
+        const res = await Book.where({title: '111' }).distinct([ 'code', 'title' ]).list();
+        assert.strictEqual(res.length, 2);
+      });
+    });
+
+    //
+    describe('select', () => {
+      it('should use custom select', async () => {
+        await Book.create({ code: '123', title: 'title' });
+        const books = await Book.select('title').list();
+        assert(books[0].title, 'title');
+        assert(!books[0].code);
+      });
+
+      it('should use custom select', async () => {
+        await Book.create({ code: '123', title: 'title' });
+        const books = await Book.select('*, EXTRACT(YEAR FROM created_at) AS "year"').list();
+        const currentYear = new Date().getFullYear();
+        assert(books[0].title, 'title');
+        assert(books[0].year, currentYear);
+      });
+    });
+
+    //
+    describe('count', () => {
+      it('should count elements', async () => {
+        const nb = 100;
+        const books = [];
+        for (let n = 0; n < nb; n++) {
+          const book = await Book.create();
+          books.push(book);
+        }
+        assert.strictEqual(nb, books.length);
+        
+        const count = await Book.count();
+        assert.strictEqual(nb, count);
+      });
+    });
+  });
+
+
+  describe('instance operations', () => {
+
+    describe('delete', () => {
+      it('should delete a book', async () => {
+        await Book.create();
+        await Book.create();
+        const last = await Book.create();
+        await last.delete();
+        const book = await Book.find(last.id);
+        assert(!book);
+      });
+    });
+
+    describe('update', () => {
+      it('should update a book', async () => {
+        let book = await Book.create();
+        book = await book.update({ code: 'hop', hello: 'world' });
+        assert.strictEqual(book.code, 'hop');
+        assert.notStrictEqual(book.hello, 'world');
+        book = await book.reload();
+        assert.strictEqual(book.code, 'hop');
+      });
+
+      it('should update a book with beforeUpdate', async () => {
+        class BookWithBeforeUpdate extends Model(schema) {
+          beforeUpdate(values) {
+            values.title = values.code;
+          }
+        }
+        let book = await BookWithBeforeUpdate.create();
+        book = await book.update({ code: '234' });
+        assert.strictEqual(book.title, '234');
+        book = await book.reload();
+        assert.strictEqual(book.title, '234');
+      });
+    });
+
+  });
+
+  describe('scopes', () => {
+
+    var schema = {
+      table:    'books',
+      primary:  ['id'],
+      columns: [
+        'id',
+        'code',
+        'title',
+        {name: 'details_json', type: 'json', attr: 'details'},
+        {name:'is_available', type: 'boolean'},
+        'library_id',
+        'created_at'
+      ],
+      scopes: {
+        default:  query => query.where({ code: 'abc' }),
+        a:        query => query.where({ code: 'a' }),
+      }
+    };
+
+    class BookWithScopes extends Model(schema) {}
+
+    it('should use default scope', async () => {
+      await BookWithScopes.create({code: 'a'});
+      await BookWithScopes.create({code: 'abc'});
+      const books = await BookWithScopes.list();
+      assert.strictEqual(books.length, 1);
+    });
+
+    it('should use a scope', async () => {
+      await BookWithScopes.create({code: 'a'});
+      await BookWithScopes.create({code: 'abc'});
+      const books = await BookWithScopes.unscoped().scope('a').list();
+      assert.strictEqual(books.length, 1);
+    });
+  });
+
+  describe('count', () => {
+    it('should count rows', async () => {
+      for (let n = 0; n < 10; n++) {
+        await Book.create({ code: 'first' });
+      }
+      for (let n = 0; n < 20; n++) {
+        await Book.create({ code: 'second' });
+      }
+  
+      let count = await Book.where({code: 'first'}).count();
+      assert.strictEqual(count, 10);
+
+      count = await Book.count();
+      assert.strictEqual(count, 30);
+    });
+  });
+
+
+  describe('group', () => {
+    it('should group by code', async () => {
+      for (let n = 0; n < 10; n++) {
+        await Book.create({ code: 'first' });
+      }
+      for (let n = 0; n < 20; n++) {
+        await Book.create({ code: 'second' });
+      }
+
+      const groups = await Book.select('COUNT(*) AS "count", code').group('code').list();
+      const firsts  = _.find(groups, {code: 'first'});
+      const seconds = _.find(groups, {code: 'second'});
+      assert.strictEqual(firsts.count, 10);
+      assert.strictEqual(seconds.count, 20);
+    });
+
+    it('should group by year', async () => {
+      for (let n = 0; n < 10; n++) {
+        await Book.create({ code: 'first' });
+      }
+      for (let n = 0; n < 20; n++) {
+        await Book.create({ code: 'second' });
+      }
+
+      const groups = await Book.select('COUNT(*) AS "count", EXTRACT(YEAR FROM created_at) AS "year"').group('year').list();
+      const currentYear = new Date().getFullYear();
+      assert.strictEqual(groups[0].count, 30);
+      assert.strictEqual(groups[0].year, currentYear);
+    });
+  });
+
+
+  describe('json columns', () => {
+
+    const details = { a: 'hello', b: 'world', c: { d: '!' } };
+
+    it('should stringify on insert', async () => {
+      let book = await Book.create({ details });
+      assert.strictEqual(book.details.a, 'hello');
+      book = await Book.find(book.id);
+      assert.strictEqual(book.details.a, 'hello');
+    });
+
+    it('should stringify on update', async () => {
+      let book = await Book.create({ details });
+      book = await book.update({ details: { a: 'world' }});
+      assert.strictEqual(book.details.a, 'world');
+      book = await Book.find(book.id);
+      assert.strictEqual(book.details.a, 'world');
+    });
+
+    it('should stringify on global update', async () => {
+      let book = await Book.create({ details });
+      await Book.update({ details: { a: 'world' }});
+      book = await Book.find(book.id);
+      assert.strictEqual(book.details.a, 'world');
+    });
+
+    it('should parsejson on reload', async () => {
+      let book = await Book.create({ details });
+      book = await book.reload();
+      assert.strictEqual(book.details.a, 'hello');
+    });
+  });
+
+  describe('bool columns', () => {
+    it('should handle true booleans', async () => {
+      const book = await Book.create({ is_available: 'true' });
+      assert.strictEqual(book.is_available, true);
+    });
+    it('should handle false booleans', async () => {
+      const book = await Book.create({ is_available: '' });
+      assert.strictEqual(book.is_available, false);
+    });
+    it.skip('should let boolean to null', async () => {
+      const book = await Book.create({ is_available: null });
+      assert.strictEqual(book.is_available, null);
+    });
+  });
+
+
+  describe('array columns', () => {
+    var schema = {
+      table:    'books',
+      primary: ['id'],
+      columns: [
+        'id',
+        'code',
+        'title',
+        {name: 'details_json', type: 'array', attr: 'details'},
+        {name:'is_available', type: 'boolean'},
+        'library_id',
+        'created_at'
+      ]
+    };
+    class Book extends Model(schema) {}
+
+    it('should handle array', async () => {
+      const book = await Book.create({ details: [1, 2] });
+      assert(Array.isArray(book.details));
+      assert.strictEqual(book.details.length, 2);
+    });
+
+    it('should handle array', async () => {
+      const book = await Book.create({ details: '' });
+      assert(Array.isArray(book.details));
+      assert.strictEqual(book.details.length, 0);
+    });
+  });
+
+});