Page model (#1)

* Initial database and page MVC

* Add mocha tests

* Add docs

* Add docs about nedb query options

* Add eslint and editorconfig + husky

* Improve precommit script

* Remove unnecessary dependencies

test/models/page.js

@@ -0,0 +1,165 @@
+const {expect} = require('chai');
+const Page = require('../../models/page');
+const {pages} = require('../../database');
+
+describe('Page model', () => {
+  it('Working with empty model', async () => {
+    let page = new Page();
+
+    expect(page.data).to.be.a('object');
+
+    let {data} = page;
+
+    expect(data._id).to.be.undefined;
+    expect(data.title).to.be.undefined;
+    expect(data.body).to.be.undefined;
+    expect(data.parent).to.be.undefined;
+
+    page = new Page(null);
+
+    data = page.data;
+
+    expect(data._id).to.be.undefined;
+    expect(data.title).to.be.undefined;
+    expect(data.body).to.be.undefined;
+    expect(data.parent).to.be.undefined;
+
+    const initialData = {_id: 'page_id', title: 'Test page', body: 'Test page body'};
+
+    page = new Page(initialData);
+
+    const json = page.toJSON();
+
+    data = page.data;
+
+    expect(data._id).to.equal(initialData._id);
+    expect(data.title).to.equal(initialData.title);
+    expect(data.body).to.equal(initialData.body);
+    expect(data.parent).to.be.undefined;
+
+    expect(json._id).to.equal(initialData._id);
+    expect(json.title).to.equal(initialData.title);
+    expect(json.body).to.equal(initialData.body);
+    expect(json.parent).to.be.undefined;
+
+    const update = {
+      _id: 12345,
+      title: 'Test page',
+      body: 'Test page body'
+    };
+
+    page.data = update;
+
+    data = page.data;
+
+    expect(data._id).to.equal(initialData._id);
+    expect(data.title).to.equal(update.title);
+    expect(data.body).to.equal(update.body);
+    expect(data.parent).to.be.undefined;
+  });
+
+  it('Saving, updating and deleting model in the database', async () => {
+    const initialData = {title: 'Test page', body: 'Test page body'};
+    const page = new Page(initialData);
+
+    let savedPage = await page.save();
+
+    expect(savedPage._id).not.be.undefined;
+    expect(savedPage.title).to.equal(initialData.title);
+    expect(savedPage.body).to.equal(initialData.body);
+    expect(page._id).not.be.undefined;
+
+    const insertedPage = await pages.findOne({_id: page._id});
+
+    expect(insertedPage._id).to.equal(page._id);
+    expect(insertedPage.title).to.equal(page.title);
+    expect(insertedPage.body).to.equal(page.body);
+
+    const updateData = {title: 'Updated test page', body: 'Updated test page body'};
+
+    page.data = updateData;
+    await page.save();
+
+    expect(page._id).to.equal(insertedPage._id);
+
+    const updatedPage = await pages.findOne({_id: page._id});
+
+    expect(updatedPage._id).to.equal(savedPage._id);
+    expect(updatedPage.title).to.equal(updateData.title);
+    expect(updatedPage.body).to.equal(updateData.body);
+
+    await page.destroy();
+
+    expect(page._id).to.be.undefined;
+
+    const removedPage = await pages.findOne({_id: updatedPage._id});
+
+    expect(removedPage).to.be.null;
+  });
+
+  it('Static get method', async () => {
+    const initialData = {title: 'Test page', body: 'Test page body'};
+    const page = new Page(initialData);
+
+    const savedPage = await page.save();
+
+    const foundPage = await Page.get(savedPage._id);
+
+    const {data} = foundPage;
+
+    expect(data._id).to.equal(savedPage._id);
+    expect(data.title).to.equal(initialData.title);
+    expect(data.body).to.equal(initialData.body);
+
+    await page.destroy();
+  });
+
+  it('Static getAll method', async () => {
+    const pagesToSave = [
+      new Page({title: 'Page 1', body: 'Page 1 body'}),
+      new Page({title: 'Page 2', body: 'Page 2 body'})
+    ];
+
+    const savedPages = await Promise.all(pagesToSave.map(page => page.save()));
+
+    const foundPages = await Page.getAll({_id: {$in: savedPages.map(page => page._id)}});
+
+    expect(foundPages.length).to.equal(2);
+    foundPages.forEach((page, i) => {
+      expect(page.title).to.equal(pagesToSave[i].title);
+      expect(page.body).to.equal(pagesToSave[i].body);
+    });
+  });
+
+  it('Parent pages', async () => {
+    const parent = new Page({title: 'Parent page', body: 'Parent page body'});
+    const {_id: parentId} = await parent.save();
+
+    const child = new Page({title: 'Child page', body: 'Child page body'});
+
+    child.parent = parent;
+
+    const {_id: childId} = await child.save();
+
+    const testedParent = await child.parent;
+
+    expect(testedParent._id).to.equal(parentId);
+    expect(testedParent.title).to.equal(parent.title);
+    expect(testedParent.body).to.equal(parent.body);
+
+    const children = await parent.children;
+
+    expect(children.length).to.equal(1);
+
+    const testedChild = children.pop();
+
+    expect(testedChild._id).to.equal(childId);
+    expect(testedChild.title).to.equal(child.title);
+    expect(testedChild.body).to.equal(child.body);
+    expect(testedChild._parent).to.equal(child._parent);
+    expect(testedChild._parent).to.equal(parent._id);
+
+    parent.destroy();
+    child.destroy();
+  });
+});