fix: allMediaItems throws when a thread item is included

server/graphql/modules/manualReviewTool.ts

@@ -1687,10 +1687,7 @@ const NcmecManualReviewJobPayload: GQLNcmecManualReviewJobPayloadResolvers = {
           typeSelector:
             ncmecContentItemSubmission.contentItem.itemTypeIdentifier,
         });
-        if (
-          type === undefined ||
-          (type.kind !== 'CONTENT' && type.kind !== 'USER')
-        ) {
+        if (type === undefined) {
           throw new Error(
             `No Content Item Type found for id: ${ncmecContentItemSubmission.contentItem.itemTypeIdentifier.id}`,
           );

server/test/fixtureHelpers/createThreadItemTypes.ts

@@ -0,0 +1,64 @@
+import { faker } from '@faker-js/faker';
+import { ScalarTypes, type Field } from '@roostorg/coop-types';
+
+import { type Dependencies } from '../../iocContainer/index.js';
+import { type NonEmptyArray } from '../../utils/typescript-types.js';
+
+export default async function (opts: {
+  moderationConfigService: Dependencies['ModerationConfigService'];
+  orgId: string;
+  numItemTypes?: number;
+  includeCreator?: boolean;
+  extra: { fields?: NonEmptyArray<Field> };
+}) {
+  const {
+    moderationConfigService,
+    orgId,
+    extra,
+    numItemTypes = 1,
+    includeCreator = false,
+  } = opts;
+
+  const itemTypes = await Promise.all(
+    Array.from({ length: numItemTypes }).map(async () =>
+      moderationConfigService.createThreadType(orgId, {
+        name: `${faker.lorem.words(2)}`,
+        description: faker.lorem.sentence(),
+        schema: extra.fields ?? [
+          {
+            name: 'field1',
+            type: ScalarTypes.STRING,
+            required: false,
+            container: null,
+          },
+          ...(includeCreator
+            ? [
+                {
+                  name: 'creatorId',
+                  type: ScalarTypes.RELATED_ITEM,
+                  required: false,
+                  container: null,
+                },
+              ]
+            : []),
+        ],
+        schemaFieldRoles: includeCreator
+          ? {
+              creatorId: 'creatorId',
+            }
+          : {},
+      }),
+    ),
+  );
+
+  return {
+    itemTypes,
+    cleanup: async () => {
+      await Promise.all(
+        itemTypes.map(async (it) =>
+          moderationConfigService.deleteItemType({ itemTypeId: it.id, orgId }),
+        ),
+      );
+    },
+  };
+}

server/test/fixtureHelpers/createUser.ts

@@ -8,7 +8,10 @@ import {
 } from '../../graphql/datasources/userKyselyPersistence.js';
 import { type CombinedPg } from '../../services/combinedDbTypes.js';
 import { type LoginMethod } from '../../services/coreAppTables.js';
-import { UserRole } from '../../services/userManagementService/index.js';
+import {
+  hashPassword,
+  UserRole,
+} from '../../services/userManagementService/index.js';
 import { logErrorAndThrow } from '../utils.js';
 
 // SAML-only by default keeps the `password_null_when_not_present` CHECK
@@ -22,12 +25,17 @@ export default async function createUser(
     id?: string;
     role?: UserRole;
     loginMethods?: readonly LoginMethod[];
+    /** Plaintext; hashed before insert when provided. */
     password?: string | null;
+    approvedByAdmin?: boolean;
   } = {},
 ) {
   const userId = extra.id ?? uid();
   const loginMethods = extra.loginMethods ?? DEFAULT_LOGIN_METHODS;
-  const password = extra.password ?? null;
+  const password =
+    extra.password != null && extra.password !== ''
+      ? await hashPassword(extra.password)
+      : null;
 
   const user = await kyselyUserInsert({
     db,
@@ -39,6 +47,7 @@ export default async function createUser(
     lastName: faker.name.lastName(),
     role: extra.role ?? UserRole.ADMIN,
     loginMethods,
+    approvedByAdmin: extra.approvedByAdmin,
   }).catch(logErrorAndThrow);
 
   return {

server/test/fixtureHelpers/makeStubFetchHTTP.ts

@@ -0,0 +1,88 @@
+import { Headers } from 'undici';
+
+import {
+  type CoopRequestQuery,
+  type CoopResponse,
+  type FetchHTTP,
+  type HandleResponseBody,
+} from '../../services/networkingService/index.js';
+
+/** Shape of one recorded outgoing fetchHTTP call. */
+export type RecordedFetchHTTPCall = {
+  url: string;
+  method: string;
+  body: unknown;
+  headers?: Record<string, string | ReadonlyArray<string>>;
+};
+
+/** Records every outgoing fetchHTTP call and returns canned CyberTip
+ * responses. */
+export function makeStubFetchHTTP(
+  reportId: string,
+  fileId: string,
+  opts: { preservationUrl?: string } = {},
+): {
+  fetchHTTP: FetchHTTP;
+  calls: RecordedFetchHTTPCall[];
+} {
+  const calls: RecordedFetchHTTPCall[] = [];
+  const preservationUrl = opts.preservationUrl;
+  const ok = <T extends HandleResponseBody>(body: unknown): CoopResponse<T> =>
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- the stub returns a canned body through a slot typed by the caller's T.
+    ({
+      status: 200,
+      ok: true,
+      headers: new Headers(),
+      body,
+    }) as CoopResponse<T>;
+  const fetchHTTP: FetchHTTP = async <T extends HandleResponseBody>(
+    query: CoopRequestQuery<T>,
+  ): Promise<CoopResponse<T>> => {
+    const { url, method, body, headers } = query;
+    // eslint-disable-next-line functional/immutable-data -- request recorder mutates by design
+    calls.push({ url, method, body, headers });
+
+    // media download for #upload
+    if (method === 'get') {
+      const stream = new ReadableStream({
+        start(ctr) {
+          ctr.enqueue(new TextEncoder().encode('fake-media-bytes'));
+          ctr.close();
+        },
+      });
+      return ok<T>(stream);
+    }
+    // NCMEC CyberTip protocol — every XML endpoint returns responseCode=0.
+    // /submit, /upload, /fileinfo use `reportResponse`; /finish uses
+    // `reportDoneResponse`.
+    if (
+      url.endsWith('/ispws/submit') ||
+      url.endsWith('/ispws/upload') ||
+      url.endsWith('/ispws/fileinfo')
+    ) {
+      const isSubmit = url.endsWith('/ispws/submit');
+      const isUpload = url.endsWith('/ispws/upload');
+      return ok<T>({
+        reportResponse: {
+          responseCode: { _text: '0' },
+          ...(isSubmit ? { reportId: { _text: reportId } } : {}),
+          ...(isUpload ? { fileId: { _text: fileId } } : {}),
+        },
+      });
+    }
+    if (url.endsWith('/ispws/finish')) {
+      return ok<T>({
+        reportDoneResponse: {
+          responseCode: { _text: '0' },
+          reportId: { _text: reportId },
+          files: [{ fileId: { _text: fileId } }],
+        },
+      });
+    }
+    if (preservationUrl != null && url === preservationUrl) {
+      return ok<T>(undefined);
+    }
+    throw new Error(`stub fetchHTTP: unexpected request ${method} ${url}`);
+  };
+  return { fetchHTTP, calls };
+}