knowledge/tests/test-media-list.ts

import { eq } from 'drizzle-orm';
import { listMedia } from '../src/actions/media';
import { db } from '../src/db';
import { users } from '../src/db/schema/auth';
import { media } from '../src/db/schema/media';
import { resources } from '../src/db/schema/resource';
import { cleanupMediaRecord } from './helpers/media-cleanup';

async function upsertUser(email: string, name: string) {
  const [existing] = await db.select().from(users).where(eq(users.email, email)).limit(1);

  if (existing) {
    return existing;
  }

  const [created] = await db.insert(users).values({
    email,
    name,
    passwordHash: 'test_password_hash',
  }).returning();

  return created;
}

async function runTest() {
  console.log('Testing media list visibility and filters...');
  const createdMediaIds: string[] = [];

  const owner = await upsertUser('media-list-owner@ekb.com', 'Media List Owner');
  const outsider = await upsertUser('media-list-outsider@ekb.com', 'Media List Outsider');
  const suffix = Date.now();

  const [resource] = await db.insert(resources).values({
    name: `media-list-${suffix}.mp4`,
    path: `/media-list/${suffix}.mp4`,
    type: 'file',
    ownerId: owner.id,
  }).returning();

  const [createdMedia] = await db.insert(media).values({
    resourceId: resource.id,
    filename: `media-list-${suffix}.mp4`,
    storageKey: `uploads/media-list-${suffix}.mp4`,
    mimeType: 'video/mp4',
    size: BigInt(1),
    status: 'pending',
  }).returning();
  createdMediaIds.push(createdMedia.id);

  const [completedResource] = await db.insert(resources).values({
    name: `media-list-filter-${suffix}.mp4`,
    path: `/media-list/filter-${suffix}.mp4`,
    type: 'file',
    ownerId: owner.id,
  }).returning();

  const [completedMedia] = await db.insert(media).values({
    resourceId: completedResource.id,
    filename: `media-list-filter-${suffix}.mp4`,
    storageKey: `uploads/media-list-filter-${suffix}.mp4`,
    mimeType: 'video/mp4',
    size: BigInt(1),
    status: 'completed',
  }).returning();
  createdMediaIds.push(completedMedia.id);

  try {
    const ownerList = await listMedia({ auth: { userId: owner.id, groupIds: [] } });
    const outsiderList = await listMedia({ auth: { userId: outsider.id, groupIds: [] } });

    const ownerCanSee = ownerList.some((item) => item.id === createdMedia.id);
    const outsiderCanSee = outsiderList.some((item) => item.id === createdMedia.id);

    if (!ownerCanSee || outsiderCanSee) {
      throw new Error('Media list visibility did not respect ownership permissions.');
    }

    const queryList = await listMedia({
      auth: { userId: owner.id, groupIds: [] },
      query: `filter-${suffix}`,
    });
    const completedList = await listMedia({
      auth: { userId: owner.id, groupIds: [] },
      status: 'completed',
    });

    const queryMatched = queryList.some((item) => item.id === completedMedia.id)
      && !queryList.some((item) => item.id === createdMedia.id);
    const statusMatched = completedList.some((item) => item.id === completedMedia.id)
      && !completedList.some((item) => item.id === createdMedia.id);

    if (!queryMatched || !statusMatched) {
      throw new Error('Media list filters did not match expected results.');
    }
  } finally {
    for (const mediaId of createdMediaIds) {
      await cleanupMediaRecord(mediaId);
    }
  }

  console.log('Media list visibility and filters passed.');
  process.exit(0);
}

runTest().catch((error) => {
  console.error('Test failed with error:', error);
  process.exit(1);
});