unit tests

src/models/pageOrder.js

@@ -38,7 +38,7 @@ class PageOrder {
    *
    * @param {PageOrderData} data
    */
-  constructor(data) {
+  constructor(data = {}) {
     if (data === null) {
       data = {};
     }

test/models/pageOrder.js

@@ -0,0 +1,121 @@
+const {expect} = require('chai');
+const fs = require('fs');
+const path = require('path');
+const config = require('../../config');
+const PageOrder = require('../../src/models/pageOrder');
+const {pagesOrder} = require('../../src/utils/database');
+
+describe('PageOrder model', () => {
+  after(() => {
+    const pathToDB = path.resolve(__dirname, '../../', config.database, './pages.db');
+
+    if (fs.existsSync(pathToDB)) {
+      fs.unlinkSync(pathToDB);
+    }
+  });
+
+  it('Empty Model', async () => {
+    let pageOrder = new PageOrder();
+
+    expect(pageOrder.data).to.be.a('object');
+
+    let {data} = pageOrder;
+
+    expect(data._id).to.be.undefined;
+    expect(data.page).to.be.to.equal('0');
+    expect(data.order).to.be.an('array').that.is.empty;
+
+    page = new PageOrder(null);
+
+    data = page.data;
+
+    expect(data._id).to.be.undefined;
+    expect(data.page).to.be.to.equal('0');
+    expect(data.order).to.be.an('array').that.is.empty;
+
+    const testData = {
+      _id: 'order_id',
+      page: 'page_id',
+      order: []
+    };
+
+    page = new PageOrder(testData);
+    data = page.data;
+
+    expect(data._id).to.equal(testData._id);
+    expect(data.page).to.equal(testData.page);
+    expect(data.order).to.be.an('array').that.is.empty;
+  });
+
+  it('Testing Model methods', async () => {
+    const testData = {
+      page: 'page_id',
+      order: ['1', '2']
+    };
+    const pageOrder = new PageOrder(testData);
+    let {data} = await pageOrder.save();
+
+    expect(data._id).not.be.undefined;
+    expect(data.page).to.equal(testData.page);
+    expect(data.order).to.deep.equals(testData.order);
+
+    const insertedPageOrder = await pagesOrder.findOne({_id: data._id});
+    expect(insertedPageOrder._id).to.equal(data._id);
+    expect(insertedPageOrder.page).to.equal(data.page);
+    expect(insertedPageOrder.order).to.deep.equal(data.order);
+
+    const updateData = {
+      page: 'page_id_2',
+      order: ['3']
+    };
+
+    pageOrder.data = updateData;
+    await pageOrder.save();
+
+    expect(pageOrder.data._id).to.equal(insertedPageOrder._id);
+
+    const updatedData = await pagesOrder.findOne({_id: insertedPageOrder._id});
+
+    expect(updatedData.page).to.equal(updateData.page);
+    expect(updatedData.order).to.deep.equal(updateData.order);
+
+    await pageOrder.destroy();
+
+    expect(pageOrder.data._id).to.be.undefined;
+
+    const removedPage = await pagesOrder.findOne({_id: updatedData._id});
+
+    expect(removedPage).to.be.null;
+  });
+
+  it('Testing push and remove order methods', async () => {
+    const testData = {
+      page: 'page_id',
+      order: ['1', '2']
+    };
+    const pageOrder = new PageOrder(testData);
+    await pageOrder.save();
+    pageOrder.push('3');
+    expect(pageOrder.data.order).to.deep.equals(['1', '2', '3']);
+
+    pageOrder.remove('2');
+    expect(pageOrder.data.order).to.deep.equals(['1', '3']);
+
+    await pageOrder.destroy();
+  });
+
+  it('Testing static methods', async () => {
+    const testData = {
+      page: 'page_id',
+      order: ['1', '2']
+    };
+    const pageOrder = new PageOrder(testData);
+    const insertedData = await pageOrder.save();
+
+    const insertedPageOrder = await PageOrder.get(insertedData.data.page);
+    expect(insertedPageOrder).to.instanceOf(PageOrder);
+    expect(insertedPageOrder.data._id).to.be.equal(insertedData.data._id);
+
+    await pageOrder.destroy();
+  });
+});

test/rest/pages.js

@@ -1,5 +1,6 @@
 const {app} = require('../../bin/www');
 const model = require('../../src/models/page');
+const PageOrder = require('../../src/models/pageOrder');
 
 const fs = require('fs');
 const path = require('path');
@@ -34,12 +35,12 @@ describe('Pages REST: ', () => {
             text: 'Page header'
           }
         }
-      ]
+      ],
     };
-
+    const parent =  0;
     const res = await agent
       .put('/api/page')
-      .send({body});
+      .send({body, parent});
 
     expect(res).to.have.status(200);
     expect(res).to.be.json;
@@ -58,7 +59,11 @@ describe('Pages REST: ', () => {
     expect(createdPage.title).to.equal(body.blocks[0].data.text);
     expect(createdPage.body).to.deep.equal(body);
 
-    createdPage.destroy();
+    const pageOrder = await PageOrder.get('' + (createdPage.data.parent || 0));
+    expect(pageOrder.order).to.be.an('array').and.length(1);
+
+    await createdPage.destroy();
+    await pageOrder.destroy()
   });
 
   it('Page data validation on create', async () => {
@@ -106,12 +111,14 @@ describe('Pages REST: ', () => {
     expect(success).to.be.true;
 
     const foundPage = await model.get(_id);
+    const pageOrder = await PageOrder.get('' + foundPage._parent);
 
     expect(foundPage._id).to.equal(_id);
     expect(foundPage.title).to.equal(body.blocks[0].data.text);
     expect(foundPage.body).to.deep.equal(body);
 
-    foundPage.destroy();
+    await pageOrder.destroy();
+    await foundPage.destroy();
   });
 
   it('Finding page with not existing id', async () => {
@@ -175,6 +182,7 @@ describe('Pages REST: ', () => {
     expect(result.body).to.deep.equal(updatedBody);
 
     const updatedPage = await model.get(_id);
+    const pageOrder = await PageOrder.get('' + updatedPage._parent);
 
     expect(updatedPage._id).to.equal(_id);
     expect(updatedPage.title).not.equal(body.blocks[0].data.text);
@@ -182,7 +190,8 @@ describe('Pages REST: ', () => {
     expect(updatedPage.body).not.equal(body);
     expect(updatedPage.body).to.deep.equal(updatedBody);
 
-    updatedPage.destroy();
+    await pageOrder.destroy();
+    await updatedPage.destroy();
   });
 
   it('Updating page with not existing id', async () => {