import * as chai from 'chai'; import * as chaiAsPromised from 'chai-as-promised'; import * as dirtyChai from 'dirty-chai'; import * as _ from 'lodash'; import 'make-promises-safe'; import 'mocha'; import { NewmanRunExecution, NewmanRunExecutionAssertion, NewmanRunExecutionAssertionError, NewmanRunSummary, } from 'newman'; import * as nock from 'nock'; import * as sraReportCollectionJSON from '../../postman_collections/sra_report.postman_collection.json'; import { utils } from '../src/utils'; import * as postmanEnvironmentJSON from './environments/postman_environment.json'; chai.config.includeStack = true; chai.use(dirtyChai); chai.use(chaiAsPromised); const expect = chai.expect; const CONTENT_TYPE_ASSERTION_NAME = 'Has Content-Type header with value application/json'; const SCHEMA_ASSERTION_NAME = 'Schema is valid'; const SUCCESS_STATUS = 200; const baseNewmanRunOptions = { collection: sraReportCollectionJSON, environment: postmanEnvironmentJSON, reporter: { cli: { noConsole: true, }, }, }; export const testRunner = { runContentTypeTests( nockInterceptor: nock.Interceptor, postmanCollectionFolderName: string, postmanCollectionRequestName: string, ): void { const newmanRunOptions = { ...baseNewmanRunOptions, folder: postmanCollectionFolderName, }; describe(CONTENT_TYPE_ASSERTION_NAME, () => { it('fails when there are no headers', async () => { nockInterceptor.reply(SUCCESS_STATUS, {}); const summary = await utils.newmanRunAsync(newmanRunOptions); const error = findAssertionErrorIfExists( summary, postmanCollectionRequestName, CONTENT_TYPE_ASSERTION_NAME, ); const errorMessage = _.get(error, 'message'); expect(error).to.not.be.undefined(); expect(errorMessage).to.equal(`expected response to have header with key 'Content-Type'`); }); it('fails when Content-Type header exists but not with value application/json', async () => { const headers = { 'Content-Type': 'text/html', }; nockInterceptor.reply(SUCCESS_STATUS, {}, headers); const summary = await utils.newmanRunAsync(newmanRunOptions); const error = findAssertionErrorIfExists( summary, postmanCollectionRequestName, CONTENT_TYPE_ASSERTION_NAME, ); const errorMessage = _.get(error, 'message'); expect(error).to.not.be.undefined(); expect(errorMessage).to.equal(`expected 'text/html' to include 'application/json'`); }); it('passes when Content-Type header exists with value application/json', async () => { const headers = { 'Content-Type': 'charset=utf-8; application/json', }; nockInterceptor.reply(SUCCESS_STATUS, {}, headers); const summary = await utils.newmanRunAsync(newmanRunOptions); const error = findAssertionErrorIfExists( summary, postmanCollectionRequestName, CONTENT_TYPE_ASSERTION_NAME, ); expect(error).to.be.undefined(); }); }); }, runSchemaTests( nockInterceptor: nock.Interceptor, postmanCollectionFolderName: string, postmanCollectionRequestName: string, malformedJson: object, correctJson: object, ): void { const newmanRunOptions = { ...baseNewmanRunOptions, folder: postmanCollectionFolderName, }; describe(SCHEMA_ASSERTION_NAME, () => { it('fails when schema is invalid', async () => { nockInterceptor.reply(SUCCESS_STATUS, malformedJson); const summary = await utils.newmanRunAsync(newmanRunOptions); const error = findAssertionErrorIfExists(summary, postmanCollectionRequestName, SCHEMA_ASSERTION_NAME); const errorMessage = _.get(error, 'message'); expect(error).to.not.be.undefined(); expect(errorMessage).to.equal('expected false to be true'); }); it('passes when schema is valid', async () => { nockInterceptor.reply(SUCCESS_STATUS, correctJson); const summary = await utils.newmanRunAsync(newmanRunOptions); const error = findAssertionErrorIfExists(summary, postmanCollectionRequestName, SCHEMA_ASSERTION_NAME); expect(error).to.be.undefined(); }); }); }, }; function findAssertionErrorIfExists( summary: NewmanRunSummary, postmanCollectionRequestName: string, postmanCollectionAssertionName: string, ): NewmanRunExecutionAssertionError | undefined { const matchingExecutionIfExists = _.find(summary.run.executions, (execution: NewmanRunExecution) => { return execution.item.name === postmanCollectionRequestName; }); if (_.isUndefined(matchingExecutionIfExists)) { return undefined; } const matchingAssertionIfExists = _.find( matchingExecutionIfExists.assertions, (assertion: NewmanRunExecutionAssertion) => { return assertion.assertion === postmanCollectionAssertionName; }, ); if (_.isUndefined(matchingAssertionIfExists)) { return undefined; } else { const error = matchingAssertionIfExists.error; return error; } }