feat(assignable_entities): Get assignable entities (#98)

Allows users to retrieve assignable routes and assignable stops from
Track API.

Supports EN-7151.

Signed-off-by: Jeff Cuevas-Koch <jcuevas-koch@gmvsync.com>

Co-authored-by: Jeff Cuevas-Koch <jcuevas-koch@gmvsync.com>

Author: cuevaskoch

src/examples/get_assignable_route.test.js

@@ -0,0 +1,47 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import fetchMock from 'fetch-mock';
+import Track from '../index';
+import { charlie, assignableRoutes as mockAssignableRoutes } from '../mocks';
+
+chai.should();
+chai.use(chaiAsPromised);
+
+describe('When getting assignable routes', () => {
+  const api = new Track({ autoRenew: false });
+
+  beforeEach(() => charlie.setUpSuccessfulMock(api.client));
+  beforeEach(() => mockAssignableRoutes.setUpSuccessfulMock(api.client));
+  beforeEach(() => fetchMock.catch(503));
+  afterEach(fetchMock.restore);
+
+  it('should get a list of assignable routes', () => {
+    api.logIn({ username: 'charlie@example.com', password: 'securepassword' });
+
+    const assignableRoutesPromise = api.customer('SYNC').assignableRoutes()
+      .getPage()
+      .then(page => page.list)
+      .then(assignableRoutes => assignableRoutes); // Do things with list of assignableRoutes
+
+    return assignableRoutesPromise;
+  });
+});
+
+describe('When retrieving an assignable route by ID', () => {
+  const api = new Track({ autoRenew: false });
+
+  beforeEach(() => charlie.setUpSuccessfulMock(api.client));
+  beforeEach(() => mockAssignableRoutes.setUpSuccessfulMock(api.client));
+  beforeEach(() => fetchMock.catch(503));
+  afterEach(fetchMock.restore);
+
+  it('should get an assignable route', () => {
+    api.logIn({ username: 'charlie@example.com', password: 'securepassword' });
+
+    const assignableRoutePromise = api.customer('SYNC').assignableRoute('blue_line')
+      .fetch()
+      .then(assignableRoute => assignableRoute); // Do things with assignable route
+
+    return assignableRoutePromise;
+  });
+});

src/examples/get_assignable_stop.test.js

@@ -0,0 +1,47 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import fetchMock from 'fetch-mock';
+import Track from '../index';
+import { charlie, assignableStops as mockAssignableStops } from '../mocks';
+
+chai.should();
+chai.use(chaiAsPromised);
+
+describe('When getting assignable stops', () => {
+  const api = new Track({ autoRenew: false });
+
+  beforeEach(() => charlie.setUpSuccessfulMock(api.client));
+  beforeEach(() => mockAssignableStops.setUpSuccessfulMock(api.client));
+  beforeEach(() => fetchMock.catch(503));
+  afterEach(fetchMock.restore);
+
+  it('should get a list of assignable stops', () => {
+    api.logIn({ username: 'charlie@example.com', password: 'securepassword' });
+
+    const assignableStopsPromise = api.customer('SYNC').assignableStops()
+      .getPage()
+      .then(page => page.list)
+      .then(assignableStops => assignableStops); // Do things with list of assignableStops
+
+    return assignableStopsPromise;
+  });
+});
+
+describe('When retrieving an assignable stop by ID', () => {
+  const api = new Track({ autoRenew: false });
+
+  beforeEach(() => charlie.setUpSuccessfulMock(api.client));
+  beforeEach(() => mockAssignableStops.setUpSuccessfulMock(api.client));
+  beforeEach(() => fetchMock.catch(503));
+  afterEach(fetchMock.restore);
+
+  it('should get an assignable stop', () => {
+    api.logIn({ username: 'charlie@example.com', password: 'securepassword' });
+
+    const assignableStopPromise = api.customer('SYNC').assignableStop('1st_and_main')
+      .fetch()
+      .then(assignableStop => assignableStop); // Do things with assignable stop
+
+    return assignableStopPromise;
+  });
+});

src/mocks/assignableRoutes.js

@@ -0,0 +1,44 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import fetchMock from 'fetch-mock';
+import Client from '../Client';
+
+const assignableRoutes = {
+  setUpSuccessfulMock: (client) => {
+    const listResponse = () => new Response(
+      Client.toBlob(assignableRoutes.list), {
+        headers: {
+          Link: '</1/SYNC/assignable_entities/routes?page=1&per_page=10&sort=>; rel="next", </1/SYNC/assignable_entities/routes?page=1&per_page=10&sort=>; rel="last"',
+        },
+      });
+    const singleResponse = () => new Response(Client.toBlob(assignableRoutes.getById('blue_line')));
+
+    fetchMock
+      .get(client.resolve('/1/SYNC/assignable_entities/routes?page=1&per_page=10&sort='), listResponse)
+      .get(client.resolve('/1/SYNC/assignable_entities/routes/blue_line'), singleResponse);
+  },
+  getById: id => assignableRoutes.list.find(v => v.id === id),
+  list: [{
+    id: 'blue_line',
+    href: '/1/SYNC/assignable_entities/routes/blue_line',
+    name: 'Blue Line',
+    short_name: 'BLU',
+    color: '#0000FF',
+    text_color: '#FFFFFF',
+    provider_id: 1,
+    agency_id: 'SYNC',
+    route_type: 'MetropolitanStreetLevelRail'
+  },
+  {
+    id: 'red_line',
+    href: '/1/SYNC/assignable_entities/routes/red_line',
+    name: 'Red Line',
+    short_name: 'RED',
+    color: '#FF0000',
+    text_color: '#FFFFFF',
+    provider_id: 1,
+    agency_id: 'SYNC',
+    route_type: 'MetropolitanUndergroundRail'
+  }],
+};
+
+export default assignableRoutes;

src/mocks/assignableStops.js

@@ -0,0 +1,36 @@
+// eslint-disable-next-line import/no-extraneous-dependencies
+import fetchMock from 'fetch-mock';
+import Client from '../Client';
+
+const assignableStops = {
+  setUpSuccessfulMock: (client) => {
+    const listResponse = () => new Response(
+      Client.toBlob(assignableStops.list), {
+        headers: {
+          Link: '</1/SYNC/assignable_entities/stops?page=1&per_page=10&sort=>; rel="next", </1/SYNC/assignable_entities/stops?page=1&per_page=10&sort=>; rel="last"',
+        },
+      });
+    const singleResponse = () => new Response(Client.toBlob(assignableStops.getById('1st_and_main')));
+
+    fetchMock
+      .get(client.resolve('/1/SYNC/assignable_entities/stops?page=1&per_page=10&sort='), listResponse)
+      .get(client.resolve('/1/SYNC/assignable_entities/stops/1st_and_main'), singleResponse);
+  },
+  getById: id => assignableStops.list.find(v => v.id === id),
+  list: [{
+    id: '1st_and_main',
+    href: '/1/SYNC/assignable_entities/stops/1st_and_main',
+    name: 'First and Main',
+    provider_id: 1,
+    agency_id: 'SYNC',
+  },
+  {
+    id: '6th_and_olive',
+    href: '/1/SYNC/assignable_entities/stops/6th_and_olive',
+    name: 'Sixth and Olive',
+    provider_id: 1,
+    agency_id: 'SYNC',
+  }],
+};
+
+export default assignableStops;

src/mocks/index.js

@@ -5,6 +5,8 @@ import Client from '../Client';
 export { default as agencies } from './agencies';
 export { default as areas } from './areas';
 export { default as assets } from './assets';
+export { default as assignableRoutes } from './assignableRoutes';
+export { default as assignableStops } from './assignableStops';
 export { default as blocks } from './blocks';
 export { default as calls } from './calls';
 export { default as callParticipants } from './callParticipants';

src/resources/AssignableRoute.js

@@ -0,0 +1,50 @@
+import Resource from './Resource';
+
+/**
+ * AssignableRoute resource
+ */
+class AssignableRoute extends Resource {
+  /**
+   * Creates a new AssignableRoute
+   *
+   * @param {Client} client Instance of pre-configured client
+   * @param  {Array} rest Remaining arguments to use in assigning values to this instance
+   */
+  constructor(client, ...rest) {
+    super(client);
+
+    const newProperties = Object.assign({}, ...rest);
+    const hydrated = !Object.keys(newProperties).every(k => k === 'href' || k === 'code');
+
+    Object.assign(this, newProperties, {
+      hydrated,
+    });
+  }
+
+  /**
+   * Makes a href for a given customer code and ID
+   *
+   * @param {string} customerCode Customer code
+   * @param {string} id  Assignable Route ID
+   * @returns {{href: string}} URI to instance of Assignable Route
+   */
+  static makeHref(customerCode, id) {
+    return {
+      href: `/1/${customerCode}/assignable_entities/routes/${id}`,
+      code: customerCode,
+    };
+  }
+
+  /**
+   * Fetches the data for this assignable route via the client.
+   *
+   * @returns {Promise} If successful, a hydrated instance of this assignable route
+   */
+  fetch() {
+    return this.client.get(this.href)
+      .then(response => response.json())
+      .then(assignableRoute => new AssignableRoute(this.client, this, assignableRoute));
+  }
+}
+
+export default AssignableRoute;

src/resources/AssignableRoute.test.js

@@ -0,0 +1,44 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import fetchMock from 'fetch-mock';
+import Client from '../Client';
+import AssignableStop from './AssignableStop';
+import { assignableStops as mockAssignableStops } from '../mocks';
+
+chai.should();
+chai.use(chaiAsPromised);
+
+describe('When instantiating an assignable route based on customer and ID', () => {
+  const client = new Client();
+  const assignableRoute = new AssignableStop(client, AssignableStop.makeHref('SYNC', '1st_and_main'));
+
+  it('should set the href', () => assignableRoute.href.should.equal('/1/SYNC/assignable_entities/stops/1st_and_main'));
+  it('should not be hydrated', () => assignableRoute.hydrated.should.equal(false));
+});
+
+describe('When instantiating an assignable route based on an object', () => {
+  const client = new Client();
+  const assignableRoute = new AssignableStop(client, mockAssignableStops.getById('1st_and_main'));
+
+  it('should set the ID', () => assignableRoute.id.should.equal('1st_and_main'));
+  it('should set the href', () => assignableRoute.href.should.equal('/1/SYNC/assignable_entities/stops/1st_and_main'));
+  it('should be hydrated', () => assignableRoute.hydrated.should.equal(true));
+});
+
+describe('When fetching an assignable route based on customer and ID', () => {
+  const client = new Client();
+
+  beforeEach(() => mockAssignableStops.setUpSuccessfulMock(client));
+  beforeEach(() => fetchMock.catch(503));
+  afterEach(fetchMock.restore);
+
+  let promise;
+  beforeEach(() => {
+    promise = new AssignableStop(client, AssignableStop.makeHref('SYNC', '1st_and_main')).fetch();
+  });
+
+  it('should resolve the promise', () => promise.should.be.fulfilled);
+  it('should set the ID', () => promise.then(v => v.id).should.eventually.equal('1st_and_main'));
+  it('should set the href', () => promise.then(v => v.href).should.eventually.equal('/1/SYNC/assignable_entities/stops/1st_and_main'));
+  it('should be hydrated', () => promise.then(v => v.hydrated).should.eventually.equal(true));
+});

src/resources/AssignableRoutesContext.js

@@ -0,0 +1,32 @@
+import 'isomorphic-fetch';
+import PagedContext from './PagedContext';
+import AssignableRoute from './AssignableRoute';
+
+/**
+ * AssignableRoutes querying context
+ *
+ * This is used to query the list of Assignable Routes for a customer
+ */
+class AssignableRoutesContext extends PagedContext {
+  /**
+   *
+   * @param {Client} client Instance of pre-configurred client
+   * @param {string} customerCode Customer code
+   * @param {object} params Object of querystring parameters to append to the URL
+   */
+  constructor(client, customerCode, params) {
+    super(client, { ...params });
+    this.code = customerCode;
+  }
+
+  /**
+   * Gets the first page of results for this context
+   * @returns {Promise} If successful, a page of AssignableRoute objects
+   * @see AssignableRoute
+   */
+  getPage() {
+    return this.page(AssignableRoute, `/1/${this.code}/assignable_entities/routes`);
+  }
+}
+
+export default AssignableRoutesContext;

src/resources/AssignableRoutesContext.test.js

@@ -0,0 +1,30 @@
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import fetchMock from 'fetch-mock';
+import Client from '../Client';
+import AssignableRoutesContext from './AssignableRoutesContext';
+import { assignableRoutes as mockAssignableRoutes } from '../mocks';
+
+chai.should();
+chai.use(chaiAsPromised);
+
+describe('When building a query for assignable routes', () => {
+  const client = new Client();
+  client.setAuthenticated();
+
+  beforeEach(() => fetchMock
+    .get(client.resolve('/1/SYNC/assignable_entities/routes?page=1&per_page=10&sort='), mockAssignableRoutes.list)
+    .catch(503));
+  afterEach(fetchMock.restore);
+
+  let promise;
+  beforeEach(() => {
+    const routes = new AssignableRoutesContext(client, 'SYNC');
+    promise = routes
+      .withPage(1)
+      .withPerPage(10)
+      .getPage();
+  });
+
+  it('should make the expected request', () => promise.should.be.fulfilled);
+});

src/resources/AssignableStop.js

@@ -0,0 +1,50 @@
+import Resource from './Resource';
+
+/**
+ * AssignableStop resource
+ */
+class AssignableStop extends Resource {
+  /**
+   * Creates a new AssignableStop
+   *
+   * @param {Client} client Instance of pre-configured client
+   * @param  {Array} rest Remaining arguments to use in assigning values to this instance
+   */
+  constructor(client, ...rest) {
+    super(client);
+
+    const newProperties = Object.assign({}, ...rest);
+    const hydrated = !Object.keys(newProperties).every(k => k === 'href' || k === 'code');
+
+    Object.assign(this, newProperties, {
+      hydrated,
+    });
+  }
+
+  /**
+   * Makes a href for a given customer code and ID
+   *
+   * @param {string} customerCode Customer code
+   * @param {string} id  Assignable Stop ID
+   * @returns {{href: string}} URI to instance of Assignable Stop
+   */
+  static makeHref(customerCode, id) {
+    return {
+      href: `/1/${customerCode}/assignable_entities/stops/${id}`,
+      code: customerCode,
+    };
+  }
+
+  /**
+   * Fetches the data for this assignable stop via the client.
+   *
+   * @returns {Promise} If successful, a hydrated instance of this assignable stop
+   */
+  fetch() {
+    return this.client.get(this.href)
+      .then(response => response.json())
+      .then(assignableStop => new AssignableStop(this.client, this, assignableStop));
+  }
+}
+
+export default AssignableStop;