Adds better testing

Author: mackenly

.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+    lint:
+        runs-on: ubuntu-latest
+        timeout-minutes: 5
+        steps:
+            - uses: actions/checkout@v4
+            - name: Install dependencies
+              run: npm install
+            - name: Lint
+              run: npm run lint
+
+    test:
+        runs-on: ubuntu-latest
+        timeout-minutes: 5
+        steps:
+            - uses: actions/checkout@v4
+            - name: Install dependencies
+              run: npm install
+            - name: Test
+              run: npm test

.github/workflows/deploy.yml

@@ -5,12 +5,15 @@ on:
     branches:
       - main
   repository_dispatch:
+
 jobs:
   deploy:
     runs-on: ubuntu-latest
     name: Deploy
     steps:
-      - uses: actions/checkout@v4
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
       - name: Publish
         uses: cloudflare/wrangler-action@v3
         with:

src/constants.ts

@@ -30,7 +30,7 @@ export const PLATFORM_FILTERS = {
   },
   [AVAILABLE_PLATFORMS.Windows]: {
     extension: 'zip',
-    matches: ['x64', 'x32'],
+    matches: ['x86', 'x64', 'x32'],
   },
   [AVAILABLE_PLATFORMS.Linux]: {
     extension: 'gz',

src/getPlatform.test.ts

@@ -0,0 +1,45 @@
+import { AVAILABLE_PLATFORMS, AVAILABLE_ARCHITECTURES } from './constants'
+import { testAsset } from './getPlatform'
+import { describe, it, expect } from 'vitest'
+
+describe('testAsset', () => {
+  it('returns true for matching platform, architecture, and file extension', () => {
+    const target = AVAILABLE_PLATFORMS.Windows
+    const arch = AVAILABLE_ARCHITECTURES.x86
+    const fileName = 'example-x86.zip'
+
+    const result = testAsset(target, arch, fileName)
+
+    expect(result).toBe(true)
+  })
+
+  it('returns false for non-matching platform', () => {
+    const target = AVAILABLE_PLATFORMS.Linux
+    const arch = AVAILABLE_ARCHITECTURES.x86
+    const fileName = 'example-x86.zip'
+
+    const result = testAsset(target, arch, fileName)
+
+    expect(result).toBe(false)
+  })
+
+  it('returns false for non-matching architecture', () => {
+    const target = AVAILABLE_PLATFORMS.Windows
+    const arch = AVAILABLE_ARCHITECTURES.arm64
+    const fileName = 'example-x86.zip'
+
+    const result = testAsset(target, arch, fileName)
+
+    expect(result).toBe(false)
+  })
+
+  it('returns false for non-matching file extension', () => {
+    const target = AVAILABLE_PLATFORMS.Windows
+    const arch = AVAILABLE_ARCHITECTURES.x86
+    const fileName = 'example-x86.gz'
+
+    const result = testAsset(target, arch, fileName)
+
+    expect(result).toBe(false)
+  })
+})

src/getPlatform.ts

@@ -6,22 +6,24 @@ import {
 } from './constants'
 import { fileExt } from './utils/fileExt'
 
-export const testAsset = (
+export function testAsset(
   target: AVAILABLE_PLATFORMS,
   arch: AVAILABLE_ARCHITECTURES,
   fileName: string,
-): boolean => {
+): boolean {
   const { matches, extension } = PLATFORM_FILTERS[target]
   const arch_matches = ARCH_FILTERS[arch]
   const rightArch =
     arch_matches && ARCH_FILTERS[arch].some((arch) => fileName.includes(arch))
 
   // .app gz files don't have arch in the name
   if (!rightArch && target !== AVAILABLE_PLATFORMS.MacOS) {
+    console.error(`File ${fileName} has wrong architecture`)
     return false
   }
 
   if (fileExt(fileName) !== extension) {
+    console.error(`File ${fileName} has wrong extension`)
     return false
   }
 

src/handler.ts

@@ -7,9 +7,9 @@ import { findAssetSignature, getLatestRelease } from './services/github'
 import { TauriUpdateResponse } from './types'
 import { sanitizeVersion } from './utils/versioning'
 
-import { Request, ExecutionContext } from '@cloudflare/workers-types';
-import { WritableStream as WebWritableStream } from 'node:stream/web';
-import { Env } from '../worker-configuration';
+import { Request, ExecutionContext } from '@cloudflare/workers-types'
+import { WritableStream as WebWritableStream } from 'node:stream/web'
+import { Env } from '../worker-configuration'
 
 declare global {
   const GITHUB_ACCOUNT: string
@@ -26,10 +26,8 @@ const SendJSON = (data: Record<string, unknown>) => {
 const responses = {
   NotFound: () => new Response('Not found', { status: 404 }),
   NoContent: () => new Response(null, { status: 204 }),
-  SendUpdate: (data: TauriUpdateResponse) =>
-    SendJSON(data),
-  SendJSON
-
+  SendUpdate: (data: TauriUpdateResponse) => SendJSON(data),
+  SendJSON,
 }
 
 type RequestPathParts = [
@@ -38,7 +36,11 @@ type RequestPathParts = [
   AVAILABLE_ARCHITECTURES,
   string,
 ]
-const handleV1Request = async (request: Request, env: Env, ctx: ExecutionContext) => {
+const handleV1Request = async (
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext,
+) => {
   const path = new URL(request.url).pathname
   const [, target, arch, appVersion] = path
     .slice(1)
@@ -70,8 +72,10 @@ const handleV1Request = async (request: Request, env: Env, ctx: ExecutionContext
   }
 
   const signature = await findAssetSignature(match.name, release.assets)
-  const proxy = GITHUB_TOKEN?.length;
-  const downloadURL = proxy ? createProxiedFileUrl(request, env, ctx, match.browser_download_url) : match.browser_download_url
+  const proxy = GITHUB_TOKEN?.length
+  const downloadURL = proxy
+    ? createProxiedFileUrl(request, env, ctx, match.browser_download_url)
+    : match.browser_download_url
   const data: TauriUpdateResponse = {
     url: downloadURL,
     version: remoteVersion,
@@ -83,47 +87,65 @@ const handleV1Request = async (request: Request, env: Env, ctx: ExecutionContext
   return responses.SendUpdate(data)
 }
 
-const createProxiedFileUrl = (request: Request, env: Env, ctx: ExecutionContext, downloadURL: string) => {
-
+const createProxiedFileUrl = (
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext,
+  downloadURL: string,
+) => {
   const fileName = downloadURL.split('/')?.at(-1)
-  if (!fileName) { throw new Error('Could not get file name from download URL') }
-
+  if (!fileName) {
+    throw new Error('Could not get file name from download URL')
+  }
 
   const path = new URL(request.url)
   const root = `${path.protocol}//${path.host}`
 
   return new URL(`/latest/${fileName}`, root).toString()
 }
 
-const getLatestAssets = async (request: Request, env: Env, ctx: ExecutionContext) => {
+const getLatestAssets = async (
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext,
+) => {
   const fileName = request.url.split('/')?.at(-1)
-  if (!fileName) { throw new Error('Could not get file name from download URL') }
+  if (!fileName) {
+    throw new Error('Could not get file name from download URL')
+  }
 
   const release = await getLatestRelease(request, env, ctx)
-  const downloadPath = release.assets.find(({ name }) => name === fileName)?.browser_download_url
+  const downloadPath = release.assets.find(
+    ({ name }) => name === fileName,
+  )?.browser_download_url
 
-  if (!downloadPath) { throw new Error('Could not get file path from download URL') }
+  if (!downloadPath) {
+    throw new Error('Could not get file path from download URL')
+  }
 
-  const { readable } = new TransformStream<Uint8Array, Uint8Array>();
+  const { readable } = new TransformStream<Uint8Array, Uint8Array>()
   const file_response = await fetch(downloadPath, {
     method: 'GET',
-    redirect: 'follow'
+    redirect: 'follow',
   })
 
   if (file_response.body) {
-    const webWritableStream = new WebWritableStream();
-    await file_response.body.pipeTo(webWritableStream);
-    return new Response(readable, file_response);
+    const webWritableStream = new WebWritableStream()
+    await file_response.body.pipeTo(webWritableStream)
+    return new Response(readable, file_response)
   }
 
   throw new Error('Could not get file body from download URL')
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function handleRequest(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+export async function handleRequest(
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext,
+): Promise<Response> {
   const path = new URL(request.url).pathname
 
-
   if (path.includes('/latest')) {
     return getLatestAssets(request, env, ctx)
   }

src/index.test.ts

@@ -1,25 +1,25 @@
-import { env, createExecutionContext, waitOnExecutionContext } from "cloudflare:test";
-import { describe, it, expect } from "vitest";
-import { Env } from '../worker-configuration';
+import { createExecutionContext, waitOnExecutionContext } from 'cloudflare:test'
+import { describe, it, expect } from 'vitest'
+import { Env } from '../worker-configuration'
 // Could import any other source file/function here
-import worker from "../src";
+import worker from '../src'
 
 // For now, you'll need to do something like this to get a correctly-typed
 // `Request` to pass to `worker.fetch()`.
-const IncomingRequest = Request<unknown, IncomingRequestCfProperties>;
+const IncomingRequest = Request<unknown, IncomingRequestCfProperties>
 
-describe("handle GET", () => {
-    it("responds with 200", async () => {
-        const request = new IncomingRequest("http://example.com");
-        // Create an empty context to pass to `worker.fetch()`
-        const ctx = createExecutionContext();
-        const env: Env = {
-            GITHUB_ACCOUNT: 'killeencode',
-            GITHUB_REPO: 'brancato'
-        };
-        const response = await worker.fetch(request, env, ctx);
-        // Wait for all `Promise`s passed to `ctx.waitUntil()` to settle before running test assertions
-        await waitOnExecutionContext(ctx);
-        expect(response.status).toBe(200);
-    });
-});
+describe('handle GET', () => {
+  it('responds with 200', async () => {
+    const request = new IncomingRequest('http://example.com')
+    // Create an empty context to pass to `worker.fetch()`
+    const ctx = createExecutionContext()
+    const env: Env = {
+      GITHUB_ACCOUNT: 'killeencode',
+      GITHUB_REPO: 'brancato',
+    }
+    const response = await worker.fetch(request, env, ctx)
+    // Wait for all `Promise`s passed to `ctx.waitUntil()` to settle before running test assertions
+    await waitOnExecutionContext(ctx)
+    expect(response.status).toBe(200)
+  })
+})

src/index.ts

@@ -1,9 +1,9 @@
-import { handleRequest } from './handler';
-import { Request, ExecutionContext } from '@cloudflare/workers-types';
-import { Env } from '../worker-configuration';
+import { handleRequest } from './handler'
+import { Request, ExecutionContext } from '@cloudflare/workers-types'
+import { Env } from '../worker-configuration'
 
 export default {
   async fetch(request: Request, env: Env, ctx: ExecutionContext) {
-    return handleRequest(request, env, ctx);
+    return handleRequest(request, env, ctx)
   },
-};
+}

src/legacy/handler.ts

@@ -4,10 +4,14 @@ import { Asset, findAssetSignature, getReleases } from '../services/github'
 import { TauriUpdateResponse } from '../types'
 import { sanitizeVersion, semverGt, semverValid } from '../utils/versioning'
 
-import { Env } from '../../worker-configuration';
-import { Request, ExecutionContext } from '@cloudflare/workers-types';
-
-export async function handleLegacyRequest(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+import { Env } from '../../worker-configuration'
+import { Request, ExecutionContext } from '@cloudflare/workers-types'
+
+export async function handleLegacyRequest(
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext,
+): Promise<Response> {
   const path = new URL(request.url).pathname
   const [platform, version] = path.slice(1).split('/')
 

src/services/github.ts

@@ -1,9 +1,12 @@
-import { Env } from '../../worker-configuration';
-import { Request, Response, ExecutionContext } from '@cloudflare/workers-types';
+import { Env } from '../../worker-configuration'
+import { Request, Response } from '@cloudflare/workers-types'
 
 export type Asset = { name: string; browser_download_url: string }
 
-export const getReleases = async (request: Request, env: Env, ctx: ExecutionContext): Promise<Response> => {
+export const getReleases = async (
+  request: Request,
+  env: Env,
+): Promise<Response> => {
   const reqUrl = new URL(
     `https://api.github.com/repos/${env.GITHUB_ACCOUNT}/${env.GITHUB_REPO}/releases/latest`,
   )
@@ -12,14 +15,15 @@ export const getReleases = async (request: Request, env: Env, ctx: ExecutionCont
     'User-Agent': request.headers.get('User-Agent') as string,
   })
 
-  if (env.GITHUB_TOKEN?.length) headers.set('Authorization', `token ${env.GITHUB_TOKEN}`)
+  if (env.GITHUB_TOKEN?.length)
+    headers.set('Authorization', `token ${env.GITHUB_TOKEN}`)
 
   const response = await fetch(reqUrl.toString(), {
     method: 'GET',
     headers,
-  });
+  })
 
-  return response;
+  return response
 }
 
 type Release = {
@@ -29,8 +33,11 @@ type Release = {
   published_at: string
 }
 
-export const getLatestRelease = async (request: Request, env: Env, ctx: ExecutionContext): Promise<Release> => {
-  const releases = await getReleases(request, env, ctx)
+export const getLatestRelease = async (
+  request: Request,
+  env: Env,
+): Promise<Release> => {
+  const releases = await getReleases(request, env)
 
   return (await releases.json()) as Release
 }