sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Turso/ Organization.test.ts

import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Turso from "@alchemy.run/turso";
import { organization } from "@alchemy.run/turso/Credentials";
import * as turso from "@distilled.cloud/turso/turso";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";

const { test } = Test.make({ providers: Turso.providers() });

// Invites and members need a team organization on a paid plan. The Starter
// plan rejects them with `BadRequest`:
//   "organization <slug> can't invite users because plan starter doesn't support it"
// Set TURSO_TEST_TEAM=1 (and TURSO_TEST_MEMBER=<username>) on an entitled org.
const team = !!process.env.TURSO_TEST_TEAM;
const memberUsername = process.env.TURSO_TEST_MEMBER;
// Toggling overages changes billing; never run it by default.
const overages = !!process.env.TURSO_TEST_ORG_SETTINGS;

const INVITE_EMAIL = "alchemy-turso-invite@example.com";

test.provider.skipIf(team)(
  "invites on the Starter plan fail with a typed BadRequest",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const org = yield* organization;
      const error = yield* turso
        .inviteOrganizationMemberV2({ organizationSlug: org, email: INVITE_EMAIL, role: "member" })
        .pipe(Effect.flip);
      expect(error._tag).toBe("BadRequest");
      yield* stack.destroy();
    }),
  { tags: ["provider:turso", "provider:turso:organizationinvite", "live"], timeout: 60_000 },
);

test.provider.skipIf(!team)(
  "invite, change role, and withdraw an invite",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const org = yield* organization;
      const pending = () =>
        turso
          .listOrganizationInvitesV2({ organizationSlug: org })
          .pipe(Effect.map(({ invites }) => (invites ?? []).find((i) => i.email === INVITE_EMAIL)));

      yield* stack.deploy(Turso.OrganizationInvite("Invite", { email: INVITE_EMAIL }));
      expect((yield* pending())?.role).toBe("member");

      yield* stack.deploy(
        Turso.OrganizationInvite("Invite", { email: INVITE_EMAIL, role: "viewer" }),
      );
      expect((yield* pending())?.role).toBe("viewer");

      yield* stack.destroy();
      expect(yield* pending()).toBeUndefined();
    }),
  { tags: ["provider:turso", "provider:turso:organizationinvite", "live"], timeout: 60_000 },
);

test.provider.skipIf(!team || !memberUsername)(
  "add a member, change their role, and remove them",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const org = yield* organization;
      const username = memberUsername!;
      const role = () =>
        turso.getOrganizationMember({ organizationSlug: org, username }).pipe(
          Effect.map(({ member }) => member?.role),
          Effect.catchTag("NotFound", () => Effect.succeed(undefined)),
        );

      yield* stack.deploy(Turso.OrganizationMember("Member", { username, role: "viewer" }));
      expect(yield* role()).toBe("viewer");
      yield* stack.deploy(Turso.OrganizationMember("Member", { username, role: "member" }));
      expect(yield* role()).toBe("member");

      yield* stack.destroy();
      expect(yield* role()).toBeUndefined();
    }),
  { tags: ["provider:turso", "provider:turso:organizationmember", "live"], timeout: 60_000 },
);

test.provider(
  "restoreEnabled is applied and restored on destroy",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const org = yield* organization;
      const observe = turso
        .getOrganization({ organizationSlug: org })
        .pipe(Effect.map(({ organization }) => organization?.restore_enabled ?? false));
      const original = yield* observe;

      const settings = yield* stack.deploy(
        Turso.OrganizationSettings("Org", { restoreEnabled: !original }),
      );
      expect(settings.original.restoreEnabled).toBe(original);
      expect(settings.restoreEnabled).toBe(!original);
      // Organization reads can briefly lag a write; poll until it shows.
      const settle = (expected: boolean) =>
        observe.pipe(
          Effect.repeat({
            schedule: Schedule.spaced("1 second"),
            until: (value) => value === expected,
            times: 15,
          }),
        );
      expect(yield* settle(!original)).toBe(!original);

      yield* stack.destroy();
      expect(yield* settle(original)).toBe(original);
    }),
  // An account-wide setting: run with no other Turso test in flight.
  {
    tags: ["provider:turso", "provider:turso:organizationsettings", "live"],
    timeout: 90_000,
    exclusive: true,
  },
);

test.provider.skipIf(!overages)(
  "organization settings are applied and restored on destroy",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const org = yield* organization;
      const observe = turso
        .getOrganization({ organizationSlug: org })
        .pipe(Effect.map(({ organization }) => organization?.overages ?? false));
      const original = yield* observe;

      const settings = yield* stack.deploy(
        Turso.OrganizationSettings("Org", { overages: !original }),
      );
      expect(settings.original.overages).toBe(original);
      expect(yield* observe).toBe(!original);

      yield* stack.destroy();
      expect(yield* observe).toBe(original);
    }),
  { tags: ["provider:turso", "provider:turso:organizationsettings", "live"], timeout: 60_000 },
);