refactor: move api to monorepo

packages/api/test/bulk.spec.ts

@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCBulkAddRoute, SCBulkDoneRoute, SCDish, SCMessage, SCThingOriginType, SCThingType} from '@openstapps/core';
+import {expect} from 'chai';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import chaiSpies from 'chai-spies';
+import {suite, test} from '@testdeck/mocha';
+import moment from 'moment';
+import {Bulk} from '../src/bulk';
+import {Client} from '../src/client';
+import {BulkWithMultipleTypesError} from '../src/errors';
+import {HttpClient} from '../src/http-client';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+const sandbox = chai.spy.sandbox();
+
+const bulkAddRoute = new SCBulkAddRoute();
+const bulkDoneRoute = new SCBulkDoneRoute();
+
+const httpClient = new HttpClient();
+const client = new Client(httpClient, 'http://localhost');
+
+@suite()
+export class BulkSpec {
+  @test
+  async add() {
+    sandbox.on(client, 'invokeRoute', () => {
+      return {};
+    });
+
+    expect(client.invokeRoute).not.to.have.been.called();
+
+    const bulk = new Bulk(SCThingType.Dish, client, {
+      expiration: moment().add(3600, 'seconds').format(),
+      source: 'foo',
+      state: 'in progress',
+      type: SCThingType.Dish,
+      uid: 'bar',
+    });
+
+    const dish: SCDish = {
+      categories: [
+        'main dish',
+      ],
+      name: 'foobar',
+      origin: {
+        indexed: moment().format(),
+        name: 'bar',
+        type: SCThingOriginType.Remote,
+      },
+      type: SCThingType.Dish,
+      uid: 'foo',
+    };
+
+    await bulk.add(dish);
+
+    expect(client.invokeRoute).to.have.been.first.called.with(bulkAddRoute, {
+      UID: 'bar',
+    }, dish);
+  }
+
+  @test
+  async addFails() {
+    const bulk = new Bulk(SCThingType.Dish, client, {
+      expiration: moment().add(3600, 'seconds').format(),
+      source: 'foo',
+      state: 'in progress',
+      type: SCThingType.Dish,
+      uid: 'bar',
+    });
+
+    const message: SCMessage = {
+      audiences: [
+        'students',
+      ],
+      categories: [
+        'news'
+      ],
+      messageBody: 'Lorem ipsum.',
+      name: 'foobar',
+      origin: {
+        indexed: moment().format(),
+        name: 'bar',
+        type: SCThingOriginType.Remote,
+      },
+      type: SCThingType.Message,
+      uid: 'foo',
+    };
+
+    return bulk.add(message).should.be.rejectedWith(BulkWithMultipleTypesError);
+  }
+
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async construct() {
+    expect(() => {
+      return new Bulk(SCThingType.Dish, client, {
+        expiration: moment().add(3600, 'seconds').format(),
+        source: 'foo',
+        state: 'in progress',
+        type: SCThingType.Dish,
+        uid: 'bar',
+      });
+    }).not.to.throw();
+  }
+
+  @test
+  async done() {
+    sandbox.on(client, 'invokeRoute', () => {
+      return {};
+    });
+
+    expect(client.invokeRoute).not.to.have.been.called();
+
+    const bulk = new Bulk(SCThingType.Dish, client, {
+      expiration: moment().add(3600, 'seconds').format(),
+      source: 'foo',
+      state: 'in progress',
+      type: SCThingType.Dish,
+      uid: 'bar',
+    });
+
+    await bulk.done();
+
+    expect(client.invokeRoute).to.have.been.first.called.with(bulkDoneRoute, {
+      UID: 'bar',
+    });
+  }
+}

packages/api/test/client.spec.ts

@@ -0,0 +1,632 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {
+  SCIndexResponse,
+  SCIndexRoute,
+  SCMessage,
+  SCMultiSearchResponse,
+  SCMultiSearchRoute,
+  SCSearchRequest,
+  SCSearchResponse,
+  SCSearchRoute,
+  SCThingOriginType,
+  SCThingType,
+} from '@openstapps/core';
+import {expect} from 'chai';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import chaiSpies from 'chai-spies';
+import {suite, test} from '@testdeck/mocha';
+import {Client} from '../src/client';
+import {ApiError, OutOfRangeError} from '../src/errors';
+import {HttpClient} from '../src/http-client';
+import {HttpClientResponse} from '../src/http-client-interface';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+const sandbox = chai.spy.sandbox();
+
+const indexRoute = new SCIndexRoute();
+const multiSearchRoute = new SCMultiSearchRoute();
+const searchRoute = new SCSearchRoute();
+
+const httpClient = new HttpClient();
+
+/**
+ * Recursive Partial
+ *
+ * @see https://stackoverflow.com/a/51365037
+ */
+export type RecursivePartial<T> = {
+  [P in keyof T]?:
+  T[P] extends Array<(infer U)> ? Array<RecursivePartial<U>> :
+    T[P] extends object ? RecursivePartial<T[P]> :
+      T[P];
+};
+
+async function invokeIndexRoute(): Promise<RecursivePartial<HttpClientResponse<SCIndexResponse>>> {
+  return {
+    body: {
+      app: {
+        features: {},
+      },
+      backend: {
+        SCVersion: 'foo.bar.dummy',
+      },
+    },
+    statusCode: indexRoute.statusCodeSuccess,
+  };
+}
+
+async function invokeIndexRouteFails(): Promise<RecursivePartial<HttpClientResponse<SCIndexResponse>>> {
+  return {
+    body: {
+      backend: {
+        SCVersion: 'foo.bar.dummy',
+      },
+    },
+    statusCode: indexRoute.statusCodeSuccess + 1,
+  };
+}
+
+@suite()
+export class ClientSpec {
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async construct() {
+    expect(() => {
+      return new Client(httpClient, 'http://localhost');
+    }).not.to.throw();
+  }
+
+  @test
+  async constructWithHeaders() {
+    sandbox.on(httpClient, 'request', invokeIndexRoute);
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost', 'foo.foo.foo');
+    await client.handshake('foo.bar.dummy');
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {},
+      headers: {
+        'Content-Type': 'application/json',
+        'X-StApps-Version': 'foo.foo.foo',
+      },
+      method: indexRoute.method,
+      url: new URL('http://localhost' + indexRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async getThing() {
+    const message: SCMessage = {
+      audiences: [
+        'employees',
+      ],
+      categories: [
+        'news'
+      ],
+      messageBody: 'Lorem ipsum.',
+      name: 'foo',
+      origin: {
+        indexed: 'foo',
+        name: 'foo',
+        type: SCThingOriginType.Remote,
+      },
+      type: SCThingType.Message,
+      uid: 'foo',
+    };
+
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCSearchResponse>> => {
+      return {
+        body: {
+          data: [message],
+          facets: [],
+          pagination: {
+            count: 0,
+            offset: 0,
+            total: 0,
+          },
+          stats: {
+            time: 0,
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.getThing('foo');
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {
+        filter: {
+          arguments: {
+            field: 'uid',
+            value: 'foo',
+          },
+          type: 'value',
+        },
+        size: 1,
+      },
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: searchRoute.method,
+      url: new URL('http://localhost' + searchRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async getThingFailsByEmptyResponse() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCSearchResponse>> => {
+      return {
+        body: {
+          data: [],
+          facets: [],
+          pagination: {
+            count: 0,
+            offset: 0,
+            total: 0,
+          },
+          stats: {
+            time: 0,
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+
+    return client.getThing('bar').should.be.rejected;
+  }
+
+  @test
+  async getThingFailsByUid() {
+    const message: SCMessage = {
+      audiences: [
+        'employees',
+      ],
+      categories: [
+        'news'
+      ],
+      messageBody: 'Lorem ipsum.',
+      name: 'foo',
+      origin: {
+        indexed: 'foo',
+        name: 'foo',
+        type: SCThingOriginType.Remote,
+      },
+      type: SCThingType.Message,
+      uid: 'foo',
+    };
+
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCSearchResponse>> => {
+      return {
+        body: {
+          data: [message],
+          facets: [],
+          pagination: {
+            count: 0,
+            offset: 0,
+            total: 0,
+          },
+          stats: {
+            time: 0,
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+
+    return client.getThing('bar').should.be.rejected;
+  }
+
+  @test
+  async handshake() {
+    sandbox.on(httpClient, 'request', invokeIndexRoute);
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.handshake('foo.bar.dummy');
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: indexRoute.method,
+      url: new URL('http://localhost' + indexRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async handshakeFails() {
+    sandbox.on(httpClient, 'request', invokeIndexRoute);
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+
+    return client.handshake('bar.bar.dummy').should.be.rejectedWith(ApiError);
+  }
+
+  @test
+  async invokePlugin() {
+    sandbox.on(httpClient, 'request', async():  Promise<RecursivePartial<HttpClientResponse<SCIndexResponse>>> => {
+      return {
+        body: {
+          app: {
+            features: {
+              plugins: {
+                "supportedPlugin": { urlPath: "/" }
+              },
+            },
+          },
+        },
+        statusCode: indexRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+    const client = new Client(httpClient, 'http://localhost');
+
+    await client.invokePlugin('unsupportedPlugin').should.be.rejectedWith(ApiError,/.*supportedPlugin.*/gmi);
+
+    // again with cached feature definitions
+    return client.invokePlugin('supportedPlugin')
+                 .should.not.be.rejectedWith(ApiError,/.*supportedPlugin.*/gmi);
+  }
+
+  @test
+  async invokePluginUnavailable() {
+    sandbox.on(httpClient, 'request', async():  Promise<RecursivePartial<HttpClientResponse<SCIndexResponse>>> => {
+      return {
+        body: {},
+        statusCode: indexRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+
+    await client.invokePlugin('supportedPlugin').should.be.rejectedWith(ApiError,/.*supportedPlugin.*/gmi);
+
+    sandbox.restore();
+    sandbox.on(httpClient, 'request', async():  Promise<RecursivePartial<HttpClientResponse<SCIndexResponse>>> => {
+      return {
+        body: {
+          app: {
+            features: {
+              plugins: {
+                'unsupportedPlugin': {
+                  urlPath: '/unsupported-plugin'
+                },
+              },
+            },
+          },
+        },
+        statusCode: indexRoute.statusCodeSuccess,
+      };
+    });
+    // again with cached feature definitions
+    return client.invokePlugin('supportedPlugin')
+                 .should.be.rejectedWith(ApiError,/.*supportedPlugin.*/gmi);
+  }
+
+  @test
+  async invokeRoute() {
+    sandbox.on(httpClient, 'request', invokeIndexRoute);
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.invokeRoute(indexRoute);
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: undefined,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: indexRoute.method,
+      url: new URL('http://localhost' + indexRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async invokeRouteFails() {
+    sandbox.on(httpClient, 'request', invokeIndexRouteFails);
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+
+    return client.invokeRoute(indexRoute).should.be.rejectedWith(ApiError);
+  }
+
+  @test
+  async multiSearch() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCMultiSearchResponse>> => {
+      return {
+        body: {
+          a: {
+            data: [],
+            facets: [],
+            pagination: {
+              count: 0,
+              offset: 0,
+              total: 0,
+            },
+            stats: {
+              time: 0,
+            },
+          },
+          b: {
+            data: [],
+            facets: [],
+            pagination: {
+              count: 0,
+              offset: 0,
+              total: 0,
+            },
+            stats: {
+              time: 0,
+            },
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.multiSearch({a: {size: 1}, b: {size: 1}});
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {a: {size: 1}, b: {size: 1}},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: multiSearchRoute.method,
+      url: new URL('http://localhost' + multiSearchRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async multiSearchWithPreflight() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCMultiSearchResponse>> => {
+      return {
+        body: {
+          bar: {
+            data: [],
+            facets: [],
+            pagination: {
+              count: 0,
+              offset: 0,
+              total: 500,
+            },
+            stats: {
+              time: 0,
+            },
+          },
+          foo: {
+            data: [],
+            facets: [],
+            pagination: {
+              count: 0,
+              offset: 0,
+              total: 1000,
+            },
+            stats: {
+              time: 0,
+            },
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.multiSearch({foo: {}, bar: {}, foobar: {size: 30}});
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {foo: {size: 0}, bar: {size: 0}},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: multiSearchRoute.method,
+      url: new URL('http://localhost' + multiSearchRoute.getUrlPath()),
+    });
+    expect(httpClient.request).to.have.been.second.called.with({
+      body: {foo: {size: 1000}, bar: {size: 500}, foobar: {size: 30}},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: multiSearchRoute.method,
+      url: new URL('http://localhost' + multiSearchRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  nextWindow() {
+    let searchRequest: SCSearchRequest = {size: 30};
+    const searchResponse: SCSearchResponse = {
+      data: [],
+      facets: [],
+      pagination: {
+        count: 30,
+        offset: 0,
+        total: 60,
+      },
+      stats: {
+        time: 0,
+      },
+    };
+
+    searchRequest = Client.nextWindow(searchRequest, searchResponse);
+
+    expect(searchRequest.from).to.equal(30);
+
+    searchResponse.pagination.offset = 30;
+
+    expect(() => {
+      Client.nextWindow(searchRequest, searchResponse);
+    }).to.throw(OutOfRangeError);
+  }
+
+  @test
+  async search() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCSearchResponse>> => {
+      return {
+        body: {
+          data: [],
+          facets: [],
+          pagination: {
+            count: 0,
+            offset: 0,
+            total: 0,
+          },
+          stats: {
+            time: 0,
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.search({size: 1});
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {size: 1},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: searchRoute.method,
+      url: new URL('http://localhost' + searchRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async searchNext() {
+    const searchResponse: SCSearchResponse = {
+      data: [],
+      facets: [],
+      pagination: {
+        count: 30,
+        offset: 0,
+        total: 60,
+      },
+      stats: {
+        time: 0,
+      },
+    };
+
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCSearchResponse>> => {
+      return {
+        body: searchResponse,
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.searchNext({from: 0, size: 30}, searchResponse);
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {from: 30, size: 30},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: searchRoute.method,
+      url: new URL('http://localhost' + searchRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async searchWithPreflight() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCSearchResponse>> => {
+      return {
+        body: {
+          data: [],
+          facets: [],
+          pagination: {
+            count: 0,
+            offset: 0,
+            total: 1000,
+          },
+          stats: {
+            time: 0,
+          },
+        },
+        headers: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.first.called();
+
+    const client = new Client(httpClient, 'http://localhost');
+    await client.search({});
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {size: 0},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: searchRoute.method,
+      url: new URL('http://localhost' + searchRoute.getUrlPath()),
+    });
+    expect(httpClient.request).to.have.been.second.called.with({
+      body: {size: 1000},
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: searchRoute.method,
+      url: new URL('http://localhost' + searchRoute.getUrlPath()),
+    });
+  }
+}

packages/api/test/connector-client.spec.ts

@@ -0,0 +1,466 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {asyncPool} from '@krlwlfrt/async-pool/lib/async-pool';
+import {
+  isThing,
+  SCBulkAddResponse,
+  SCBulkAddRoute,
+  SCBulkDoneResponse,
+  SCBulkDoneRoute,
+  SCBulkResponse,
+  SCBulkRoute,
+  SCMessage,
+  SCThingOriginType,
+  SCThingType,
+  SCThingUpdateResponse,
+  SCThingUpdateRoute,
+  SCThingWithoutReferences,
+} from '@openstapps/core';
+import chai from 'chai';
+import {expect} from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import chaiSpies from 'chai-spies';
+import clone = require('rfdc');
+import {readdir, readFile} from 'fs';
+import {suite, test} from '@testdeck/mocha';
+import moment from 'moment';
+import {join, resolve} from 'path';
+import traverse from 'traverse';
+import {promisify} from 'util';
+import {ConnectorClient} from '../src/connector-client';
+import {EmptyBulkError, NamespaceNotDefinedError} from '../src/errors';
+import {HttpClient} from '../src/http-client';
+import {HttpClientRequest, HttpClientResponse} from '../src/http-client-interface';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+const sandbox = chai.spy.sandbox();
+
+const bulkAddRoute = new SCBulkAddRoute();
+const bulkDoneRoute = new SCBulkDoneRoute();
+const bulkRoute = new SCBulkRoute();
+const thingUpdateRoute = new SCThingUpdateRoute();
+
+const readdirPromisified = promisify(readdir);
+const readFilePromisified = promisify(readFile);
+
+const httpClient = new HttpClient();
+
+/**
+ * Check if something contains things
+ *
+ * @param thing Thing to check
+ */
+function doesContainThings<T extends SCThingWithoutReferences>(thing: T): boolean {
+  /* tslint:disable-next-line:only-arrow-functions */
+  return traverse(thing).reduce(function (sum, item) {
+    if (this.isRoot) {
+      return false;
+    }
+
+    return sum || (item === null) ? false : isThing(item);
+  }, false);
+}
+
+@suite()
+export class ConnectorClientSpec {
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async bulk() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCBulkResponse>> => {
+      return {
+        body: {
+          expiration: moment().add(1800, 'seconds').format(),
+          source: 'foo',
+          state: 'in progress',
+          type: SCThingType.Message,
+          uid: 'foo',
+        },
+        headers: {},
+        statusCode: bulkRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.called();
+
+    const connectorClient = new ConnectorClient(httpClient, 'http://localhost');
+    await connectorClient.bulk(SCThingType.Message, 'foo', 1800);
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {
+        expiration: moment().add(1800, 'seconds').format(),
+        source: 'foo',
+        type: SCThingType.Message,
+      },
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: bulkRoute.method,
+      url: new URL('http://localhost' + bulkRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async bulkWithoutTimeout() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCBulkResponse>> => {
+      return {
+        body: {
+          expiration: moment().add(3600, 'seconds').format(),
+          source: 'foo',
+          state: 'in progress',
+          type: SCThingType.Message,
+          uid: 'foo',
+        },
+        headers: {},
+        statusCode: bulkRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.called();
+
+    const connectorClient = new ConnectorClient(httpClient, 'http://localhost');
+    await connectorClient.bulk(SCThingType.Message, 'foo');
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {
+        expiration: moment().add(3600, 'seconds').format(),
+        source: 'foo',
+        type: SCThingType.Message,
+      },
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: bulkRoute.method,
+      url: new URL('http://localhost' + bulkRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async index() {
+    const messages: SCMessage[] = [
+      {
+        audiences: [
+          'employees',
+        ],
+        categories: [
+          'news'
+        ],
+        messageBody: 'Lorem ipsum.',
+        name: 'foo',
+        origin: {
+          indexed: 'foo',
+          name: 'foo',
+          type: SCThingOriginType.Remote,
+        },
+        type: SCThingType.Message,
+        uid: 'foo',
+      },
+      {
+        audiences: [
+          'employees',
+        ],
+        categories: [
+          'news'
+        ],
+        messageBody: 'Lorem ipsum.',
+        name: 'foo',
+        origin: {
+          indexed: 'foo',
+          name: 'foo',
+          type: SCThingOriginType.Remote,
+        },
+        type: SCThingType.Message,
+        uid: 'bar',
+      },
+    ];
+
+    type responses = SCBulkResponse | SCBulkAddResponse | SCBulkDoneResponse;
+
+    sandbox.on(httpClient, 'request', async (request: HttpClientRequest)
+      : Promise<HttpClientResponse<responses>> => {
+      if (request.url.toString() === new URL('http://localhost' + bulkRoute.getUrlPath()).toString()) {
+        return {
+          body: {
+            expiration: moment().add(3600, 'seconds').format(),
+            source: 'copy',
+            state: 'in progress',
+            type: SCThingType.Message,
+            uid: 'foo',
+          },
+          headers: {},
+          statusCode: bulkRoute.statusCodeSuccess,
+        };
+      } else if (request.url.toString() === new URL('http://localhost' + bulkAddRoute.getUrlPath({
+        UID: 'foo',
+      })).toString()) {
+        return {
+          body: {},
+          headers: {},
+          statusCode: bulkAddRoute.statusCodeSuccess,
+        };
+      }
+
+      return {
+        body: {},
+        headers: {},
+        statusCode: bulkDoneRoute.statusCodeSuccess,
+      };
+    });
+
+    const connectorClient = new ConnectorClient(httpClient, 'http://localhost');
+    await connectorClient.index(messages, 'copy');
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {
+        expiration: moment().add(3600, 'seconds').format(),
+        source: 'copy',
+        type: SCThingType.Message,
+      },
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: bulkRoute.method,
+      url: new URL('http://localhost' + bulkRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  async indexFails() {
+    const connectorClient = new ConnectorClient(httpClient, 'http://localhost');
+    return connectorClient.index([]).should.be.rejectedWith(EmptyBulkError);
+  }
+
+  @test
+  async indexWithoutSource() {
+    const messages: SCMessage[] = [
+      {
+        audiences: [
+          'employees',
+        ],
+        categories: [
+          'news'
+        ],
+        messageBody: 'Lorem ipsum.',
+        name: 'foo',
+        origin: {
+          indexed: 'foo',
+          name: 'foo',
+          type: SCThingOriginType.Remote,
+        },
+        type: SCThingType.Message,
+        uid: 'foo',
+      },
+      {
+        audiences: [
+          'employees',
+        ],
+        categories: [
+          'news'
+        ],
+        messageBody: 'Lorem ipsum.',
+        name: 'foo',
+        origin: {
+          indexed: 'foo',
+          name: 'foo',
+          type: SCThingOriginType.Remote,
+        },
+        type: SCThingType.Message,
+        uid: 'bar',
+      },
+    ];
+
+    type responses = SCBulkResponse | SCBulkAddResponse | SCBulkDoneResponse;
+
+    sandbox.on(httpClient, 'request', async (request: HttpClientRequest)
+      : Promise<HttpClientResponse<responses>> => {
+      if (request.url.toString() === new URL('http://localhost' + bulkRoute.getUrlPath()).toString()) {
+        return {
+          body: {
+            expiration: moment().add(3600, 'seconds').format(),
+            source: 'stapps-api',
+            state: 'in progress',
+            type: SCThingType.Message,
+            uid: 'foo',
+          },
+          headers: {},
+          statusCode: bulkRoute.statusCodeSuccess,
+        };
+      } else if (request.url.toString() === new URL('http://localhost' + bulkAddRoute.getUrlPath({
+        UID: 'foo',
+      })).toString()) {
+        return {
+          body: {},
+          headers: {},
+          statusCode: bulkAddRoute.statusCodeSuccess,
+        };
+      }
+
+      return {
+        body: {},
+        headers: {},
+        statusCode: bulkDoneRoute.statusCodeSuccess,
+      };
+    });
+
+    const connectorClient = new ConnectorClient(httpClient, 'http://localhost');
+    await connectorClient.index(messages);
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: {
+        expiration: moment().add(3600, 'seconds').format(),
+        source: 'stapps-api',
+        type: SCThingType.Message,
+      },
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: bulkRoute.method,
+      url: new URL('http://localhost' + bulkRoute.getUrlPath()),
+    });
+  }
+
+  @test
+  makeUuid() {
+    const uuid = ConnectorClient.makeUUID('foo', 'b-tu');
+
+    expect(uuid).to.be.equal('abad271e-d9e9-5802-b7bc-96d8a647b451');
+    expect(ConnectorClient.makeUUID('bar', 'b-tu')).not.to.be.equal(uuid);
+    expect(ConnectorClient.makeUUID('foo', 'f-u')).not.to.be.equal(uuid);
+  }
+
+  @test
+  makeUuidFails() {
+    expect(() => {
+      ConnectorClient.makeUUID('foo', 'b-u');
+    }).to.throw(NamespaceNotDefinedError);
+  }
+
+  @test
+  async removeReferences() {
+    const pathToTestFiles = resolve(
+      __dirname,
+      '..',
+      'node_modules',
+      '@openstapps',
+      'core',
+      'test',
+      'resources',
+      'indexable'
+    );
+
+    const testFiles = await readdirPromisified(pathToTestFiles);
+
+    const testInstances = await asyncPool(5, testFiles, async (testFile) => {
+      const buffer = await readFilePromisified(join(pathToTestFiles, testFile));
+      const content = JSON.parse(buffer.toString());
+
+      return content.instance;
+    });
+
+    for (const testInstance of testInstances) {
+
+      const checkInstance = clone()(testInstance);
+      const testInstanceWithoutReferences = ConnectorClient.removeReferences(testInstance);
+
+      expect(doesContainThings(testInstanceWithoutReferences)).to.be
+        .equal(false, JSON.stringify(
+          [testInstance, testInstanceWithoutReferences],
+          null,
+          2,
+        ));
+      expect((testInstanceWithoutReferences as any).origin).to.be
+        .equal(undefined, JSON.stringify(
+          [testInstance, testInstanceWithoutReferences],
+          null,
+          2,
+        ));
+      expect(testInstance).to.be.deep
+        .equal(checkInstance,
+          'Removing the references of a thing could have side effects because no deep copy is used');
+    }
+  }
+
+  @test
+  async removeUndefinedProperties() {
+    const objectWithUndefinedProperties = {value: 'foo',
+                                           novalue: undefined,
+                                           nested: {
+                                             value: 'foo',
+                                             novalue: undefined},
+                                            };
+    const objectWithoutUndefinedProperties = {value: 'foo',
+                                              nested: {
+                                                value: 'foo'},
+                                               };
+    ConnectorClient.removeUndefinedProperties(objectWithUndefinedProperties);
+
+    expect(objectWithUndefinedProperties).to.deep.equal(objectWithoutUndefinedProperties, JSON.stringify(
+      [objectWithUndefinedProperties, objectWithoutUndefinedProperties],
+      null,
+      2,
+    ));
+  }
+
+  @test
+  async update() {
+    const message: SCMessage = {
+      audiences: [
+        'employees',
+      ],
+      categories: [
+        'news'
+      ],
+      messageBody: 'Lorem ipsum.',
+      name: 'foo',
+      origin: {
+        indexed: 'foo',
+        name: 'foo',
+        type: SCThingOriginType.Remote,
+      },
+      type: SCThingType.Message,
+      uid: 'foo',
+    };
+
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCThingUpdateResponse>> => {
+      return {
+        body: {},
+        headers: {},
+        statusCode: thingUpdateRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.called();
+
+    const connectorClient = new ConnectorClient(httpClient, 'http://localhost');
+    await connectorClient.update(message);
+
+    expect(httpClient.request).to.have.been.called.with({
+      body: message,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: thingUpdateRoute.method,
+      url: new URL('http://localhost' + thingUpdateRoute.getUrlPath({
+        TYPE: SCThingType.Message,
+        UID: 'foo',
+      })),
+    });
+  }
+}

packages/api/test/copy.spec.ts

@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {
+  SCBulkAddResponse,
+  SCBulkAddRoute,
+  SCBulkDoneResponse,
+  SCBulkDoneRoute,
+  SCBulkResponse,
+  SCBulkRoute,
+  SCSearchRequest,
+  SCSearchResponse,
+  SCSearchRoute,
+  SCThingType,
+} from '@openstapps/core';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import chaiSpies from 'chai-spies';
+import {suite, test} from '@testdeck/mocha';
+import moment from 'moment';
+import {copy} from '../src/copy';
+import {ApiError} from '../src/errors';
+import {HttpClient, RequestOptions, Response} from '../src/http-client';
+import {RecursivePartial} from './client.spec';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+const sandbox = chai.spy.sandbox();
+
+const bulkRoute = new SCBulkRoute();
+const bulkAddRoute = new SCBulkAddRoute();
+const bulkDoneRoute = new SCBulkDoneRoute();
+const searchRoute = new SCSearchRoute();
+
+const httpClient = new HttpClient();
+
+@suite()
+export class CopySpec {
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async copy() {
+    type responses = Response<SCBulkAddResponse | SCBulkDoneResponse | SCBulkResponse | SCSearchResponse>;
+
+    sandbox.on(httpClient, 'request', async (request: RequestOptions): Promise<RecursivePartial<responses>> => {
+      if (request.url.toString() === 'http://foo.bar' + searchRoute.getUrlPath().toString()) {
+        const body = request.body as SCSearchRequest;
+
+        let count = 0;
+        if (typeof body.size === 'number' && body.size > 0) {
+          count = 1;
+        }
+
+        return {
+          body: {
+            data: [{
+              categories: [
+                'main dish',
+              ],
+              name: 'foobar',
+              origin: {
+                indexed: moment().format(),
+                name: 'bar',
+              },
+              type: SCThingType.Dish,
+              uid: 'foo',
+            }],
+            facets: [],
+            pagination: {
+              count: count,
+              offset: 0,
+              total: 1,
+            },
+            stats: {
+              time: 1,
+            },
+          },
+          statusCode: searchRoute.statusCodeSuccess,
+        };
+      } else if (request.url.toString() === 'http://localhost' + bulkRoute.getUrlPath().toString()) {
+        return {
+          body: {
+            state: 'in progress',
+            uid: 'foo',
+          },
+          statusCode: bulkRoute.statusCodeSuccess,
+        };
+      } else if (request.url.toString() === 'http://localhost' + bulkAddRoute.getUrlPath({
+        UID: 'foo',
+      }).toString()) {
+        return {
+          body: {},
+          statusCode: bulkAddRoute.statusCodeSuccess,
+        };
+      }
+
+      return {
+        body: {},
+        statusCode: bulkDoneRoute.statusCodeSuccess,
+      };
+    });
+
+    await copy(httpClient, {
+      batchSize: 5,
+      from: 'http://foo.bar',
+      source: 'stapps-copy',
+      to: 'http://localhost',
+      type: SCThingType.Dish,
+      version: 'foo.bar.foobar',
+    });
+  }
+
+  @test
+  async copyShouldFail() {
+    type responses = Response<SCBulkAddResponse | SCBulkDoneResponse | SCBulkResponse | SCSearchResponse>;
+
+    sandbox.on(httpClient, 'request', async (request: RequestOptions): Promise<RecursivePartial<responses>> => {
+      if (request.url.toString() === 'http://foo.bar' + searchRoute.getUrlPath().toString()) {
+        const body = request.body as SCSearchRequest;
+
+        if (typeof body.size === 'number' && body.size > 0) {
+          throw new ApiError({});
+        }
+
+        return {
+          body: {
+            data: [{
+              categories: [
+                'main dish',
+              ],
+              name: 'foobar',
+              origin: {
+                indexed: moment().format(),
+                name: 'bar',
+              },
+              type: SCThingType.Dish,
+              uid: 'foo',
+            }],
+            facets: [],
+            pagination: {
+              count: 0,
+              offset: 0,
+              total: 1,
+            },
+            stats: {
+              time: 1,
+            },
+          },
+          statusCode: searchRoute.statusCodeSuccess,
+        };
+      } else if (request.url.toString() === 'http://localhost' + bulkRoute.getUrlPath().toString()) {
+        return {
+          body: {
+            state: 'in progress',
+            uid: 'foo',
+          },
+          statusCode: bulkRoute.statusCodeSuccess,
+        };
+      } else if (request.url.toString() === 'http://localhost' + bulkAddRoute.getUrlPath({
+        UID: 'foo',
+      }).toString()) {
+        return {
+          body: {},
+          statusCode: bulkAddRoute.statusCodeSuccess,
+        };
+      }
+
+      return {
+        body: {},
+        statusCode: bulkDoneRoute.statusCodeSuccess,
+      };
+    });
+
+    return copy(httpClient, {
+      batchSize: 5,
+      from: 'http://foo.bar',
+      source: 'stapps-copy',
+      to: 'http://localhost',
+      type: SCThingType.Dish,
+      version: 'foo.bar.foobar',
+    }).should.be.rejectedWith(ApiError);
+  }
+}

packages/api/test/e2e.spec.ts

@@ -0,0 +1,200 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+// tslint:disable-next-line: max-line-length
+// tslint:disable: completed-docs no-implicit-dependencies prefer-function-over-method newline-per-chained-call member-ordering
+import {
+  SCBulkAddResponse,
+  SCBulkAddRoute,
+  SCBulkDoneResponse,
+  SCBulkDoneRoute,
+  SCBulkResponse,
+  SCBulkRoute,
+  SCSearchResponse,
+  SCSearchRoute,
+  SCThings,
+} from '@openstapps/core';
+import chai from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import chaiSpies from 'chai-spies';
+import clone = require('rfdc');
+import {existsSync, mkdirSync, rmdirSync, unlinkSync} from 'fs';
+import {createFileSync} from 'fs-extra';
+import {suite, test} from '@testdeck/mocha';
+import {join} from 'path';
+import {e2eRun, getItemsFromSamples} from '../src/e2e';
+import {ApiError} from '../src/errors';
+import {HttpClient, RequestOptions, Response} from '../src/http-client';
+import {RecursivePartial} from './client.spec';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+const sandbox = chai.spy.sandbox();
+
+const bulkRoute = new SCBulkRoute();
+const bulkAddRoute = new SCBulkAddRoute();
+const bulkDoneRoute = new SCBulkDoneRoute();
+
+const searchRoute = new SCSearchRoute();
+
+const httpClient = new HttpClient();
+
+const storedThings: Map<string, SCThings> = new Map();
+
+@suite
+export class E2EConnectorSpec {
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async getCoreTestSamples() {
+    const items = await getItemsFromSamples('./node_modules/@openstapps/core/test/resources');
+    // tslint:disable-next-line: no-unused-expression
+    chai.expect(items).to.not.be.empty;
+  }
+
+  @test
+  async getCoreTestSamplesShouldFail() {
+    await chai.expect(getItemsFromSamples('./nonexistantdirectory')).to.be.rejectedWith(Error);
+  }
+
+  @test
+  async e2eRunSimulation() {
+    type responses = Response<SCBulkAddResponse | SCBulkDoneResponse | SCBulkResponse | SCSearchResponse>;
+
+    let failOnCompare = false;
+    let failOnLookup = false;
+
+    sandbox.on(httpClient, 'request', async (request: RequestOptions): Promise<RecursivePartial<responses>> => {
+      if (request.url.toString() === `http://localhost${bulkRoute.getUrlPath().toString()}`) {
+
+        return {
+          body: {
+            state: 'in progress',
+            uid: 'foo',
+          },
+          statusCode: bulkRoute.statusCodeSuccess,
+        };
+      }
+
+      if (request.url.toString() === `http://localhost${bulkAddRoute.getUrlPath({UID: 'foo'}).toString()}`) {
+        storedThings.set(request.body.uid, clone()(request.body));
+
+        return {
+          body: {},
+          statusCode: bulkAddRoute.statusCodeSuccess,
+        };
+      }
+
+      if (request.url.toString() === `http://localhost${bulkDoneRoute.getUrlPath({UID: 'foo'}).toString()}`) {
+        return {
+          body: {},
+          statusCode: bulkDoneRoute.statusCodeSuccess,
+        };
+      }
+
+      if (request.url.toString() === `http://localhost${searchRoute.getUrlPath().toString()}`) {
+        const thing = storedThings.get(request.body.filter.arguments.value);
+        if (failOnCompare) {
+          thing!.origin!.modified = 'altered';
+        }
+        const returnThing = failOnLookup ? [] : [thing];
+        const returnBody = {
+          data: returnThing,
+          facets: [],
+          pagination: {
+            count: returnThing.length,
+            offset: 0,
+            total: returnThing.length,
+          },
+          stats: {
+            time: 42,
+          },
+        };
+
+        return {
+          body: returnBody,
+          statusCode: searchRoute.statusCodeSuccess,
+        };
+      }
+
+      return {
+        body: {},
+        statusCode: searchRoute.statusCodeSuccess,
+      };
+    });
+
+    // tslint:disable-next-line: max-line-length
+    await e2eRun(httpClient, {to: 'http://localhost', samplesLocation: './node_modules/@openstapps/core/test/resources'});
+
+    failOnLookup = true;
+    failOnCompare = false;
+    // tslint:disable-next-line: max-line-length
+    await e2eRun(httpClient, {to: 'http://localhost', samplesLocation: './node_modules/@openstapps/core/test/resources'})
+    .should.be.rejectedWith('Search for single SCThing with uid');
+
+    failOnLookup = false;
+    failOnCompare = true;
+    // tslint:disable-next-line: max-line-length
+    await e2eRun(httpClient, {to: 'http://localhost', samplesLocation: './node_modules/@openstapps/core/test/resources'})
+    .should.be.rejectedWith('Unexpected difference');
+
+  }
+
+  @test
+  async indexShouldFail() {
+    type responses = Response<SCBulkAddResponse | SCBulkDoneResponse | SCBulkResponse>;
+
+    sandbox.on(httpClient, 'request', async (): Promise<RecursivePartial<responses>> => {
+
+      return {
+        body: {},
+        statusCode: Number.MAX_SAFE_INTEGER,
+      };
+    });
+
+    // tslint:disable-next-line: max-line-length
+    return e2eRun(httpClient, {to: 'http://localhost', samplesLocation: './node_modules/@openstapps/core/test/resources'})
+    .should.be.rejectedWith(ApiError);
+  }
+
+  @test
+  async indexShouldFailDirectoryWithoutData() {
+    const emptyDirPath = join(__dirname, 'emptyDir');
+    if (!existsSync(emptyDirPath)) {
+      mkdirSync(emptyDirPath);
+    }
+    await e2eRun(httpClient, {to: 'http://localhost', samplesLocation: emptyDirPath})
+    .should.be.rejectedWith('Could not index samples. None were retrieved from the file system.');
+    rmdirSync(emptyDirPath);
+  }
+
+  @test
+  async indexShouldFailDirectoryWithoutJsonData() {
+    const somewhatFilledDirPath = join(__dirname, 'somewhatFilledDir');
+    if (!existsSync(somewhatFilledDirPath)) {
+      mkdirSync(somewhatFilledDirPath);
+    }
+    const nonJsonFile = join (somewhatFilledDirPath, 'nonjson.txt');
+    createFileSync(nonJsonFile);
+    await e2eRun(httpClient, {to: 'http://localhost', samplesLocation: somewhatFilledDirPath})
+    .should.be.rejectedWith('Could not index samples. None were retrieved from the file system.');
+    unlinkSync(nonJsonFile);
+    rmdirSync(somewhatFilledDirPath);
+  }
+}

packages/api/test/errors.spec.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import chai from 'chai';
+import {expect} from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+import chaiSpies from 'chai-spies';
+import {suite, test} from '@testdeck/mocha';
+import {ApiError} from '../src/errors';
+
+chai.should();
+chai.use(chaiSpies);
+chai.use(chaiAsPromised);
+
+const sandbox = chai.spy.sandbox();
+
+@suite()
+export class ErrorsSpec {
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async shouldAddAdditionalData() {
+    const error = new ApiError({
+      additionalData: 'Lorem ipsum',
+    });
+
+    expect(error.toString()).to.contain('Lorem ipsum');
+  }
+
+  @test
+  async shouldAddRemoteStackTrace() {
+    const error = new ApiError({
+      stack: 'Lorem ipsum',
+    });
+
+    expect(error.toString()).to.contain('Lorem ipsum');
+  }
+
+  @test
+  async shouldSetName() {
+    const error = new ApiError({
+      name: 'Foo',
+    });
+
+    expect(error.name).to.be.equal('Foo');
+  }
+}

packages/api/test/http-client.spec.ts

@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2018-2020 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {expect} from 'chai';
+import {suite, test} from '@testdeck/mocha';
+import nock from 'nock';
+import {HttpClient} from '../src/http-client';
+
+// TODO: use after each to clean up the nock (then there is no need for numerated resource links)
+
+@suite()
+export class HttpClientSpec {
+
+  @test
+  async construct() {
+    expect(() => {
+      return new HttpClient();
+    }).not.to.throw();
+  }
+
+  async after() {
+    nock.cleanAll();
+  }
+
+  @test
+  async request() {
+    const client = new HttpClient();
+
+    nock('http://www.example.com')
+      .get('/resource')
+      .reply(200, 'foo');
+
+    const response = await client.request({
+      url: new URL('http://www.example.com/resource'),
+    });
+
+    expect(response.body).to.be.equal('foo');
+  }
+
+  @test
+  async requestWithBody() {
+    const client = new HttpClient();
+
+    nock('http://www.example.com')
+      .get('/resource')
+      .reply(200, 'foo');
+
+    const response = await client.request({
+      url: new URL('http://www.example.com/resource')
+    });
+
+    expect(response.body).to.be.equal('foo');
+  }
+
+  @test
+  async requestWithError() {
+    const client = new HttpClient();
+    let caughtErr;
+
+    nock('http://www.example.com')
+      .get('/resource')
+      .replyWithError('foo');
+
+    try {
+      await client.request({
+        body: {
+          foo: 'bar',
+        },
+        url: new URL('http://www.example.com/resource'),
+      });
+    } catch (err) {
+      caughtErr = err;
+    }
+
+    expect(caughtErr).not.to.be.undefined;
+  }
+
+  @test
+  async requestWithHeaders() {
+    const client = new HttpClient();
+
+    nock('http://www.example.com')
+      .get('/resource')
+      .reply(200, 'foo');
+
+    const response = await client.request({
+      headers: {
+        'X-StApps-Version': 'foo.bar.foobar',
+      },
+      url: new URL('http://www.example.com/resource'),
+    });
+
+    expect(response.body).to.be.equal('foo');
+  }
+
+  @test
+  async requestWithMethodGet() {
+    const client = new HttpClient();
+
+    nock('http://www.example.com')
+      .get('/resource')
+      .reply(200, 'foo');
+
+    const response = await client.request({
+      method: 'GET',
+      url: new URL('http://www.example.com/resource'),
+    });
+
+    expect(response.body).to.be.equal('foo');
+  }
+
+  @test
+  async requestWithMethodPost() {
+    const client = new HttpClient();
+
+    nock('http://www.example.com')
+      .post('/resource')
+      .reply(200, 'foo');
+
+    const response = await client.request({
+      method: 'POST',
+      url: new URL('http://www.example.com/resource'),
+    });
+
+    expect(response.body).to.be.equal('foo');
+  }
+}

packages/api/test/plugin-client.spec.ts

@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {SCPluginRegisterRequest, SCPluginRegisterResponse, SCPluginRegisterRoute} from '@openstapps/core';
+import chai from 'chai';
+import {expect} from 'chai';
+import chaiSpies from 'chai-spies';
+import {suite, test, timeout} from '@testdeck/mocha';
+import {HttpClient} from '../src/http-client';
+import {HttpClientResponse} from '../src/http-client-interface';
+import {PluginClient} from '../src/plugin-client';
+import {TestPlugin} from './plugin-resources/test-plugin';
+
+chai.use(chaiSpies);
+
+const sandbox = chai.spy.sandbox();
+
+const httpClient = new HttpClient();
+
+const pluginRegisterRoute = new SCPluginRegisterRoute();
+
+const pluginClient = new PluginClient(httpClient, 'http://localhost');
+
+@suite(timeout(10000))
+export class PluginClientSpec {
+  static plugin: TestPlugin;
+
+  static async after() {
+    await this.plugin.close();
+  }
+
+  static async before() {
+    this.plugin = new TestPlugin(4000, '', '', '', '', {getSchema: () => {/***/}} as any, '', '', '');
+  }
+
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async registerPlugin() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCPluginRegisterResponse>> => {
+      return {
+        body: {
+          success: true,
+        },
+        headers: {},
+        statusCode: pluginRegisterRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.called();
+
+    await pluginClient.registerPlugin(PluginClientSpec.plugin);
+
+    const request: SCPluginRegisterRequest = {
+      action: 'add',
+      plugin: {
+        address: PluginClientSpec.plugin.fullUrl,
+        name: PluginClientSpec.plugin.name,
+        requestSchema: PluginClientSpec.plugin.requestSchema,
+        responseSchema: PluginClientSpec.plugin.responseSchema,
+        route: PluginClientSpec.plugin.route,
+      },
+    };
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: request,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: pluginRegisterRoute.method,
+      url: new URL(`http://localhost${pluginRegisterRoute.getUrlPath()}`),
+    });
+  }
+
+  @test
+  async unregisterPlugin() {
+    sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCPluginRegisterResponse>> => {
+      return {
+        body: {
+          success: true,
+        },
+        headers: {},
+        statusCode: pluginRegisterRoute.statusCodeSuccess,
+      };
+    });
+
+    expect(httpClient.request).not.to.have.been.called();
+
+    await pluginClient.unregisterPlugin(PluginClientSpec.plugin);
+
+    const request: SCPluginRegisterRequest = {
+        action: 'remove',
+        route: PluginClientSpec.plugin.route,
+    };
+
+    expect(httpClient.request).to.have.been.first.called.with({
+      body: request,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: pluginRegisterRoute.method,
+      url: new URL(`http://localhost${pluginRegisterRoute.getUrlPath()}`),
+    });
+  }
+}

packages/api/test/plugin-resources/test-plugin-response.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2021 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+/**
+ * The Response Interface
+ *
+ * @validatable
+ */
+ export interface TestPluginResponse {
+  /**
+   * Query dummy
+   */
+    query: string;
+}

packages/api/test/plugin-resources/test-plugin.ts

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as express from 'express';
+import {Plugin} from '../../src/plugin';
+
+/**
+ * A test plugin we use for all the tests
+ *
+ * It can be constructed without any parameter at all, or with all parameters if we want to test it
+ * It also serves as kind of a minimal plugin
+ */
+export class TestPlugin extends Plugin {
+  // tslint:disable-next-line: completed-docs prefer-function-over-method
+  protected async onRouteInvoke(_req: express.Request, res: express.Response): Promise<void> {
+    res.json({});
+
+    return undefined;
+  }
+}

packages/api/test/plugin.spec.ts

@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2019 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import {Converter} from '@openstapps/core-tools/lib/schema';
+import chai from 'chai';
+import {expect} from 'chai';
+import chaiSpies from 'chai-spies';
+import {readFileSync} from 'fs';
+import {suite, test, timeout} from '@testdeck/mocha';
+import {resolve} from 'path';
+import {HttpClient} from '../src/http-client';
+import {TestPlugin} from './plugin-resources/test-plugin';
+
+chai.use(chaiSpies);
+
+process.on('unhandledRejection', (err) => {
+  throw err;
+});
+
+const sandbox = chai.spy.sandbox();
+
+const httpClient = new HttpClient();
+
+@suite(timeout(20000))
+export class PluginSpec {
+  static testPlugin: TestPlugin;
+
+  static async after() {
+    PluginSpec.testPlugin.close();
+  }
+
+  static async before() {
+    PluginSpec.testPlugin = new TestPlugin(4000, '', '', '', '', {
+      getSchema: () => {/***/
+      },
+    } as any, '', '', '');
+  }
+
+  async after() {
+    sandbox.restore();
+  }
+
+  @test
+  async construct() {
+    const converter = new Converter(__dirname, resolve(__dirname,'plugin-resources','test-plugin-response.ts'));
+
+    sandbox.on(converter, 'getSchema', (schemaName) => {
+      return {$id: schemaName};
+    });
+
+    const constructTestPlugin = new TestPlugin(
+      4001,
+      'A',
+      'http://B',
+      '/C', // this doesn't matter for our tests, it's only something that affects the backend
+      'http://D',
+      // @ts-ignore fake converter is not a converter
+      converter,
+      'PluginTestRequest',
+      'PluginTestResponse',
+      JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json')).toString()).version,
+    );
+    expect(constructTestPlugin.port).to.be.equal(4001);
+    expect(constructTestPlugin.name).to.be.equal('A');
+    expect(constructTestPlugin.url).to.be.equal('http://B');
+    expect(constructTestPlugin.route).to.be.equal('/C');
+    // @ts-ignore backendUrl is protected
+    expect(constructTestPlugin.backendUrl).to.be.equal('http://D');
+    // schemas are already covered, together with the directory and version
+    // @ts-ignore active is private
+    expect(constructTestPlugin.active).to.be.equal(false);
+    expect(constructTestPlugin.requestSchema.$id).to.be.equal('PluginTestRequest');
+    expect(constructTestPlugin.responseSchema.$id).to.be.equal('PluginTestResponse');
+
+    sandbox.on(constructTestPlugin, 'onRouteInvoke');
+    await httpClient.request({
+      url: new URL('http://localhost:4001'),
+    });
+    // onRouteInvoke is a protected method, but we need to access it from the outside to test it
+    // @ts-ignore
+    expect(constructTestPlugin.onRouteInvoke).not.to.have.been.called();
+
+    await constructTestPlugin.close();
+    sandbox.restore(constructTestPlugin, 'onRouteInvoke');
+  }
+
+  @test
+  async fullUrl() {
+    const constructTestPlugin = new TestPlugin(4001, '', 'http://B', '', '', {
+      getSchema: () => {/***/
+      },
+    } as any, '', '', '');
+    expect(constructTestPlugin.fullUrl).to.be.equal('http://B:4001');
+    await constructTestPlugin.close();
+  }
+
+  @test
+  async start() {
+    PluginSpec.testPlugin.start();
+
+    sandbox.on(PluginSpec.testPlugin, 'onRouteInvoke');
+
+    await httpClient.request({
+      url: new URL('http://localhost:4000'),
+    });
+
+    // onRouteInvoke is a protected method, but we need to access it from the outside to test it
+    // @ts-ignore
+    expect(PluginSpec.testPlugin.onRouteInvoke).to.have.been.called();
+  }
+
+  @test
+  async stop() {
+    // simulate a normal use case by first starting the plugin and then stopping it
+    PluginSpec.testPlugin.start();
+    PluginSpec.testPlugin.stop();
+
+    sandbox.on(PluginSpec.testPlugin, 'onRouteInvoke');
+
+    const response = await httpClient.request({
+      url: new URL('http://localhost:4000'),
+    });
+
+    await expect(response.statusCode).to.be.equal(404);
+    // onRouteInvoke is a protected method, but we need to access it from the outside to test it
+    // @ts-ignore
+    expect(PluginSpec.testPlugin.onRouteInvoke).not.to.have.been.called();
+  }
+}