sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ GitHub/ Release.test.ts

import * as GitHub from "@alchemy.run/github";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Repos from "@distilled.cloud/github/repos";
import * as Output from "alchemy/Output";
import * as Provider from "alchemy/Provider";
import { destroy } from "alchemy/RemovalPolicy";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
import { gh, scopedToOwner } from "./scope.ts";

const owner = process.env.GITHUB_TEST_OWNER ?? "alchemy-run-test";
if (owner !== "alchemy-run-test" && owner !== "alchemy-run-test-2") {
  throw new Error(`Unsafe GITHUB_TEST_OWNER: ${owner}`);
}

const { test } = Test.make({
  providers: GitHub.providers({ baseUrl: "github.com" }),
});

// Repositories are retained because the test token lacks delete_repo scope.
const repository = (name: string) =>
  GitHub.Repository("Repo", {
    owner,
    name: `alchemy-effect-pr-1577-release-${name}`,
    autoInit: true,
    visibility: "public",
    description: "Retained fixture for Alchemy PR #1577 release tests",
  });

const release = (fixture: string, props: Omit<GitHub.ReleaseProps, "owner" | "repository">) =>
  Effect.gen(function* () {
    const repo = yield* repository(fixture);
    return yield* GitHub.Release("Release", {
      ...props,
      owner,
      repository: Output.map(repo.fullName, (fullName) => fullName.split("/")[1]!),
    }).pipe(destroy());
  });

const getRelease = (fixture: string, releaseId: number) =>
  Effect.gen(function* () {
    return yield* gh(
      Repos.getRelease({
        owner,
        repo: `alchemy-effect-pr-1577-release-${fixture}`,
        release_id: releaseId,
      }),
    ).pipe(Effect.catchTag("NotFound", () => Effect.succeed(undefined)));
  });

const assertDeleted = (fixture: string, releaseId: number) =>
  Effect.gen(function* () {
    expect(yield* getRelease(fixture, releaseId)).toBeUndefined();
    const data = yield* gh(
      Repos.listReleases({
        owner,
        repo: `alchemy-effect-pr-1577-release-${fixture}`,
      }),
    );
    expect(data).toEqual([]);
  });

test.provider(
  "create and update release",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        release("update", {
          tagName: "v1.0.0",
          name: "Version 1.0.0",
          body: "First release",
        }),
      );
      expect(created.tagName).toBe("v1.0.0");
      expect(created.name).toBe("Version 1.0.0");
      expect(created.body).toBe("First release");
      expect(created.draft).toBe(false);
      expect(created.prerelease).toBe(false);
      expect((yield* getRelease("update", created.releaseId))?.body).toBe("First release");

      const updated = yield* stack.deploy(
        release("update", {
          tagName: "v1.0.0",
          name: "Version 1.0.0",
          body: "Updated: Bug fixes and improvements",
          prerelease: true,
        }),
      );
      expect(updated.releaseId).toBe(created.releaseId);
      expect(updated.body).toBe("Updated: Bug fixes and improvements");
      const observed = yield* getRelease("update", updated.releaseId);
      expect(observed?.body).toBe(updated.body);
      expect(observed?.prerelease).toBe(true);

      const reset = yield* stack.deploy(release("update", { tagName: "v1.0.0" }));
      expect(reset.releaseId).toBe(created.releaseId);
      expect(reset.name).toBe("v1.0.0");
      expect(reset.body).toBe("");
      expect(reset.prerelease).toBe(false);
      const observedReset = yield* getRelease("update", reset.releaseId);
      expect(observedReset?.body).toBe("");
      expect(observedReset?.prerelease).toBe(false);
      yield* stack.deploy(repository("update"));
      yield* assertDeleted("update", reset.releaseId);
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:release", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "create draft and publish",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        release("draft", {
          tagName: "v2.0.0",
          name: "Version 2.0.0",
          body: "Draft release notes",
          draft: true,
        }),
      );
      expect(created.draft).toBe(true);
      expect(created.publishedAt).toBe(null);
      expect((yield* getRelease("draft", created.releaseId))?.draft).toBe(true);

      const updated = yield* stack.deploy(
        release("draft", {
          tagName: "v2.0.0",
          name: "Version 2.0.0",
          body: "Published release notes",
          draft: false,
        }),
      );
      expect(updated.releaseId).toBe(created.releaseId);
      expect(updated.draft).toBe(false);
      expect(updated.publishedAt).not.toBe(null);
      const observed = yield* getRelease("draft", updated.releaseId);
      expect(observed?.draft).toBe(false);
      expect(observed?.body).toBe("Published release notes");
      yield* stack.deploy(repository("draft"));
      yield* assertDeleted("draft", updated.releaseId);
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:release", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "create prerelease",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        release("prerelease", {
          tagName: "v3.0.0-beta.1",
          name: "v3.0.0 Beta 1",
          body: "Beta release for testing",
          prerelease: true,
        }),
      );
      expect(created.tagName).toBe("v3.0.0-beta.1");
      expect(created.prerelease).toBe(true);
      expect(created.draft).toBe(false);
      expect((yield* getRelease("prerelease", created.releaseId))?.prerelease).toBe(true);
      yield* stack.deploy(repository("prerelease"));
      yield* assertDeleted("prerelease", created.releaseId);
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:release", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "list enumeration includes deployed release",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        release("list", {
          tagName: "v1.0.0",
          name: "Test Release",
          body: "For list test",
        }),
      );
      const name = "alchemy-effect-pr-1577-release-list";
      const provider = yield* Provider.findProvider(GitHub.Release);
      // list() enumerates /user/repos; confine it to this suite's fixture.
      const all = yield* provider.list().pipe(
        scopedToOwner(owner, { repository: name, path: "releases" }),
        // Repository listings are eventually consistent for fresh fixtures.
        Effect.repeat({
          schedule: Schedule.spaced("2 seconds"),
          times: 10,
          until: (releases) => releases.some((item) => item.releaseId === created.releaseId),
        }),
      );
      expect(all.every((item) => item.htmlUrl.startsWith(`https://github.com/${owner}/`))).toBe(
        true,
      );
      const found = all.find((item) => item.releaseId === created.releaseId);
      expect(found).toBeDefined();
      expect(found?.tagName).toBe(created.tagName);
      yield* stack.deploy(repository("list"));
      yield* assertDeleted("list", created.releaseId);
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:release", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "tag change replaces release and deletes the old release",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(release("replace", { tagName: "v1.0.0" }));
      const replaced = yield* stack.deploy(release("replace", { tagName: "v2.0.0" }));
      expect(replaced.releaseId).not.toBe(created.releaseId);
      expect(replaced.tagName).toBe("v2.0.0");
      expect(yield* getRelease("replace", created.releaseId)).toBeUndefined();
      expect((yield* getRelease("replace", replaced.releaseId))?.tag_name).toBe("v2.0.0");
      yield* stack.deploy(repository("replace"));
      yield* assertDeleted("replace", replaced.releaseId);
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:release", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);