You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
120 lines
3.8 KiB
120 lines
3.8 KiB
import { expect } from "chai";
|
|
import sinon from "sinon";
|
|
import "mocha";
|
|
|
|
import {
|
|
ExitCode,
|
|
InternalService,
|
|
Microservice
|
|
} from "../../src";
|
|
|
|
class MockService1 extends InternalService {};
|
|
class MockService2 extends InternalService {};
|
|
|
|
class FaultyBootService extends InternalService {
|
|
public async boot() {
|
|
throw new Error("Boot error");
|
|
}
|
|
};
|
|
|
|
class FaultyStartService extends InternalService {
|
|
public async start() {
|
|
throw new Error("Start error");
|
|
}
|
|
}
|
|
|
|
class FaultyShutdownService extends InternalService {
|
|
public async shutdown() {
|
|
throw new Error("Shutdown error");
|
|
}
|
|
}
|
|
|
|
describe("Internal service integration", () => {
|
|
describe("Service installation", () => {
|
|
let service = new Microservice();
|
|
service.installServices([MockService1, MockService2]);
|
|
it("should have one service installed", () => {
|
|
expect(service.services().size).to.equal(2);
|
|
});
|
|
it("should have the microservice instance", () => {
|
|
expect(service.service(MockService1).microservice()).to.equal(service);
|
|
});
|
|
});
|
|
describe("Duplicate service installation", () => {
|
|
let service = new Microservice();
|
|
service.installService(MockService1);
|
|
it("should throw the correct error type", () => {
|
|
// For some reason checking error type fails here...
|
|
expect(() => service.installService(MockService1)).to.throw();
|
|
// expect(() => service.installService(MockService1)).to.throw(InternalServiceNotFoundError);
|
|
});
|
|
});
|
|
describe("Fetch an installed service", () => {
|
|
let service = new Microservice();
|
|
service.installService(MockService1);
|
|
it("should return the correct service instance", () => {
|
|
expect(service.service(MockService1)).to.be.an.instanceOf(MockService1);
|
|
});
|
|
});
|
|
describe("Fetch a non-installed service", () => {
|
|
let service = new Microservice();
|
|
it("should throw an error", () => {
|
|
expect(() => service.service(MockService1)).to.throw();
|
|
});
|
|
});
|
|
|
|
describe("Invoke the appropriate boot, start, and shutdown methods", () => {
|
|
let microservice = new Microservice();
|
|
microservice.installService(MockService1);
|
|
let service = microservice.service(MockService1);
|
|
|
|
let spyBoot = sinon.spy(service, "boot");
|
|
let spyStart = sinon.spy(service, "start");
|
|
let spyShutdown = sinon.spy(service, "shutdown");
|
|
it("should start and finish the app", async () => {
|
|
let cb = new Promise<void>((resolve) => microservice.once("ready", resolve));
|
|
let execPromise = microservice.exec();
|
|
await cb;
|
|
microservice.quit();
|
|
await execPromise;
|
|
});
|
|
it("should have invoked boot method", () => {
|
|
sinon.assert.calledOnce(spyBoot);
|
|
});
|
|
it("should have invoked start method", () => {
|
|
sinon.assert.calledOnce(spyStart);
|
|
});
|
|
it("should have invoked shutdown method", () => {
|
|
sinon.assert.calledOnce(spyShutdown);
|
|
});
|
|
});
|
|
|
|
describe("Error handling", () => {
|
|
describe("Faulty boot service", () => {
|
|
let microservice = new Microservice();
|
|
microservice.installServices([MockService1, FaultyBootService]);
|
|
it("should crash with correct exit code", async () => {
|
|
let exitCode = await microservice.exec();
|
|
expect(exitCode).to.equal(ExitCode.BootError);
|
|
});
|
|
});
|
|
describe("Faulty start service", () => {
|
|
let microservice = new Microservice();
|
|
microservice.installServices([MockService1, FaultyStartService]);
|
|
it("should crash with correct exit code", async () => {
|
|
let exitCode = await microservice.exec();
|
|
expect(exitCode).to.equal(ExitCode.StartError);
|
|
});
|
|
});
|
|
describe("Faulty shutdown service", () => {
|
|
let microservice = new Microservice();
|
|
microservice.installServices([MockService1, FaultyShutdownService]);
|
|
it("should crash with correct exit code", async () => {
|
|
let execPromise = microservice.exec();
|
|
microservice.quit();
|
|
let exitCode = await execPromise;
|
|
expect(exitCode).to.equal(ExitCode.ShutdownError);
|
|
});
|
|
});
|
|
});
|
|
});
|