AG-23655 'prevent-fetch' / 'prevent-xhr' are broken. #334

Squashed commit of the following:

commit e055b3e
Author: Adam Wróblewski <adam@adguard.com>
Date:   Wed Jun 28 18:46:48 2023 +0200

    Add test with response.url

commit 4cea127
Author: Slava Leleka <v.leleka@adguard.com>
Date:   Wed Jun 28 19:30:41 2023 +0300

    Update a comment

commit e054ab2
Author: Slava Leleka <v.leleka@adguard.com>
Date:   Wed Jun 28 19:29:15 2023 +0300

    Update changelog

commit 7d43e43
Author: Slava Leleka <v.leleka@adguard.com>
Date:   Wed Jun 28 19:28:45 2023 +0300

    Add a comment with link to issue

commit 252040b
Author: Adam Wróblewski <adam@adguard.com>
Date:   Wed Jun 28 17:05:51 2023 +0200

    Update changelog

commit b0a4bc3
Author: Adam Wróblewski <adam@adguard.com>
Date:   Wed Jun 28 17:00:06 2023 +0200

    Fix issue with prevent-fetch and prevent-xhr

CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 <!-- TODO: add @added tag to the files with specific version -->
 <!--       during new scriptlets or redirects releasing -->
 
+## [Unreleased]
+
+### Fixed
+
+- error throwing in `prevent-fetch` and `prevent-xhr` scriptlets when a request is blocked
+  [#334](https://github.com/AdguardTeam/Scriptlets/issues/334)
+
 ## <a name="v1.9.37"></a> [v1.9.37] - 2023-06-06
 
 ### Added
@@ -181,6 +188,7 @@ prevent inline `onerror` and match `link` tag [#276](https://github.com/AdguardT
     - `googlesyndication-adsbygoogle` [#252](https://github.com/AdguardTeam/Scriptlets/issues/252)
 
 
+[Unreleased]: https://github.com/AdguardTeam/Scriptlets/compare/v1.9.37...HEAD
 [v1.9.37]: https://github.com/AdguardTeam/Scriptlets/compare/v1.9.7...v1.9.37
 [v1.9.7]: https://github.com/AdguardTeam/Scriptlets/compare/v1.9.1...v1.9.7
 [v1.9.1]: https://github.com/AdguardTeam/Scriptlets/compare/v1.8.2...v1.9.1

src/scriptlets/prevent-fetch.js

@@ -4,6 +4,7 @@ import {
     objectToString,
     matchRequestProps,
     logMessage,
+    noopPromiseResolve,
     modifyResponse,
     // following helpers should be imported and injected
     // because they are used by helpers above
@@ -156,14 +157,25 @@ export function preventFetch(source, propsToMatch, responseBody = 'emptyObj', re
 
         if (shouldPrevent) {
             hit(source);
-            const origResponse = await Reflect.apply(target, thisArg, args);
-            return modifyResponse(
-                origResponse,
-                {
-                    body: strResponseBody,
-                    type: responseType,
-                },
-            );
+            try {
+                const origResponse = await Reflect.apply(target, thisArg, args);
+                // In the case of apps, the blocked request has status 500
+                // and no error is thrown, so it's necessary to check response.ok
+                // https://github.com/AdguardTeam/Scriptlets/issues/334
+                if (!origResponse.ok) {
+                    return noopPromiseResolve(strResponseBody, fetchData.url, responseType);
+                }
+                return modifyResponse(
+                    origResponse,
+                    {
+                        body: strResponseBody,
+                        type: responseType,
+                    },
+                );
+            } catch (ex) {
+                // https://github.com/AdguardTeam/Scriptlets/issues/334
+                return noopPromiseResolve(strResponseBody, fetchData.url, responseType);
+            }
         }
 
         return Reflect.apply(target, thisArg, args);
@@ -190,6 +202,7 @@ preventFetch.injections = [
     objectToString,
     matchRequestProps,
     logMessage,
+    noopPromiseResolve,
     modifyResponse,
     toRegExp,
     isValidStrPattern,

src/scriptlets/prevent-xhr.js

@@ -185,19 +185,19 @@ export function preventXHR(source, propsToMatch, customResponseText) {
                 readyState,
                 responseURL,
                 responseXML,
-                status,
                 statusText,
             } = forgedRequest;
 
             // Mock response object
             Object.defineProperties(thisArg, {
                 // original values
                 readyState: { value: readyState, writable: false },
-                status: { value: status, writable: false },
                 statusText: { value: statusText, writable: false },
-                responseURL: { value: responseURL, writable: false },
+                // If the request is blocked, responseURL is an empty string
+                responseURL: { value: responseURL || xhrData.url, writable: false },
                 responseXML: { value: responseXML, writable: false },
                 // modified values
+                status: { value: 200, writable: false },
                 response: { value: modifiedResponse, writable: false },
                 responseText: { value: modifiedResponseText, writable: false },
             });

tests/scriptlets/prevent-fetch.test.js

@@ -139,6 +139,28 @@ if (!isSupported) {
         done();
     });
 
+    test('prevent not existing fetch call', async (assert) => {
+        // blocked_request.json doesn't exist,
+        // it's required for test for blocked requests
+        const BLOCKED_REQUEST = `${FETCH_OBJECTS_PATH}/blocked_request.json`;
+        const inputRequest = new Request(BLOCKED_REQUEST);
+
+        runScriptlet(name, ['blocked_request']);
+        const done = assert.async(1);
+
+        const response = await fetch(inputRequest);
+        const parsedData = await response.json();
+
+        if (!response.ok) {
+            assert.strictEqual(response.ok, true, 'Request blocked');
+            done();
+        }
+        assert.ok(response.url.includes('/blocked_request.json'), 'Response URL is mocked');
+        assert.ok(isEmptyObject(parsedData), 'Response is mocked');
+        assert.strictEqual(window.hit, 'FIRED', 'hit function fired');
+        done();
+    });
+
     test('simple fetch - match single pair prop', async (assert) => {
         const INPUT_JSON_PATH = `${FETCH_OBJECTS_PATH}/test03.json`;
         const options = {

tests/scriptlets/prevent-xhr.test.js

@@ -508,6 +508,32 @@ if (isSupported) {
         xhr.send();
     });
 
+    test('Args matched, prevent blocked request', async (assert) => {
+        // blocked_request.json doesn't exist,
+        // it's required for test for blocked requests
+        const METHOD = 'GET';
+        const URL = `${FETCH_OBJECTS_PATH}/blocked_request.json`;
+        const MATCH_DATA = [`blocked_request method:${METHOD}`];
+
+        runScriptlet(name, MATCH_DATA);
+
+        const done = assert.async();
+
+        const reqListener = (e) => {
+            assert.strictEqual(e.target.status, 200, 'Status mocked');
+            assert.ok(e.target.responseURL.includes('/blocked_request.json'), 'Origianl URL mocked');
+            assert.strictEqual(e.target.readyState, 4, 'Response done');
+            assert.strictEqual(e.target.response, '', 'Response data mocked');
+            assert.strictEqual(window.hit, 'FIRED', 'hit function fired');
+            done();
+        };
+
+        const xhr = new XMLHttpRequest();
+        xhr.open(METHOD, URL);
+        xhr.addEventListener('load', reqListener);
+        xhr.send();
+    });
+
     test('Args, match, listeners after .send work', async (assert) => {
         const METHOD = 'GET';
         const URL = `${FETCH_OBJECTS_PATH}/test01.json`;