1 files changed, 270 insertions, 0 deletions
diff --git a/tests/integration.test.ts b/tests/integration.test.ts
new file mode 100644
index 0000000..666115a
--- /dev/null
+++ b/tests/integration.test.ts
@@ -0,0 +1,270 @@
+import { assertEquals, assertExists } from "@std/assert";
+
+const BASE_URL = "http://localhost:8000";
+
+// Helper to check if server is running
+async function isServerRunning(): Promise<boolean> {
+  try {
+    const response = await fetch(BASE_URL);
+    // Consume the response body to prevent resource leak
+    await response.body?.cancel();
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+Deno.test({
+  name: "GET / - returns upload page",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    const response = await fetch(BASE_URL);
+    assertEquals(response.status, 200);
+    assertEquals(response.headers.get("content-type"), "text/html");
+
+    const html = await response.text();
+    assertExists(html.includes("File Upload"));
+  },
+});
+
+Deno.test({
+  name: "GET /browse - returns browse page",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    const response = await fetch(`${BASE_URL}/browse`);
+    assertEquals(response.status, 200);
+    assertEquals(response.headers.get("content-type"), "text/html");
+
+    const html = await response.text();
+    assertExists(html.includes("Browse Files"));
+  },
+});
+
+Deno.test({
+  name: "GET /gallery - returns gallery page",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    const response = await fetch(`${BASE_URL}/gallery`);
+    assertEquals(response.status, 200);
+    assertEquals(response.headers.get("content-type"), "text/html");
+
+    const html = await response.text();
+    assertExists(html.includes("Gallery"));
+  },
+});
+
+Deno.test({
+  name: "POST /upload - uploads a file",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    const formData = new FormData();
+    const testFile = new File(["test content"], "test.txt", { type: "text/plain" });
+    formData.append("files", testFile);
+
+    const response = await fetch(`${BASE_URL}/upload`, {
+      method: "POST",
+      body: formData,
+    });
+
+    if (response.status === 429) {
+      console.log("⚠️  Rate limit exceeded, skipping test");
+      await response.body?.cancel();
+      return;
+    }
+
+    assertEquals(response.status, 200);
+    const data = await response.json();
+    assertExists(data.files);
+    assertEquals(Array.isArray(data.files), true);
+    assertEquals(data.files.length, 1);
+  },
+});
+
+Deno.test({
+  name: "POST /upload - rejects file exceeding size limit",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    // Create a file larger than the configured max size (512MB)
+    // For testing, we'll just check if the validation logic works
+    const formData = new FormData();
+
+    // Create a large blob (10MB for testing purposes)
+    const largeContent = new Uint8Array(10 * 1024 * 1024);
+    const largeFile = new File([largeContent], "large.bin", { type: "application/octet-stream" });
+    formData.append("files", largeFile);
+
+    const response = await fetch(`${BASE_URL}/upload`, {
+      method: "POST",
+      body: formData,
+    });
+
+    if (response.status === 429) {
+      console.log("⚠️  Rate limit exceeded, skipping test");
+      await response.body?.cancel();
+      return;
+    }
+
+    // Should succeed because 10MB < 512MB limit
+    assertEquals(response.status, 200);
+    await response.body?.cancel();
+  },
+});
+
+Deno.test({
+  name: "GET /download/:filename - downloads uploaded file",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    // First upload a file
+    const formData = new FormData();
+    const testContent = "download test content";
+    const testFile = new File([testContent], "downloadtest.txt", { type: "text/plain" });
+    formData.append("files", testFile);
+
+    const uploadResponse = await fetch(`${BASE_URL}/upload`, {
+      method: "POST",
+      body: formData,
+    });
+
+    if (uploadResponse.status === 429) {
+      console.log("⚠️  Rate limit exceeded, skipping test");
+      await uploadResponse.body?.cancel();
+      return;
+    }
+
+    const uploadData = await uploadResponse.json();
+    const filename = uploadData.files[0];
+
+    // Now download it
+    const downloadResponse = await fetch(`${BASE_URL}/download/${encodeURIComponent(filename)}`);
+    assertEquals(downloadResponse.status, 200);
+
+    const content = await downloadResponse.text();
+    assertEquals(content, testContent);
+  },
+});
+
+Deno.test({
+  name: "GET /download/:filename - handles spaces in filename",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    // Upload a file with spaces
+    const formData = new FormData();
+    const testContent = "space test content";
+    const testFile = new File([testContent], "test file with spaces.txt", { type: "text/plain" });
+    formData.append("files", testFile);
+
+    const uploadResponse = await fetch(`${BASE_URL}/upload`, {
+      method: "POST",
+      body: formData,
+    });
+
+    if (uploadResponse.status === 429) {
+      console.log("⚠️  Rate limit exceeded, skipping test");
+      await uploadResponse.body?.cancel();
+      return;
+    }
+
+    const uploadData = await uploadResponse.json();
+    const filename = uploadData.files[0];
+
+    // Download with encoded filename
+    const downloadResponse = await fetch(`${BASE_URL}/download/${encodeURIComponent(filename)}`);
+    assertEquals(downloadResponse.status, 200);
+
+    const content = await downloadResponse.text();
+    assertEquals(content, testContent);
+  },
+});
+
+Deno.test({
+  name: "GET /download/nonexistent - returns 404",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    const response = await fetch(`${BASE_URL}/download/nonexistent.txt`);
+    assertEquals(response.status, 404);
+    // Consume response body to prevent leak
+    await response.body?.cancel();
+  },
+});
+
+Deno.test({
+  name: "POST /upload-chunk - uploads file in chunks",
+  async fn() {
+    if (!await isServerRunning()) {
+      console.log("⚠️  Server not running, skipping integration test");
+      return;
+    }
+
+    const content = "chunked upload test content";
+    const filename = "chunked-test.txt";
+    const blob = new Blob([content]);
+    const chunkSize = 10; // Small chunk size for testing
+    const chunks = Math.ceil(blob.size / chunkSize);
+
+    // Upload chunks
+    for (let i = 0; i < chunks; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, blob.size);
+      const chunk = blob.slice(start, end);
+
+      const formData = new FormData();
+      formData.append("chunk", new File([chunk], "chunk"));
+      formData.append("filename", filename);
+      formData.append("chunkIndex", String(i));
+      formData.append("totalChunks", String(chunks));
+
+      const response = await fetch(`${BASE_URL}/upload-chunk`, {
+        method: "POST",
+        body: formData,
+      });
+
+      if (response.status === 429) {
+        console.log("⚠️  Rate limit exceeded, skipping test");
+        await response.body?.cancel();
+        return;
+      }
+
+      assertEquals(response.status, 200);
+      await response.body?.cancel();
+    }
+
+    // Verify the file was assembled correctly
+    const downloadResponse = await fetch(`${BASE_URL}/download/${encodeURIComponent(filename)}`);
+    assertEquals(downloadResponse.status, 200);
+
+    const downloadedContent = await downloadResponse.text();
+    assertEquals(downloadedContent, content);
+  },
+});