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.
109 lines
4.1 KiB
109 lines
4.1 KiB
import { InternalService, Microservice } from "../../src";
|
|
import { InternalServiceConflictError, InternalServiceNotFoundError } from "../../src/errors";
|
|
import { ExitCode, MicroserviceState } from "../../src/schema";
|
|
|
|
class MockInternalService1 extends InternalService<Microservice> { NAME = "1"; }
|
|
class MockInternalService2 extends InternalService<Microservice> { NAME = "2"; }
|
|
|
|
class MockedMicroservice extends Microservice {
|
|
|
|
public readonly quitState: MicroserviceState;
|
|
public hasBooted = false;
|
|
public hasStarted = false;
|
|
public hasRun = false;
|
|
public hasShutdown = false;
|
|
|
|
public constructor(quitState: MicroserviceState) {
|
|
super();
|
|
this.quitState = quitState;
|
|
}
|
|
|
|
protected override async boot() {
|
|
this.hasBooted = true;
|
|
let result = await super.boot();
|
|
this.quitState === MicroserviceState.Booting && this.quit(25);
|
|
return result;
|
|
}
|
|
|
|
protected override async start() {
|
|
this.hasStarted = true;
|
|
let result = await super.start();
|
|
this.quitState === MicroserviceState.Starting && this.quit(50);
|
|
return result;
|
|
}
|
|
|
|
protected override async run() {
|
|
this.hasRun = true;
|
|
return await super.run();
|
|
}
|
|
|
|
protected override async shutdown() {
|
|
this.hasShutdown = true;
|
|
let result = super.shutdown();
|
|
this.quitState === MicroserviceState.Quitting && this.quit(100);
|
|
return result;
|
|
}
|
|
}
|
|
|
|
describe("Microservice:", () => {
|
|
describe("Internal Service Installation", () => {
|
|
test("Install an internal service", () => {
|
|
let microservice = new Microservice();
|
|
microservice.installServices([MockInternalService1, MockInternalService2]);
|
|
expect(microservice.service(MockInternalService1)).toBeInstanceOf(MockInternalService1);
|
|
expect(microservice.service(MockInternalService2)).toBeInstanceOf(MockInternalService2);
|
|
expect(microservice.service(MockInternalService1)).not.toBeInstanceOf(MockInternalService2);
|
|
});
|
|
test("Prevent installing already-installed services", () => {
|
|
let microservice = new Microservice();
|
|
expect(() => microservice.installServices([MockInternalService1, MockInternalService1])).toThrowError(InternalServiceConflictError);
|
|
});
|
|
test("Fail when accessing non-installed services", () => {
|
|
let microservice = new Microservice();
|
|
expect(() => microservice.service(MockInternalService1)).toThrowError(InternalServiceNotFoundError);
|
|
});
|
|
});
|
|
describe("Microservice State", () => {
|
|
// Quitting
|
|
test("Quit before executing process", async () => {
|
|
let microservice = new Microservice();
|
|
microservice.quit();
|
|
expect(microservice.state).toEqual(MicroserviceState.Finished);
|
|
expect(await microservice.exec()).toEqual(ExitCode.BootError);
|
|
});
|
|
test("Quit during boot state", async () => {
|
|
let microservice = new MockedMicroservice(MicroserviceState.Booting);
|
|
let exitCode = await microservice.exec();
|
|
expect(microservice.state).toEqual(MicroserviceState.Finished);
|
|
expect(microservice.hasBooted).toBe(true);
|
|
expect(microservice.hasShutdown).toBe(true);
|
|
expect(microservice.hasStarted).toBe(false);
|
|
expect(exitCode).toEqual(25);
|
|
});
|
|
test("Quit during starting state", async () => {
|
|
let microservice = new MockedMicroservice(MicroserviceState.Starting);
|
|
let exitCode = await microservice.exec();
|
|
expect(microservice.state).toEqual(MicroserviceState.Finished);
|
|
expect(microservice.hasBooted).toBe(true);
|
|
expect(microservice.hasShutdown).toBe(true);
|
|
expect(microservice.hasStarted).toBe(true);
|
|
expect(exitCode).toEqual(50);
|
|
});
|
|
test("Quit during running state", async () => {
|
|
let microservice = new MockedMicroservice(MicroserviceState.Running);
|
|
let runningPromise = microservice.exec();
|
|
setImmediate(() => microservice.quit(75));
|
|
let exitCode = await runningPromise;
|
|
expect(microservice.state).toEqual(MicroserviceState.Finished);
|
|
expect(exitCode).toEqual(75);
|
|
});
|
|
test("Quit during quitting state", async () => {
|
|
let microservice = new MockedMicroservice(MicroserviceState.Quitting);
|
|
let runningPromise = microservice.exec();
|
|
microservice.quit();
|
|
let exitCode = await runningPromise;
|
|
expect(microservice.state).toEqual(MicroserviceState.Finished);
|
|
expect(exitCode).toEqual(0);
|
|
});
|
|
});
|
|
});
|