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

Declaratively publish functions for remote invocation.

import { expect } from 'chai';
import { registerMethods } from '../../src/client/Client';
import http from 'http-promises/browser';
import { FakeXMLHttpRequest } from 'sinon';
import ClientMethod from '../../src/client/ClientMethod';
import Client from '../../src/client/Client';
import { STATE } from '../../src/client/Client';



describe('Client:methods (proxy-stubs)', () => {
  let client, fakeXhr;
  before(() => {
      // Inject a fake XHR object.
      http.createXhr = () => {
          fakeXhr = new FakeXMLHttpRequest();
          return fakeXhr;
      };
  });
  beforeEach(() => { client = Client({ http:http, host:'localhost' }); });


  it('does not have any methods prior to loading', () => {
    expect(client.isReady).to.equal(false);
    expect(client.methods).to.eql({});
  });


  it('registers methods upon receiving manifest from server', (done) => {
    client.onReady(() => {
        expect(client.isReady).to.equal(true);
        expect(client.methods['foo']).not.to.equal(undefined);
        done();
    });

    fakeXhr.responseText = JSON.stringify({
      methods: {
        foo: { params: [] }
      }
    });
    fakeXhr.status = 200;
    fakeXhr.readyState = 4;
    fakeXhr.onreadystatechange();
  });


  it('stores methods in state', () => {
    registerMethods(client, {
      'foo': {},
      'foo/bar': { get:{ params:['p1'] } }
    });
    expect(client[STATE].methods['foo']).to.be.an.instanceof(ClientMethod);
    expect(client[STATE].methods['foo/bar']).to.be.an.instanceof(ClientMethod);
  });


  it('has a proxy-stub for each method', () => {
    registerMethods(client, {
      'foo': { get: {}, put:{}, post:{}, delete:{} }
    });
    expect(client.methods.foo).to.be.an.instanceof(Object);
    expect(client.methods.foo.get).to.be.an.instanceof(Function);
    expect(client.methods.foo.put).to.be.an.instanceof(Function);
    expect(client.methods.foo.post).to.be.an.instanceof(Function);
    expect(client.methods.foo.delete).to.be.an.instanceof(Function);
  });


  it('has no proxy-stubs', () => {
    registerMethods(client, {
      'foo': {}
    });
    expect(client.methods.foo).to.be.an.instanceof(Object);
    expect(client.methods.foo.get).to.equal(undefined);
    expect(client.methods.foo.put).to.equal(undefined);
    expect(client.methods.foo.post).to.equal(undefined);
    expect(client.methods.foo.delete).to.equal(undefined);
  });


  it('nests methods within a namespace', () => {
    registerMethods(client, {
      'foo': { get: {} },
      'foo/bar': { get: {} },
      'foo/bar/baz': { get: {} }
    });
    expect(client.methods.foo).to.be.an.instanceof(Object);
    expect(client.methods.foo.bar).to.be.an.instanceof(Object);
    expect(client.methods.foo.bar.baz).to.be.an.instanceof(Object);

    expect(client.methods.foo.get).to.be.an.instanceof(Function);
    expect(client.methods.foo.bar.get).to.be.an.instanceof(Function);
    expect(client.methods.foo.bar.baz.get).to.be.an.instanceof(Function);
  });


  it('invokes the helper method for each HTTP verb returning a promise', (done) => {
    registerMethods(client, {
      'foo': { get: {}, put:{}, post:{}, delete:{} }
    });
    ['get', 'put', 'post', 'delete'].forEach(verb => {
        let fakeXhr, sent;
        http.createXhr = () => {
            sent = [];
            fakeXhr = new FakeXMLHttpRequest();
            fakeXhr.send = (data) => { sent.push(data); };
            return fakeXhr;
        };

        let args = undefined
        if (verb === 'put' || verb === 'post') { args = 123; }

        client.methods.foo[verb](args)
        .then((result) => {
              expect(fakeXhr.method).to.equal(verb.toUpperCase());
              expect(result).to.eql({ myResponse: true });
              if (verb === 'delete') { done(); }
        })
        fakeXhr.responseText = JSON.stringify({ myResponse: true });
        fakeXhr.status = 200;
        fakeXhr.readyState = 4;
        fakeXhr.onreadystatechange();
    });
  });


  it('invokes the proxy-stub within a nested namespace', (done) => {
    registerMethods(client, {
      'foo/bar/baz': { put: {} }
    });
    let fakeXhr, sent;
    http.createXhr = () => {
        sent = [];
        fakeXhr = new FakeXMLHttpRequest();
        fakeXhr.send = (data) => { sent.push(data); };
        return fakeXhr;
    };

    client.methods.foo.bar.baz.put(123)
    .then((result) => {
          expect(fakeXhr.method).to.equal('PUT');
          expect(result).to.eql({ myResponse: true });
          done();
    })
    fakeXhr.responseText = JSON.stringify({ myResponse: true });
    fakeXhr.status = 200;
    fakeXhr.readyState = 4;
    fakeXhr.onreadystatechange();
  });
});