normalize tests

test/integration/account.accessor.http.spec.js

@@ -0,0 +1,221 @@
+import _ from 'lodash';
+import request from 'supertest';
+import { expect, faker, clear, create } from '@lykmapipo/mongoose-test-helpers';
+import { app, mount } from '@lykmapipo/express-common';
+import { Jurisdiction } from '@codetanzania/majifix-jurisdiction';
+import account from '../../src';
+
+const { Account, apiVersion, accountRouter } = account;
+
+mount(accountRouter);
+describe('Account accessor Rest API', () => {
+  const jurisdiction = Jurisdiction.fake();
+  let customerAccount = Account.fake();
+  customerAccount.set({ jurisdiction });
+
+  before(done => clear(Jurisdiction, Account, done));
+
+  before(done => create(jurisdiction, done));
+
+  before(done => create(customerAccount, done));
+
+  it('should handle POST /accounts/:id/accessors', done => {
+    const accessor = Account.fake().accessors[0].toObject();
+
+    request(app)
+      .post(`/${apiVersion}/accounts/${customerAccount._id}/accessors`)
+      .set('Accept', 'application/json')
+      .set('Content-Type', 'application/json')
+      .send(accessor)
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+
+        const updates = new Account(response.body);
+
+        expect(updates._id).to.exist;
+        expect(updates._id).to.be.eql(customerAccount._id);
+        expect(updates.number).to.be.equal(customerAccount.number);
+        expect(updates.name).to.be.equal(customerAccount.name);
+
+        expect(updates.accessors.length).to.be.above(
+          customerAccount.accessors.length
+        );
+
+        customerAccount = updates;
+
+        done(error, response);
+      });
+  });
+
+  it('should handle GET /accounts/:id/accessors', done => {
+    request(app)
+      .get(`/${apiVersion}/accounts/${customerAccount._id}/accessors`)
+      .set('Accept', 'application/json')
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+
+        // assert payload
+        const result = new Account(response.body);
+        expect(result._id).to.exist;
+        expect(result._id).to.be.eql(customerAccount._id);
+        expect(result.number).to.be.equal(customerAccount.number);
+        expect(result.name).to.be.equal(customerAccount.name);
+        expect(result.accessors).to.have.length.at.least(1);
+        done(error, response);
+      });
+  });
+
+  it('should handle PATCH /accounts/:id/accessors/:phone', done => {
+    const accessor = customerAccount.accessors[0];
+    const { phone } = accessor;
+    const patch = { phone: faker.phone.phoneNumber() };
+
+    request(app)
+      .patch(
+        `/${apiVersion}/accounts/${customerAccount._id}/accessors/${phone}`
+      )
+      .set('Accept', 'application/json')
+      .set('Content-Type', 'application/json')
+      .send(patch)
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+
+        const patched = response.body;
+
+        expect(patched._id).to.exist;
+        expect(patched._id).to.be.equal(customerAccount._id.toString());
+        expect(patched.number).to.be.equal(customerAccount.number);
+        expect(patched.name).to.be.equal(customerAccount.name);
+
+        // assert accessor
+        const _accessor = _.find(patched.accessors, patch);
+        expect(_accessor).to.exist;
+        expect(_accessor.name).to.be.eql(accessor.name);
+        expect(_accessor.email).to.be.eql(accessor.email);
+        expect(_accessor.phone).to.be.eql(patch.phone);
+
+        customerAccount = patched;
+
+        done(error, response);
+      });
+  });
+
+  it('should handle PUT /accounts/:id/accessors/:phone', done => {
+    const accessor = customerAccount.accessors[0];
+    const { phone } = accessor;
+    const put = { phone: faker.phone.phoneNumber() };
+
+    request(app)
+      .put(`/${apiVersion}/accounts/${customerAccount._id}/accessors/${phone}`)
+      .set('Accept', 'application/json')
+      .set('Content-Type', 'application/json')
+      .send(put)
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+
+        const puted = response.body;
+
+        expect(puted._id).to.exist;
+        expect(puted._id).to.be.equal(customerAccount._id.toString());
+        expect(puted.number).to.be.equal(customerAccount.number);
+        expect(puted.name).to.be.equal(customerAccount.name);
+
+        // assert accessor
+        const _accessor = _.find(puted.accessors, put);
+        expect(_accessor).to.exist;
+        expect(_accessor.name).to.be.eql(accessor.name);
+        expect(_accessor.email).to.be.eql(accessor.email);
+        expect(_accessor.phone).to.be.eql(put.phone);
+
+        customerAccount = puted;
+
+        done(error, response);
+      });
+  });
+
+  it('should handle POST /accounts/verify', done => {
+    const requestor = {
+      phone: customerAccount.phone,
+      account: customerAccount.number,
+    };
+
+    request(app)
+      .post(`/${apiVersion}/accounts/verify`)
+      .set('Accept', 'application/json')
+      .set('Content-Type', 'application/json')
+      .send(requestor)
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+
+        const updates = response.body;
+
+        expect(updates._id).to.exist;
+        expect(updates._id).to.be.equal(customerAccount._id);
+        expect(updates.number).to.be.equal(customerAccount.number);
+        expect(updates.name).to.be.equal(customerAccount.name);
+
+        done(error, response);
+      });
+  });
+
+  it('should handle DELETE /accounts/:id/accessors/:phone', done => {
+    const accessor = customerAccount.accessors[0];
+    const { phone } = accessor;
+    request(app)
+      .delete(
+        `/${apiVersion}/accounts/${customerAccount._id}/accessors/${phone}`
+      )
+      .set('Accept', 'application/json')
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+        const deleted = response.body;
+        expect(deleted._id).to.exist;
+        expect(deleted._id).to.be.equal(customerAccount._id);
+        expect(deleted.number).to.be.equal(customerAccount.number);
+        expect(deleted.name).to.be.equal(customerAccount.name);
+        // assert accessors
+        const _accessor = _.find(deleted.accessors, { phone });
+        expect(_accessor).to.not.exist;
+        customerAccount = deleted;
+        done(error, response);
+      });
+  });
+
+  it('should handle HTTP GET on /jurisdictions/:id/accounts', done => {
+    request(app)
+      .get(
+        `/${apiVersion}/jurisdictions/${customerAccount.jurisdiction._id}/accounts`
+      )
+      .set('Accept', 'application/json')
+      .expect(200)
+      .end((error, response) => {
+        expect(error).to.not.exist;
+        expect(response).to.exist;
+
+        // assert payload
+        const result = response.body;
+        expect(result.data).to.exist;
+        expect(result.total).to.exist;
+        expect(result.limit).to.exist;
+        expect(result.skip).to.exist;
+        expect(result.page).to.exist;
+        expect(result.pages).to.exist;
+        expect(result.lastModified).to.exist;
+        done(error, response);
+      });
+  });
+
+  after(done => clear(Jurisdiction, Account, done));
+});

test/integration/account.delete.spec.js

@@ -3,63 +3,67 @@ import account from '../../src';
 
 const { Account } = account;
 
-describe('Account', () => {
+describe('Account static delete', () => {
   let customerAccount;
+
   before(done => clear(Account, done));
-  describe('static delete', () => {
-    before(done => {
-      customerAccount = Account.fake();
-      customerAccount.post((error, created) => {
-        customerAccount = created;
-        done(error, created);
-      });
+
+  before(done => {
+    customerAccount = Account.fake();
+    customerAccount.post((error, created) => {
+      customerAccount = created;
+      done(error, created);
     });
+  });
 
-    it('should be able to delete', done => {
-      Account.del(customerAccount._id, (error, deleted) => {
-        expect(error).to.not.exist;
-        expect(deleted).to.exist;
-        expect(deleted._id).to.eql(customerAccount._id);
-        done(error, deleted);
-      });
+  it('should be able to delete', done => {
+    Account.del(customerAccount._id, (error, deleted) => {
+      expect(error).to.not.exist;
+      expect(deleted).to.exist;
+      expect(deleted._id).to.eql(customerAccount._id);
+      done(error, deleted);
     });
+  });
 
-    it('should throw if not exists', done => {
-      Account.del(customerAccount._id, (error, deleted) => {
-        expect(error).to.exist;
-        // expect(error.status).to.exist;
-        expect(error.name).to.be.equal('DocumentNotFoundError');
-        expect(deleted).to.not.exist;
-        done();
-      });
+  it('should throw if not exists', done => {
+    Account.del(customerAccount._id, (error, deleted) => {
+      expect(error).to.exist;
+      // expect(error.status).to.exist;
+      expect(error.name).to.be.equal('DocumentNotFoundError');
+      expect(deleted).to.not.exist;
+      done();
     });
   });
 
-  describe('instance delete', () => {
-    before(done => {
-      customerAccount = Account.fake();
-      customerAccount.post((error, created) => {
-        customerAccount = created;
-        done(error, created);
-      });
+  after(done => clear(Account, done));
+});
+
+describe('Account instance delete', () => {
+  let customerAccount;
+
+  before(done => {
+    customerAccount = Account.fake();
+    customerAccount.post((error, created) => {
+      customerAccount = created;
+      done(error, created);
     });
+  });
 
-    it('should be able to delete', done => {
-      customerAccount.del((error, deleted) => {
-        expect(error).to.not.exist;
-        expect(deleted).to.exist;
-        expect(deleted._id).to.eql(customerAccount._id);
-        done(error, deleted);
-      });
+  it('should be able to delete', done => {
+    customerAccount.del((error, deleted) => {
+      expect(error).to.not.exist;
+      expect(deleted).to.exist;
+      expect(deleted._id).to.eql(customerAccount._id);
+      done(error, deleted);
     });
+  });
 
-    it('should throw if not exists', done => {
-      customerAccount.del((error, deleted) => {
-        expect(error).to.not.exist;
-        expect(deleted).to.exist;
-        expect(deleted._id).to.eql(customerAccount._id);
-        done();
-      });
+  it('should throw if not exists', done => {
+    customerAccount.del((error, deleted) => {
+      expect(error).to.not.exist;
+      expect(deleted).to.exist;
+      expect(deleted._id).to.eql(customerAccount._id);
+      done();
     });
   });