@reportfy/tester/helpers/equalTest.js

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

/**
 * @function
 * @param x
 * @param y
 * @returns {boolean|this is string[]|boolean}
 */
const objectEqual = (x, y) => {
    if (x === null || x === undefined || y === null || y === undefined) { return x === y }

    if (x.constructor !== y.constructor) { return false }

    if (x instanceof Function) { return x === y }

    if (x instanceof RegExp) { return x === y }
    if (x === y || x.valueOf() === y.valueOf()) { return true }
    if (Array.isArray(x) && x.length !== y.length) { return false }

    if (x instanceof Date) { return false }

    if (!(x instanceof Object)) { return false }
    if (!(y instanceof Object)) { return false }
    const p = Object.keys(x)
    return Object.keys(y).every(function (i) { return p.indexOf(i) !== -1 }) &&
        p.every(function (i) { return objectEqual(x[i], y[i]) })
}

/**
 * @function
 * @param equalStatus
 * @param responseStatus
 * @returns {boolean}
 */
const getStatusEqual = (equalStatus, responseStatus) => Number(equalStatus) === Number(responseStatus)

/**
 * @function
 * @param equalBody
 * @param responseBody
 * @returns {*|boolean}
 */
const getBodyEqual = (equalBody, responseBody) => objectEqual(equalBody, responseBody)

/**
 * @function
 * @param rules
 * @param response
 * @param statusCode
 * @returns {{responseStatusCode: *, responseBody: *, passedBody: (*|boolean), passedStatusCode: boolean}}
 */
exports.getPassed = ({ rules, response, statusCode }) => {
    const passedStatusCode = getStatusEqual(statusCode, response.status)
    const passedBody = mountedRules(rules, rules.equal, response.data)
    return { passedBody, passedStatusCode, responseStatusCode: response.status, responseBody: response.data }
}

/**
 * @function
 * @param obj
 * @param keyValue
 * @returns {string}
 */
const getElementByKey = (obj, keyValue) => {
    let valueReturn = ''
    JSON.stringify(obj, (key, value) => {
        if (key === keyValue) valueReturn = value
        return value
    })

    return valueReturn
}
//
// /**
//  * @function
//  * @param obj
//  * @param keyValue
//  * @returns {string}
//  */
// const getElementByValue = (obj, keyValue) => {
//   let valueReturn = ''
//   JSON.stringify(obj, (key, value) => {
//     if (value === keyValue) valueReturn = value
//     return value
//   })
//
//   return valueReturn
// }

/**
 * @function
 * @param responseBody
 * @param keys
 * @returns {boolean|*}
 */
const getKeysContains = (responseBody, keys) =>
    !keys || !Array.isArray(keys) || keys.length === 0
        ? true
        : keys.every(val => getElementByKey(responseBody, val).length > 0)

// /**
//  * @function
//  * @param responseBody
//  * @param values
//  * @returns {boolean|*}
//  */
// const getValueContains = (responseBody, values) =>
//   !values || !Array.isArray(values) || values.length === 0
//     ? true
//     : values.every(val => getElementByValue(responseBody, val).length > 2)

/**
 * @function
 * @param responseBody
 * @param keys
 * @param values
 */
const getContains = (responseBody, keys, values) => {
    const validateKeys = getKeysContains(responseBody, values)
    // const validateValues = getValueContains(responseBody, values)
    // return validateKeys !== false && validateValues !== false
    return validateKeys !== false
}

/**
 * @function
 * @param rules
 * @param equalBody
 * @param responseBody
 * @returns {boolean|*}
 */
const mountedRules = (rules, equalBody, responseBody) => {
    switch (rules.options) {
        case 'equal':
            return getBodyEqual(equalBody, responseBody || {})
        case 'contain':
            return getContains(responseBody || {}, rules.keys || [], rules.values || [])
    }
    return true
}

/**
 * @function
 * @param passedStatusCode
 * @param passedBody
 * @returns {boolean}
 */
const isPassed = ({ passedStatusCode, passedBody }) => (passedStatusCode === true && passedBody === true)

/**
 * @function
 * @param passedStatusCode
 * @param passedBody
 * @returns {boolean}
 */
const isReproved = ({ passedStatusCode, passedBody }) => (passedStatusCode === false || passedBody === false)

/**
 * @function
 * @param array
 * @returns {{approved, reproved}}
 */
exports.listTestCase = (array) => ({
    approved: array.filter(({ report: { passedStatusCode, passedBody } }) => isPassed({ passedStatusCode, passedBody })),
    reproved: array.filter(({ report: { passedStatusCode, passedBody } }) => isReproved({ passedStatusCode, passedBody }))
})