rest-methods/test/client/ClientMethod.test.js

Declaratively publish functions for remote invocation.

import { expect } from 'chai';
import ClientMethod from '../../src/client/ClientMethod';
import { ServerMethodError } from '../../src/errors';
import { FakeXMLHttpRequest } from 'sinon';
import Promise from 'bluebird';
import sinon from 'sinon';
import http from 'http-promises/browser';


describe('Client:ClientMethod', () => {
  describe('state', () => {
    it('stores the method name', () => {
      let method = new ClientMethod('foo', http);
      expect(method.name).to.equal('foo');
    });


    it('has no verbs', () => {
      let method = new ClientMethod('foo', http);
      expect(method.verbs).to.eql({});
    });


    it('has verbs', () => {
      const options = {
        get: {}, put: { params:['text'] }
      };
      let method = new ClientMethod('foo', http, options);
      expect(method.verbs.get).to.eql({});
      expect(method.verbs.put.params).to.eql(['text']);
    });
  });


  describe('url', () => {
    it('derives the URL from the method name', () => {
      let method = new ClientMethod('////foo/bar', http);
      expect(method.urlPattern).to.equal('/foo/bar');
      expect(method.url()).to.equal('/foo/bar');
    });


    it('takes a custom URL (no parameters)', () => {
      let method = new ClientMethod('foo', http, { url:'/foo' });
      expect(method.url()).to.equal('/foo');
    });

    it('prepends the host-name', () => {
      let method = new ClientMethod('foo', http, { url:'/foo', host:'http://localhost:3030' });
      expect(method.url()).to.equal('http://localhost:3030/foo');
    });


    it('constructs URL with parameters', () => {
      let method = new ClientMethod('foo', http, { url:'/foo/:org/:org/:id/edit?q=abc' });
      let url = method.url('acme', 'edge-case', 'bob');
      expect(url).to.equal('/foo/acme/edge-case/bob/edit?q=abc');
    });


    it('throws if there are not enough arguments', () => {
      let method = new ClientMethod('foo', http, { url:'/foo/:org/:id/edit?q=abc' });
      let fn = () => { method.url(); };
      expect(fn).to.throw();
    });
  });


  describe('invoke()', () => {
    let fakeXhr, sent;
    beforeEach(() => {
      sent = [];
      http.createXhr = () => {
          fakeXhr = new FakeXMLHttpRequest();
          fakeXhr.send = (data) => {
              if (data) { data = JSON.parse(data); }
              sent.push(data);
          };
          return fakeXhr;
      };
    });


    it('sends to the method URL', () => {
      let method = new ClientMethod('foo/bar', http);
      method.invoke();
      expect(fakeXhr.url).to.equal('/foo/bar');
    });


    it('sends to a simple URL', () => {
      let method = new ClientMethod('foo/bar', http, { url:'/yo' });
      method.invoke();
      expect(fakeXhr.url).to.equal('/yo');
    });


    it('sends to a paramatised URL', () => {
      let method = new ClientMethod('foo', http, { url:'/foo/:id/edit' });
      method.invoke('GET', 'my-id');
      expect(fakeXhr.url).to.equal('/foo/my-id/edit');
    });


    it('invokes with no arguments', () => {
      let method = new ClientMethod('foo', http);
      method.invoke('PUT');
      expect(sent[0].method).to.equal('foo');
      expect(sent[0].verb).to.equal('PUT');
      expect(sent[0].args).to.eql([]);
    });


    it('invokes with arguments', () => {
      let method = new ClientMethod('foo/bar', http);
      method.invoke('PUT', 1, 'two', { three:3 });
      expect(sent[0].verb).to.equal('PUT');
      expect(sent[0].args).to.eql([1, 'two', { three:3 }]);
    });


    it('removes the arguments passed in the URL', () => {
      let method = new ClientMethod('foo', http, { url:'foo/:id' });
      method.invoke('PUT', 'my-id', 1, 2);
      expect(sent[0].args).to.eql([1, 2]);
    });


    it('resolves promise with return value', (done) => {
      new ClientMethod('foo', http).invoke()
      .then((result) => {
          expect(result).to.eql({ foo:123 });
          done()
      });
      fakeXhr.responseText = JSON.stringify({ foo:123 });
      fakeXhr.status = 200;
      fakeXhr.readyState = 4;
      fakeXhr.onreadystatechange();
    });


    it('throws an error (malformed, no reponse-text from server)', (done) => {
      new ClientMethod('foo', http).invoke()
      .catch((err) => {
          expect(err).to.be.an.instanceof(ServerMethodError);
          expect(err.status).to.equal(500);
          done()
      });
      fakeXhr.status = 500;
      fakeXhr.readyState = 4;
      fakeXhr.onreadystatechange();
    });


    it('throws an error ([ServerMethodError] returned from server)', (done) => {
      new ClientMethod('foo', http).invoke()
      .catch((err) => {
          expect(err).to.be.an.instanceof(ServerMethodError);
          expect(err.status).to.equal(503);
          expect(err.method).to.equal('my-method');
          expect(err.args).to.eql([1,2,3]);
          expect(err.message).to.equal(':(');
          done()
      });
      let serverError = new ServerMethodError(503, 'my-method', [1,2,3], ':(');
      fakeXhr.responseText = JSON.stringify(serverError);
      fakeXhr.status = 500;
      fakeXhr.readyState = 4;
      fakeXhr.onreadystatechange();
    });
  });
});