providers/src/__test__/providers/providerUtils.ts

import { ScrapeMedia } from "@/entrypoint/utils/media";
import { Embed, Sourcerer, SourcererEmbed } from "@/providers/base";
import { buildProviders } from "@/entrypoint/builder";
import { describe, expect, it } from "vitest";
import { makeStandardFetcher } from "@/fetchers/standardFetch";
import { ProviderControls } from "@/entrypoint/controls";
import { NotFoundError } from "@/utils/errors";
import { targets } from "@/entrypoint/utils/targets";
import { getBuiltinEmbeds } from "@/entrypoint/providers";
import { makeSimpleProxyFetcher } from "@/fetchers/simpleProxy";

export type TestTypes = 'standard' | 'ip:standard' | 'proxied';

export interface TestSourceOptions {
  source: Sourcerer;
  testSuite: ScrapeMedia[];
  types: TestTypes[];
  debug?: boolean;
  expect: {
    embeds?: number;
    streams?: number;
    error?: boolean;
    notfound?: boolean;
  }
}

function makeBaseProviders() {
  const builder = buildProviders()
    .setTarget(targets.ANY)
    .setFetcher(makeStandardFetcher(fetch));
  const embeds = getBuiltinEmbeds();
  embeds.forEach(embed => builder.addEmbed(embed));
  return builder;
}

export function testSource(ops: TestSourceOptions) {
  if (ops.testSuite.length === 0) throw new Error("Test suite must have at least one test");
  describe(`source:${ops.source.id}`, () => {
    ops.testSuite.forEach((test) => {
      describe(`test ${test.title}`, () => {
        async function runTest(providers: ProviderControls) {
          let hasNotFound = false;
          let hasError = false;
          let streamCount = 0;
          let embedCount = 0;
          let embeds = [];
          try {
            const result = await providers.runSourceScraper({
              id: ops.source.id,
              media: test,
            })
            if (ops.debug) console.log(result);
            streamCount = (result.stream ?? []).length;
            embedCount = result.embeds.length;
          } catch (err) {
            if (ops.debug) console.log(err);
            if (err instanceof NotFoundError)
              hasNotFound = true;
            else
              hasError = true;
          }
          expect(ops.expect.error ?? false).toBe(hasError);
          expect(ops.expect.notfound ?? false).toBe(hasNotFound);
          expect(ops.expect.streams ?? 0).toBe(streamCount);
          expect(ops.expect.embeds ?? 0).toBe(embedCount);
        }

        if (ops.types.includes('standard')) {
          it(`standard`, async () => {
            const providers = makeBaseProviders()
              .addSource(ops.source)
              .build();
            await runTest(providers);
          })
        }

        if (ops.types.includes('ip:standard')) {
          it(`standard:ip`, async () => {
            const providers = makeBaseProviders()
              .addSource(ops.source)
              .enableConsistentIpForRequests()
              .build();
            await runTest(providers);
          })
        }

        if (ops.types.includes('proxied')) {
          it(`proxied`, async () => {
            if (!process.env.MOVIE_WEB_PROXY_URL)
              throw new Error("Cant use proxied test without setting MOVIE_WEB_PROXY_URL env");
            const providers = makeBaseProviders()
              .addSource(ops.source)
              .setProxiedFetcher(makeSimpleProxyFetcher(process.env.MOVIE_WEB_PROXY_URL, fetch))
              .build();
            await runTest(providers);
          })
        }
                
      })
    })
  })
}