import * as AWS from "@alchemy.run/aws";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as datasync from "@distilled.cloud/aws/datasync";
import * as S3 from "@distilled.cloud/aws/s3";
import * as Output from "alchemy/Output";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";
const { test } = Test.make({ providers: AWS.providers() });
const waitUntilTaskGone = (taskArn: string) =>
datasync.describeTask({ TaskArn: taskArn }).pipe(
Effect.as(false),
Effect.catchTag("TaskNotFound", () => Effect.succeed(true)),
Effect.repeat({
schedule: Schedule.fixed("1 seconds"),
until: (gone) => gone,
times: 20,
}),
);
const trustPolicy = {
Version: "2012-10-17" as const,
Statement: [
{
Effect: "Allow" as const,
Principal: { Service: "datasync.amazonaws.com" },
Action: ["sts:AssumeRole"],
},
],
};
const s3Policy = (arn: Output.Output<string>) => ({
Version: "2012-10-17" as const,
Statement: [
{
Effect: "Allow" as const,
Action: ["s3:GetBucketLocation", "s3:ListBucket", "s3:ListBucketMultipartUploads"],
Resource: [arn],
},
{
Effect: "Allow" as const,
Action: [
"s3:AbortMultipartUpload",
"s3:DeleteObject",
"s3:GetObject",
"s3:GetObjectTagging",
"s3:ListMultipartUploadParts",
"s3:PutObject",
"s3:PutObjectTagging",
],
Resource: [Output.interpolate`${arn}/*`],
},
],
});
const buildStack = (options?: datasync.Options) =>
Effect.gen(function* () {
const src = yield* AWS.S3.Bucket("TaskSrc", { forceDestroy: true });
const dst = yield* AWS.S3.Bucket("TaskDst", { forceDestroy: true });
const role = yield* AWS.IAM.Role("TaskRole", {
assumeRolePolicyDocument: trustPolicy,
inlinePolicies: {
Src: s3Policy(src.bucketArn),
Dst: s3Policy(dst.bucketArn),
},
});
const source = yield* AWS.DataSync.LocationS3("TaskSrcLoc", {
s3BucketArn: src.bucketArn,
bucketAccessRoleArn: role.roleArn,
});
const dest = yield* AWS.DataSync.LocationS3("TaskDstLoc", {
s3BucketArn: dst.bucketArn,
bucketAccessRoleArn: role.roleArn,
});
const task = yield* AWS.DataSync.Task("BackupTask", {
sourceLocationArn: source.locationArn,
destinationLocationArn: dest.locationArn,
...(options !== undefined ? { options } : {}),
});
return { task, src, dst };
});
test.provider(
"typed TaskNotFound on a nonexistent task",
() =>
Effect.gen(function* () {
const result = yield* datasync
.describeTask({
TaskArn: "arn:aws:datasync:us-west-2:391965393224:task/task-00000000000000000",
})
.pipe(Effect.result);
expect(result._tag).toBe("Failure");
if (result._tag === "Failure") {
const err = result.failure as { _tag: string };
expect(err._tag).toBe("TaskNotFound");
}
}),
{ tags: ["provider:aws", "provider:aws:datasync", "live"], timeout: 60_000 },
);
test.provider(
"create S3 -> S3 task, update options, delete",
(stack) =>
Effect.gen(function* () {
yield* stack.destroy();
// --- create: two S3 locations + a transfer task ---
const created = yield* stack.deploy(buildStack());
expect(created.task.taskArn).toContain(":task/task-");
expect(created.task.sourceLocationArn).toContain(":location/loc-");
expect(created.task.destinationLocationArn).toContain(":location/loc-");
const arn = created.task.taskArn;
const observed = yield* datasync.describeTask({ TaskArn: arn });
expect(observed.SourceLocationArn).toBe(created.task.sourceLocationArn);
const tags = Object.fromEntries(
((yield* datasync.listTagsForResource({ ResourceArn: arn })).Tags ?? []).map((t) => [
t.Key,
t.Value,
]),
);
expect(tags["alchemy::id"]).toBe("BackupTask");
// --- update: change transfer options in place ---
const updated = yield* stack.deploy(buildStack({ VerifyMode: "ONLY_FILES_TRANSFERRED" }));
expect(updated.task.taskArn).toBe(arn);
const observed2 = yield* datasync.describeTask({ TaskArn: arn });
expect(observed2.Options?.VerifyMode).toBe("ONLY_FILES_TRANSFERRED");
// --- delete ---
yield* stack.destroy();
const gone = yield* waitUntilTaskGone(arn);
expect(gone).toBe(true);
}),
{
tags: ["provider:aws", "provider:aws:datasync", "provider:aws:iam", "provider:aws:s3", "live"],
timeout: 240_000,
},
);
// A live BASIC-mode task execution has 1–4 minutes of launch/prepare
// overhead (~2.5 min observed), so it is skipped under --fast.
test.provider.skipIf(!!process.env.FAST)(
"live S3 -> S3 task execution transfers an object",
(stack) =>
Effect.gen(function* () {
yield* stack.destroy();
const created = yield* stack.deploy(buildStack({ VerifyMode: "ONLY_FILES_TRANSFERRED" }));
yield* S3.putObject({
Bucket: created.src.bucketName,
Key: "hello.txt",
Body: "hello datasync",
});
// The freshly-created IAM role's permissions take a while to propagate
// to DataSync's location access test (typed LocationAccessTestFailed,
// patched from InvalidRequestException + "location access test failed").
const started = yield* datasync.startTaskExecution({ TaskArn: created.task.taskArn }).pipe(
Effect.retry({
while: (e) => e._tag === "LocationAccessTestFailed",
schedule: Schedule.max([Schedule.fixed("10 seconds"), Schedule.recurs(12)]),
}),
);
const finished = yield* datasync
.describeTaskExecution({
TaskExecutionArn: started.TaskExecutionArn!,
})
.pipe(
Effect.repeat({
schedule: Schedule.spaced("15 seconds"),
until: (e) => e.Status === "SUCCESS" || e.Status === "ERROR",
times: 40,
}),
);
if (finished.Status !== "SUCCESS") {
// surface the execution failure detail before the assertion trips
yield* Effect.log("task execution result", finished.Result);
}
expect(finished.Status).toBe("SUCCESS");
// out-of-band: the object landed in the destination bucket
yield* S3.headObject({
Bucket: created.dst.bucketName,
Key: "hello.txt",
});
yield* stack.destroy();
const gone = yield* waitUntilTaskGone(created.task.taskArn);
expect(gone).toBe(true);
}),
{
tags: ["provider:aws", "provider:aws:datasync", "provider:aws:iam", "provider:aws:s3", "live"],
timeout: 900_000,
},
);