graphql-http 1.6.0 → 1.7.0

package/lib/audits/server.mjs

@@ -3,7 +3,7 @@
  * audit/server
  *
  */
-import { assert, audit, extendedTypeof } from './utils.mjs';
+import { assert, assertBodyAsExecutionResult, audit, extendedTypeof, } from './utils.mjs';
 /**
  * List of server audits required to check GraphQL over HTTP spec conformance.
  *
@@ -13,7 +13,9 @@ export function serverAudits(opts) {
     const fetchFn = (opts.fetchFn || fetch);
     return [
         // Media Types
-        audit('MUST accept application/graphql-response+json and match the content-type', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD accept application/graphql-response+json and match the content-type', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{ __typename }');
             const res = await fetchFn(url.toString(), {
@@ -35,7 +37,9 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/json');
         }),
-        audit('MUST accept */* and use application/graphql-response+json for the content-type', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD accept */* and use application/graphql-response+json for the content-type', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{ __typename }');
             const res = await fetchFn(url.toString(), {
@@ -46,30 +50,61 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/graphql-response+json');
         }),
-        audit('MUST assume application/graphql-response+json content-type when accept is missing', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD assume application/graphql-response+json content-type when accept is missing', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{ __typename }');
             const res = await fetchFn(url.toString());
             assert('Status code', res.status).toBe(200);
             assert('Content-Type header', res.headers.get('content-type')).toContain('application/graphql-response+json');
         }),
-        audit('MUST use utf-8 charset in response', async () => {
+        audit('MUST use utf-8 encoding when responding', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{ __typename }');
             const res = await fetchFn(url.toString());
             assert('Status code', res.status).toBe(200);
-            assert('Content-Type header', res.headers.get('content-type')).toContain('charset=utf-8');
+            // has charset set to utf-8
+            try {
+                assert('Content-Type header', res.headers.get('content-type')).toContain('charset=utf-8');
+                return;
+            }
+            catch (_a) {
+                // noop, continue
+            }
+            // has no charset specified
+            assert('Content-Type header', res.headers.get('content-type')).notToContain('charset');
+            // and the content is utf-8 encoded
+            try {
+                const decoder = new TextDecoder('utf-8');
+                const decoded = decoder.decode(await res.arrayBuffer());
+                assert('UTF-8 decoded body', decoded).toBe('{"data":{"__typename":"Query"}}');
+            }
+            catch (_b) {
+                throw 'Body is not UTF-8 encoded';
+            }
+        }),
+        audit('MUST accept utf-8 encoding', async () => {
+            const url = new URL(opts.url);
+            url.searchParams.set('query', '{ __typename }');
+            const res = await fetchFn(url.toString(), {
+                headers: {
+                    'content-type': 'application/json; charset=utf-8',
+                },
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Content-Type header', res.headers.get('content-type')).toContain('utf-8');
         }),
-        audit('MUST accept only utf-8 charset', async () => {
+        audit('MUST assume utf-8 if encoding is unspecified', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{ __typename }');
             const res = await fetchFn(url.toString(), {
                 headers: {
-                    accept: 'application/graphql-response+json; charset=iso-8859-1',
+                    'content-type': 'application/json',
                 },
             });
-            assert('Status code', res.status).toBe(406);
-            assert('Accept header', res.headers.get('accept')).toContain('charset=utf-8');
+            assert('Status code', res.status).toBe(200);
+            assert('Content-Type header', res.headers.get('content-type')).toContain('utf-8');
         }),
         // Request
         audit('MUST accept POST requests', async () => {
@@ -103,7 +138,7 @@ export function serverAudits(opts) {
                 method: 'POST',
             });
             assert('Status code', res.status).toBeGreaterThanOrEqual(400);
-            assert('Status code', res.status).toBeLessThanOrEqual(599);
+            assert('Status code', res.status).toBeLessThanOrEqual(499);
         }),
         audit('MUST accept application/json POST requests', async () => {
             const res = await fetchFn(opts.url, {
@@ -121,7 +156,9 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(400);
         }),
         // Request Parameters
-        audit('MUST require the {query} parameter', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD use 400 status code on missing {query} parameter when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -132,7 +169,21 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(400);
         }),
-        ...[{ obj: 'ect' }, 0, false, ['array']].map((invalid) => audit(`MUST NOT allow ${extendedTypeof(invalid)} for the {query} parameter`, async () => {
+        audit('SHOULD use 200 status code with errors field on missing {query} parameter when accepting application/json', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({ notquery: '{ __typename }' }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).toHaveProperty('errors');
+        }),
+        ...[{ obj: 'ect' }, 0, false, ['array']].map((invalid) => audit(
+        // TODO: convert to MUST after watershed
+        `SHOULD use 400 status code on ${extendedTypeof(invalid)} {query} parameter when accepting application/graphql-response+json`, async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -145,7 +196,23 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(400);
         })),
-        audit('MUST accept a string for the {query} parameter', async () => {
+        ...[{ obj: 'ect' }, 0, false, ['array']].map((invalid) => audit(`SHOULD use 200 status code with errors field on ${extendedTypeof(invalid)} {query} parameter when accepting application/json`, async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: invalid,
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).toHaveProperty('errors');
+        })),
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD allow string {query} parameter when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -158,7 +225,23 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(200);
         }),
-        ...[{ obj: 'ect' }, 0, false, ['array']].map((invalid) => audit(`MUST NOT allow ${extendedTypeof(invalid)} for the {operationName} parameter`, async () => {
+        audit('MUST allow string {query} parameter when accepting application/json', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: '{ __typename }',
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).notToHaveProperty('errors');
+        }),
+        ...[{ obj: 'ect' }, 0, false, ['array']].map((invalid) => audit(
+        // TODO: convert to MUST after watershed
+        `SHOULD use 400 status code on ${extendedTypeof(invalid)} {operationName} parameter when accepting application/graphql-response+json`, async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -172,7 +255,24 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(400);
         })),
-        audit('MUST accept a string for the {operationName} parameter', async () => {
+        ...[{ obj: 'ect' }, 0, false, ['array']].map((invalid) => audit(`SHOULD use 200 status code with errors field on ${extendedTypeof(invalid)} {operationName} parameter when accepting application/json`, async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    operationName: invalid,
+                    query: '{ __typename }',
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).toHaveProperty('errors');
+        })),
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD allow string {operationName} parameter when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -186,7 +286,24 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(200);
         }),
-        ...['string', 0, false, ['array']].map((invalid) => audit(`MUST NOT allow ${extendedTypeof(invalid)} for the {variables} parameter`, async () => {
+        audit('MUST allow string {operationName} parameter when accepting application/json', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    operationName: 'Query',
+                    query: 'query Query { __typename }',
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).notToHaveProperty('errors');
+        }),
+        ...['string', 0, false, ['array']].map((invalid) => audit(
+        // TODO: convert to MUST after watershed
+        `SHOULD use 400 status code on ${extendedTypeof(invalid)} {variables} parameter when accepting application/graphql-response+json`, async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -200,7 +317,24 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(400);
         })),
-        audit('MUST accept a map for the {variables} parameter', async () => {
+        ...['string', 0, false, ['array']].map((invalid) => audit(`SHOULD use 200 status code with errors field on ${extendedTypeof(invalid)} {variables} parameter when accepting application/json`, async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: '{ __typename }',
+                    variables: invalid,
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).toHaveProperty('errors');
+        })),
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD allow map {variables} parameter when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -213,21 +347,52 @@ export function serverAudits(opts) {
                 }),
             });
             assert('Status code', res.status).toBe(200);
-            const result = (await res.json());
-            assert('Execution result', result).notToHaveProperty('errors');
         }),
-        audit('MUST accept a URL-encoded JSON string for the {variables} parameter in GETs', async () => {
+        audit('MUST allow map {variables} parameter when accepting application/json', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: 'query Type($name: String!) { __type(name: $name) { name } }',
+                    variables: { name: 'sometype' },
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).notToHaveProperty('errors');
+        }),
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD allow URL-encoded JSON string {variables} parameter in GETs when accepting application/graphql-response+json', async () => {
+            const url = new URL(opts.url);
+            url.searchParams.set('query', 'query Type($name: String!) { __type(name: $name) { name } }');
+            url.searchParams.set('variables', JSON.stringify({ name: 'sometype' }));
+            const res = await fetchFn(url.toString(), {
+                method: 'GET',
+                headers: {
+                    accept: 'application/graphql-response+json',
+                },
+            });
+            assert('Status code', res.status).toBe(200);
+        }),
+        audit('MUST allow URL-encoded JSON string {variables} parameter in GETs when accepting application/json', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', 'query Type($name: String!) { __type(name: $name) { name } }');
             url.searchParams.set('variables', JSON.stringify({ name: 'sometype' }));
             const res = await fetchFn(url.toString(), {
                 method: 'GET',
+                headers: {
+                    accept: 'application/json',
+                },
             });
             assert('Status code', res.status).toBe(200);
-            const result = (await res.json());
-            assert('Execution result', result).notToHaveProperty('errors');
+            assert('Execution result', await assertBodyAsExecutionResult(res)).notToHaveProperty('errors');
         }),
-        ...['string', 0, false, ['array']].map((invalid) => audit(`MUST NOT allow ${extendedTypeof(invalid)} for the {extensions} parameter`, async () => {
+        ...['string', 0, false, ['array']].map((invalid) => audit(
+        // TODO: convert to MUST after watershed
+        `SHOULD use 400 status code on ${extendedTypeof(invalid)} {extensions} parameter when accepting application/graphql-response+json`, async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -241,7 +406,24 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(400);
         })),
-        audit('MUST accept a map for the {extensions} parameter', async () => {
+        ...['string', 0, false, ['array']].map((invalid) => audit(`SHOULD use 200 status code with errors field on ${extendedTypeof(invalid)} {extensions} parameter when accepting application/json`, async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: '{ __typename }',
+                    extensions: invalid,
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).toHaveProperty('errors');
+        })),
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD allow map {extensions} parameter when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -255,6 +437,21 @@ export function serverAudits(opts) {
             });
             assert('Status code', res.status).toBe(200);
         }),
+        audit('MUST allow map {extensions} parameter when accepting application/json', async () => {
+            const res = await fetchFn(opts.url, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    accept: 'application/json',
+                },
+                body: JSON.stringify({
+                    query: '{ __typename }',
+                    extensions: { some: 'value' },
+                }),
+            });
+            assert('Status code', res.status).toBe(200);
+            assert('Execution result', await assertBodyAsExecutionResult(res)).notToHaveProperty('errors');
+        }),
         // TODO: audit('MUST accept a map for the {extensions} parameter'),
         // Response application/json
         audit('SHOULD use 200 status code on JSON parsing failure when accepting application/json', async () => {
@@ -296,7 +493,9 @@ export function serverAudits(opts) {
             assert('Status code', res.status).toBe(200);
         }),
         // Response application/graphql-response+json
-        audit('MUST use 4xx or 5xx status codes on JSON parsing failure when accepting application/graphql-response+json', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD use 4xx or 5xx status codes on JSON parsing failure when accepting application/graphql-response+json', async () => {
             const res = await fetchFn(opts.url, {
                 method: 'POST',
                 headers: {
@@ -328,9 +527,11 @@ export function serverAudits(opts) {
                 },
                 body: '{ "not a JSON',
             });
-            assert('Data entry', (await res.json()).data).toBe(undefined);
+            assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),
-        audit('MUST use 4xx or 5xx status codes if parameters are invalid when accepting application/graphql-response+json', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD use 4xx or 5xx status codes if parameters are invalid when accepting application/graphql-response+json', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('qeury' /* typo */, '{ __typename }');
             const res = await fetchFn(url.toString(), {
@@ -356,9 +557,11 @@ export function serverAudits(opts) {
                 method: 'GET',
                 headers: { accept: 'application/graphql-response+json' },
             });
-            assert('Data entry', (await res.json()).data).toBe(undefined);
+            assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),
-        audit('MUST use 4xx or 5xx status codes on document parsing failure when accepting application/graphql-response+json', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD use 4xx or 5xx status codes on document parsing failure when accepting application/graphql-response+json', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{');
             const res = await fetchFn(url.toString(), {
@@ -384,9 +587,11 @@ export function serverAudits(opts) {
                 method: 'GET',
                 headers: { accept: 'application/graphql-response+json' },
             });
-            assert('Data entry', (await res.json()).data).toBe(undefined);
+            assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),
-        audit('MUST use 4xx or 5xx status codes on document validation failure when accepting application/graphql-response+json', async () => {
+        audit(
+        // TODO: convert to MUST after watershed
+        'SHOULD use 4xx or 5xx status codes on document validation failure when accepting application/graphql-response+json', async () => {
             const url = new URL(opts.url);
             url.searchParams.set('query', '{ 8f31403dfe404bccbb0e835f2629c6a7 }'); // making sure the field doesnt exist
             const res = await fetchFn(url.toString(), {
@@ -412,7 +617,7 @@ export function serverAudits(opts) {
                 method: 'GET',
                 headers: { accept: 'application/graphql-response+json' },
             });
-            assert('Data entry', (await res.json()).data).toBe(undefined);
+            assert('Data entry', (await assertBodyAsExecutionResult(res)).data).toBe(undefined);
         }),
         // TODO: how to fail and have the data entry?
         // audit('MUST use 2xx status code if response contains the data entry and it is not null when accepting application/graphql-response+json'),

package/lib/audits/utils.d.mts

@@ -0,0 +1,38 @@
+/**
+ *
+ * audit/utils
+ *
+ */
+import type { ExecutionResult } from 'graphql';
+import { Audit, AuditName } from './common';
+export * from '../utils';
+/**
+ * Wrap and prepare an audit for testing.
+ *
+ * @private
+ */
+export declare function audit(name: AuditName, fn: () => Promise<void>): Audit;
+/**
+ * Will throw a string if the assertion fails.
+ *
+ * All fatal problems will throw an instance of Error.
+ *
+ * @private
+ */
+export declare function assert<T = unknown>(name: string, actual: T): {
+    toBe: (expected: T) => void;
+    toBeLessThanOrEqual: (expected: T extends number ? T : never) => void;
+    toBeGreaterThanOrEqual: (expected: T extends number ? T : never) => void;
+    toContain: (expected: T extends (infer U)[] ? U : T extends string ? T : never) => void;
+    notToContain: (expected: T extends (infer U_1)[] ? U_1 : T extends string ? T : never) => void;
+    toHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;
+    notToHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;
+};
+/**
+ * Parses the string as JSON and safely reports parsing issues for audits.
+ *
+ * Assumes the parsed JSON will be an `ExecutionResult`.
+ *
+ * @private
+ * */
+export declare function assertBodyAsExecutionResult(res: Response): Promise<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;

package/lib/audits/utils.d.ts

@@ -3,6 +3,7 @@
  * audit/utils
  *
  */
+import type { ExecutionResult } from 'graphql';
 import { Audit, AuditName } from './common';
 export * from '../utils';
 /**
@@ -23,5 +24,15 @@ export declare function assert<T = unknown>(name: string, actual: T): {
     toBeLessThanOrEqual: (expected: T extends number ? T : never) => void;
     toBeGreaterThanOrEqual: (expected: T extends number ? T : never) => void;
     toContain: (expected: T extends (infer U)[] ? U : T extends string ? T : never) => void;
+    notToContain: (expected: T extends (infer U_1)[] ? U_1 : T extends string ? T : never) => void;
+    toHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;
     notToHaveProperty: (prop: T extends Record<any, any> ? PropertyKey : never) => void;
 };
+/**
+ * Parses the string as JSON and safely reports parsing issues for audits.
+ *
+ * Assumes the parsed JSON will be an `ExecutionResult`.
+ *
+ * @private
+ * */
+export declare function assertBodyAsExecutionResult(res: Response): Promise<ExecutionResult<import("graphql/jsutils/ObjMap").ObjMap<unknown>, import("graphql/jsutils/ObjMap").ObjMap<unknown>>>;

package/lib/audits/utils.js

@@ -19,7 +19,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assert = exports.audit = void 0;
+exports.assertBodyAsExecutionResult = exports.assert = exports.audit = void 0;
 __exportStar(require("../utils"), exports);
 /**
  * Wrap and prepare an audit for testing.
@@ -87,6 +87,21 @@ function assert(name, actual) {
                 throw `${name} ${JSON.stringify(actual)} does not contain ${JSON.stringify(expected)}`;
             }
         },
+        notToContain: (expected) => {
+            // @ts-expect-error types will match, otherwise never
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (actual.includes(expected)) {
+                throw `${name} ${JSON.stringify(actual)} contains ${JSON.stringify(expected)}`;
+            }
+        },
+        toHaveProperty: (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        prop) => {
+            // @ts-expect-error types will match, otherwise never
+            if (!(prop in actual)) {
+                throw `${name} ${JSON.stringify(actual)} does not have a property '${String(prop)}'`;
+            }
+        },
         notToHaveProperty: (
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         prop) => {
@@ -98,3 +113,20 @@ function assert(name, actual) {
     };
 }
 exports.assert = assert;
+/**
+ * Parses the string as JSON and safely reports parsing issues for audits.
+ *
+ * Assumes the parsed JSON will be an `ExecutionResult`.
+ *
+ * @private
+ * */
+async function assertBodyAsExecutionResult(res) {
+    const str = await res.text();
+    try {
+        return JSON.parse(str);
+    }
+    catch (err) {
+        throw `Response body is not valid JSON. Got ${JSON.stringify(str)}`;
+    }
+}
+exports.assertBodyAsExecutionResult = assertBodyAsExecutionResult;

package/lib/audits/utils.mjs

@@ -69,6 +69,21 @@ export function assert(name, actual) {
                 throw `${name} ${JSON.stringify(actual)} does not contain ${JSON.stringify(expected)}`;
             }
         },
+        notToContain: (expected) => {
+            // @ts-expect-error types will match, otherwise never
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (actual.includes(expected)) {
+                throw `${name} ${JSON.stringify(actual)} contains ${JSON.stringify(expected)}`;
+            }
+        },
+        toHaveProperty: (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        prop) => {
+            // @ts-expect-error types will match, otherwise never
+            if (!(prop in actual)) {
+                throw `${name} ${JSON.stringify(actual)} does not have a property '${String(prop)}'`;
+            }
+        },
         notToHaveProperty: (
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         prop) => {
@@ -79,3 +94,19 @@ export function assert(name, actual) {
         },
     };
 }
+/**
+ * Parses the string as JSON and safely reports parsing issues for audits.
+ *
+ * Assumes the parsed JSON will be an `ExecutionResult`.
+ *
+ * @private
+ * */
+export async function assertBodyAsExecutionResult(res) {
+    const str = await res.text();
+    try {
+        return JSON.parse(str);
+    }
+    catch (err) {
+        throw `Response body is not valid JSON. Got ${JSON.stringify(str)}`;
+    }
+}