cumulocity-cypress/shared/c8ypact/c8ydefaultpactrecord.js

Cypress commands for Cumulocity IoT

import { isAuthOptions, isPactAuthObject, toPactAuthObject, } from "../auth";
import { toPactRequest, toPactResponse, } from "./c8ypact";
import { get_i } from "../util";
import { isAbsoluteURL } from "./url";
import _ from "lodash";
/**
 * Default implementation of C8yPactRecord. Use C8yDefaultPactRecord.from to create
 * a C8yPactRecord from a Cypress.Response object or an C8yPactRecord object.
 */
export class C8yDefaultPactRecord {
    constructor(request, response, options, auth, createdObject, modifiedResponse) {
        this.request = request;
        this.response = response;
        if (options)
            this.options = options;
        if (auth)
            this.auth = auth;
        if (createdObject)
            this.createdObject = createdObject;
        if (modifiedResponse)
            this.modifiedResponse = modifiedResponse;
        if (request?.method?.toLowerCase() === "post") {
            const newId = response.body?.id;
            if (newId) {
                this.createdObject = newId;
            }
            else {
                const location = get_i(response, "headers.location");
                if (isAbsoluteURL(location)) {
                    try {
                        const url = new URL(location);
                        const pathSegments = url.pathname.split("/").filter(Boolean);
                        this.createdObject = pathSegments.pop();
                    }
                    catch {
                        // do nothing
                    }
                }
            }
        }
    }
    /**
     * Creates a C8yPactRecord from a Cypress.Response or an C8yPactRecord object.
     * @param obj The Cypress.Response<any> or C8yPactRecord object.
     * @param client The C8yClient for options and auth information.
     */
    static from(obj, auth, client) {
        // if (obj == null) return obj;
        if ("request" in obj && "response" in obj) {
            return new C8yDefaultPactRecord(_.get(obj, "request"), _.get(obj, "response"), _.get(obj, "options") || {}, _.get(obj, "auth"), _.get(obj, "createdObject"), _.get(obj, "modifiedResponse"));
        }
        const r = _.cloneDeep(obj);
        return new C8yDefaultPactRecord(toPactRequest(r) || {}, toPactResponse(r) || {}, client?._options, isAuthOptions(auth) || isPactAuthObject(auth)
            ? toPactAuthObject(auth)
            : client?._auth
                ? toPactAuthObject(client?._auth)
                : undefined);
    }
    /**
     * Returns the date of the response.
     */
    date() {
        const date = _.get(this.response, "headers.date");
        if ((date && _.isString(date)) || _.isNumber(date) || _.isDate(date)) {
            const result = new Date(date);
            if (!isNaN(result.getTime())) {
                return result;
            }
        }
        return null;
    }
    /**
     * Converts the C8yPactRecord to a Cypress.Response object.
     */
    toCypressResponse() {
        const result = _.cloneDeep(this.response);
        _.extend(result, {
            ...(result.status && {
                isOkStatusCode: result.status > 199 && result.status < 300,
            }),
            ...(this.request.headers && {
                requestHeaders: Object.fromEntries(Object.entries(this.request.headers || [])),
            }),
            ...(this.request.url && { url: this.request.url }),
            ...(result.allRequestResponses && { allRequestResponses: [] }),
            ...(this.request.body && { requestBody: this.request.body }),
            method: this.request.method || this.response.method || "GET",
        });
        return result;
    }
    hasRequestHeader(key) {
        return Object.keys(this.request.headers ?? {})
            .map((k) => k.toLowerCase())
            .includes(key?.toLowerCase());
    }
    authType() {
        const type = this.auth?.type;
        if (type === "BasicAuth" || type === "CookieAuth") {
            return type;
        }
        if (this.hasRequestHeader("x-xsrf-token")) {
            return "CookieAuth";
        }
        if (this.hasRequestHeader("authorization")) {
            return "BasicAuth";
        }
        return undefined;
    }
}
export function createPactRecord(response, client, options = {}) {
    let auth = undefined;
    const envUser = options.loggedInUser;
    const envAlias = options.loggedInUserAlias;
    const envType = options.authType;
    const envAuth = {
        ...(envUser && { user: envUser }),
        ...(envAlias && { userAlias: envAlias }),
        ...(envAlias && { type: envType ?? "CookieAuth" }),
    };
    if (client?._auth) {
        // do not pick the password. passwords must not be stored in the pact.
        auth = _.defaultsDeep(client._auth, envAuth);
        if (client._auth.constructor != null) {
            if (!auth) {
                auth = { type: client._auth.constructor.name };
            }
            else {
                auth.type = client._auth.constructor.name;
            }
        }
    }
    if (!auth && (envUser || envAlias)) {
        auth = envAuth;
    }
    // only store properties that need to be exposed. do not store password.
    auth = auth ? toPactAuthObject(auth) : auth;
    return C8yDefaultPactRecord.from(response, auth, client);
}