@contract-case/case-core
Version:
Core functionality for the ContractCase contract testing suite
120 lines • 8.09 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.findAndCallTrigger = void 0;
const case_plugin_base_1 = require("@contract-case/case-plugin-base");
const entities_1 = require("../../entities");
const invokeTrigger = (trigger, testResponse, config, context) => trigger(config).then((response) => {
try {
return testResponse(response, config);
}
catch (e) {
throw new case_plugin_base_1.VerifyTriggerReturnObjectError(e);
}
}, (e) => {
if (e instanceof case_plugin_base_1.CaseTriggerError ||
e instanceof case_plugin_base_1.CaseConfigurationError ||
e instanceof case_plugin_base_1.CaseCoreError ||
e instanceof case_plugin_base_1.VerifyTriggerReturnObjectError) {
context.logger.maintainerDebug(`Trigger function received a case error (${e.name}): ${e.message}`);
throw e;
}
context.logger.maintainerDebug(`Trigger function received a non-case error (${e.name}): ${e.message}`);
throw new case_plugin_base_1.CaseTriggerError(e.message, context, e.userFacingStackTrace);
});
const invokeFailingTrigger = (trigger, testErrorResponse, config, context) => trigger(config).then((data) => {
throw new entities_1.CaseFailedAssertionError(`Expected the provided trigger to throw an error, but instead it was ${data}'`, (0, case_plugin_base_1.makeResults)((0, case_plugin_base_1.failedExpectationError)(`Expected the provided trigger to throw an error, but instead it was ${data}'`, data, 'TriggerWasMeantToFail', context, 'A rejecting Promise object')));
}, (actualError) => Promise.resolve()
.then(() => testErrorResponse(actualError, config))
.catch((err) => {
throw new case_plugin_base_1.VerifyTriggerReturnObjectError(err);
}));
const findAndCallTrigger = (mock, { trigger, triggerAndTest, triggerAndTests, triggers, names, testErrorResponse, testResponse, }, assertable, context) => Promise.resolve().then(() => {
context.logger.maintainerDebug(`In this mock (${mock['_case:mock:type']}), in '${context['_case:currentRun:context:contractMode']}' mode, the triggers must be ${mock['_case:run:context:setup'][context['_case:currentRun:context:contractMode']].triggers}`);
if (mock['_case:run:context:setup'][context['_case:currentRun:context:contractMode']].triggers === 'generated') {
context.logger.maintainerDebug("Triggers don't need to be provided for this mock type; skipping");
return Promise.resolve();
}
context.logger.maintainerDebug('The provided triggers at this point are', {
trigger,
triggerAndTest,
triggerAndTests,
triggers,
names,
testErrorResponse,
testResponse,
});
if (triggerAndTest !== undefined) {
context.logger.debug(`Invoking provided trigger / test for '${names.requestName}'`);
return invokeTrigger(triggerAndTest, () => { }, assertable.config, context);
}
if (trigger !== undefined) {
if (testErrorResponse === undefined && testResponse === undefined) {
throw new case_plugin_base_1.CaseCoreError('callTrigger received a trigger, but with no testErrorResponse or testResponse supplied\n.This is supposed to be prevented by DefineCaseContract');
}
if (testResponse !== undefined) {
context.logger.debug(`Invoking provided trigger for '${names.requestName}', and testing a successful response`);
return invokeTrigger(trigger, testResponse, assertable.config, context);
}
if (testErrorResponse !== undefined) {
context.logger.debug(`Invoking provided trigger for '${names.requestName}', and testing a response that is expected to fail`);
return invokeFailingTrigger(trigger, testErrorResponse, assertable.config, context);
}
}
if (triggerAndTests !== undefined) {
const triggerName = `${names.requestName}::${names.responseName}`;
const fun = triggerAndTests[triggerName];
context.logger.deepMaintainerDebug(`Trigger ${fun ? 'exists' : 'undefined'} for '${triggerName}'`);
if (fun !== undefined) {
context.logger.debug(`Invoking provided trigger for '${names.requestName}', and verification for a successful '${names.responseName}'`);
context.logger.maintainerDebug(`Trigger is from triggersAndTests`);
return invokeTrigger(fun, () => { }, assertable.config, context);
}
}
if (triggers !== undefined) {
const req = triggers[names.requestName];
if (req !== undefined) {
context.logger.maintainerDebug('Was provided the request trigger; now finding the result trigger');
const res = req.testResponses?.[names.responseName];
if (res !== undefined) {
context.logger.debug(`Invoking provided trigger for '${names.requestName}', and verification for a successful '${names.responseName}'`);
return invokeTrigger(req.trigger, res, assertable.config, context);
}
const errRes = req.testErrorResponses?.[names.responseName];
if (errRes !== undefined) {
context.logger.debug(`Invoking provided trigger for '${names.requestName}', and verification for an error '${names.responseName}'`);
return invokeFailingTrigger(req.trigger, errRes, assertable.config, context);
}
context.logger.error(`No verifier or errorVerifier for '${names.responseName}' provided`);
throw new case_plugin_base_1.CaseConfigurationError(`No verifier or errorVerifier provided for response:\n ${names.responseName}`, context);
}
if (triggerAndTests !== undefined) {
const possibleNames = Object.keys(triggerAndTests).filter((s) => s.startsWith(`${names.requestName}::`));
if (possibleNames.length > 0) {
context.logger.error('');
}
context.logger.error(`No response handler for '${names.responseName}' provided. The request '${names.requestName}' is present`);
throw new case_plugin_base_1.CaseConfigurationError(`No response handler provided for response:\n ${names.responseName}`, context);
}
context.logger.error(`No trigger for request '${names.requestName}' provided`);
throw new case_plugin_base_1.CaseConfigurationError(`No trigger provided for request:\n ${names.requestName}`, context);
}
if (triggerAndTests !== undefined) {
const allFunctions = Object.keys(triggerAndTests);
const startsWith = allFunctions.filter((s) => s.startsWith(`${names.requestName}::`));
if (startsWith.length > 0) {
throw new case_plugin_base_1.CaseConfigurationError(`The trigger configuration for\n ${names.requestName}\n is missing a test for\n ${names.responseName}\n However, the following response tests exist:\n${startsWith
.map((s) => ` ${s.split('::')[1]}`)
.join('\n')}`, context, 'UNDOCUMENTED');
}
const endsWith = allFunctions.filter((s) => s.endsWith(`::${names.responseName}`));
if (endsWith.length > 0) {
throw new case_plugin_base_1.CaseConfigurationError(`Missing a trigger pair for request:\n ${names.requestName}\n with a response test for response:\n ${names.responseName}\n However, tests for that response name do exist in the following configurations:\n${endsWith
.map((s) => ` ${s.split('::')[0]}`)
.join('\n')}`, context, 'UNDOCUMENTED');
}
throw new case_plugin_base_1.CaseConfigurationError(`Missing a trigger for:\n ${names.requestName}\n this should be paired with a test for:\n ${names.responseName}`, context, 'UNDOCUMENTED');
}
throw new case_plugin_base_1.CaseConfigurationError(`No trigger or trigger map provided for:\n ${names.requestName}\n You must set a trigger or a trigger map`, context);
});
exports.findAndCallTrigger = findAndCallTrigger;
//# sourceMappingURL=triggers.js.map