get test coverage back

Signed-off-by: karthik2804 <[email protected]>

Author: karthik2804

test/test-app/package-lock.json

@@ -19,8 +19,8 @@
   },
   "dependencies": {
     "@spinframework/build-tools": "file:../../packages/build-tools",
+    "@spinframework/spin-kv": "file:../../packages/spin-kv",
     "@spinframework/spin-variables": "file:../../packages/spin-variables",
-    "@spinframework/spin-redis": "file:../../packages/spin-redis",
     "@spinframework/wasi-http-proxy": "file:../../packages/http-trigger",
     "itty-router": "^5.0.18"
   },

test/test-app/package.json

@@ -13,6 +13,8 @@ component = "test-app"
 [component.test-app]
 source = "dist/test-app.wasm"
 exclude_files = ["**/node_modules"]
+allowed_outbound_hosts = ["http://localhost:3000"]
+key_value_stores = ["default"]
 [component.test-app.build]
 command = ["npm install", "npm run build"]
 watch = ["src/**/*.ts"]

test/test-app/spin.toml

@@ -0,0 +1,50 @@
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+
+export function isEqualBytes(
+    bytes1: Uint8Array,
+    bytes2: Uint8Array
+
+): boolean {
+
+    if (bytes1.length !== bytes2.length) {
+        return false;
+    }
+
+    for (let i = 0; i < bytes1.length; i++) {
+        if (bytes1[i] !== bytes2[i]) {
+            return false;
+        }
+    }
+
+    return true;
+
+}
+
+export function sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function readStreamChunks(stream: ReadableStream) {
+    const reader = stream.getReader();
+    const chunks = [];
+
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        chunks.push(decoder.decode(value));
+    }
+
+    return chunks;
+}
+
+export async function pushStreamChunks(stream: WritableStream<any>, chunks: string[]) {
+    const writer = stream.getWriter();
+
+    for (const chunk of chunks) {
+        await writer.write(encoder.encode(chunk));
+        await sleep(20);
+    }
+
+    writer.close();
+}

test/test-app/src/helpers.ts

@@ -1,18 +1,19 @@
-// For AutoRouter documentation refer to https://itty.dev/itty-router/routers/autorouter
-import { AutoRouter } from 'itty-router';
-import * as Variables from '@spinframework/spin-variables';
+import { AutoRouter } from "itty-router"
+import { headersTest, health, kvTest, kvTestUint8Array, outboundHttp, statusTest, stream, streamTest, testFunctionality } from "./test";
 
-let router = AutoRouter();
+let router = AutoRouter()
 
-// Route ordering matters, the first route that matches will be used
-// Any route that does not return will be treated as a middleware
-// Any unmatched route will return a 404
-router
-    .get("/", () => new Response("hello universe"))
-    .get('/hello/:name', ({ name }) => `Hello, ${name}!`)
+router.get("/health", health)
+router.get("/stream", stream)
+router.get("/statusTest", statusTest)
+router.get("/headersTest", headersTest)
+router.get("/outboundHttp", outboundHttp)
+router.get("/kvTest", kvTest)
+router.get("/kvTestUint8Array", kvTestUint8Array)
+router.get("/streamTest", streamTest)
+router.get("/testFunctionality", testFunctionality)
 
 //@ts-ignore
 addEventListener('fetch', async (event: FetchEvent) => {
-    console.log(Variables.get('test'));
     event.respondWith(router.fetch(event.request));
-});
+});

test/test-app/src/index.ts

@@ -0,0 +1,117 @@
+import * as Kv from "@spinframework/spin-kv";
+import { pushStreamChunks, isEqualBytes, readStreamChunks } from "./helpers";
+
+const decoder = new TextDecoder()
+const streamingChunks = ["chunk1", "chunk2", "chunk3", "chunk4", "chunk5"]
+
+function health(req: Request) {
+    return new Response("Healthy", { status: 200 })
+}
+
+function stream(req: Request) {
+    const { readable, writable } = new TransformStream();
+    pushStreamChunks(writable, streamingChunks)
+
+    // Return the stream as a Response
+    return new Response(readable, {
+        headers: { 'Content-Type': 'text/plain' },
+    })
+}
+
+function statusTest(req: Request) {
+    return new Response(null, { status: 201 })
+}
+
+function headersTest(req: Request) {
+    return new Response(null, { headers: { "content-type": "text/html" } })
+}
+
+async function outboundHttp(req: Request) {
+    let requestUrl = "http://localhost:3000/health"
+    let response = await fetch(requestUrl)
+    if (response.status == 200) {
+        if (await response.text() == "Healthy") {
+            return new Response("success", { status: 200 })
+        }
+    }
+    return new Response("failed", { status: 500 })
+}
+
+function kvTest(req: Request) {
+    let store = Kv.openDefault()
+    store.set("test", "try")
+    if (decoder.decode(store.get("test") || new Uint8Array()) == "try") {
+        return new Response("success", { status: 200 })
+    }
+    return new Response("failed", { status: 500 })
+}
+
+function kvTestUint8Array(req: Request) {
+    let store = Kv.openDefault()
+
+    let arr = new Uint8Array([1, 2, 3])
+    store.set("arr", arr)
+    let ret = store.get("arr")
+
+    if (ret == null || !isEqualBytes(ret, arr)) {
+        return new Response("failed", { status: 500 })
+    }
+    return new Response("success", { status: 200 })
+}
+
+async function streamTest(req: Request) {
+    let response = await fetch("http://localhost:3000/stream")
+
+    if (response.body == null) {
+        return new Response("response has no body", { status: 500 })
+    }
+
+    let chunks = await readStreamChunks(response.body)
+
+    if (chunks.length != streamingChunks.length) {
+        return new Response("chunks length mismatch", { status: 500 })
+    }
+
+    for (let i = 0; i < chunks.length; i++) {
+        if (chunks[i] != streamingChunks[i]) {
+            return new Response("chunks mismatch", { status: 500 })
+        }
+    }
+
+    return new Response("success", { status: 200 })
+}
+
+async function testFunctionality(req: Request) {
+    const testCases = [
+        { name: "statusTest", validate: (resp: Response) => resp.status === 201 },
+        { name: "headersTest", validate: (resp: Response) => resp.status === 200 && resp.headers.get("Content-Type") === "text/html" },
+        { name: "outboundHttp", validate: (resp: Response) => resp.status === 200 },
+        { name: "kvTest", validate: (resp: Response) => resp.status === 200 },
+        { name: "kvTestUint8Array", validate: (resp: Response) => resp.status === 200 },
+        { name: "streamTest", validate: (resp: Response) => resp.status === 200 },
+    ];
+
+    const results: { [key: string]: boolean } = {};
+
+    for (const test of testCases) {
+        const resp = await fetch(`http://localhost:3000/${test.name}`);
+        results[test.name] = test.validate(resp);
+    }
+
+    const allPassed = Object.values(results).every(Boolean);
+    let status = allPassed ? 200 : 500;
+    return new Response(JSON.stringify(results, null, 2), { status });
+}
+
+
+export {
+    health,
+    stream,
+    testFunctionality,
+    headersTest,
+    statusTest,
+    outboundHttp,
+    kvTest,
+    kvTestUint8Array,
+    streamTest
+}

test/test-app/src/test.ts

@@ -22,11 +22,11 @@ SPIN_PID=$!
 
 # wait for app to be up and running
 echo "Waiting for Spin app to be ready"
-timeout 60s bash -c 'until curl --silent -f http://localhost:3000/ > /dev/null; do sleep 2; done'
+timeout 60s bash -c 'until curl --silent -f http://localhost:3000/health > /dev/null; do sleep 2; done'
 
 # start the test
 echo "Starting test\n"
-curl -f http://localhost:3000/ || isFailed=true
+curl -f http://localhost:3000/testFunctionality || isFailed=true
 echo "\n\nTest completed"
 
 # kill the spin app