smartexpect/ts/smartexpect.classes.assertion.ts
2022-02-02 02:45:45 +01:00

158 lines
4.4 KiB
TypeScript

import * as plugins from './smartexpect.plugins';
export type TExecutionType = 'sync' | 'async';
export class Assertion {
executionMode: TExecutionType;
baseReference: any;
private notSetting = false;
private timeoutSetting = 0;
constructor(baseReferenceArg: any, executionModeArg: TExecutionType) {
this.baseReference = baseReferenceArg;
this.executionMode = executionModeArg;
}
public get not() {
this.notSetting = true;
return this;
}
public timeout(millisArg: number) {
this.timeoutSetting = millisArg;
return this;
}
private runCheck(checkFunction: () => any) {
const runDirectOrNegated = (checkFunction: () => any) => {
if (!this.notSetting) {
return checkFunction();
} else {
let isOk = false;
try {
runDirectOrNegated(checkFunction())
} catch (e) {
isOk = true;
}
if (!isOk) {
throw new Error('Negated assertion is not ok!');
}
}
}
if (this.executionMode === 'async') {
const done = plugins.smartpromise.defer();
if (!(this.baseReference instanceof Promise)) {
done.reject(new Error(`${this.baseReference} is not of type promise.`));
} else {
if (this.timeoutSetting) {
plugins.smartdelay.delayFor(this.timeoutSetting).then(() => {
if (done.status === 'pending') {
done.reject(new Error(`${this.baseReference} timed out at ${this.timeoutSetting}!`))
}
});
}
this.baseReference.then(promiseResultArg => {
this.baseReference = promiseResultArg;
done.resolve(runDirectOrNegated(checkFunction));
})
}
return done.promise;
} else {
return runDirectOrNegated(checkFunction);
}
}
public toBeTypeofString() {
return this.runCheck(() => {
if (typeof this.baseReference !== 'string') {
throw new Error(
`Assertion failed: ${this.baseReference} is not of type string, but typeof ${typeof this.baseReference}`
);
}
});
}
public toBeTypeofNumber() {
return this.runCheck(() => {
if (typeof this.baseReference !== 'number') {
throw new Error(
`Assertion failed: ${this.baseReference} is not of type string, but typeof ${typeof this.baseReference}`
);
}
});
}
public toBeTypeofBoolean() {
return this.runCheck(() => {
if (typeof this.baseReference !== 'boolean') {
throw new Error(
`Assertion failed: ${this.baseReference} is not of type string, but typeof ${typeof this.baseReference}`
);
}
});
}
public toEqual(comparisonObject: any) {
return this.runCheck(() => {
const result = plugins.fastDeepEqual(this.baseReference, comparisonObject);
if (!result) {
throw new Error(`${this.baseReference} does not equal ${comparisonObject}`);
}
});
}
public toBeTrue() {
return this.runCheck(() => {
const result = typeof this.baseReference === 'boolean' && this.baseReference === true;
if (!result) {
throw new Error(`${this.baseReference} is not true or not of type boolean`);
}
});
}
public toBeFalse() {
return this.runCheck(() => {
const result = typeof this.baseReference === 'boolean' && this.baseReference === false;
if (!result) {
throw new Error(`${this.baseReference} is not false or not of type boolean`);
}
});
}
public toBeInstanceOf(classArg: any) {
return this.runCheck(() => {
const result = this.baseReference instanceof classArg;
if (!result) {
throw new Error(`${this.baseReference} is not an instance of ${classArg}`);
}
});
}
public toHaveProperty(propertyArg: string) {
return this.runCheck(() => {
const result = !!this.baseReference[propertyArg];
if (!result) {
throw new Error(`${this.baseReference} does not have property ${propertyArg}`);
}
});
}
public toBeGreaterThan(numberArg: number) {
return this.runCheck(() => {
const result = this.baseReference > numberArg;
if (!result) {
throw new Error(`${this.baseReference} is not greater than ${numberArg}`);
}
});
}
public toBeLessThan(numberArg: number) {
return this.runCheck(() => {
const result = this.baseReference < numberArg;
if (!result) {
throw new Error(`${this.baseReference} is not less than ${numberArg}`);
}
});
}
}