sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Railway/ Service.test.ts

import * as Railway from "@alchemy.run/railway";
import { activeReplicaRegions, serviceRegionPlacement } from "@alchemy.run/railway/ServiceRegion";
import { withEnvironmentConfigLock } from "@alchemy.run/railway/transient";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import { Query } from "@distilled.cloud/core/query";
import { Railway as RailwayApi } from "@distilled.cloud/railway";
import * as Provider from "alchemy/Provider";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import { MinimumLogLevel } from "effect/References";
import * as Result from "effect/Result";
import * as Schedule from "effect/Schedule";
import { suitePartition } from "./suiteProject.ts";

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

const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");

const readServiceDeletedAt = Query.fn((id: string) => ({
  deletedAt: RailwayApi.service({ id }).deletedAt,
}));

const readService = Query.fn((id: string) => {
  const service = RailwayApi.service({ id });
  return {
    id: service.id,
    name: service.name,
    projectId: service.projectId,
    deletedAt: service.deletedAt,
  };
});

const readServiceInstance = Query.fn((environmentId: string, serviceId: string) => {
  const instance = RailwayApi.serviceInstance({ environmentId, serviceId });
  return {
    serviceId: instance.serviceId,
    environmentId: instance.environmentId,
    source: instance.source.pipe(
      Query.map((source) => ({ image: source.image, repo: source.repo })),
    ),
    healthcheckPath: instance.healthcheckPath,
    preDeployCommand: instance.preDeployCommand,
    numReplicas: instance.numReplicas,
    dockerfilePath: instance.dockerfilePath,
  };
});

const readServiceDomains = Query.fn(
  (input: { projectId: string; environmentId: string; serviceId: string }) => ({
    serviceDomains: RailwayApi.domains(input).serviceDomains.pipe(
      Query.map((domain) => ({
        id: domain.id,
        domain: domain.domain,
        targetPort: domain.targetPort,
        deletedAt: domain.deletedAt,
        syncStatus: domain.syncStatus,
      })),
    ),
  }),
);

const environmentPatchCommit = Query.fn(
  (args: { environmentId: string; commitMessage: string; patch: unknown }) =>
    RailwayApi.environmentPatchCommit(args),
);

const readGithubRepos = Query.fn(() =>
  RailwayApi.githubRepos().pipe(
    Query.map((repo) => ({ fullName: repo.fullName, defaultBranch: repo.defaultBranch })),
  ),
);

const readEnvironmentConfig = Query.fn((id: string, projectId: string) => ({
  config: RailwayApi.environment({ id, projectId }).config,
}));

const waitUntilGone = (serviceId: string) =>
  readServiceDeletedAt(serviceId).pipe(
    Effect.map((service) => (service.deletedAt != null ? ("gone" as const) : ("found" as const))),
    Effect.catchTag("RailwayNotFound", () => Effect.succeed("gone" as const)),
    Effect.repeat({
      schedule: Schedule.spaced("1 second"),
      until: (status) => status === "gone",
      times: 10,
    }),
  );

const waitUntilNoServiceDomains = (input: {
  projectId: string;
  environmentId: string;
  serviceId: string;
}) =>
  readServiceDomains(input).pipe(
    Effect.map((domains) =>
      domains.serviceDomains.some(
        (domain) =>
          domain.deletedAt == null &&
          domain.syncStatus !== "DELETED" &&
          domain.syncStatus !== "DELETING",
      )
        ? ("found" as const)
        : ("gone" as const),
    ),
    Effect.repeat({
      schedule: Schedule.spaced("1 second"),
      until: (status) => status === "gone",
      times: 10,
    }),
  );

test.provider(
  "create, serve, list, update, and delete an image service",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const created = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            image: "nginx:alpine",
            port: 80,
            healthcheckPath: "/",
            preDeploy: { command: "echo predeploy" },
          });
          return { project, environment, api };
        }),
      );

      expect(created.api.serviceId).toEqual(expect.any(String));
      expect(created.api.serviceId.length).toBeGreaterThan(0);
      expect(created.api.projectId).toEqual(created.project.projectId);
      expect(created.api.environmentId).toEqual(created.environment.environmentId);
      expect(created.api.name).toEqual(expect.any(String));
      expect(created.api.name.length).toBeGreaterThan(0);
      expect(created.api.name.length).toBeLessThanOrEqual(32);
      expect(created.api.name).toMatch(/^[a-z][a-z0-9-]*$/);
      expect(created.api.port).toEqual(80);
      expect(created.api.domain).toEqual(expect.any(String));
      expect(created.api.domain).toContain("up.railway.app");
      expect(created.api.url).toEqual(`https://${created.api.domain}`);
      expect(created.api.domainId).toEqual(expect.any(String));
      expect(created.api.domainId!.length).toBeGreaterThan(0);

      const fetched = yield* readService(created.api.serviceId);
      expect(fetched.id).toEqual(created.api.serviceId);
      expect(fetched.name).toEqual(created.api.name);
      expect(fetched.projectId).toEqual(created.api.projectId);
      expect(fetched.deletedAt).toBeNull();

      const instance = yield* readServiceInstance(created.api.environmentId, created.api.serviceId);
      expect(instance.serviceId).toEqual(created.api.serviceId);
      expect(instance.environmentId).toEqual(created.api.environmentId);
      expect(instance.source?.image).toEqual(expect.stringContaining("nginx:alpine"));
      expect(instance.healthcheckPath).toEqual("/");
      expect(
        instance.preDeployCommand === "echo predeploy" ||
          (Array.isArray(instance.preDeployCommand) &&
            instance.preDeployCommand.length === 1 &&
            instance.preDeployCommand[0] === "echo predeploy"),
      ).toEqual(true);
      // Railway omits numReplicas until you scale; default is one replica.
      expect(instance.numReplicas === null || instance.numReplicas === 1).toEqual(true);
      expect(created.api.healthcheckPath).toEqual("/");
      expect(created.api.replicas === undefined || created.api.replicas === 1).toEqual(true);

      const domains = yield* readServiceDomains({
        environmentId: created.api.environmentId,
        projectId: created.api.projectId,
        serviceId: created.api.serviceId,
      });
      const liveDomain = domains.serviceDomains.find(
        (domain) => domain.deletedAt == null && domain.syncStatus !== "DELETED",
      );
      expect(liveDomain).toBeDefined();
      expect(liveDomain?.domain).toEqual(created.api.domain);
      expect(liveDomain?.targetPort).toEqual(80);

      const provider = yield* Provider.findProvider(Railway.Service);
      const listed = yield* provider.list();
      const found = listed.find((service) => service.serviceId === created.api.serviceId);
      expect(found).toBeDefined();
      expect(found?.name).toEqual(created.api.name);
      expect(found?.projectId).toEqual(created.api.projectId);

      const client = yield* HttpClient.HttpClient;
      const body = yield* client.get(created.api.url!).pipe(
        Effect.flatMap((res) =>
          res.status === 200 ? res.text : Effect.fail(new Error(`api returned ${res.status}`)),
        ),
        Effect.retry({ schedule: Schedule.spaced("4 seconds"), times: 10 }),
      );
      expect(typeof body).toEqual("string");
      expect(body.length).toBeGreaterThan(0);

      const nextName = created.api.name.slice(0, -1) + (created.api.name.endsWith("z") ? "y" : "z");

      const updated = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            image: "nginx:alpine",
            port: 80,
            name: nextName,
            healthcheckPath: "/",
            preDeploy: { command: null },
          });
          return { project, environment, api };
        }),
      );

      expect(updated.api.serviceId).toEqual(created.api.serviceId);
      expect(updated.api.name).toEqual(nextName);
      expect(updated.api.projectId).toEqual(created.api.projectId);
      expect(updated.api.url).toEqual(created.api.url);

      const updatedInstance = yield* readServiceInstance(
        updated.api.environmentId,
        updated.api.serviceId,
      );
      expect(updatedInstance.healthcheckPath).toEqual("/");
      expect(
        updatedInstance.preDeployCommand == null ||
          (Array.isArray(updatedInstance.preDeployCommand) &&
            updatedInstance.preDeployCommand.length === 0),
      ).toEqual(true);

      const fetchedUpdate = yield* readService(updated.api.serviceId);
      expect(fetchedUpdate.id).toEqual(updated.api.serviceId);
      expect(fetchedUpdate.name).toEqual(nextName);

      const privateUpdate = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            name: nextName,
            healthcheckPath: "/health",
            publicDomain: false,
          });
          return { api };
        }),
      );

      expect(privateUpdate.api.serviceId).toEqual(created.api.serviceId);
      expect(privateUpdate.api.dnsName).toEqual(`${nextName}.railway.internal`);
      expect(privateUpdate.api.url).toBeUndefined();
      expect(privateUpdate.api.domain).toBeUndefined();
      expect(privateUpdate.api.domainId).toBeUndefined();
      expect(
        yield* waitUntilNoServiceDomains({
          projectId: privateUpdate.api.projectId,
          environmentId: privateUpdate.api.environmentId,
          serviceId: privateUpdate.api.serviceId,
        }),
      ).toEqual("gone");

      const publicUpdate = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            name: nextName,
            healthcheckPath: "/health",
            publicDomain: true,
          });
          return { api };
        }),
      );

      expect(publicUpdate.api.serviceId).toEqual(created.api.serviceId);
      expect(publicUpdate.api.domainId).toEqual(expect.any(String));
      expect(publicUpdate.api.url).toEqual(`https://${publicUpdate.api.domain}`);
      expect(publicUpdate.api.dnsName).toEqual(`${nextName}.railway.internal`);

      // Add a foreign generated domain. The config map key may not equal
      // the GraphQL id, and list order is not ownership — wait for a new
      // live row rather than assuming `[0] === patch UUID`.
      const liveDomainIds = (domains: {
        serviceDomains: ReadonlyArray<{ id: string; deletedAt: string | null; syncStatus: string }>;
      }) =>
        domains.serviceDomains
          .filter(
            (domain) =>
              domain.deletedAt == null &&
              domain.syncStatus !== "DELETED" &&
              domain.syncStatus !== "DELETING",
          )
          .map((domain) => domain.id);
      const beforeForeign = new Set(
        liveDomainIds(
          yield* readServiceDomains({
            projectId: publicUpdate.api.projectId,
            environmentId: publicUpdate.api.environmentId,
            serviceId: publicUpdate.api.serviceId,
          }),
        ),
      );
      const foreignPatchId = yield* Effect.sync(() => crypto.randomUUID());
      yield* withEnvironmentConfigLock(
        publicUpdate.api.environmentId,
        environmentPatchCommit({
          environmentId: publicUpdate.api.environmentId,
          commitMessage: "Arrange generated domains for ownership test",
          patch: {
            services: {
              [publicUpdate.api.serviceId]: {
                networking: {
                  serviceDomains: { [foreignPatchId]: {}, [publicUpdate.api.domainId!]: {} },
                },
              },
            },
          },
        }),
      );
      const orderedIds = yield* readServiceDomains({
        projectId: publicUpdate.api.projectId,
        environmentId: publicUpdate.api.environmentId,
        serviceId: publicUpdate.api.serviceId,
      }).pipe(
        Effect.map(liveDomainIds),
        Effect.repeat({
          schedule: Schedule.spaced("1 second"),
          until: (ids) =>
            ids.includes(publicUpdate.api.domainId!) &&
            (ids.includes(foreignPatchId) || ids.some((id) => !beforeForeign.has(id))),
          times: 10,
        }),
      );
      const foreignDomainId =
        orderedIds.find((id) => id === foreignPatchId) ??
        orderedIds.find((id) => !beforeForeign.has(id));
      expect(foreignDomainId).toBeDefined();
      if (foreignDomainId === undefined) {
        return;
      }
      expect(foreignDomainId).not.toEqual(publicUpdate.api.domainId);
      expect(orderedIds).toContain(publicUpdate.api.domainId);

      const publicWithForeignDomain = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            name: nextName,
            healthcheckPath: "/health",
            publicDomain: true,
          });
          return { api };
        }),
      );
      expect(publicWithForeignDomain.api.domainId).toEqual(publicUpdate.api.domainId);

      const privateWithForeignDomain = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            name: nextName,
            healthcheckPath: "/health",
            publicDomain: false,
          });
          return { api };
        }),
      );
      expect(privateWithForeignDomain.api.domainId).toBeUndefined();
      const remainingDomains = yield* readServiceDomains({
        projectId: publicUpdate.api.projectId,
        environmentId: publicUpdate.api.environmentId,
        serviceId: publicUpdate.api.serviceId,
      });
      const remainingIds = remainingDomains.serviceDomains
        .filter((domain) => domain.deletedAt == null && domain.syncStatus !== "DELETED")
        .map((domain) => domain.id);
      expect(remainingIds).toContain(foreignDomainId);
      expect(remainingIds).not.toContain(publicUpdate.api.domainId);

      yield* stack.destroy();

      const gone = yield* waitUntilGone(created.api.serviceId);
      expect(gone).toEqual("gone");
    }).pipe(logLevel),
  {
    tags: [
      "provider:railway",
      "provider:railway:project",
      "provider:railway:projectenvironment",
      "provider:railway:service",
      "live",
    ],
    // Multiple deployment cycles plus deletion need their own lifecycle budget.
    // Leave 30 seconds before the 240-second process cap for failure cleanup.
    timeout: 210_000,
  },
);

test.provider(
  "create, read, and delete a private image service",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const created = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const worker = yield* Railway.Service("Worker", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
          });
          return { worker };
        }),
      );

      expect(created.worker.serviceId).toEqual(expect.any(String));
      expect(created.worker.dnsName).toEqual(`${created.worker.name}.railway.internal`);
      expect(created.worker.url).toBeUndefined();
      expect(created.worker.domain).toBeUndefined();
      expect(created.worker.domainId).toBeUndefined();
      expect(
        yield* waitUntilNoServiceDomains({
          projectId: created.worker.projectId,
          environmentId: created.worker.environmentId,
          serviceId: created.worker.serviceId,
        }),
      ).toEqual("gone");

      // A second deploy exercises refresh/read without claiming or creating a
      // generated domain.
      const refreshed = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const worker = yield* Railway.Service("Worker", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
          });
          return { worker };
        }),
      );
      expect(refreshed.worker.serviceId).toEqual(created.worker.serviceId);
      expect(refreshed.worker.dnsName).toEqual(created.worker.dnsName);
      expect(refreshed.worker.url).toBeUndefined();
      expect(refreshed.worker.domain).toBeUndefined();
      expect(refreshed.worker.domainId).toBeUndefined();

      yield* stack.destroy();
      expect(yield* waitUntilGone(created.worker.serviceId)).toEqual("gone");
    }).pipe(logLevel),
  {
    tags: [
      "provider:railway",
      "provider:railway:project",
      "provider:railway:projectenvironment",
      "provider:railway:service",
      "live",
    ],
    timeout: 120_000,
  },
);

test.provider(
  "deleting one environment's service keeps its instances in other environments",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      // Railway keeps one service per project with an instance per
      // environment. A second Service with the same name attaches to it.
      const created = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const staging = yield* Railway.Environment("Staging", { project });
          const prod = yield* Railway.Service("WebProd", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
          });
          const stage = yield* Railway.Service("WebStaging", {
            project,
            environment: staging,
            name: prod.name,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
          });
          return { prod, stage };
        }),
      );
      expect(created.stage.serviceId).toEqual(created.prod.serviceId);
      expect(created.stage.environmentId).not.toEqual(created.prod.environmentId);

      // Dropping the staging Service must only delete its instance.
      yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          yield* Railway.Environment("Staging", { project });
          const prod = yield* Railway.Service("WebProd", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
          });
          return { prod };
        }),
      );

      const service = yield* readService(created.prod.serviceId);
      expect(service.deletedAt).toBeNull();
      const prodInstance = yield* readServiceInstance(
        created.prod.environmentId,
        created.prod.serviceId,
      );
      expect(prodInstance.serviceId).toEqual(created.prod.serviceId);

      yield* stack.destroy();
      expect(yield* waitUntilGone(created.prod.serviceId)).toEqual("gone");
    }).pipe(logLevel),
  {
    tags: [
      "provider:railway",
      "provider:railway:project",
      "provider:railway:projectenvironment",
      "provider:railway:service",
      "live",
    ],
    timeout: 240_000,
  },
);

const localContextDir = `${import.meta.dirname}/fixtures/local-context`;

test.provider(
  "create, serve, switch to image, and delete a local Docker context service",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const created = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Ctx", {
            project,
            environment,
            context: localContextDir,
            port: 80,
            healthcheckPath: "/",
          });
          return { api };
        }),
      );

      expect(created.api.serviceId).toEqual(expect.any(String));
      expect(created.api.domain).toContain("up.railway.app");
      expect(created.api.url).toEqual(`https://${created.api.domain}`);

      const fromContext = yield* readServiceInstance(
        created.api.environmentId,
        created.api.serviceId,
      );
      expect(fromContext.dockerfilePath).toEqual("Dockerfile");

      const client = yield* HttpClient.HttpClient;
      const body = yield* client.get(created.api.url!).pipe(
        Effect.flatMap((res) =>
          res.status === 200 ? res.text : Effect.fail(new Error(`api returned ${res.status}`)),
        ),
        Effect.retry({ schedule: Schedule.spaced("4 seconds"), times: 10 }),
      );
      expect(typeof body).toEqual("string");
      expect(body.length).toBeGreaterThan(0);

      const updated = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Ctx", {
            project,
            environment,
            image: "nginx:alpine",
            port: 80,
            healthcheckPath: "/",
          });
          return { api };
        }),
      );
      expect(updated.api.serviceId).toEqual(created.api.serviceId);

      const fromImage = yield* readServiceInstance(
        updated.api.environmentId,
        updated.api.serviceId,
      );
      expect(fromImage.source?.image).toEqual(expect.stringContaining("nginx:alpine"));

      const afterImage = yield* client.get(updated.api.url!).pipe(
        Effect.flatMap((res) =>
          res.status === 200 ? res.text : Effect.fail(new Error(`api returned ${res.status}`)),
        ),
        Effect.retry({ schedule: Schedule.spaced("4 seconds"), times: 10 }),
      );
      expect(typeof afterImage).toEqual("string");
      expect(afterImage.length).toBeGreaterThan(0);

      yield* stack.destroy();
      expect(yield* waitUntilGone(created.api.serviceId)).toEqual("gone");
    }).pipe(logLevel),
  {
    tags: [
      "provider:railway",
      "provider:railway:project",
      "provider:railway:projectenvironment",
      "provider:railway:service",
      "live",
    ],
    timeout: 120_000,
  },
);

// GitHub repo source requires a GitHub App connection on the Railway
// account. The probe always runs and pins the typed gate tag. The
// lifecycle is opt-in via RAILWAY_TEST_GITHUB=1.
const githubEntitled = !!process.env.RAILWAY_TEST_GITHUB;

test.provider(
  "unconnected GitHub surfaces a typed entitlement error",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const result = yield* Effect.result(readGithubRepos());
      if (Result.isSuccess(result)) {
        yield* Effect.logInfo(
          `GitHub is connected (${result.success.length} repos); probe is a no-op`,
        );
        yield* stack.destroy();
        return;
      }

      // GitHub App is not connected for this token: GraphQL `Not Authorized`
      // is already the typed `RailwayForbidden` tag (never UnknownRailwayError).
      expect(result.failure._tag === "RailwayForbidden").toBe(true);

      yield* stack.destroy();
    }).pipe(logLevel),
  { tags: ["provider:railway", "provider:railway:service", "live"], timeout: 120_000 },
);

test.provider.skipIf(!githubEntitled)(
  "create a github repo service",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const repos = yield* readGithubRepos();
      const repo = repos[0];
      expect(repo).toBeDefined();
      expect(repo!.fullName.length).toBeGreaterThan(0);

      const created = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Api", {
            project,
            environment,
            repo: repo!.fullName,
            branch: repo!.defaultBranch,
          });
          return { project, environment, api };
        }),
      );

      expect(created.api.serviceId).toEqual(expect.any(String));
      expect(created.api.repo).toEqual(repo!.fullName);

      const instance = yield* readServiceInstance(created.api.environmentId, created.api.serviceId);
      expect(instance.source?.repo).toEqual(repo!.fullName);

      yield* stack.destroy();

      const gone = yield* waitUntilGone(created.api.serviceId);
      expect(gone).toEqual("gone");
    }).pipe(logLevel),
  {
    tags: [
      "provider:railway",
      "provider:railway:project",
      "provider:railway:projectenvironment",
      "provider:railway:service",
      "live",
    ],
    timeout: 120_000,
  },
);

const placedRegions = (config: unknown, serviceId: string) =>
  activeReplicaRegions(serviceRegionPlacement(config, serviceId)).map((row) => row.region);

test.provider(
  "pin a service to a region and move it",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const region = "europe-west4-drams3a";
      const created = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Region", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
            region,
          });
          return { api };
        }),
      );

      expect(created.api.region).toEqual(region);
      const createdConfig = yield* readEnvironmentConfig(
        created.api.environmentId,
        created.api.projectId,
      );
      expect(placedRegions(createdConfig.config, created.api.serviceId)).toEqual([region]);

      const moved = "us-west2";
      const updated = yield* stack.deploy(
        Effect.gen(function* () {
          const { project, environment } = yield* suitePartition;
          const api = yield* Railway.Service("Region", {
            project,
            environment,
            image: "hashicorp/http-echo",
            port: 5678,
            publicDomain: false,
            region: moved,
          });
          return { api };
        }),
      );

      expect(updated.api.serviceId).toEqual(created.api.serviceId);
      expect(updated.api.region).toEqual(moved);
      const updatedConfig = yield* readEnvironmentConfig(
        updated.api.environmentId,
        updated.api.projectId,
      );
      expect(placedRegions(updatedConfig.config, updated.api.serviceId)).toEqual([moved]);

      yield* stack.destroy();

      const gone = yield* waitUntilGone(created.api.serviceId);
      expect(gone).toEqual("gone");
    }).pipe(logLevel),
  {
    tags: [
      "provider:railway",
      "provider:railway:project",
      "provider:railway:projectenvironment",
      "provider:railway:service",
      "live",
    ],
    timeout: 180_000,
  },
);