usenet-indexer/tests/functional/web_api.spec.ts

import { test } from '@japa/runner'
import ReleaseCompleteness from '#services/ReleaseCompleteness'
import db from '@adonisjs/lucid/services/db'
import FileStore from '#services/FileStore'
import testUtils from '@adonisjs/core/services/test_utils'

async function seed() {
  const now = new Date()
  const [release] = await db
    .table('releases')
    .insert({ release_key: 'w'.repeat(40), name: 'Webtest.Show.S01E02.1080p', source: 'par2', groups: '["alt.binaries.test"]', posted_at: now, first_seen_at: now, last_seen_at: now, contents: JSON.stringify([{ name: 'Webtest.Show.S01E02.1080p/episode.mkv', size: 1000 }]) })
    .returning('id')
  await FileStore.insert([{
    filename: 'Xq8r2KdLm3Zw91PqA7webtest', real_name: 'Webtest.Show.S01E02.1080p.mkv', poster: 'p@example.invalid',
    date: now.getTime(), parts: 2, size: 1400, release_id: release.id, groups: '["alt.binaries.test"]',
    segments: [{ number: 1, id: 'one@test', size: 700 }, { number: 2, id: 'two@test', size: 700 }],
    created_at: now, updated_at: now,
  }])
  return Number(release.id)
}

test.group('Web API', (group) => {
  group.each.setup(() => testUtils.db().withGlobalTransaction())

  test('searches by words in any order, with dots and spaces interchangeable', async ({ client, assert }) => {
    const id = await seed()
    for (const q of ['webtest show s01e02', 'Webtest.Show', 'episode.mkv 1080p']) {
      const response = await client.get('/api/v1/releases').qs({ q })
      response.assertStatus(200)
      assert.include(response.body().releases.map((r: any) => r.id), id, q)
    }
    const none = await client.get('/api/v1/releases').qs({ q: 'webtest nosuchword' })
    assert.notInclude(none.body().releases.map((r: any) => r.id), id)
  })

  test('filters and details', async ({ client, assert }) => {
    const id = await seed()
    const readable = await client.get('/api/v1/releases').qs({ q: 'webtest', readable: '1', source: 'par2' })
    assert.include(readable.body().releases.map((r: any) => r.id), id)
    const other = await client.get('/api/v1/releases').qs({ q: 'webtest', source: 'rar' })
    assert.notInclude(other.body().releases.map((r: any) => r.id), id)

    const detail = await client.get(`/api/v1/releases/${id}`)
    detail.assertStatus(200)
    assert.equal(detail.body().files[0].name, 'Webtest.Show.S01E02.1080p.mkv')
    assert.equal(detail.body().fileCount, 1)
    assert.equal(detail.body().size, 1400)
    ;(await client.get('/api/v1/releases/999999999')).assertStatus(404)
  })

  test('filters by size in MB and by file extension as a whole word', async ({ client, assert }) => {
    const id = await seed() // 1400 bytes, an episode.mkv in its listing
    const ids = async (qs: Record<string, string>) =>
      (await client.get('/api/v1/releases').qs({ q: 'webtest', ...qs })).body().releases.map((r: any) => r.id)

    assert.include(await ids({ min_size: '0.001', max_size: '0.002' }), id)
    assert.notInclude(await ids({ min_size: '1' }), id)
    assert.notInclude(await ids({ max_size: '0.001' }), id)

    assert.include(await ids({ ext: 'mkv' }), id)
    assert.include(await ids({ ext: '.iso, MKV' }), id)
    assert.notInclude(await ids({ ext: 'iso' }), id)
    // "sho" is part of "show", not an extension.
    assert.notInclude(await ids({ ext: 'sho' }), id)

    // A plainly posted file counts too, not only archive entries; volumes count as their archive.
    const now = new Date()
    await FileStore.insert([
      { filename: 'Webtest.Show.S01E02.1080p.nfo', poster: 'p', date: now.getTime(), parts: 1, size: 10, release_id: id, groups: '[]', segments: [], created_at: now, updated_at: now },
      { filename: 'Webtest.Show.S01E02.1080p.7z.002', poster: 'p', date: now.getTime(), parts: 1, size: 10, release_id: id, groups: '[]', segments: [], created_at: now, updated_at: now },
    ])
    assert.include(await ids({ ext: 'nfo' }), id)
    assert.include(await ids({ ext: '7z' }), id)
    assert.deepEqual((await db.from('releases').where('id', id).first()).extensions, ['7z', 'mkv', 'nfo'])
  })

  test('serves an NZB with the real file name', async ({ client, assert }) => {
    const id = await seed()
    const response = await client.get(`/api/v1/releases/${id}/nzb`)
    response.assertStatus(200)
    assert.include(response.header('content-type'), 'application/x-nzb')
    assert.include(response.header('content-disposition'), 'Webtest.Show.S01E02.1080p.nzb')
    assert.include(response.text(), '&quot;Webtest.Show.S01E02.1080p.mkv&quot; yEnc (1/2)')
    assert.include(response.text(), '<segment bytes="700" number="1">one@test</segment>')
  })

  test('stats', async ({ client }) => {
    const response = await client.get('/api/v1/stats')
    response.assertStatus(200)
    response.assertBodyContains({ sources: [] })
  })

  test('completeness follows files and par2 lists (triggers note releases, the sweep recomputes)', async ({ assert }) => {
    const now = new Date()
    const complete = async (id: number) => {
      await ReleaseCompleteness.sweep()
      return (await db.from('releases').where('id', id).first()).complete
    }
    const file = (releaseId: number, name: string) => ({
      filename: name, poster: 'p', date: now.getTime(), parts: 1, size: 100_000, release_id: releaseId,
      groups: '[]', segments: [], created_at: now, updated_at: now,
    })

    // Counter rule: [i/M] announced 2 files.
    const [counted] = await db.table('releases').insert({ release_key: 'c'.repeat(40), name: 'Counted', groups: '[]', file_total: 2, first_seen_at: now, last_seen_at: now }).returning('id')
    await FileStore.insert([file(counted.id, 'a.rar')])
    assert.isFalse(await complete(counted.id))
    await FileStore.insert([file(counted.id, 'b.rar')])
    assert.isTrue(await complete(counted.id))

    // par2 rule: the listed file becomes present once a file of its exact size is there.
    const [listed] = await db.table('releases').insert({ release_key: 'l'.repeat(40), name: 'Listed', groups: '[]', first_seen_at: now, last_seen_at: now }).returning('id')
    await db.table('release_files').insert({ release_id: listed.id, par2_file_id: '1'.repeat(32), name: 'Listed.mkv', size: 5_000_000, md5_16k: '0'.repeat(32) })
    assert.isFalse(await complete(listed.id))
    const [f] = await FileStore.insert([file(listed.id, 'Xq8r2KdLm3Zw91PqA7')])
    const [b] = await db.table('binaries').insert({ file_key: 'z'.repeat(40), poster: 'p', subject: '"x" yEnc', name: 'x', total_parts: 1, groups: '[]', first_seen_at: now, last_seen_at: now, file_id: f.id }).returning('id')
    assert.isFalse(await complete(listed.id))
    await db.from('binaries').where('id', b.id).update({ size: 5_000_000 })
    assert.isTrue(await complete(listed.id))
  })

  test('par2-only releases are hidden unless asked for', async ({ client, assert }) => {
    const now = new Date()
    const [release] = await db.table('releases')
      .insert({ release_key: 'p'.repeat(40), name: 'Webtest.Par2only.S01E01.1080p.WEB-DL-GRP', groups: '[]', first_seen_at: now, last_seen_at: now })
      .returning('id')
    await db.table('release_files').insert({ release_id: release.id, par2_file_id: '2'.repeat(32), name: 'Webtest.Par2only.S01E01.mkv', size: 1_000_000_000, md5_16k: '0'.repeat(32) })
    await FileStore.insert([{ filename: 'Xq8r2KdLm3Zw91PqA7', content_type: 'par2', poster: 'p', date: now.getTime(), parts: 1, size: 3919,
      release_id: release.id, groups: '[]', segments: [], created_at: now, updated_at: now }])

    const hidden = await client.get('/api/v1/releases').qs({ q: 'webtest par2only' })
    assert.notInclude(hidden.body().releases.map((r: any) => r.id), Number(release.id))
    const shown = await client.get('/api/v1/releases').qs({ q: 'webtest par2only', par2_only: '1' })
    const row = shown.body().releases.find((r: any) => r.id === Number(release.id))
    assert.isTrue(row.par2Only)
  })
})

test.group('Health check', () => {
  test('/health answers when the database does', async ({ client }) => {
    const response = await client.get('/health')
    response.assertStatus(200)
    response.assertBody({ ok: true })
  })
})