@reportfy/tester/helpers/parseBody.js

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

/**
 * @function
 * @param ob
 * @returns {{}}
 */
const flattenObject = (ob) => {
    const result = {}
    for (const i in ob) {
        if ((typeof ob[i]) === 'object') {
            const temp = flattenObject(ob[i])
            for (const j in temp) {
                result[i + '.' + j] = temp[j]
            }
        } else result[i] = ob[i]
    }
    return result
}

/**
 * @function
 * @param obj
 * @param keyValue
 * @returns {string}
 */
const getElementByKey = (obj, keyValue) => {
    let valueReturn = ''
    const flatOb = flattenObject(obj)
    if (flatOb[keyValue] !== undefined) valueReturn = flatOb[keyValue]
    return valueReturn
}

/**
 * @function
 * @param obj
 * @param keyValue
 * @param newValue
 * @returns {any}
 */
const objectNewSetValue = (obj, keyValue, newValue) =>
    JSON.parse(
        JSON.stringify(obj, (key, value) => {
            if (value === keyValue) return newValue
            return value
        })
    )

/**
 * @function
 * @param element
 * @param arrayResponse
 * @param keys
 * @returns {*}
 */
exports.replacementBody = (element, arrayResponse, keys) => {
    if (!keys || !Array.isArray(keys) || keys.length === 0) return element.body

    for (let i = 0; i < arrayResponse.length; i++) {
        const elementResponse = arrayResponse[i].bodyResponse
        if (elementResponse === undefined) continue
        const validate = element.rules.keys.filter(val => Number(val.step) === i)

        if (validate.length) {
            for (const validateElement of validate) {
                const value = getElementByKey(elementResponse, validateElement.key)
                element.body = objectNewSetValue(element.body || {}, validateElement.alias, value)
            }
        }
    }

    return element.body
}

/**
 * @function
 * @param element
 * @param arrayResponse
 * @param keys
 * @returns {*}
 */
exports.replacementQuery = (element, arrayResponse, keys) => {
    if (!keys || !Array.isArray(keys) || keys.length === 0) return element.query

    for (let i = 0; i < arrayResponse.length; i++) {
        const elementResponse = arrayResponse[i].bodyResponse
        if (elementResponse === undefined) continue
        const validate = element.rules.keys.filter(val => Number(val.step) === i)

        if (validate.length) {
            for (const validateElement of validate) {
                const value = getElementByKey(elementResponse, validateElement.key)
                element.query = objectNewSetValue(element.query || {}, validateElement.alias, value)
            }
        }
    }
    return element.query
}

/**
 * @function
 * @param element
 * @param arrayResponse
 * @param keys
 * @returns {*}
 */
exports.replacementPath = (element, arrayResponse, keys) => {
    if (!keys || !Array.isArray(keys) || keys.length === 0) return element.path

    for (let i = 0; i < arrayResponse.length; i++) {
        const elementResponse = arrayResponse[i].bodyResponse
        if (elementResponse === undefined) continue
        const validate = element.rules.keys.filter(val => Number(val.step) === i)

        if (validate.length) {
            for (const validateElement of validate) {
                const value = getElementByKey(elementResponse, validateElement.key)
                element.path = element.path.replace(`${validateElement.alias}`, value)
            }
        }
    }
    return element.path
}

/**
 * @function
 * @param element
 * @param arrayResponse
 * @param keys
 * @returns {*}
 */
exports.replaceHeaders = (element, arrayResponse, keys) => {
    if (!keys || !Array.isArray(keys) || keys.length === 0) return element.header

    for (let i = 0; i < arrayResponse.length; i++) {
        const elementResponse = arrayResponse[i].bodyResponse
        if (elementResponse === undefined) continue
        const validate = element.rules.keys.filter(val => Number(val.step) === i)

        if (validate.length) {
            for (const validateElement of validate) {
                const value = getElementByKey(elementResponse, validateElement.key)
                element.header = objectNewSetValue(element.header || {}, validateElement.alias, value)
            }
        }
    }
    return element.headers || {}
}

const replacementHeaderAuthenticate = (element, arrayResponse, options) => {
    for (let i = 0; i < arrayResponse.length; i++) {
        const elementResponse = arrayResponse[i].bodyResponse
        if (elementResponse === undefined) continue
        const validate = element.rules.keys.filter(val => Number(val.step) === i)

        if (validate.length) {
            for (const validateElement of validate) {
                const value = getElementByKey(elementResponse, validateElement.key)

                if (options && element.authenticate.value.token) {
                    element.authenticate = { value: element.authenticate.value.token.replace(`${validateElement.alias}`, value) }
                } else if (!element.authenticate.value) {
                    element.authenticate.value.username = element.authenticate.value.username.replace(`${validateElement.alias}`, value)
                    element.authenticate.value.password = element.authenticate.value.password.replace(`${validateElement.alias}`, value)
                }
            }
        }
    }
    return element.authenticate
}

const generatePasswordBase64 = ({ username, password }) => new Buffer.from(username + ':' + password).toString('base64')

/**
 * @function
 * @param authenticate
 * @param headers
 * @returns {(*&{Authorization})|*}
 */
exports.replaceAuthenticate = (element, arrayResponse) => {
    switch (element.authenticate.type.toLowerCase()) {
        case 'bearer':
            return { ...element.header, authorization: `Bearer ${replacementHeaderAuthenticate(element, arrayResponse, true).value}` }
        case 'basic':
            return { ...element.header, authorization: `Basic ${generatePasswordBase64(replacementHeaderAuthenticate(element, arrayResponse, false))}` }
        default:
            return element.header
    }
}

/**
 * @function
 * @param query
 * @param path
 * @returns {string}
 */
exports.replacementQueryToPath = (query, path) =>
    Object.keys(query).length > 0
        ? `${path}?${Object.entries(query).map(e => e.join('=')).join('&')}`
        : `${path}`