@case-contract-testing/case/dist/src/core/WritingCaseContract.js

Next-generation contract testing suite

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.WritingCaseContract = void 0;
const async_mutex_1 = require("async-mutex");
const entities_1 = require("../entities");
const context_1 = require("../entities/context");
const contract_1 = require("../entities/contract");
const results_1 = require("../entities/results");
const types_1 = require("../entities/types");
const BaseCaseContract_1 = require("./BaseCaseContract");
const structure_1 = require("./structure");
const config_1 = require("./config");
const executeExample_1 = require("./executeExample");
class WritingCaseContract extends BaseCaseContract_1.BaseCaseContract {
    testIndex = 0;
    mutex;
    dependencies;
    constructor(description, dependencies, config) {
        super(description, config, dependencies.defaultConfig, dependencies.resultPrinter, dependencies.makeLogger);
        this.mutex = new async_mutex_1.Mutex();
        this.dependencies = dependencies;
    }
    executeTest({ states = [], mockDescription, trigger, testResponse, triggers, testErrorResponse, stateHandlers = {}, }, runConfig) {
        const thisIndex = this.testIndex;
        this.testIndex += 1;
        const runContext = (0, context_1.applyNodeToContext)(mockDescription, this.initialContext, {
            'case:currentRun:context:throwOnFail': true,
            'case:currentRun:context:contractMode': 'write',
            'case:currentRun:context:testName': `${thisIndex}`,
            ...(0, config_1.configToRunContext)(runConfig),
        });
        if (runContext['case:currentRun:context:contractMode'] !== 'write') {
            runContext.logger.warn(`The contractMode is expected to be 'write', but it was '${runContext['case:currentRun:context:contractMode']}'. If you are not expecting this message, this is almost certainly a misconfiguration`);
        }
        return this.mutex.runExclusive(() => {
            states.forEach((state) => {
                if (state['case:state:type'] === types_1.SETUP_VARIABLE_STATE) {
                    Object.entries(state.variables).forEach(([key, value]) => runContext.addDefaultVariable(key, state.stateName, value));
                }
            });
            const example = {
                states,
                mock: (0, contract_1.nameMock)(mockDescription, runContext),
                result: 'PENDING',
            };
            return (0, executeExample_1.executeExample)(example, {
                stateHandlers,
                trigger,
                triggers,
                testResponse,
                testErrorResponse,
                names: (0, contract_1.exampleToNames)(example, `${this.testIndex}`),
            }, this, runContext);
        });
    }
    recordExample(example, currentContext) {
        if (!this.currentContract) {
            currentContext.logger.error('recordSuccess was called without initialising the contract file. This should not be possible.');
            throw new entities_1.CaseCoreError('Contract was not initialised at the time that recordSuccess was called');
        }
        if (example.result === 'PENDING') {
            throw new entities_1.CaseCoreError('Trying to record a pending example. This should never happen.');
        }
        this.currentContract = (0, structure_1.addExample)(this.currentContract, example, currentContext);
        return example;
    }
    async endRecord() {
        const writingContext = (0, context_1.addLocation)('WritingContract', this.initialContext);
        if ((0, structure_1.hasFailure)(this.currentContract)) {
            // TODO: Print all failures
            throw new entities_1.CaseFailedAssertionError((0, results_1.makeResults)({
                type: types_1.ERROR_TYPE_EXECUTION,
                message: 'There were contract failures',
                code: 'FAIL',
                location: ['Writing Contract'],
                toString: () => 'There were contract failures',
            }));
        }
        //  - if success, write contract
        const fileName = this.dependencies.writeContract(this.currentContract, writingContext);
        writingContext.logger.debug(`Wrote contract file: ${fileName}`);
        if (!this.initialContext['case:currentRun:context:brokerCiAccessToken']) {
            this.initialContext.logger.warn('Not publishing a contract, as there is no brokerCiAccessToken set');
            return;
        }
        await this.dependencies
            .makeBrokerService(writingContext)
            .publishContract(this.currentContract, (0, context_1.addLocation)('PublishingContract', this.initialContext));
    }
}
exports.WritingCaseContract = WritingCaseContract;