Refactor how influx lib is tested

Author: pyropy

bin/worker.js

@@ -1,14 +1,9 @@
-import { reportRequestMetric } from "../lib/influx.js";
+import { reportRequestMetric } from '../lib/influx.js'
 
 export default {
-  async fetch(request, env, ctx) {
-    const response = await fetch(request);
-    ctx.waitUntil(
-      caches.default.put(request, response.clone())
-    )
-    ctx.waitUntil(
-      reportRequestMetric(request, env)
-    );
-    return response;
-  }
+  async fetch(request, env, ctx, { reportRequestMetric } = { reportRequestMetric }) {
+    const response = await fetch(request)
+    ctx.waitUntil(reportRequestMetric(request, env))
+    return response
+  },
 }

lib/influx.js

@@ -13,7 +13,7 @@ export const reportRequestMetric = async (request, env) => {
 * @param {Request} request - incoming request
 * @param {object} env - environment variables
 */
-const createMetricsFromRequest = (request, env) => {
+export const createMetricsFromRequest = (request, env) => {
   const url = new URL(request.url);
   const timestamp = Date.now();
   const apiKey = request.headers.get('api-key') ||
@@ -32,7 +32,7 @@ const createMetricsFromRequest = (request, env) => {
 * @param {string} lineProtocolData - InfluxDB line protocol formatted data
 * @param {object} env - environment variables
 */
-const writeMetrics = async (lineProtocolData, env) => {
+export const writeMetrics = async (lineProtocolData, env) => {
   // Define API endpoint and headers
   const url = `${env.INFLUX_URL}/api/v2/write?&bucket=${env.INFLUX_DATABASE}&precision=ms`;
 

test/influx.test.js

@@ -1,75 +1,96 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { reportRequestMetric } from '../lib/influx.js';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { createMetricsFromRequest, writeMetrics } from '../lib/influx.js'
 
-describe('reportRequestMetric', () => {
-  const date = new Date();
-  const env = {
-    INFLUX_METRIC_NAME: 'test_metric',
-    INFLUX_URL: 'https://influx.example.com',
-    INFLUX_DATABASE: 'test_db',
-    INFLUX_TOKEN: 'test_token'
-  };
+describe('createMetricsFromRequest', () => {
+  const date = new Date()
+  const env = withTestEnvitronment()
 
   beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(date);
-    global.fetch = vi.fn().mockResolvedValue({ status: 204 });
-  });
+    vi.useFakeTimers()
+    vi.setSystemTime(date)
+  })
+
+  afterEach(() => {
+    vi.useRealTimers()
+  })
 
   const testCases = [
     {
       description: 'when request has an API key in the Authorization header',
       request: {
         url: 'https://example.com/path',
         method: 'GET',
-        headers: new Map([['Authorization', 'Bearer test-key']])
+        headers: new Map([['Authorization', 'Bearer test-key']]),
       },
-      expectedApiKey: 'test-key'
+      expectedApiKey: 'test-key',
     },
     {
       description: 'when request has an API key in the api-key header',
       request: {
         url: 'https://example.com/path',
         method: 'GET',
-        headers: new Map([['api-key', 'test-key']])
+        headers: new Map([['api-key', 'test-key']]),
       },
-      expectedApiKey: 'test-key'
+      expectedApiKey: 'test-key',
     },
     {
       description: 'when request has an API key in the query string',
       request: {
         url: 'https://example.com/path?api-key=test-key',
         method: 'GET',
-        headers: new Map()
+        headers: new Map(),
       },
-      expectedApiKey: 'test-key'
+      expectedApiKey: 'test-key',
     },
     {
       description: 'when request has no API key',
       request: {
         url: 'https://example.com/path',
         method: 'GET',
-        headers: new Map()
+        headers: new Map(),
       },
-      expectedApiKey: 'unknown'
-    }
-  ];
+      expectedApiKey: 'unknown',
+    },
+  ]
 
   testCases.forEach(({ description, request, expectedApiKey }) => {
-    it(description, async () => {
-      await reportRequestMetric(request, env);
+    it(description, () => {
+      const result = createMetricsFromRequest(request, env)
+      expect(result).toContain(expectedApiKey)
+    })
+  })
+})
+
+describe('writeMetrics', () => {
+  it('send request metrics to InfluxDB over HTTP', async () => {
+    const env = withTestEnvitronment()
+    const lineProtocolData = 'test_metric api_key="test-key"'
+    global.fetch = vi
+      .fn()
+      .mockResolvedValue(new Response(null, { status: 204 }))
 
-      expect(global.fetch).toHaveBeenCalledWith(
-        'https://influx.example.com/api/v2/write?&bucket=test_db&precision=ms',
-        expect.objectContaining({
-          method: 'POST',
-          headers: expect.objectContaining({
-            'Authorization': 'Token test_token',
-            'Content-Type': 'application/octet-stream'
-          }),
-          body: `test_metric api_key="${expectedApiKey}" ${date.valueOf()}`
-        })
-      );
-    });
-  });
-});
+    const response = await writeMetrics(lineProtocolData, env)
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://influx.example.com/api/v2/write?&bucket=test_db&precision=ms',
+      expect.objectContaining({
+        method: 'POST',
+        headers: expect.objectContaining({
+          Authorization: 'Token test_token',
+          'Content-Type': 'application/octet-stream',
+        }),
+        body: lineProtocolData,
+      }),
+    )
+    expect(response.status).toBe(204)
+  })
+})
+
+const withTestEnvitronment = () => {
+  return {
+    INFLUX_METRIC_NAME: 'test_metric',
+    INFLUX_URL: 'https://influx.example.com',
+    INFLUX_DATABASE: 'test_db',
+    INFLUX_TOKEN: 'test_token',
+  }
+}

test/worker.test.js

@@ -1,32 +1,22 @@
-import { describe, it, expect, vi } from 'vitest';
 import worker from '../bin/worker.js';
-import { reportRequestMetric } from '../lib/influx.js';
-
-
+import { describe, it, expect, vi } from 'vitest';
 
 describe('worker.fetch', () => {
-  it('should fetch and report metrics correctly', async () => {
+  it('should fetch and report metrics', async () => {
     const request = {
-      url: 'https://example.com/path?api-key=test-key',
+      url: 'https://example.com/path',
       method: 'GET'
     };
-    const env = {
-      REQUEST_URL: 'https://proxy.example.com'
-    };
+    const env = {};
     const ctx = {
       waitUntil: vi.fn()
     };
-
-    global.fetch = vi.fn().mockResolvedValue(new Response(null, { status: 200 }));
-    const response = await worker.fetch(request, env, ctx);
-
-    expect(global.fetch).toHaveBeenCalledWith(
-      expect.objectContaining({
-        url: 'https://example.com/path?api-key=test-key',
-        method: 'GET'
-      })
-    );
-    expect(ctx.waitUntil).toHaveBeenCalledWith(reportRequestMetric(request, response, env));
-    expect(response.status).toBe(200);
+    global.fetch = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const reportRequestMetric = vi.fn()
+    const response = await worker.fetch(request, env, ctx, { reportRequestMetric });
+    expect(global.fetch).toHaveBeenCalledWith(request);
+    expect(ctx.waitUntil).toHaveBeenCalledWith(reportRequestMetric(request, env));
+    expect(reportRequestMetric).toHaveBeenCalledWith(request, env);
+    expect(response.status).toBe(204);
   });
 });