testcafe 2.3.1 → 2.6.1

package/lib/native-automation/request-pipeline/index.js

@@ -0,0 +1,329 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const lodash_1 = require("lodash");
+const event_provider_1 = __importDefault(require("../request-hooks/event-provider"));
+const resource_injector_1 = __importDefault(require("../resource-injector"));
+const headers_1 = require("../utils/headers");
+const cdp_1 = require("../utils/cdp");
+const error_route_1 = __importDefault(require("../error-route"));
+const debug_loggers_1 = require("../../utils/debug-loggers");
+const testcafe_hammerhead_1 = require("testcafe-hammerhead");
+const special_handlers_1 = __importDefault(require("./special-handlers"));
+const safe_api_1 = require("./safe-api");
+const api_base_1 = __importDefault(require("../api-base"));
+const resendAuthRequest_1 = require("./resendAuthRequest");
+const test_run_bridge_1 = __importDefault(require("./test-run-bridge"));
+const context_info_1 = __importDefault(require("./context-info"));
+const errors_1 = require("../errors");
+const ALL_REQUEST_RESPONSES = { requestStage: 'Request' };
+const ALL_REQUEST_REQUESTS = { requestStage: 'Response' };
+const ALL_REQUESTS_DATA = [ALL_REQUEST_REQUESTS, ALL_REQUEST_RESPONSES];
+class NativeAutomationRequestPipeline extends api_base_1.default {
+    constructor(browserId, client, options) {
+        super(browserId, client, options);
+        this._testRunBridge = new test_run_bridge_1.default(browserId);
+        this._contextInfo = new context_info_1.default(this._testRunBridge);
+        this._specialServiceRoutes = this._getSpecialServiceRoutes();
+        this.requestHookEventProvider = new event_provider_1.default();
+        this._resourceInjector = new resource_injector_1.default(this._testRunBridge);
+        this._stopped = false;
+        this._currentFrameTree = null;
+        this._failedRequestIds = [];
+        this.restoringStorages = null;
+        this.contextStorage = null;
+        this._pendingCertificateError = null;
+        this._setOptionsForResourceInjector();
+    }
+    _setOptionsForResourceInjector() {
+        const options = this._createResourceInjectorOptions();
+        this._resourceInjector.setOptions(options);
+    }
+    _createResourceInjectorOptions() {
+        return {
+            specialServiceRoutes: this._specialServiceRoutes,
+            developmentMode: this.options.developmentMode,
+        };
+    }
+    _getSpecialServiceRoutes() {
+        const browserConnection = this._testRunBridge.getBrowserConnection();
+        const proxy = browserConnection.browserConnectionGateway.proxy;
+        return {
+            errorPage1: proxy.resolveRelativeServiceUrl(error_route_1.default, proxy.server1Info.domain),
+            errorPage2: proxy.resolveRelativeServiceUrl(error_route_1.default, proxy.server2Info.domain),
+            idlePage: browserConnection.idleUrl,
+            openFileProtocolUrl: browserConnection.openFileProtocolUrl,
+        };
+    }
+    async _handleMockErrorIfNecessary(pipelineContext, event) {
+        if (!pipelineContext.mock.hasError)
+            return;
+        await pipelineContext.handleMockError(this.requestHookEventProvider);
+        (0, debug_loggers_1.requestPipelineMockLogger)('%s\n%s', event.networkId, pipelineContext.mock.error);
+    }
+    async _handleMockResponse(mockedResponse, pipelineContext, event, sessionId) {
+        if (this._stopped)
+            return;
+        const mockedResponseBodyStr = mockedResponse.getBody().toString();
+        const fulfillInfo = {
+            requestId: event.requestId,
+            responseCode: mockedResponse.statusCode,
+            responseHeaders: (0, headers_1.convertToHeaderEntries)(mockedResponse.headers),
+            body: mockedResponseBodyStr,
+        };
+        if (pipelineContext.reqOpts.isAjax)
+            await this._resourceInjector.processNonProxiedContent(fulfillInfo, this._client, sessionId);
+        else {
+            await this._resourceInjector.processHTMLPageContent(fulfillInfo, {
+                isIframe: false,
+                contextStorage: this.contextStorage,
+            }, this._client, sessionId);
+        }
+        (0, debug_loggers_1.requestPipelineMockLogger)(`sent mocked response for the ${event.requestId}`);
+    }
+    _createContinueResponseRequest(event, modified) {
+        const continueResponseRequest = {
+            requestId: event.requestId,
+        };
+        if (modified) {
+            continueResponseRequest.responseHeaders = event.responseHeaders;
+            continueResponseRequest.responseCode = event.responseStatusCode;
+        }
+        return continueResponseRequest;
+    }
+    _shouldRedirectToErrorPage(event) {
+        return event.resourceType === 'Document'
+            && !this._isIframe(event.frameId);
+    }
+    async _getUserScripts(event) {
+        const { pipelineContext, eventFactory } = this._contextInfo.getContextData(event);
+        await pipelineContext.prepareInjectableUserScripts(eventFactory, this._testRunBridge.getUserScripts());
+        return pipelineContext.injectableUserScripts;
+    }
+    async _respondToOtherRequest(event, sessionId) {
+        if ((0, testcafe_hammerhead_1.isRedirectStatusCode)(event.responseStatusCode)) {
+            await (0, safe_api_1.safeContinueResponse)(this._client, { requestId: event.requestId }, sessionId);
+            return;
+        }
+        const resourceInfo = await this._resourceInjector.getDocumentResourceInfo(event, this._client);
+        if (resourceInfo.error) {
+            if (this._shouldRedirectToErrorPage(event)) {
+                await this._resourceInjector.redirectToErrorPage(this._client, resourceInfo.error, event.request.url);
+                this._contextInfo.dispose((0, cdp_1.getRequestId)(event));
+            }
+            return;
+        }
+        const modified = await this.requestHookEventProvider.onResponse(event, resourceInfo.body, this._contextInfo, this._client);
+        if (this._needInjectResources(event)) {
+            const fulfillInfo = {
+                requestId: event.requestId,
+                responseHeaders: event.responseHeaders,
+                responseCode: event.responseStatusCode,
+                body: resourceInfo.body.toString(),
+            };
+            // NOTE: Strange behavior of the CDP API:
+            // if we pass the empty "responseStatusText" value, we get an error 'Invalid status code or phrase'.
+            if (event.responseStatusText !== '')
+                fulfillInfo.responsePhrase = event.responseStatusText;
+            if ((0, cdp_1.isUnauthorized)(event.responseStatusCode))
+                await this._tryAuthorizeWithHttpBasicAuthCredentials(event, fulfillInfo);
+            const userScripts = await this._getUserScripts(event);
+            await this._resourceInjector.processHTMLPageContent(fulfillInfo, {
+                isIframe: this._isIframe(event.frameId),
+                url: event.request.url,
+                restoringStorages: this.restoringStorages,
+                contextStorage: this.contextStorage,
+                userScripts,
+            }, this._client, sessionId);
+            this._contextInfo.dispose((0, cdp_1.getRequestId)(event));
+            this.restoringStorages = null;
+        }
+        else {
+            const continueResponseRequest = this._createContinueResponseRequest(event, modified);
+            await (0, safe_api_1.safeContinueResponse)(this._client, continueResponseRequest, sessionId);
+            this._contextInfo.dispose((0, cdp_1.getRequestId)(event));
+        }
+    }
+    _needInjectResources(event) {
+        var _a, _b;
+        if (event.resourceType !== 'Document')
+            return false;
+        const contentType = (_b = (_a = event.responseHeaders) === null || _a === void 0 ? void 0 : _a.find(header => header.name.toLowerCase() === 'content-type')) === null || _b === void 0 ? void 0 : _b.value;
+        if (contentType)
+            return testcafe_hammerhead_1.contentTypeUtils.isPage(contentType);
+        return true;
+    }
+    async _tryAuthorizeWithHttpBasicAuthCredentials(event, fulfillInfo) {
+        const credentials = this._testRun.getAuthCredentials();
+        if (!credentials)
+            return;
+        const authRequest = await (0, resendAuthRequest_1.resendAuthRequest)(event.request, credentials);
+        if (typeof authRequest !== 'string' && !(0, cdp_1.isUnauthorized)(authRequest.status)) {
+            fulfillInfo.responseCode = authRequest.status;
+            fulfillInfo.body = authRequest.body.toString();
+            fulfillInfo.responsePhrase = authRequest.statusText;
+        }
+    }
+    _createError(event) {
+        if (this._pendingCertificateError)
+            return (0, errors_1.sslCertificateError)(this._pendingCertificateError.errorType);
+        if (event.responseErrorReason === 'NameNotResolved')
+            return (0, errors_1.failedToFindDNSError)(event.request.url);
+        return new Error(event.responseErrorReason);
+    }
+    async _tryRespondToOtherRequest(event, sessionId) {
+        try {
+            if (event.responseErrorReason && this._shouldRedirectToErrorPage(event)) {
+                const error = this._createError(event);
+                await this._resourceInjector.redirectToErrorPage(this._client, error, event.request.url);
+            }
+            else
+                await this._respondToOtherRequest(event, sessionId);
+        }
+        catch (err) {
+            if (event.networkId && this._failedRequestIds.includes(event.networkId)) {
+                (0, lodash_1.remove)(this._failedRequestIds, event.networkId);
+                return;
+            }
+            throw err;
+        }
+    }
+    async _handleOtherRequests(event, sessionId) {
+        (0, debug_loggers_1.requestPipelineOtherRequestLogger)('%r', event);
+        if (!event.responseErrorReason && ((0, cdp_1.isRequest)(event) || (0, testcafe_hammerhead_1.isRedirectStatusCode)(event.responseStatusCode))) {
+            this._contextInfo.init(event);
+            await this.requestHookEventProvider.onRequest(event, this._contextInfo);
+            const pipelineContext = this._contextInfo.getPipelineContext((0, cdp_1.getRequestId)(event));
+            if (!pipelineContext || !pipelineContext.mock)
+                await (0, safe_api_1.safeContinueRequest)(this._client, event, sessionId, this._createContinueEventArgs(event, pipelineContext.reqOpts));
+            else {
+                (0, debug_loggers_1.requestPipelineMockLogger)('begin mocking request %r', event);
+                const mockedResponse = await pipelineContext.getMockResponse();
+                await this._handleMockErrorIfNecessary(pipelineContext, event);
+                const mockedResponseEvent = (0, cdp_1.createRequestPausedEventForResponse)(mockedResponse, event);
+                await this.requestHookEventProvider.onResponse(mockedResponseEvent, mockedResponse.getBody(), this._contextInfo, this._client);
+                await this._handleMockResponse(mockedResponse, pipelineContext, event, sessionId);
+                this._contextInfo.dispose((0, cdp_1.getRequestId)(event));
+                (0, debug_loggers_1.requestPipelineMockLogger)('end mocking request %r', event);
+            }
+        }
+        else
+            await this._tryRespondToOtherRequest(event, sessionId);
+    }
+    _getUploadPostData(event) {
+        if (!event.request.postData)
+            return void 0;
+        const contentTypeHeader = event.request.headers['Content-Type'];
+        const postData = Buffer.from(event.request.postData, 'utf-8');
+        const bodyWithUploads = (0, testcafe_hammerhead_1.injectUpload)(contentTypeHeader, postData);
+        return bodyWithUploads ? bodyWithUploads.toString('base64') : void 0;
+    }
+    _topFrameNavigation(event) {
+        return event.type === 'Navigation'
+            && !event.frame.parentId;
+    }
+    async _updateCurrentFrameTree() {
+        // NOTE: Due to CDP restrictions (it hangs), we can't get the frame tree
+        // right before injecting service scripts.
+        // So, we are forced tracking frames tree.
+        const result = await this._client.Page.getFrameTree();
+        this._currentFrameTree = result.frameTree;
+    }
+    _isIframe(frameId) {
+        if (!this._currentFrameTree)
+            return false;
+        return this._currentFrameTree.frame.id !== frameId;
+    }
+    async start() {
+        // NOTE: We are forced to handle all requests and responses at once
+        // because CDP API does not allow specifying request filtering behavior for different handlers.
+        await this._client.Fetch.enable({
+            patterns: ALL_REQUESTS_DATA,
+        });
+        await this._client.Target.setAutoAttach({
+            autoAttach: true,
+            waitForDebuggerOnStart: true,
+            flatten: true,
+        });
+        // NOTE: We need to enable the Fetch domain for iframe targets
+        // to intercept some requests. We need to use the `sessionId` option
+        // in continueRequest/continueResponse/fulfillRequest methods
+        await this._client.Target.on('attachedToTarget', async (event) => {
+            // @ts-ignore
+            await this._client.Runtime.runIfWaitingForDebugger(event.sessionId);
+            if (event.targetInfo.type !== 'worker')
+                // @ts-ignore
+                await this._client.Fetch.enable({ patterns: ALL_REQUESTS_DATA }, event.sessionId);
+        });
+        // @ts-ignore
+        this._client.Fetch.on('requestPaused', async (event, sessionId) => {
+            if (this._stopped)
+                return;
+            const specialRequestHandler = (0, special_handlers_1.default)(event, this.options, this._specialServiceRoutes);
+            if (specialRequestHandler)
+                await specialRequestHandler(event, this._client, this.options, sessionId);
+            else
+                await this._handleOtherRequests(event, sessionId);
+        });
+        this._client.Page.on('frameNavigated', async (event) => {
+            (0, debug_loggers_1.requestPipelineLogger)('%f', event);
+            if (!this._topFrameNavigation(event)
+                || event.frame.url !== testcafe_hammerhead_1.SPECIAL_BLANK_PAGE)
+                return;
+            this._contextInfo.init(event);
+            const userScripts = await this._getUserScripts(event);
+            await this._resourceInjector.processAboutBlankPage(event, userScripts, this.contextStorage, this._client);
+            this._contextInfo.dispose((0, cdp_1.getRequestId)(event));
+        });
+        this._client.Page.on('frameStartedLoading', async () => {
+            await this._updateCurrentFrameTree();
+        });
+        this._client.Network.on('loadingFailed', async (event) => {
+            (0, debug_loggers_1.requestPipelineLogger)('%l', event);
+            this._failedRequestIds.push(event.requestId);
+            if (event.requestId)
+                this._contextInfo.dispose(event.requestId);
+        });
+        await this._client.Page.setBypassCSP({ enabled: true });
+        await this._client.Security.enable();
+        this._client.Security.on('certificateError', async (event) => {
+            this._pendingCertificateError = event;
+        });
+    }
+    stop() {
+        this._stopped = true;
+    }
+    async dispose() {
+        await this._client.Fetch.disable();
+    }
+    _createContinueEventArgs(event, reqOpts) {
+        const modifiedUrl = new URL(event.request.url);
+        const host = modifiedUrl.host;
+        let hostModified = false;
+        let portModified = false;
+        if (modifiedUrl.hostname !== reqOpts.hostname) {
+            modifiedUrl.hostname = reqOpts.hostname;
+            hostModified = true;
+        }
+        if (modifiedUrl.port !== reqOpts.port) {
+            modifiedUrl.port = reqOpts.port;
+            portModified = true;
+        }
+        if (host !== reqOpts.host) {
+            const { port, hostname } = new URL(reqOpts.protocol + '//' + reqOpts.host);
+            if (!hostModified)
+                modifiedUrl.hostname = hostname;
+            if (!portModified)
+                modifiedUrl.port = port;
+        }
+        const postData = this._getUploadPostData(event);
+        const url = modifiedUrl.toString() !== event.request.url ? modifiedUrl.toString() : void 0;
+        const method = reqOpts.method;
+        return { postData, url, method };
+    }
+}
+exports.default = NativeAutomationRequestPipeline;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/native-automation/request-pipeline/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { remove } from 'lodash';\nimport { ProtocolApi } from 'chrome-remote-interface';\nimport Protocol from 'devtools-protocol';\nimport RequestPausedEvent = Protocol.Fetch.RequestPausedEvent;\nimport FrameNavigatedEvent = Protocol.Page.FrameNavigatedEvent;\nimport LoadingFailedEvent = Protocol.Network.LoadingFailedEvent;\nimport ContinueResponseRequest = Protocol.Fetch.ContinueResponseRequest;\nimport FrameTree = Protocol.Page.FrameTree;\nimport FulfillRequestRequest = Protocol.Fetch.FulfillRequestRequest;\nimport RequestPattern = Protocol.Fetch.RequestPattern;\nimport CertificateErrorEvent = Protocol.Security.CertificateErrorEvent;\nimport NativeAutomationRequestHookEventProvider from '../request-hooks/event-provider';\nimport ResourceInjector, { ResourceInjectorOptions } from '../resource-injector';\nimport { convertToHeaderEntries } from '../utils/headers';\n\nimport {\n    createRequestPausedEventForResponse,\n    getRequestId,\n    isRequest,\n    isUnauthorized,\n} from '../utils/cdp';\n\nimport ERROR_ROUTE from '../error-route';\n\nimport {\n    ContinueRequestArgs,\n    SessionId,\n    SessionStorageInfo,\n    SpecialServiceRoutes,\n} from '../types';\n\nimport {\n    requestPipelineLogger,\n    requestPipelineMockLogger,\n    requestPipelineOtherRequestLogger,\n} from '../../utils/debug-loggers';\n\nimport {\n    IncomingMessageLike,\n    isRedirectStatusCode,\n    SPECIAL_BLANK_PAGE,\n    StoragesSnapshot,\n    injectUpload,\n    contentTypeUtils,\n} from 'testcafe-hammerhead';\n\nimport NativeAutomationPipelineContext from '../request-hooks/pipeline-context';\nimport { NativeAutomationInitOptions } from '../../shared/types';\nimport getSpecialRequestHandler from './special-handlers';\nimport { safeContinueRequest, safeContinueResponse } from './safe-api';\nimport NativeAutomationApiBase from '../api-base';\nimport { resendAuthRequest } from './resendAuthRequest';\nimport TestRunBridge from './test-run-bridge';\nimport NativeAutomationRequestContextInfo from './context-info';\nimport { failedToFindDNSError, sslCertificateError } from '../errors';\n\n\nconst ALL_REQUEST_RESPONSES = { requestStage: 'Request' } as RequestPattern;\nconst ALL_REQUEST_REQUESTS  = { requestStage: 'Response' } as RequestPattern;\n\nconst ALL_REQUESTS_DATA = [ALL_REQUEST_REQUESTS, ALL_REQUEST_RESPONSES];\n\nexport default class NativeAutomationRequestPipeline extends NativeAutomationApiBase {\n    private readonly _testRunBridge: TestRunBridge;\n    private readonly _contextInfo: NativeAutomationRequestContextInfo;\n    public readonly requestHookEventProvider: NativeAutomationRequestHookEventProvider;\n    public restoringStorages: StoragesSnapshot | null;\n    public contextStorage: SessionStorageInfo | null;\n    private readonly _resourceInjector: ResourceInjector;\n    private readonly _specialServiceRoutes: SpecialServiceRoutes;\n    private _stopped: boolean;\n    private _currentFrameTree: FrameTree | null;\n    private readonly _failedRequestIds: string[];\n    private _pendingCertificateError: CertificateErrorEvent | null;\n\n    public constructor (browserId: string, client: ProtocolApi, options: NativeAutomationInitOptions) {\n        super(browserId, client, options);\n\n        this._testRunBridge           = new TestRunBridge(browserId);\n        this._contextInfo             = new NativeAutomationRequestContextInfo(this._testRunBridge);\n        this._specialServiceRoutes    = this._getSpecialServiceRoutes();\n        this.requestHookEventProvider = new NativeAutomationRequestHookEventProvider();\n        this._resourceInjector        = new ResourceInjector(this._testRunBridge);\n        this._stopped                 = false;\n        this._currentFrameTree        = null;\n        this._failedRequestIds        = [];\n        this.restoringStorages        = null;\n        this.contextStorage           = null;\n        this._pendingCertificateError = null;\n\n        this._setOptionsForResourceInjector();\n    }\n\n    private _setOptionsForResourceInjector (): void {\n        const options = this._createResourceInjectorOptions();\n\n        this._resourceInjector.setOptions(options);\n    }\n\n    private _createResourceInjectorOptions (): ResourceInjectorOptions {\n        return {\n            specialServiceRoutes: this._specialServiceRoutes,\n            developmentMode:      this.options.developmentMode,\n        };\n    }\n\n    private _getSpecialServiceRoutes (): SpecialServiceRoutes {\n        const browserConnection = this._testRunBridge.getBrowserConnection();\n        const proxy             = browserConnection.browserConnectionGateway.proxy;\n\n        return {\n            errorPage1:          proxy.resolveRelativeServiceUrl(ERROR_ROUTE, proxy.server1Info.domain),\n            errorPage2:          proxy.resolveRelativeServiceUrl(ERROR_ROUTE, proxy.server2Info.domain),\n            idlePage:            browserConnection.idleUrl,\n            openFileProtocolUrl: browserConnection.openFileProtocolUrl,\n        };\n    }\n\n    private async _handleMockErrorIfNecessary (pipelineContext: NativeAutomationPipelineContext, event: RequestPausedEvent): Promise<void> {\n        if (!pipelineContext.mock.hasError)\n            return;\n\n        await pipelineContext.handleMockError(this.requestHookEventProvider);\n\n        requestPipelineMockLogger('%s\\n%s', event.networkId, pipelineContext.mock.error);\n    }\n\n    private async _handleMockResponse (mockedResponse: IncomingMessageLike, pipelineContext: NativeAutomationPipelineContext, event: RequestPausedEvent, sessionId: SessionId): Promise<void> {\n        if (this._stopped)\n            return;\n\n        const mockedResponseBodyStr = (mockedResponse.getBody() as Buffer).toString();\n\n        const fulfillInfo = {\n            requestId:       event.requestId,\n            responseCode:    mockedResponse.statusCode,\n            responseHeaders: convertToHeaderEntries(mockedResponse.headers),\n            body:            mockedResponseBodyStr,\n        };\n\n        if (pipelineContext.reqOpts.isAjax)\n            await this._resourceInjector.processNonProxiedContent(fulfillInfo, this._client, sessionId);\n        else {\n            await this._resourceInjector.processHTMLPageContent(fulfillInfo, {\n                isIframe:       false,\n                contextStorage: this.contextStorage,\n            }, this._client, sessionId);\n        }\n\n        requestPipelineMockLogger(`sent mocked response for the ${event.requestId}`);\n    }\n\n    private _createContinueResponseRequest (event: RequestPausedEvent, modified: boolean): ContinueResponseRequest {\n        const continueResponseRequest = {\n            requestId: event.requestId,\n        } as ContinueResponseRequest;\n\n        if (modified) {\n            continueResponseRequest.responseHeaders = event.responseHeaders;\n            continueResponseRequest.responseCode    = event.responseStatusCode as number;\n        }\n\n        return continueResponseRequest;\n    }\n\n    private _shouldRedirectToErrorPage (event: RequestPausedEvent): boolean {\n        return event.resourceType === 'Document'\n            && !this._isIframe(event.frameId);\n    }\n\n    private async _getUserScripts (event: RequestPausedEvent | FrameNavigatedEvent): Promise<string[]> {\n        const { pipelineContext, eventFactory } = this._contextInfo.getContextData(event);\n\n        await pipelineContext.prepareInjectableUserScripts(eventFactory, this._testRunBridge.getUserScripts());\n\n        return pipelineContext.injectableUserScripts;\n    }\n\n    private async _respondToOtherRequest (event: RequestPausedEvent, sessionId: SessionId): Promise<void> {\n        if (isRedirectStatusCode(event.responseStatusCode)) {\n            await safeContinueResponse(this._client, { requestId: event.requestId }, sessionId);\n\n            return;\n        }\n\n        const resourceInfo = await this._resourceInjector.getDocumentResourceInfo(event, this._client);\n\n        if (resourceInfo.error) {\n            if (this._shouldRedirectToErrorPage(event)) {\n                await this._resourceInjector.redirectToErrorPage(this._client, resourceInfo.error, event.request.url);\n\n                this._contextInfo.dispose(getRequestId(event));\n            }\n\n            return;\n        }\n\n        const modified = await this.requestHookEventProvider.onResponse(event, resourceInfo.body, this._contextInfo, this._client);\n\n        if (this._needInjectResources(event)) {\n            const fulfillInfo = {\n                requestId:       event.requestId,\n                responseHeaders: event.responseHeaders,\n                responseCode:    event.responseStatusCode as number,\n                body:            (resourceInfo.body as Buffer).toString(),\n            } as FulfillRequestRequest;\n\n            // NOTE: Strange behavior of the CDP API:\n            // if we pass the empty \"responseStatusText\" value, we get an error 'Invalid status code or phrase'.\n            if (event.responseStatusText !== '')\n                fulfillInfo.responsePhrase = event.responseStatusText;\n\n            if (isUnauthorized(event.responseStatusCode as number))\n                await this._tryAuthorizeWithHttpBasicAuthCredentials(event, fulfillInfo);\n\n            const userScripts = await this._getUserScripts(event);\n\n            await this._resourceInjector.processHTMLPageContent(\n                fulfillInfo,\n                {\n                    isIframe:          this._isIframe(event.frameId),\n                    url:               event.request.url,\n                    restoringStorages: this.restoringStorages,\n                    contextStorage:    this.contextStorage,\n                    userScripts,\n                },\n                this._client, sessionId);\n\n            this._contextInfo.dispose(getRequestId(event));\n\n            this.restoringStorages = null;\n        }\n        else {\n            const continueResponseRequest = this._createContinueResponseRequest(event, modified);\n\n            await safeContinueResponse(this._client, continueResponseRequest, sessionId);\n\n            this._contextInfo.dispose(getRequestId(event));\n        }\n    }\n\n    private _needInjectResources (event: Protocol.Fetch.RequestPausedEvent): boolean {\n        if (event.resourceType !== 'Document')\n            return false;\n\n        const contentType = event.responseHeaders\n            ?.find(header => header.name.toLowerCase() === 'content-type')\n            ?.value;\n\n        if (contentType)\n            return contentTypeUtils.isPage(contentType);\n\n        return true;\n    }\n\n    private async _tryAuthorizeWithHttpBasicAuthCredentials (event: RequestPausedEvent, fulfillInfo: FulfillRequestRequest): Promise<void> {\n        const credentials = this._testRun.getAuthCredentials();\n\n        if (!credentials)\n            return;\n\n        const authRequest = await resendAuthRequest(event.request, credentials);\n\n        if (typeof authRequest !== 'string' && !isUnauthorized(authRequest.status)) {\n            fulfillInfo.responseCode = authRequest.status;\n            fulfillInfo.body = authRequest.body.toString();\n            fulfillInfo.responsePhrase = authRequest.statusText;\n        }\n    }\n\n    private _createError (event: RequestPausedEvent): Error {\n        if (this._pendingCertificateError)\n            return sslCertificateError(this._pendingCertificateError.errorType);\n\n        if (event.responseErrorReason === 'NameNotResolved')\n            return failedToFindDNSError(event.request.url);\n\n        return new Error(event.responseErrorReason);\n    }\n\n    private async _tryRespondToOtherRequest (event: RequestPausedEvent, sessionId: SessionId): Promise<void> {\n        try {\n            if (event.responseErrorReason && this._shouldRedirectToErrorPage(event)) {\n                const error = this._createError(event);\n\n                await this._resourceInjector.redirectToErrorPage(this._client, error, event.request.url);\n            }\n            else\n                await this._respondToOtherRequest(event, sessionId);\n        }\n        catch (err) {\n            if (event.networkId && this._failedRequestIds.includes(event.networkId)) {\n                remove(this._failedRequestIds, event.networkId);\n\n                return;\n            }\n\n            throw err;\n        }\n    }\n\n    private async _handleOtherRequests (event: RequestPausedEvent, sessionId: SessionId): Promise<void> {\n        requestPipelineOtherRequestLogger('%r', event);\n\n        if (!event.responseErrorReason && (isRequest(event) || isRedirectStatusCode(event.responseStatusCode))) {\n            this._contextInfo.init(event);\n\n            await this.requestHookEventProvider.onRequest(event, this._contextInfo);\n\n            const pipelineContext = this._contextInfo.getPipelineContext(getRequestId(event));\n\n            if (!pipelineContext || !pipelineContext.mock)\n                await safeContinueRequest(this._client, event, sessionId, this._createContinueEventArgs(event, pipelineContext.reqOpts));\n            else {\n                requestPipelineMockLogger('begin mocking request %r', event);\n\n                const mockedResponse = await pipelineContext.getMockResponse();\n\n                await this._handleMockErrorIfNecessary(pipelineContext, event);\n\n                const mockedResponseEvent = createRequestPausedEventForResponse(mockedResponse, event);\n\n                await this.requestHookEventProvider.onResponse(mockedResponseEvent, mockedResponse.getBody(), this._contextInfo, this._client);\n\n                await this._handleMockResponse(mockedResponse, pipelineContext, event, sessionId);\n\n                this._contextInfo.dispose(getRequestId(event));\n\n                requestPipelineMockLogger('end mocking request %r', event);\n            }\n        }\n        else\n            await this._tryRespondToOtherRequest(event, sessionId);\n    }\n\n    private _getUploadPostData (event: Protocol.Fetch.RequestPausedEvent): string | undefined {\n        if (!event.request.postData)\n            return void 0;\n\n        const contentTypeHeader = event.request.headers['Content-Type'] as string;\n        const postData          = Buffer.from(event.request.postData, 'utf-8');\n        const bodyWithUploads   = injectUpload(contentTypeHeader, postData);\n\n        return bodyWithUploads ? bodyWithUploads.toString('base64') : void 0;\n    }\n\n    private _topFrameNavigation (event: FrameNavigatedEvent): boolean {\n        return event.type === 'Navigation'\n            && !event.frame.parentId;\n    }\n\n    private async _updateCurrentFrameTree (): Promise<void> {\n        // NOTE: Due to CDP restrictions (it hangs), we can't get the frame tree\n        // right before injecting service scripts.\n        // So, we are forced tracking frames tree.\n        const result = await this._client.Page.getFrameTree();\n\n        this._currentFrameTree = result.frameTree;\n    }\n\n    private _isIframe (frameId: string): boolean {\n        if (!this._currentFrameTree)\n            return false;\n\n        return this._currentFrameTree.frame.id !== frameId;\n    }\n\n    public async start (): Promise<void> {\n        // NOTE: We are forced to handle all requests and responses at once\n        // because CDP API does not allow specifying request filtering behavior for different handlers.\n        await this._client.Fetch.enable({\n            patterns: ALL_REQUESTS_DATA,\n        });\n\n        await this._client.Target.setAutoAttach({\n            autoAttach:             true,\n            waitForDebuggerOnStart: true,\n            flatten:                true,\n        });\n\n        // NOTE: We need to enable the Fetch domain for iframe targets\n        // to intercept some requests. We need to use the `sessionId` option\n        // in continueRequest/continueResponse/fulfillRequest methods\n        await this._client.Target.on('attachedToTarget', async event => {\n            // @ts-ignore\n            await this._client.Runtime.runIfWaitingForDebugger(event.sessionId);\n\n            if (event.targetInfo.type !== 'worker')\n                // @ts-ignore\n                await this._client.Fetch.enable({ patterns: ALL_REQUESTS_DATA }, event.sessionId);\n\n        });\n\n        // @ts-ignore\n        this._client.Fetch.on('requestPaused', async (event: RequestPausedEvent, sessionId: SessionId) => {\n            if (this._stopped)\n                return;\n\n            const specialRequestHandler = getSpecialRequestHandler(event, this.options, this._specialServiceRoutes);\n\n            if (specialRequestHandler)\n                await specialRequestHandler(event, this._client, this.options, sessionId);\n            else\n                await this._handleOtherRequests(event, sessionId);\n        });\n\n        this._client.Page.on('frameNavigated', async (event: FrameNavigatedEvent) => {\n            requestPipelineLogger('%f', event);\n\n            if (!this._topFrameNavigation(event)\n                || event.frame.url !== SPECIAL_BLANK_PAGE)\n                return;\n\n            this._contextInfo.init(event);\n\n            const userScripts = await this._getUserScripts(event);\n\n            await this._resourceInjector.processAboutBlankPage(event, userScripts, this.contextStorage, this._client);\n\n            this._contextInfo.dispose(getRequestId(event));\n        });\n\n        this._client.Page.on('frameStartedLoading', async () => {\n            await this._updateCurrentFrameTree();\n        });\n\n        this._client.Network.on('loadingFailed', async (event: LoadingFailedEvent) => {\n            requestPipelineLogger('%l', event);\n\n            this._failedRequestIds.push(event.requestId);\n\n            if (event.requestId)\n                this._contextInfo.dispose(event.requestId);\n        });\n\n        await this._client.Page.setBypassCSP({ enabled: true });\n\n        await this._client.Security.enable();\n\n        this._client.Security.on('certificateError', async (event: CertificateErrorEvent) => {\n            this._pendingCertificateError = event;\n        });\n    }\n\n    public stop (): void {\n        this._stopped = true;\n    }\n\n    public async dispose (): Promise<void> {\n        await this._client.Fetch.disable();\n    }\n\n    private _createContinueEventArgs (event: Protocol.Fetch.RequestPausedEvent, reqOpts: any): ContinueRequestArgs {\n        const modifiedUrl  = new URL(event.request.url);\n        const host         = modifiedUrl.host;\n\n        let hostModified = false;\n        let portModified = false;\n\n        if (modifiedUrl.hostname !== reqOpts.hostname) {\n            modifiedUrl.hostname = reqOpts.hostname;\n            hostModified         = true;\n        }\n\n        if (modifiedUrl.port !== reqOpts.port) {\n            modifiedUrl.port = reqOpts.port;\n            portModified     = true;\n        }\n\n        if (host !== reqOpts.host) {\n            const { port, hostname } = new URL(reqOpts.protocol + '//' + reqOpts.host);\n\n            if (!hostModified)\n                modifiedUrl.hostname = hostname;\n\n            if (!portModified)\n                modifiedUrl.port = port;\n        }\n\n        const postData = this._getUploadPostData(event);\n        const url      = modifiedUrl.toString() !== event.request.url ? modifiedUrl.toString() : void 0;\n        const method   = reqOpts.method;\n\n        return { postData, url, method };\n    }\n}\n"]}

package/lib/native-automation/request-pipeline/resendAuthRequest.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resendAuthRequest = void 0;
+const send_1 = require("../../test-run/request/send");
+const testcafe_hammerhead_1 = require("testcafe-hammerhead");
+// @ts-ignore
+const url_to_options_1 = __importDefault(require("url-to-options"));
+async function resendAuthRequest(request, credentials) {
+    const url = new URL(request.url);
+    const urlRequestOptions = (0, url_to_options_1.default)(url);
+    const requestOptions = new testcafe_hammerhead_1.RequestOptions(Object.assign(urlRequestOptions, {
+        body: request.postData || '',
+        auth: `${credentials.username}:${credentials.password}`,
+        headers: request.headers,
+        method: request.method,
+    }));
+    return (0, send_1.send)(requestOptions);
+}
+exports.resendAuthRequest = resendAuthRequest;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/native-automation/request-pipeline/safe-api.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeFailRequest = exports.safeContinueRequest = exports.safeFulfillRequest = exports.safeContinueResponse = void 0;
+const debug_loggers_1 = require("../../utils/debug-loggers");
+const cdp_1 = require("../utils/cdp");
+const INVALID_INTERCEPTED_RESPONSE_ERROR_MSG = 'Invalid InterceptionId.';
+// In some cases (a request was aborted, any page that initiated the request doesn't exist, etc.)
+// Chrome Debug Protocol doesn't allow to continue request pipeline
+// and raises the "Invalid InterceptionId" error.
+// We use the simplest way to fix it - omit such an error.
+async function connectionResetGuard(handleRequestFn, handleErrorFn) {
+    try {
+        await handleRequestFn();
+    }
+    catch (err) {
+        if (err.message === INVALID_INTERCEPTED_RESPONSE_ERROR_MSG)
+            return;
+        handleErrorFn(err);
+        throw err;
+    }
+}
+async function safeContinueResponse(client, data, sessionId) {
+    const isPausedEvent = (0, cdp_1.isRequestPausedEvent)(data);
+    await connectionResetGuard(async () => {
+        const param = isPausedEvent
+            ? { requestId: data.requestId }
+            : data;
+        // @ts-ignore
+        await client.Fetch.continueResponse(param, sessionId);
+    }, err => {
+        const formatter = isPausedEvent ? '%r' : '%s';
+        (0, debug_loggers_1.requestPipelineLogger)(`Fetch.continueResponse. Unhandled error %s during processing ${formatter}`, err, data);
+    });
+}
+exports.safeContinueResponse = safeContinueResponse;
+async function safeFulfillRequest(client, fulfillInfo, sessionId) {
+    await connectionResetGuard(async () => {
+        // @ts-ignore
+        await client.Fetch.fulfillRequest(fulfillInfo, sessionId);
+    }, err => {
+        (0, debug_loggers_1.requestPipelineLogger)(`Fetch.fulfillRequest. Unhandled error %s during processing %s`, err, fulfillInfo.requestId);
+    });
+}
+exports.safeFulfillRequest = safeFulfillRequest;
+async function safeContinueRequest(client, event, sessionId, continueRequestArgs) {
+    const { postData, method, url } = continueRequestArgs || {};
+    await connectionResetGuard(async () => {
+        // @ts-ignore
+        await client.Fetch.continueRequest({ requestId: event.requestId, postData, method, url }, sessionId);
+    }, err => {
+        (0, debug_loggers_1.requestPipelineLogger)(`Fetch.continueRequest. Unhandled error %s during processing %r`, err, event);
+    });
+}
+exports.safeContinueRequest = safeContinueRequest;
+async function safeFailRequest(client, event, errorReason = 'Aborted') {
+    await connectionResetGuard(async () => {
+        await client.Fetch.failRequest({
+            requestId: event.requestId,
+            errorReason,
+        });
+    }, err => {
+        (0, debug_loggers_1.requestPipelineLogger)(`Fetch.failRequest. Unhandled error %s during processing %s`, err, event.requestId);
+    });
+}
+exports.safeFailRequest = safeFailRequest;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/native-automation/request-pipeline/special-handlers.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const injectables_1 = require("../../assets/injectables");
+const debug_loggers_1 = require("../../utils/debug-loggers");
+const cdp_1 = require("../utils/cdp");
+const constants_1 = require("./constants");
+const http_status_codes_1 = require("http-status-codes");
+const load_assets_1 = __importDefault(require("../../load-assets"));
+const string_1 = require("../utils/string");
+const safe_api_1 = require("./safe-api");
+async function handleRequestPauseEvent(event, client, sessionId) {
+    if ((0, cdp_1.isRequest)(event))
+        await (0, safe_api_1.safeContinueRequest)(client, event, sessionId);
+    else
+        await (0, safe_api_1.safeContinueResponse)(client, event, sessionId);
+}
+const internalRequest = {
+    condition: (event) => !event.networkId && event.resourceType !== 'Document' && !event.request.url,
+    handler: async (event, client, options, sessionId) => {
+        (0, debug_loggers_1.requestPipelineInternalRequestLogger)('%r', event);
+        await handleRequestPauseEvent(event, client, sessionId);
+    },
+};
+const serviceRequest = {
+    condition: (event, options, serviceRoutes) => {
+        const url = event.request.url;
+        // NOTE: the service 'Error page' should be proxied.
+        if (url === serviceRoutes.errorPage1
+            || url === serviceRoutes.errorPage2)
+            return false;
+        return options.serviceDomains.some(domain => url.startsWith(domain));
+    },
+    handler: async (event, client, options, sessionId) => {
+        (0, debug_loggers_1.requestPipelineServiceRequestLogger)('%r', event);
+        await handleRequestPauseEvent(event, client, sessionId);
+    },
+};
+const defaultFaviconRequest = {
+    condition: (event) => {
+        const parsedUrl = new URL(event.request.url);
+        return parsedUrl.pathname === injectables_1.DEFAULT_FAVICON_PATH;
+    },
+    handler: async (event, client, options, sessionId) => {
+        (0, debug_loggers_1.requestPipelineLogger)('%r', event);
+        if ((0, cdp_1.isRequest)(event))
+            await (0, safe_api_1.safeContinueRequest)(client, event, sessionId);
+        else {
+            if (event.responseStatusCode === http_status_codes_1.StatusCodes.NOT_FOUND) { // eslint-disable-line no-lonely-if
+                const { favIcon } = (0, load_assets_1.default)(options.developmentMode);
+                await (0, safe_api_1.safeFulfillRequest)(client, {
+                    requestId: event.requestId,
+                    responseCode: http_status_codes_1.StatusCodes.OK,
+                    responseHeaders: [constants_1.FAVICON_CONTENT_TYPE_HEADER],
+                    body: (0, string_1.toBase64String)(favIcon),
+                }, sessionId);
+            }
+            else
+                await (0, safe_api_1.safeContinueResponse)(client, event, sessionId);
+        }
+    },
+};
+const SPECIAL_REQUEST_HANDLERS = [
+    internalRequest,
+    serviceRequest,
+    defaultFaviconRequest,
+];
+function getSpecialRequestHandler(event, options, serviceRoutes) {
+    const specialRequestHandler = SPECIAL_REQUEST_HANDLERS.find(h => h.condition(event, options, serviceRoutes));
+    return specialRequestHandler ? specialRequestHandler.handler : null;
+}
+exports.default = getSpecialRequestHandler;
+module.exports = exports.default;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"special-handlers.js","sourceRoot":"","sources":["../../../src/native-automation/request-pipeline/special-handlers.ts"],"names":[],"mappings":"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","sourcesContent":["import Protocol from 'devtools-protocol';\nimport RequestPausedEvent = Protocol.Fetch.RequestPausedEvent;\nimport { DEFAULT_FAVICON_PATH } from '../../assets/injectables';\nimport {\n    RequestHandler,\n    SessionId,\n    SpecialServiceRoutes,\n} from '../types';\nimport { ProtocolApi } from 'chrome-remote-interface';\nimport {\n    requestPipelineInternalRequestLogger,\n    requestPipelineLogger,\n    requestPipelineServiceRequestLogger,\n} from '../../utils/debug-loggers';\nimport { NativeAutomationInitOptions } from '../../shared/types';\nimport { isRequest } from '../utils/cdp';\nimport { FAVICON_CONTENT_TYPE_HEADER } from './constants';\nimport { StatusCodes } from 'http-status-codes';\nimport loadAssets from '../../load-assets';\nimport { toBase64String } from '../utils/string';\nimport {\n    safeContinueRequest,\n    safeContinueResponse,\n    safeFulfillRequest,\n} from './safe-api';\n\nasync function handleRequestPauseEvent (event: RequestPausedEvent, client: ProtocolApi, sessionId: SessionId): Promise<void> {\n    if (isRequest(event))\n        await safeContinueRequest(client, event, sessionId);\n    else\n        await safeContinueResponse(client, event, sessionId);\n}\n\n\nconst internalRequest = {\n    condition: (event: RequestPausedEvent): boolean => !event.networkId && event.resourceType !== 'Document' && !event.request.url,\n    handler:   async (event: RequestPausedEvent, client: ProtocolApi, options: NativeAutomationInitOptions, sessionId: SessionId): Promise<void> => {\n        requestPipelineInternalRequestLogger('%r', event);\n\n        await handleRequestPauseEvent(event, client, sessionId);\n    },\n} as RequestHandler;\n\nconst serviceRequest = {\n    condition: (event: RequestPausedEvent, options: NativeAutomationInitOptions, serviceRoutes: SpecialServiceRoutes): boolean => {\n        const url = event.request.url;\n\n        // NOTE: the service 'Error page' should be proxied.\n        if (url === serviceRoutes.errorPage1\n            || url === serviceRoutes.errorPage2)\n            return false;\n\n        return options.serviceDomains.some(domain => url.startsWith(domain));\n    },\n    handler: async (event: RequestPausedEvent, client: ProtocolApi, options: NativeAutomationInitOptions, sessionId: SessionId): Promise<void> => {\n        requestPipelineServiceRequestLogger('%r', event);\n\n        await handleRequestPauseEvent(event, client, sessionId);\n    },\n} as RequestHandler;\n\nconst defaultFaviconRequest = {\n    condition: (event: RequestPausedEvent): boolean => {\n        const parsedUrl = new URL(event.request.url);\n\n        return parsedUrl.pathname === DEFAULT_FAVICON_PATH;\n    },\n    handler: async (event: RequestPausedEvent, client: ProtocolApi, options: NativeAutomationInitOptions, sessionId: SessionId): Promise<void> => {\n        requestPipelineLogger('%r', event);\n\n        if (isRequest(event))\n            await safeContinueRequest(client, event, sessionId);\n        else {\n            if (event.responseStatusCode === StatusCodes.NOT_FOUND) { // eslint-disable-line no-lonely-if\n                const { favIcon } = loadAssets(options.developmentMode);\n\n                await safeFulfillRequest(client, {\n                    requestId:       event.requestId,\n                    responseCode:    StatusCodes.OK,\n                    responseHeaders: [ FAVICON_CONTENT_TYPE_HEADER ],\n                    body:            toBase64String(favIcon),\n                }, sessionId);\n            }\n            else\n                await safeContinueResponse(client, event, sessionId);\n        }\n    },\n} as RequestHandler;\n\nconst SPECIAL_REQUEST_HANDLERS = [\n    internalRequest,\n    serviceRequest,\n    defaultFaviconRequest,\n];\n\nexport default function getSpecialRequestHandler (event: RequestPausedEvent, options?: NativeAutomationInitOptions, serviceRoutes?: SpecialServiceRoutes): any {\n    const specialRequestHandler = SPECIAL_REQUEST_HANDLERS.find(h => h.condition(event, options, serviceRoutes));\n\n    return specialRequestHandler ? specialRequestHandler.handler : null;\n}\n\n"]}