sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Neon/ Role.test.ts

import { Branch } from "@alchemy.run/neon/Branch";
import type { PostgresOrigin } from "@alchemy.run/neon/PostgresOrigin";
import { Project, waitForOperations } from "@alchemy.run/neon/Project";
import { providers } from "@alchemy.run/neon/Providers";
import { Role } from "@alchemy.run/neon/Role";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import { createProjectBranchRole, getProjectBranchRole } from "@distilled.cloud/neon";
import * as PgClient from "@effect/sql-pg/PgClient";
import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
import * as Effect from "effect/Effect";
import * as Redacted from "effect/Redacted";
import * as Result from "effect/Result";

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

const tags = ["provider:neon", "provider:neon:role", "live"];

/** Log in as the role and return `current_user`. */
const currentUser = Effect.fn(
  function* (_origin: PostgresOrigin, _user: string, _password: Redacted.Redacted<string>) {
    const sql = yield* PgClient.PgClient;
    const rows = yield* sql<{ user: string }>`select current_user as user`;
    return rows[0]?.user;
  },
  (effect, origin, user, password) =>
    effect.pipe(
      Effect.provide(
        PgClient.layer({
          host: origin.host,
          port: origin.port,
          database: origin.database,
          username: user,
          password,
          ssl: true,
        }),
      ),
    ),
);

const roleExists = (scope: { projectId: string; branchId: string }, roleName: string) =>
  getProjectBranchRole({
    project_id: scope.projectId,
    branch_id: scope.branchId,
    role_name: roleName,
  }).pipe(
    Effect.as(true),
    Effect.catchTag("NotFound", () => Effect.succeed(false)),
  );

describe.concurrent("Neon.Role", { tags }, () => {
  test.provider(
    "creates a login role, keeps its password, replaces on noLogin, and deletes",
    (stack) =>
      Effect.gen(function* () {
        yield* stack.destroy();
        const program = (noLogin?: boolean) =>
          Effect.gen(function* () {
            const project = yield* Project("RoleProject");
            const branch = yield* Branch("RoleBranch", { project });
            const role = yield* Role("AppRole", { branch, noLogin });
            return { branch, role };
          });

        const { branch, role } = yield* stack.deploy(program());
        expect(role.roleName).toMatch(/^[a-z0-9_]+$/);
        expect(role.noLogin).toBe(false);
        expect(role.password).toBeDefined();
        expect(yield* currentUser(branch.origin, role.roleName, role.password!)).toBe(
          role.roleName,
        );

        // An unchanged redeploy keeps the same password.
        expect((yield* stack.plan(program())).resources.AppRole.action).toBe("noop");
        const redeployed = yield* stack.deploy(program());
        expect(Redacted.value(redeployed.role.password!)).toBe(Redacted.value(role.password!));

        // noLogin is creation-only; a generated name gets a new role, created first.
        const groupPlan = yield* stack.plan(program(true));
        expect(groupPlan.resources.AppRole).toMatchObject({
          action: "replace",
          deleteFirst: false,
        });
        const group = yield* stack.deploy(program(true));
        expect(group.role.roleName).not.toBe(role.roleName);
        expect(group.role.noLogin).toBe(true);
        expect(group.role.password).toBeUndefined();
        expect(yield* roleExists(role, role.roleName)).toBe(false);

        yield* stack.destroy();
        expect(yield* roleExists(group.role, group.role.roleName)).toBe(false);
      }),
    { timeout: 180_000 },
  );

  test.provider(
    "renames an explicit role on the project's default branch and replaces it delete-first",
    (stack) =>
      Effect.gen(function* () {
        yield* stack.destroy();
        const program = (name: string, noLogin?: boolean) =>
          Effect.gen(function* () {
            const project = yield* Project("RoleDefaultProject");
            const role = yield* Role("Migrator", { project, name, noLogin });
            return { project, role };
          });
        const first = yield* stack.deploy(program("migrator"));
        expect(first.role.branchId).toBe(first.project.defaultBranchId);
        expect(first.role.roleName).toBe("migrator");

        const renamed = yield* stack.deploy(program("migrator_v2"));
        expect(renamed.role.roleName).toBe("migrator_v2");
        expect(yield* roleExists(first.role, "migrator")).toBe(false);
        expect(
          yield* currentUser(first.project.origin, "migrator_v2", renamed.role.password!),
        ).toBe("migrator_v2");

        // The same explicit name must be freed before the replacement is created.
        expect((yield* stack.plan(program("migrator_v2", true))).resources.Migrator).toMatchObject({
          action: "replace",
          deleteFirst: true,
        });
        const group = yield* stack.deploy(program("migrator_v2", true));
        expect(group.role.roleName).toBe("migrator_v2");
        expect(group.role.noLogin).toBe(true);

        yield* stack.destroy();
        expect(yield* roleExists(first.role, "migrator_v2")).toBe(false);
      }),
    { timeout: 180_000 },
  );

  test.provider(
    "refuses a foreign role until adopted, then reveals its existing password",
    (stack) =>
      Effect.gen(function* () {
        yield* stack.destroy();
        const base = Project("RoleAdoptProject");
        const project = yield* stack.deploy(base);
        const foreign = yield* createProjectBranchRole({
          project_id: project.projectId,
          branch_id: project.defaultBranchId,
          role: { name: "foreign_role" },
        });
        yield* waitForOperations(foreign.operations);
        const program = (allow: boolean) =>
          Effect.gen(function* () {
            const project = yield* base;
            return yield* Role("ForeignRole", { project, name: "foreign_role" }).pipe(adopt(allow));
          });

        const refused = yield* stack.deploy(program(false)).pipe(Effect.result);
        expect(Result.isFailure(refused)).toBe(true);
        if (Result.isFailure(refused)) expect(refused.failure).toBeInstanceOf(OwnedBySomeoneElse);

        const adopted = yield* stack.deploy(program(true));
        const foreignPassword = foreign.role.password!;
        expect(Redacted.value(adopted.password!)).toBe(
          Redacted.isRedacted(foreignPassword) ? Redacted.value(foreignPassword) : foreignPassword,
        );
        expect(yield* currentUser(project.origin, "foreign_role", adopted.password!)).toBe(
          "foreign_role",
        );

        yield* stack.destroy();
      }),
    { timeout: 180_000 },
  );
});