sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ GitHub/ Milestone.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 Issues from "@distilled.cloud/github/issues";
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 Stream from "effect/Stream";
import { scopedToOwner } from "./scope.ts";
import { gh } from "./scope.ts";

const owner = process.env.GITHUB_TEST_OWNER ?? "alchemy-run-test";
if (!["alchemy-run-test", "alchemy-run-test-2"].includes(owner)) {
  throw new Error("GITHUB_TEST_OWNER must be alchemy-run-test or alchemy-run-test-2");
}

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

const repositoryName = (fixture: string) => `alchemy-pr-1566-milestone-${fixture}`;

// Repositories are retained because the test token does not have delete_repo.
const repository = (name: string) =>
  GitHub.Repository("Repo", {
    owner,
    name: repositoryName(name),
    visibility: "public",
    autoInit: true,
  });

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

const listMilestones = (fixture: string) =>
  Effect.gen(function* () {
    return yield* gh(
      Stream.runCollect(
        Issues.listMilestones.items({
          owner,
          repo: repositoryName(fixture),
          state: "all",
          per_page: 100,
        }),
      ),
    );
  });

const verifyDeleted = (fixture: string) =>
  Effect.gen(function* () {
    expect(yield* listMilestones(fixture)).toEqual([]);
  });

test.provider(
  "create and update milestone",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        fixture("update", {
          title: "v1.0.0",
          description: "First release",
        }),
      );
      expect(created.title).toBe("v1.0.0");
      expect(created.state).toBe("open");
      expect(created.description).toBe("First release");
      const updated = yield* stack.deploy(
        fixture("update", {
          title: "v1.0.0",
          description: "Updated: Bug fixes and improvements",
          dueOn: "2027-12-31",
        }),
      );
      expect(updated.milestoneNumber).toBe(created.milestoneNumber);
      expect(updated.description).toBe("Updated: Bug fixes and improvements");
      expect(updated.dueOn).toBe("2027-12-31T00:00:00Z");
      const observed = yield* listMilestones("update");
      expect(observed).toHaveLength(1);
      expect(observed[0]?.description).toBe(updated.description);
      expect(observed[0]?.due_on).toBe(updated.dueOn);
      yield* stack.deploy(repository("update"));
      yield* verifyDeleted("update");
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:milestone", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "close and reopen milestone",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        fixture("state", { title: "Release v2.0", state: "open" }),
      );
      expect(created.state).toBe("open");
      expect(created.closedAt).toBe(null);
      const closed = yield* stack.deploy(
        fixture("state", { title: "Release v2.0", state: "closed" }),
      );
      expect(closed.milestoneNumber).toBe(created.milestoneNumber);
      expect(closed.state).toBe("closed");
      expect(closed.closedAt).not.toBe(null);
      expect((yield* listMilestones("state"))[0]?.state).toBe("closed");
      const reopened = yield* stack.deploy(
        fixture("state", { title: "Release v2.0", state: "open" }),
      );
      expect(reopened.milestoneNumber).toBe(created.milestoneNumber);
      expect(reopened.state).toBe("open");
      expect(reopened.closedAt).toBe(null);
      expect((yield* listMilestones("state"))[0]?.state).toBe("open");
      yield* stack.deploy(repository("state"));
      yield* verifyDeleted("state");
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:milestone", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "replace milestone when title changes",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        fixture("replace", {
          title: "Q1 2026",
          description: "First quarter goals",
        }),
      );
      expect(created.title).toBe("Q1 2026");
      const replaced = yield* stack.deploy(
        fixture("replace", {
          title: "Q1 2027",
          description: "Updated quarter goals",
        }),
      );
      expect(replaced.title).toBe("Q1 2027");
      expect(replaced.milestoneNumber).not.toBe(created.milestoneNumber);
      const observed = yield* listMilestones("replace");
      expect(observed.map((milestone) => milestone.number)).toEqual([replaced.milestoneNumber]);
      yield* stack.deploy(repository("replace"));
      yield* verifyDeleted("replace");
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:milestone", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "list enumeration includes deployed milestone",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        fixture("list", {
          title: "PR 1566 list milestone",
          description: "For list test",
        }),
      );
      const provider = yield* Provider.findProvider(GitHub.Milestone);
      const allMilestones = yield* provider.list().pipe(scopedToOwner(owner));
      const found = allMilestones.find((milestone) => milestone.nodeId === created.nodeId);
      expect(found).toBeDefined();
      expect(found?.title).toBe(created.title);
      expect(found?.htmlUrl).toBe(created.htmlUrl);
      yield* stack.deploy(repository("list"));
      yield* verifyDeleted("list");
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:milestone", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "milestone with due date",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        fixture("duedate", {
          title: "Sprint 1",
          description: "Complete authentication",
          dueOn: "2026-12-31",
        }),
      );
      expect(created.title).toBe("Sprint 1");
      expect(created.dueOn).toBe("2026-12-31T00:00:00Z");
      expect((yield* listMilestones("duedate"))[0]?.due_on).toBe(created.dueOn);
      yield* stack.deploy(repository("duedate"));
      yield* verifyDeleted("duedate");
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:milestone", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);

test.provider(
  "removing optional properties restores defaults",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const created = yield* stack.deploy(
        fixture("defaults", {
          title: "Defaults",
          state: "closed",
          description: "Remove me",
          dueOn: "2027-12-31",
        }),
      );
      const updated = yield* stack.deploy(fixture("defaults", { title: "Defaults" }));
      expect(updated.milestoneNumber).toBe(created.milestoneNumber);
      expect(updated.state).toBe("open");
      expect(updated.description ?? "").toBe("");
      expect(updated.dueOn).toBe(null);
      const observed = (yield* listMilestones("defaults"))[0];
      expect(observed?.state).toBe("open");
      expect(observed?.description ?? "").toBe("");
      expect(observed?.due_on).toBe(null);
      yield* stack.deploy(repository("defaults"));
      yield* verifyDeleted("defaults");
      yield* stack.destroy();
    }),
  {
    tags: ["provider:github", "provider:github:milestone", "provider:github:repository", "live"],
    timeout: 120_000,
  },
);