Theaninova/openstapps
1
0
Fork 0
mirror of https://gitlab.com/openstapps/openstapps.git synced 2026-01-19 16:13:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: split api into api, api-cli & api-plugin

Browse Source
This commit is contained in:
Thea Schöbl
2023-06-02 16:41:25 +02:00
parent 495a63977c
commit b21833de40
205 changed files with 1981 additions and 1492 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
packages/api/test/bulk.spec.ts
View File

@@ -24,8 +24,8 @@ import {expect} from 'chai';
import chai from 'chai';
import chaiAsPromised from 'chai-as-promised';
import chaiSpies from 'chai-spies';
import moment from 'moment';
import {HttpClient, Bulk, Client, BulkWithMultipleTypesError} from '../src/index.js';
import {addHours} from 'date-fns';
chai.should();
chai.use(chaiSpies);
@@ -50,9 +50,10 @@ describe('Bulk', function () {
});
expect(client.invokeRoute).not.to.have.been.called();
const expiration = addHours(new Date(), 1).toISOString();
const bulk = new Bulk(SCThingType.Dish, client, {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'foo',
state: 'in progress',
type: SCThingType.Dish,
@@ -63,7 +64,7 @@ describe('Bulk', function () {
categories: ['main dish'],
name: 'foobar',
origin: {
indexed: moment().format(),
indexed: new Date().toISOString(),
name: 'bar',
type: SCThingOriginType.Remote,
},
@@ -84,7 +85,7 @@ describe('Bulk', function () {
it('should fail add', async function () {
const bulk = new Bulk(SCThingType.Dish, client, {
expiration: moment().add(3600, 'seconds').format(),
expiration: addHours(new Date(), 1).toISOString(),
source: 'foo',
state: 'in progress',
type: SCThingType.Dish,
@@ -97,7 +98,7 @@ describe('Bulk', function () {
messageBody: 'Lorem ipsum.',
name: 'foobar',
origin: {
indexed: moment().format(),
indexed: new Date().toISOString(),
name: 'bar',
type: SCThingOriginType.Remote,
},
@@ -111,7 +112,7 @@ describe('Bulk', function () {
it('should construct', function () {
expect(() => {
return new Bulk(SCThingType.Dish, client, {
expiration: moment().add(3600, 'seconds').format(),
expiration: addHours(new Date(), 1).toISOString(),
source: 'foo',
state: 'in progress',
type: SCThingType.Dish,
@@ -128,7 +129,7 @@ describe('Bulk', function () {
expect(client.invokeRoute).not.to.have.been.called();
const bulk = new Bulk(SCThingType.Dish, client, {
expiration: moment().add(3600, 'seconds').format(),
expiration: addHours(new Date(), 1).toISOString(),
source: 'foo',
state: 'in progress',
type: SCThingType.Dish,

34
packages/api/test/connector-client.spec.ts
View File

@@ -32,8 +32,6 @@ import chai from 'chai';
import {expect} from 'chai';
import chaiAsPromised from 'chai-as-promised';
import chaiSpies from 'chai-spies';
import clone = require('rfdc');
import moment from 'moment';
import traverse from 'traverse';
import {
ConnectorClient,
@@ -82,10 +80,12 @@ describe('ConnectorClient', function () {
});
it('should bulk', async function () {
sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCBulkResponse>> => {
let expiration = 'ERROR';
sandbox.on(httpClient, 'request', async (response): Promise<HttpClientResponse<SCBulkResponse>> => {
expiration = response?.body?.expiration ?? 'ERROR';
return {
body: {
expiration: moment().add(1800, 'seconds').format(),
expiration,
source: 'foo',
state: 'in progress',
type: SCThingType.Message,
@@ -103,7 +103,7 @@ describe('ConnectorClient', function () {
expect(httpClient.request).to.have.been.first.called.with({
body: {
expiration: moment().add(1800, 'seconds').format(),
expiration,
source: 'foo',
type: SCThingType.Message,
},
@@ -116,10 +116,12 @@ describe('ConnectorClient', function () {
});
it('should bulk without timeout', async function () {
sandbox.on(httpClient, 'request', async (): Promise<HttpClientResponse<SCBulkResponse>> => {
let expiration = 'ERROR';
sandbox.on(httpClient, 'request', async (request): Promise<HttpClientResponse<SCBulkResponse>> => {
expiration = request?.body?.expiration ?? 'ERROR';
return {
body: {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'foo',
state: 'in progress',
type: SCThingType.Message,
@@ -137,7 +139,7 @@ describe('ConnectorClient', function () {
expect(httpClient.request).to.have.been.first.called.with({
body: {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'foo',
type: SCThingType.Message,
},
@@ -181,14 +183,17 @@ describe('ConnectorClient', function () {
type responses = SCBulkResponse | SCBulkAddResponse | SCBulkDoneResponse;
let expiration = 'ERROR';
sandbox.on(
httpClient,
'request',
async (request: HttpClientRequest): Promise<HttpClientResponse<responses>> => {
if (request.url.toString() === new URL('http://localhost' + bulkRoute.getUrlPath()).toString()) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expiration = (request?.body as any)?.expiration ?? 'ERROR';
return {
body: {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'copy',
state: 'in progress',
type: SCThingType.Message,
@@ -226,7 +231,7 @@ describe('ConnectorClient', function () {
expect(httpClient.request).to.have.been.first.called.with({
body: {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'copy',
type: SCThingType.Message,
},
@@ -275,14 +280,17 @@ describe('ConnectorClient', function () {
type responses = SCBulkResponse | SCBulkAddResponse | SCBulkDoneResponse;
let expiration = 'ERROR';
sandbox.on(
httpClient,
'request',
async (request: HttpClientRequest): Promise<HttpClientResponse<responses>> => {
if (request.url.toString() === new URL('http://localhost' + bulkRoute.getUrlPath()).toString()) {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
expiration = (request?.body as any)?.expiration ?? 'ERROR';
return {
body: {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'stapps-api',
state: 'in progress',
type: SCThingType.Message,
@@ -320,7 +328,7 @@ describe('ConnectorClient', function () {
expect(httpClient.request).to.have.been.first.called.with({
body: {
expiration: moment().add(3600, 'seconds').format(),
expiration,
source: 'stapps-api',
type: SCThingType.Message,
},
@@ -370,7 +378,7 @@ describe('ConnectorClient', function () {
);
for (const testInstance of testInstances) {
const checkInstance = clone()(testInstance);
const checkInstance = JSON.parse(JSON.stringify(testInstance));
const testInstanceWithoutReferences = ConnectorClient.removeReferences(testInstance);
expect(doesContainThings(testInstanceWithoutReferences)).to.be.equal(

212
packages/api/test/copy.spec.ts
View File

@@ -1,212 +0,0 @@
/*
* 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 moment from 'moment';
import {copy, ApiError, HttpClient, RequestOptions, Response} from '../src/index.js';
import {RecursivePartial} from './client.spec.js';
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();
describe('Copy', function () {
afterEach(function () {
sandbox.restore();
});
it('should copy', async function () {
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',
});
});
it('should fail to copy', async function () {
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,
};
},
);
await 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);
});
});

211
packages/api/test/e2e.spec.ts
View File

@@ -1,211 +0,0 @@
/*
* 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/>.
*/
// eslint-disable-next-line unicorn/prevent-abbreviations
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';
// eslint-disable-next-line unicorn/prevent-abbreviations
import {e2eRun, getItemsFromSamples, ApiError, HttpClient, RequestOptions, Response} from '../src/index.js';
import {RecursivePartial} from './client.spec.js';
import {expect} from 'chai';
import path from 'path';
import {fileURLToPath} from 'url';
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();
describe('e2e Connector', function () {
afterEach(function () {
sandbox.restore();
});
it('should get core test samples', async function () {
const items = await getItemsFromSamples('./node_modules/@openstapps/core/test/resources');
expect(items).to.not.be.empty;
});
it('should fail to get core test samples', async function () {
await chai.expect(getItemsFromSamples('./non-existent-directory')).to.be.rejectedWith(Error);
});
it('should run e2e simulation', async function () {
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');
});
it('should fail to index', async function () {
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);
});
it('should fail to index directory without data', async function () {
const emptyDirectoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'emptyDir');
if (!existsSync(emptyDirectoryPath)) {
mkdirSync(emptyDirectoryPath);
}
await e2eRun(httpClient, {
to: 'http://localhost',
samplesLocation: emptyDirectoryPath,
}).should.be.rejectedWith('Could not index samples. None were retrieved from the file system.');
rmdirSync(emptyDirectoryPath);
});
it('should fail to index directory without json data', async function () {
const somewhatFilledDirectoryPath = path.join(
path.dirname(fileURLToPath(import.meta.url)),
'somewhatFilledDir',
);
if (!existsSync(somewhatFilledDirectoryPath)) {
mkdirSync(somewhatFilledDirectoryPath);
}
const nonJsonFile = path.join(somewhatFilledDirectoryPath, 'nonjson.txt');
createFileSync(nonJsonFile);
await e2eRun(httpClient, {
to: 'http://localhost',
samplesLocation: somewhatFilledDirectoryPath,
}).should.be.rejectedWith('Could not index samples. None were retrieved from the file system.');
unlinkSync(nonJsonFile);
rmdirSync(somewhatFilledDirectoryPath);
});
});

65
packages/api/test/http-client.spec.ts
View File

@@ -13,14 +13,18 @@
* this program. If not, see <https://www.gnu.org/licenses/>.
*/
import {expect} from 'chai';
import nock from 'nock';
import {Interceptable, MockAgent, setGlobalDispatcher} from 'undici';
import {HttpClient} from '../src/index.js';
// TODO: use after each to clean up the nock (then there is no need for numerated resource links)
const mockAgent = new MockAgent();
setGlobalDispatcher(mockAgent);
describe('HttpClient', function () {
afterEach(function () {
nock.cleanAll();
let mockPool: Interceptable;
beforeEach(function () {
mockPool?.close();
mockPool = mockAgent.get('http://www.example.com');
});
it('should construct', function () {
@@ -32,32 +36,32 @@ describe('HttpClient', function () {
it('should request', async function () {
const client = new HttpClient();
nock('http://www.example.com').get('/resource').reply(200, 'foo');
mockPool.intercept({path: '/resource', method: 'GET'}).reply(200, {foo: 'bar'});
const response = await client.request({
url: new URL('http://www.example.com/resource'),
});
expect(response.body).to.be.equal('foo');
expect(response.body).to.be.deep.equal({foo: 'bar'});
});
it('should request with body', async function () {
const client = new HttpClient();
nock('http://www.example.com').get('/resource').reply(200, 'foo');
mockPool.intercept({path: '/resource', method: 'GET'}).reply(200, {foo: 'foo'});
const response = await client.request({
url: new URL('http://www.example.com/resource'),
});
expect(response.body).to.be.equal('foo');
expect(response.body).to.be.deep.equal({foo: 'foo'});
});
it('should request with error', async function () {
const client = new HttpClient();
let caughtError;
nock('http://www.example.com').get('/resource').replyWithError('foo');
mockPool.intercept({path: '/resource', method: 'GET'}).replyWithError(new Error('foo'));
try {
await client.request({
@@ -76,7 +80,15 @@ describe('HttpClient', function () {
it('should request with headers', async function () {
const client = new HttpClient();
nock('http://www.example.com').get('/resource').reply(200, 'foo');
mockPool
.intercept({
path: '/resource',
method: 'GET',
headers: {
'X-StApps-Version': 'foo.bar.foobar',
},
})
.reply(200, {foo: 'bar'});
const response = await client.request({
headers: {
@@ -85,32 +97,55 @@ describe('HttpClient', function () {
url: new URL('http://www.example.com/resource'),
});
expect(response.body).to.be.equal('foo');
expect(response.body).to.be.deep.equal({foo: 'bar'});
});
it('should request with body', async function () {
const client = new HttpClient();
mockPool
.intercept({
path: '/resource',
method: 'POST',
headers: {
'content-type': 'application/json',
},
body: JSON.stringify({bar: 'baz'}),
})
.reply(200, {foo: 'foo'});
const response = await client.request({
body: {bar: 'baz'},
method: 'POST',
url: new URL('http://www.example.com/resource'),
});
expect(response.body).to.be.deep.equal({foo: 'foo'});
});
it('should request with method GET', async function () {
const client = new HttpClient();
nock('http://www.example.com').get('/resource').reply(200, 'foo');
mockPool.intercept({path: '/resource', method: 'GET'}).reply(200, {foo: 'foo'});
const response = await client.request({
method: 'GET',
url: new URL('http://www.example.com/resource'),
});
expect(response.body).to.be.equal('foo');
expect(response.body).to.be.deep.equal({foo: 'foo'});
});
it('should request with method POST', async function () {
const client = new HttpClient();
nock('http://www.example.com').post('/resource').reply(200, 'foo');
mockPool.intercept({path: '/resource', method: 'POST'}).reply(200, {foo: 'foo'});
const response = await client.request({
method: 'POST',
url: new URL('http://www.example.com/resource'),
});
expect(response.body).to.be.equal('foo');
expect(response.body).to.be.deep.equal({foo: 'foo'});
});
});

123
packages/api/test/plugin-client.spec.ts
View File

@@ -1,123 +0,0 @@
/*
* 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 {HttpClient, HttpClientResponse, PluginClient} from '../src/index.js';
import {TestPlugin} from './plugin-resources/test-plugin.js';
chai.use(chaiSpies);
const sandbox = chai.spy.sandbox();
const httpClient = new HttpClient();
const pluginRegisterRoute = new SCPluginRegisterRoute();
const pluginClient = new PluginClient(httpClient, 'http://localhost');
describe('PluginClient', function () {
this.timeout(10_000);
let plugin: TestPlugin;
beforeEach(async function () {
plugin = new TestPlugin(
4000,
'',
'',
'',
'',
{
getSchema: () => {
/***/
},
} as never,
'',
'',
'',
);
});
afterEach(async function () {
await plugin.close();
sandbox.restore();
});
it('should register the plugin', async function () {
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(plugin);
const request: SCPluginRegisterRequest = {
action: 'add',
plugin: {
address: plugin.fullUrl,
name: plugin.name,
requestSchema: plugin.requestSchema,
responseSchema: plugin.responseSchema,
route: 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()}`),
});
});
it('should unregister the plugin', async function () {
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(plugin);
const request: SCPluginRegisterRequest = {
action: 'remove',
route: 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()}`),
});
});
});

25
packages/api/test/plugin-resources/test-plugin-response.ts
View File

@@ -1,25 +0,0 @@
/*
* 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;
}

32
packages/api/test/plugin-resources/test-plugin.ts
View File

@@ -1,32 +0,0 @@
/*
* 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.js';
/**
* 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;
}
}

161
packages/api/test/plugin.spec.ts
View File

@@ -1,161 +0,0 @@
/*
* 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';
import chai from 'chai';
import {expect} from 'chai';
import chaiSpies from 'chai-spies';
import {HttpClient} from '../src/index.js';
import {TestPlugin} from './plugin-resources/test-plugin.js';
import path from 'path';
import {readFile} from 'fs/promises';
import {fileURLToPath} from 'url';
chai.use(chaiSpies);
process.on('unhandledRejection', error => {
throw error;
});
const sandbox = chai.spy.sandbox();
const httpClient = new HttpClient();
const dirname = path.dirname(fileURLToPath(import.meta.url));
describe('Plugin', function () {
this.timeout(20_000);
let testPlugin: TestPlugin;
beforeEach(function () {
testPlugin = new TestPlugin(
4000,
'',
'',
'',
'',
{
getSchema: () => {
/***/
},
} as never,
'',
'',
'',
);
});
afterEach(async function () {
await testPlugin.close();
sandbox.restore();
});
it('should construct', async function () {
const converter = new Converter(
dirname,
path.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',
converter,
'PluginTestRequest',
'PluginTestResponse',
JSON.parse(await readFile(path.resolve(dirname, '..', 'package.json'), 'utf8')).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-expect-error private property
expect(constructTestPlugin.backendUrl).to.be.equal('http://D');
// schemas are already covered, together with the directory and version
// @ts-expect-error private property
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-expect-error protected method
expect(constructTestPlugin.onRouteInvoke).not.to.have.been.called();
await constructTestPlugin.close();
sandbox.restore(constructTestPlugin, 'onRouteInvoke');
});
it('should have full url', async function () {
const constructTestPlugin = new TestPlugin(
4001,
'',
'http://B',
'',
'',
{
getSchema: () => {
/***/
},
} as never,
'',
'',
'',
);
expect(constructTestPlugin.fullUrl).to.be.equal('http://B:4001');
await constructTestPlugin.close();
});
it('should start', async function () {
testPlugin.start();
sandbox.on(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-expect-error protected method
expect(testPlugin.onRouteInvoke).to.have.been.called();
});
it('should stop', async function () {
// simulate a normal use case by first starting the plugin and then stopping it
testPlugin.start();
testPlugin.stop();
sandbox.on(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-expect-error protected method
expect(testPlugin.onRouteInvoke).not.to.have.been.called();
});
});