@reportfy/tester/rules/mountedRequest.js

Lib para teste de integração usando serviço do reportfy

const path = require('path')
const request = require("supertest");
const qs = require('qs')
const { getPassed } = require('../helpers/equalTest')


exports.getParamsServer = (server, option) => {
    switch (option.toLowerCase()) {
        case 'express':
        case 'restify':
            return instanceHttpExpress(server)
        case 'hapijs':
            return instanceHttpHapiJS(server)
        case 'koa':
            return instanceHttpKoaJS(server)
        default:
            throw new Error('Configuração do server invalida!')
    }
}


const instanceHttpKoaJS = (server) => {
    try {
        const url = path.join(process.cwd(), server)
        const app = require(url)
        return request(app.listen())
    } catch (error) {
        throw new Error('Configuração do server invalida!')
    }
}

const instanceHttpHapiJS = (server) => {
    try {
        const url = path.join(process.cwd(), server)
        const app = require(url)
        return request(app.listener)
    } catch (error) {
        throw new Error('Configuração do server invalida!')
    }
}


/**
 * @function
 * @param server
 * @returns {Test}
 */
const instanceHttpExpress = (server) => {
    try {
        const url = path.join(process.cwd(), server)
        const app = require(url)
        return request(app)
    } catch (error) {
        throw new Error('Configuração do server invalida!')
    }
}

/**
 * @function
 * @param method
 * @returns {string}
 */
const getMethod = (method) => {
    if (method.toLowerCase() === 'delete') return 'del'
    return method.toLowerCase()
}

/**
 * @function
 * @param err
 * @returns {{bodyResponse: {}, passed: {responseStatusCode: number, responseBody: {}, passedBody: null}}}
 */
const getThrowErrorRequest = (err) => {
    if(err.message.indexOf('ECONNREFUSED') >= 0) {
        return {
            passed: { passedBody: false, passedStatusCode: false, responseStatusCode: 501, responseBody: {} },
            bodyResponse: {}
        }
    }
    throw new Error('Configuração do server invalida!')
}

/**
 * @function
 * @param path
 * @param statusCode
 * @param headers
 * @param body
 * @param rules
 * @param method
 * @param instance
 * @returns {Promise<{bodyResponse: {}, passed: {responseStatusCode: number, responseBody: {}, passedBody: null}}>}
 */
const requestNoBody = async ({ path, statusCode, header, body, rules, method }, instance) => {
    try {
        const response = await instance[getMethod(method)](path).set({...header})
        const passed = getPassed({ rules, body, response, statusCode })
        return { passed, bodyResponse: response.body  }
    } catch (err) {
        return getThrowErrorRequest(err, body)
    }
}




const getContentType = (key, body) => {
    switch (key.toLowerCase()) {
        case 'application/x-www-form-urlencoded':
            return qs.stringify(body);
        case 'application/json':
        default:
            return body
    }
}

const switchHeaderContent = (header, body) => {
    for (let [key, value] of Object.keys(header)) {
        if (key.toLowerCase() === 'content-type')
            body = getContentType(value, body)
    }
    return body
}

/**
 * @function
 * @param path
 * @param statusCode
 * @param headers
 * @param body
 * @param rules
 * @param method
 * @param instance
 * @returns {Promise<{bodyResponse: {}, passed: {responseStatusCode: number, responseBody: {}, passedBody: null}}>}
 */
const requestBody = async ({ path, statusCode, header, body, rules, method }, instance) => {
    try {
        const response = await instance[getMethod(method)](path).set(header).send(switchHeaderContent(header, body))
        const passed = getPassed({ rules, response, statusCode })
        return { passed, bodyResponse: response.body }
    } catch (err) {
        return getThrowErrorRequest(err)
    }
}

/**
 * @function
 * @param config
 * @param instance
 * @returns {null|Promise<{bodyResponse: *, passed: {responseStatusCode: *, responseBody: *, passedBody: (*|boolean), passedStatusCode: boolean}}>}
 */
exports.execTestAndMethod = (config, instance) => {
    switch (config.method.toLowerCase()) {
        case 'get':
        case 'delete':
            return requestNoBody(config, instance)
        case 'post':
        case 'patch':
        case 'put':
            return requestBody(config, instance)
    }
    return null
}

/**
 * @function
 * @param array
 * @returns {*}
 */
const mountedRequest = (array) => array.map(element => ({
    path: element.path,
    method: element.method,
    query: element.query,
    header: element.header,
    body: element.body || {},
    bodyResponse: element.bodyResponse || {},
    statusCode: element.statusCode,
    report: element.report,
    ConfigIntegrationId: element.id,
    passedBody: element.passedBody,
    name: element.name,
    rules: { ...element.rules, ...element.report },
    ...element.report
}))


/**
 * @function
 * @param objectGetConfig
 * @param env
 * @returns {{reportConfig: {[p: string]: *}, reportIntegrations}}
 */
exports.mountedSenderReport = (objectGetConfig, url, environment, passed) => ({
    reportConfig: {
        ConfigTesterId: objectGetConfig.id,
        environment: environment,
        url: url,
        passed: passed
    },
    reportIntegrations: mountedRequest(objectGetConfig.ConfigIntegrations)
})