Skip to content

armgit / kaneo

Public Imported from GitHub
0

⚡ Project management that doesn't become the project. Boards, Gantt charts, and GitHub integration. Self-host it or use Kaneo Cloud.

20.8 KB
Raw Blame
import { S3Client } from "@aws-sdk/client-s3";
import {
  afterEach,
  beforeEach,
  describe,
  expect,
  it,
  vi,
} from "vite-plus/test";
import {
  applyKeyPrefix,
  assertProjectBackgroundKeyMatchesContext,
  assertStorageConfigured,
  assertTaskImageKeyMatchesContext,
  buildObjectKey,
  buildObjectKeyPrefix,
  buildProjectBackgroundObjectKey,
  buildProjectBackgroundObjectKeyPrefix,
  copyTaskAssetObject,
  createProjectBackgroundUploadUrl,
  createTaskImageUploadUrl,
  getFileExtension,
  isImageContentType,
  parseBoolean,
  parsePositiveInt,
  resolveS3Credentials,
  sanitizePathSegment,
  validateProjectBackgroundUploadInput,
  validateTaskAssetUploadInput,
  verifyTaskAssetUpload,
} from "../../../apps/api/src/storage/s3";

describe("S3 helpers", () => {
  it("binds project background upload URLs to the declared content length", async () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    process.env.S3_REGION = "us-east-1";
    process.env.S3_FORCE_PATH_STYLE = "true";
    process.env.S3_KEY_PREFIX = "uploads";

    const upload = await createProjectBackgroundUploadUrl({
      workspaceId: "workspace-1",
      projectId: "project-1",
      contentType: "image/png",
      size: 12345,
    });

    expect(upload.key).toBe(
      `uploads/workspace/workspace-1/project/project-1/backgrounds/background-${upload.version}`,
    );
    expect(upload.headers).toEqual({ "Content-Type": "image/png" });
    expect(
      new URL(upload.uploadUrl).searchParams.get("X-Amz-SignedHeaders"),
    ).toContain("content-length");
  });
  it("validates project background type and size", () => {
    process.env.S3_MAX_IMAGE_UPLOAD_BYTES = "1048576";

    expect(() => validateProjectBackgroundUploadInput("", 10)).toThrow(
      "A valid content type is required.",
    );
    expect(() =>
      validateProjectBackgroundUploadInput("application/pdf", 10),
    ).toThrow('Unsupported content type "application/pdf"');
    expect(() => validateProjectBackgroundUploadInput("image/webp", 0)).toThrow(
      "Upload size must be greater than zero.",
    );
    expect(() =>
      validateProjectBackgroundUploadInput("image/webp", 1048577),
    ).toThrow("Upload exceeds the maximum upload size of 1MB.");
    expect(() =>
      validateProjectBackgroundUploadInput("image/webp", 1048576),
    ).not.toThrow();
  });
  it("only accepts the exact project background key and version", () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    process.env.S3_KEY_PREFIX = "staging";

    const context = {
      workspaceId: "workspace-1",
      projectId: "project-1",
      version: "version-1",
    };
    const validKey =
      "staging/workspace/workspace-1/project/project-1/backgrounds/background-version-1";

    expect(assertProjectBackgroundKeyMatchesContext(validKey, context)).toBe(
      true,
    );
    expect(
      assertProjectBackgroundKeyMatchesContext(
        validKey.replace("project-1", "project-2"),
        context,
      ),
    ).toBe(false);
    expect(
      assertProjectBackgroundKeyMatchesContext(
        `${validKey}/../../project-2/background`,
        context,
      ),
    ).toBe(false);
    expect(
      assertProjectBackgroundKeyMatchesContext(
        validKey.replace("version-1", "version-2"),
        context,
      ),
    ).toBe(false);
  });
  it("builds project background keys inside the project scope", () => {
    const context = {
      workspaceId: "Workspace 1",
      projectId: "Project 2",
    };
    const { rawKey, version } = buildProjectBackgroundObjectKey(context);

    expect(buildProjectBackgroundObjectKeyPrefix(context)).toBe(
      "workspace/workspace-1/project/project-2/backgrounds",
    );
    expect(rawKey).toBe(
      `workspace/workspace-1/project/project-2/backgrounds/background-${version}`,
    );
    expect(version).toMatch(/^[a-z0-9]+$/);
  });
  const originalMaxSize = process.env.S3_MAX_IMAGE_UPLOAD_BYTES;
  const originalEndpoint = process.env.S3_ENDPOINT;
  const originalBucket = process.env.S3_BUCKET;
  const originalAccessKeyId = process.env.S3_ACCESS_KEY_ID;
  const originalSecretAccessKey = process.env.S3_SECRET_ACCESS_KEY;
  const originalRegion = process.env.S3_REGION;
  const originalPathStyle = process.env.S3_FORCE_PATH_STYLE;
  const originalKeyPrefix = process.env.S3_KEY_PREFIX;

  beforeEach(() => {
    delete process.env.S3_MAX_IMAGE_UPLOAD_BYTES;
  });

  afterEach(() => {
    vi.restoreAllMocks();

    if (originalMaxSize === undefined) {
      delete process.env.S3_MAX_IMAGE_UPLOAD_BYTES;
    } else {
      process.env.S3_MAX_IMAGE_UPLOAD_BYTES = originalMaxSize;
    }

    if (originalEndpoint === undefined) {
      delete process.env.S3_ENDPOINT;
    } else {
      process.env.S3_ENDPOINT = originalEndpoint;
    }

    if (originalBucket === undefined) {
      delete process.env.S3_BUCKET;
    } else {
      process.env.S3_BUCKET = originalBucket;
    }

    if (originalAccessKeyId === undefined) {
      delete process.env.S3_ACCESS_KEY_ID;
    } else {
      process.env.S3_ACCESS_KEY_ID = originalAccessKeyId;
    }

    if (originalSecretAccessKey === undefined) {
      delete process.env.S3_SECRET_ACCESS_KEY;
    } else {
      process.env.S3_SECRET_ACCESS_KEY = originalSecretAccessKey;
    }

    if (originalRegion === undefined) {
      delete process.env.S3_REGION;
    } else {
      process.env.S3_REGION = originalRegion;
    }

    if (originalPathStyle === undefined) {
      delete process.env.S3_FORCE_PATH_STYLE;
    } else {
      process.env.S3_FORCE_PATH_STYLE = originalPathStyle;
    }

    if (originalKeyPrefix === undefined) {
      delete process.env.S3_KEY_PREFIX;
    } else {
      process.env.S3_KEY_PREFIX = originalKeyPrefix;
    }
  });

  it("recognizes allowed image content types case-insensitively", () => {
    expect(isImageContentType("IMAGE/PNG")).toBe(true);
    expect(isImageContentType("text/plain")).toBe(false);
  });

  it("parses booleans and positive integers with fallbacks", () => {
    expect(parseBoolean(undefined, true)).toBe(true);
    expect(parseBoolean(" false ", true)).toBe(false);
    expect(parsePositiveInt("42", 10)).toBe(42);
    expect(parsePositiveInt("0", 10)).toBe(10);
    expect(parsePositiveInt("nope", 10)).toBe(10);
  });

  it("sanitizes path segments and extracts normalized extensions", () => {
    expect(sanitizePathSegment(" Release Notes!!.PNG ")).toBe(
      "release-notes-.png",
    );
    expect(sanitizePathSegment("")).toBe("file");
    expect(getFileExtension("Screenshot.Final.PNG")).toBe("png");
    expect(getFileExtension("README")).toBe("file");
  });

  it("builds stable key prefixes and keys", () => {
    vi.spyOn(Date, "now").mockReturnValue(1_717_171_717_000);

    const key = buildObjectKey({
      workspaceId: "Workspace 1",
      projectId: "Project 2",
      taskId: "Task 3",
      surface: "comment",
      filename: "Sprint Plan Final!!.PNG",
      contentType: "image/png",
    });

    expect(
      buildObjectKeyPrefix({
        workspaceId: "Workspace 1",
        projectId: "Project 2",
        taskId: "Task 3",
        surface: "comment",
      }),
    ).toBe("workspace/workspace-1/project/project-2/task/task-3/comments");

    expect(key).toMatch(
      /^workspace\/workspace-1\/project\/project-2\/task\/task-3\/comments\/sprint-plan-final-1717171717000-[a-z0-9]+\.png$/,
    );
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    delete process.env.S3_KEY_PREFIX;

    expect(
      assertTaskImageKeyMatchesContext(key, {
        workspaceId: "Workspace 1",
        projectId: "Project 2",
        taskId: "Task 3",
        surface: "comment",
      }),
    ).toBe(true);
  });

  it("assertTaskImageKeyMatchesContext rejects traversal past the prefix", () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    delete process.env.S3_KEY_PREFIX;

    const ctx = {
      workspaceId: "ws1",
      projectId: "p1",
      taskId: "t1",
      surface: "description" as const,
    };
    const prefix = "workspace/ws1/project/p1/task/t1/descriptions";

    expect(
      assertTaskImageKeyMatchesContext(`${prefix}/image-1-abc.png`, ctx),
    ).toBe(true);

    for (const suffix of [
      "../../../../../../workspace/victim/secret.png",
      "nested/deeper.png",
      "..%2Fescape.png",
      ".hidden",
      "back\\slash.png",
    ]) {
      expect(assertTaskImageKeyMatchesContext(`${prefix}/${suffix}`, ctx)).toBe(
        false,
      );
    }
  });

  it("applyKeyPrefix prepends prefix and trims trailing slashes", () => {
    expect(applyKeyPrefix("", "workspace/a/file.png")).toBe(
      "workspace/a/file.png",
    );
    expect(applyKeyPrefix("staging", "workspace/a/file.png")).toBe(
      "staging/workspace/a/file.png",
    );
    expect(applyKeyPrefix("prod/kaneo/", "workspace/a/file.png")).toBe(
      "prod/kaneo/workspace/a/file.png",
    );
    expect(applyKeyPrefix("prefix///", "key")).toBe("prefix/key");
  });

  it("assertTaskImageKeyMatchesContext respects S3_KEY_PREFIX", () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    process.env.S3_KEY_PREFIX = "staging";

    const ctx = {
      workspaceId: "ws1",
      projectId: "p1",
      taskId: "t1",
      surface: "description" as const,
    };

    const prefixedKey =
      "staging/workspace/ws1/project/p1/task/t1/descriptions/img-123-abc.png";
    const unprefixedKey =
      "workspace/ws1/project/p1/task/t1/descriptions/img-123-abc.png";

    expect(assertTaskImageKeyMatchesContext(prefixedKey, ctx)).toBe(true);
    expect(assertTaskImageKeyMatchesContext(unprefixedKey, ctx)).toBe(false);
  });

  it("validates upload size against the configured maximum", () => {
    process.env.S3_MAX_IMAGE_UPLOAD_BYTES = "1048576";

    expect(() => validateTaskAssetUploadInput("", 10)).toThrow(
      "A valid content type is required.",
    );
    expect(() => validateTaskAssetUploadInput("image/png", 0)).toThrow(
      "Upload size must be a positive safe integer.",
    );
    expect(() =>
      validateTaskAssetUploadInput("image/png", 2 * 1024 * 1024),
    ).toThrow("Upload exceeds the maximum upload size of 1MB.");
    expect(() => validateTaskAssetUploadInput("image/png", 512)).not.toThrow();
  });

  it.each([
    Number.NaN,
    Number.POSITIVE_INFINITY,
    Number.NEGATIVE_INFINITY,
    -1,
    0.5,
    Number.MAX_SAFE_INTEGER + 1,
  ])("rejects invalid byte length %s before signing", (size) => {
    expect(() => validateTaskAssetUploadInput("image/png", size)).toThrow(
      "Upload size must be a positive safe integer.",
    );
  });

  it("creates presigned upload URLs without hoisted checksum query params", async () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    process.env.S3_REGION = "us-east-1";
    process.env.S3_FORCE_PATH_STYLE = "true";
    delete process.env.S3_KEY_PREFIX;

    const upload = await createTaskImageUploadUrl({
      workspaceId: "workspace-1",
      projectId: "project-1",
      taskId: "task-1",
      surface: "description",
      filename: "report.png",
      contentType: "image/png",
      size: 512,
    });

    const searchParams = new URL(upload.uploadUrl).searchParams;
    expect(searchParams.get("X-Amz-SignedHeaders")?.split(";")).toEqual(
      expect.arrayContaining(["content-length", "content-type", "host"]),
    );
    expect(upload.headers).not.toHaveProperty("Content-Length");
    expect(searchParams.has("x-amz-checksum-crc32")).toBe(false);
    expect(searchParams.has("x-amz-sdk-checksum-algorithm")).toBe(false);
  });

  it("logs a safe summary when an uploaded object cannot be verified", async () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";

    vi.spyOn(S3Client.prototype, "send").mockRejectedValue(
      Object.assign(
        new Error("https://storage.example.test/kaneo?X-Amz-Signature=x"),
        { name: "InternalError", $metadata: { httpStatusCode: 500 } },
      ) as never,
    );
    const log = vi.spyOn(console, "error").mockImplementation(() => {});

    await expect(
      verifyTaskAssetUpload("workspace/w1/project/p1/task/t1/a.png", {
        size: 12,
        contentType: "image/png",
      }),
    ).rejects.toThrow("Unable to verify uploaded object.");

    expect(log).toHaveBeenCalledWith("Unable to verify uploaded object:", {
      name: "InternalError",
      status: 500,
    });
    expect(JSON.stringify(log.mock.calls)).not.toContain("X-Amz-Signature");
  });

  it("accepts an upload that storage refuses for a moment after the PUT", async () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";

    const send = vi
      .spyOn(S3Client.prototype, "send")
      .mockRejectedValueOnce(
        Object.assign(new Error("UnknownError"), {
          name: "Unknown",
          $metadata: { httpStatusCode: 403 },
        }) as never,
      )
      .mockResolvedValue({
        ContentLength: 12,
        ContentType: "image/png",
      } as never);

    vi.useFakeTimers();
    try {
      const verified = verifyTaskAssetUpload(
        "workspace/w1/project/p1/task/t1/a.png",
        { size: 12, contentType: "image/png" },
      );
      await vi.runAllTimersAsync();

      await expect(verified).resolves.toEqual({
        size: 12,
        contentType: "image/png",
      });
      expect(send).toHaveBeenCalledTimes(2);
    } finally {
      vi.useRealTimers();
    }
  });

  it("copies a stored object into the destination task prefix", async () => {
    process.env.S3_ENDPOINT = "https://storage.example.test";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "test-access-key";
    process.env.S3_SECRET_ACCESS_KEY = "test-secret-key";
    process.env.S3_KEY_PREFIX = "kaneo-assets";

    const send = vi
      .spyOn(S3Client.prototype, "send")
      .mockResolvedValue(undefined as never);

    const key = await copyTaskAssetObject({
      sourceKey: "workspace/w1/project/p1/task/t1/descriptions/report.png",
      destination: {
        workspaceId: "workspace-1",
        projectId: "project-1",
        taskId: "task-2",
        surface: "description",
        filename: "report.png",
        contentType: "image/png",
      },
    });

    expect(key).toMatch(
      /^kaneo-assets\/workspace\/workspace-1\/project\/project-1\/task\/task-2\/descriptions\/report-\d+-[a-z0-9]+\.png$/,
    );

    const command = send.mock.calls[0]?.[0] as {
      input: Record<string, string>;
    };

    expect(command.input).toMatchObject({
      Bucket: "kaneo",
      CopySource:
        "kaneo/workspace/w1/project/p1/task/t1/descriptions/report.png",
      Key: key,
    });
  });

  it("resolveS3Credentials returns explicit credentials when both keys are set", () => {
    expect(resolveS3Credentials("AKIA", "secret")).toEqual({
      accessKeyId: "AKIA",
      secretAccessKey: "secret",
    });
  });

  it("resolveS3Credentials returns undefined when both keys are absent (IAM role fallback)", () => {
    expect(resolveS3Credentials("", "")).toBeUndefined();
  });

  it("resolveS3Credentials throws when only one key is set", () => {
    expect(() => resolveS3Credentials("AKIA", "")).toThrow(
      /both S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY/,
    );
    expect(() => resolveS3Credentials("", "secret")).toThrow(
      /both S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY/,
    );
  });

  it("assertStorageConfigured succeeds without static keys (IAM role mode)", () => {
    process.env.S3_ENDPOINT = "https://s3.us-east-1.amazonaws.com";
    process.env.S3_BUCKET = "kaneo";
    delete process.env.S3_ACCESS_KEY_ID;
    delete process.env.S3_SECRET_ACCESS_KEY;

    const config = assertStorageConfigured();
    expect(config.bucket).toBe("kaneo");
    expect(config.accessKeyId).toBe("");
    expect(config.secretAccessKey).toBe("");
  });

  it("assertStorageConfigured throws when only one credential key is set", () => {
    process.env.S3_ENDPOINT = "https://s3.us-east-1.amazonaws.com";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_ACCESS_KEY_ID = "AKIA";
    delete process.env.S3_SECRET_ACCESS_KEY;

    expect(() => assertStorageConfigured()).toThrow(
      /Incomplete S3 credentials/,
    );
  });

  it("assertStorageConfigured throws when endpoint or bucket is missing", () => {
    delete process.env.S3_ENDPOINT;
    delete process.env.S3_BUCKET;

    expect(() => assertStorageConfigured()).toThrow(
      /S3 uploads are not configured/,
    );
  });
});

describe("S3 credential provider chain (IAM role)", () => {
  const trackedKeys = [
    "S3_ENDPOINT",
    "S3_BUCKET",
    "S3_ACCESS_KEY_ID",
    "S3_SECRET_ACCESS_KEY",
    "S3_REGION",
    "S3_FORCE_PATH_STYLE",
    "S3_KEY_PREFIX",
    "AWS_ACCESS_KEY_ID",
    "AWS_SECRET_ACCESS_KEY",
    "AWS_SESSION_TOKEN",
  ] as const;

  const original: Partial<Record<(typeof trackedKeys)[number], string>> = {};

  beforeEach(() => {
    for (const key of trackedKeys) {
      original[key] = process.env[key];
      delete process.env[key];
    }
  });

  afterEach(() => {
    for (const key of trackedKeys) {
      const value = original[key];
      if (value === undefined) {
        delete process.env[key];
      } else {
        process.env[key] = value;
      }
    }
  });

  it("signs presigned URLs using ambient credentials when S3 keys are unset", async () => {
    // Non-sensitive, obviously-fake credentials generated at runtime so no
    // credential-like literals are committed (avoids secret-scanning hits).
    const ambientAccessKeyId = `test-ambient-key-${Date.now()}`;
    const ambientSecretAccessKey = `test-ambient-secret-${Date.now()}`;

    // Simulates an IAM role / IRSA / instance profile: no S3_ACCESS_KEY_ID is
    // configured, but ambient AWS credentials are resolvable from the
    // environment (the AWS SDK default provider chain reads AWS_* env vars).
    process.env.S3_ENDPOINT = "https://s3.us-east-1.amazonaws.com";
    process.env.S3_BUCKET = "kaneo";
    process.env.S3_REGION = "us-east-1";
    process.env.S3_FORCE_PATH_STYLE = "false";
    process.env.AWS_ACCESS_KEY_ID = ambientAccessKeyId;
    process.env.AWS_SECRET_ACCESS_KEY = ambientSecretAccessKey;

    const upload = await createTaskImageUploadUrl({
      workspaceId: "workspace-1",
      projectId: "project-1",
      taskId: "task-1",
      surface: "description",
      filename: "report.png",
      contentType: "image/png",
      size: 512,
    });

    const searchParams = new URL(upload.uploadUrl).searchParams;
    // The signature must be derived from the ambient credentials, proving the
    // SDK default provider chain (used for IAM roles) was applied.
    expect(searchParams.get("X-Amz-Credential")).toContain(ambientAccessKeyId);
    expect(searchParams.has("X-Amz-Signature")).toBe(true);
  });
});

vi.mock("../../../apps/api/src/database", () => ({ default: {} }));

const { contentReferencesAsset, extractAssetIds } =
  await import("../../../apps/api/src/storage/cleanup-assets");

describe("extractAssetIds", () => {
  it("extracts asset IDs from content with /api/asset/ URLs", () => {
    const content =
      '<p>Hello <img src="http://localhost:1337/api/asset/abc123" /> world <img src="/api/asset/def456" /></p>';
    const ids = extractAssetIds(content);
    expect(ids).toEqual(new Set(["abc123", "def456"]));
  });

  it("returns empty set for null/undefined/empty content", () => {
    expect(extractAssetIds(null)).toEqual(new Set());
    expect(extractAssetIds(undefined)).toEqual(new Set());
    expect(extractAssetIds("")).toEqual(new Set());
  });

  it("returns empty set when no asset URLs are present", () => {
    expect(extractAssetIds("<p>No images here</p>")).toEqual(new Set());
  });

  it("deduplicates repeated asset IDs", () => {
    const content = "/api/asset/abc123 and again /api/asset/abc123";
    expect(extractAssetIds(content)).toEqual(new Set(["abc123"]));
  });

  it("does not treat asset ID prefixes as references", () => {
    expect(contentReferencesAsset("/api/asset/abc123xyz", "abc123")).toBe(
      false,
    );
    expect(contentReferencesAsset("/api/asset/abc123", "abc123")).toBe(true);
  });
});