@powersync/service-core 0.8.7 → 0.9.0

package/test/src/env.ts

@@ -2,7 +2,5 @@ import { utils } from '@powersync/lib-services-framework';
 
 export const env = utils.collectEnvironmentVariables({
   MONGO_TEST_URL: utils.type.string.default('mongodb://localhost:27017/powersync_test'),
-  PG_TEST_URL: utils.type.string.default('postgres://postgres:postgres@localhost:5432/powersync_test'),
-  CI: utils.type.boolean.default('false'),
-  SLOW_TESTS: utils.type.boolean.default('false')
+  CI: utils.type.boolean.default('false')
 });

package/test/src/merge_iterable.test.ts

@@ -1,11 +1,6 @@
+import { mergeAsyncIterablesNew, mergeAsyncIterablesOld } from '@/sync/merge.js';
 import * as timers from 'timers/promises';
 import { describe, expect, test } from 'vitest';
-import {
-  FixedMergeAsyncIterable,
-  mergeAsyncIterables,
-  mergeAsyncIterablesNew,
-  mergeAsyncIterablesOld
-} from '../../src/sync/merge.js';
 
 type MergeIteratorFunction = <T>(source: AsyncIterable<T>[]) => AsyncIterable<T>;
 

package/test/src/routes/probes.integration.test.ts

@@ -0,0 +1,235 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import Fastify, { FastifyInstance } from 'fastify';
+import { container } from '@powersync/lib-services-framework';
+import * as auth from '../../../src/routes/auth.js';
+import * as system from '../../../src/system/system-index.js';
+import { configureFastifyServer } from '../../../src/index.js';
+import { ProbeRoutes } from '../../../src/routes/endpoints/probes.js';
+
+vi.mock('@powersync/lib-services-framework', async () => {
+  const actual = (await vi.importActual('@powersync/lib-services-framework')) as any;
+  return {
+    ...actual,
+    container: {
+      ...actual.container,
+      probes: {
+        state: vi.fn()
+      }
+    }
+  };
+});
+
+describe('Probe Routes Integration', () => {
+  let app: FastifyInstance;
+  let mockSystem: system.ServiceContext;
+
+  beforeEach(async () => {
+    app = Fastify();
+    mockSystem = { routerEngine: {} } as system.ServiceContext;
+    await configureFastifyServer(app, { service_context: mockSystem });
+    await app.ready();
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe('Startup Probe', () => {
+    it('returns 200 when system is started', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date()
+      };
+      vi.spyOn(auth, 'authUser').mockResolvedValue({ authorized: true });
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.STARTUP
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.payload)).toEqual({
+        ...mockState,
+        touched_at: mockState.touched_at.toISOString()
+      });
+    });
+
+    it('returns 400 when system is not started', async () => {
+      const mockState = {
+        started: false,
+        ready: false,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.STARTUP
+      });
+
+      expect(response.statusCode).toBe(400);
+      expect(JSON.parse(response.payload)).toEqual({
+        ...mockState,
+        touched_at: mockState.touched_at.toISOString()
+      });
+    });
+  });
+
+  describe('Liveness Probe', () => {
+    it('returns 200 when system was touched recently', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.LIVENESS
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.payload)).toEqual({
+        ...mockState,
+        touched_at: mockState.touched_at.toISOString()
+      });
+    });
+
+    it('returns 400 when system has not been touched recently', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date(Date.now() - 15000) // 15 seconds ago
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.LIVENESS
+      });
+
+      expect(response.statusCode).toBe(400);
+      expect(JSON.parse(response.payload)).toEqual({
+        ...mockState,
+        touched_at: mockState.touched_at.toISOString()
+      });
+    });
+  });
+
+  describe('Readiness Probe', () => {
+    it('returns 200 when system is ready', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.READINESS
+      });
+
+      expect(response.statusCode).toBe(200);
+      expect(JSON.parse(response.payload)).toEqual({
+        ...mockState,
+        touched_at: mockState.touched_at.toISOString()
+      });
+    });
+
+    it('returns 400 when system is not ready', async () => {
+      const mockState = {
+        started: true,
+        ready: false,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.READINESS
+      });
+
+      expect(response.statusCode).toBe(400);
+      expect(JSON.parse(response.payload)).toEqual({
+        ...mockState,
+        touched_at: mockState.touched_at.toISOString()
+      });
+    });
+  });
+
+  describe('Request Queue Behavior', () => {
+    it('handles concurrent requests within limits', async () => {
+      const mockState = { started: true, ready: true, touched_at: new Date() };
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      // Create array of 15 concurrent requests (default concurrency is 10)
+      const requests = Array(15)
+        .fill(null)
+        .map(() =>
+          app.inject({
+            method: 'GET',
+            url: ProbeRoutes.STARTUP
+          })
+        );
+
+      const responses = await Promise.all(requests);
+
+      // All requests should complete successfully
+      responses.forEach((response) => {
+        expect(response.statusCode).toBe(200);
+        expect(JSON.parse(response.payload)).toEqual({
+          ...mockState,
+          touched_at: mockState.touched_at.toISOString()
+        });
+      });
+    });
+
+    it('respects max queue depth', async () => {
+      const mockState = { started: true, ready: true, touched_at: new Date() };
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      // Create array of 35 concurrent requests (default max_queue_depth is 20)
+      const requests = Array(35)
+        .fill(null)
+        .map(() =>
+          app.inject({
+            method: 'GET',
+            url: ProbeRoutes.STARTUP
+          })
+        );
+
+      const responses = await Promise.all(requests);
+
+      // Some requests should succeed and some should fail with 429
+      const successCount = responses.filter((r) => r.statusCode === 200).length;
+      const queueFullCount = responses.filter((r) => r.statusCode === 429).length;
+
+      expect(successCount).toBeGreaterThan(0);
+      expect(queueFullCount).toBeGreaterThan(0);
+      expect(successCount + queueFullCount).toBe(35);
+    });
+  });
+
+  describe('Content Types', () => {
+    it('returns correct content type headers', async () => {
+      const mockState = { started: true, ready: true, touched_at: new Date() };
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await app.inject({
+        method: 'GET',
+        url: ProbeRoutes.STARTUP
+      });
+
+      expect(response.headers['content-type']).toMatch(/application\/json/);
+    });
+  });
+});

package/test/src/routes/probes.test.ts

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { container } from '@powersync/lib-services-framework';
+import { startupCheck, livenessCheck, readinessCheck } from '../../../src/routes/endpoints/probes.js';
+
+// Mock the container
+vi.mock('@powersync/lib-services-framework', () => ({
+  container: {
+    probes: {
+      state: vi.fn()
+    }
+  },
+  router: {
+    HTTPMethod: {
+      GET: 'GET'
+    },
+    RouterResponse: class RouterResponse {
+      status: number;
+      data: any;
+      headers: Record<string, string>;
+      afterSend: () => Promise<void>;
+      __micro_router_response = true;
+
+      constructor({ status, data, headers, afterSend }: {
+        status?: number;
+        data: any;
+        headers?: Record<string, string>;
+        afterSend?: () => Promise<void>;
+      }) {
+        this.status = status || 200;
+        this.data = data;
+        this.headers = headers || { 'Content-Type': 'application/json' };
+        this.afterSend = afterSend ?? (() => Promise.resolve());
+      }
+    }
+  }
+}));
+
+describe('Probe Routes', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('startupCheck', () => {
+    it('has the correct route definitions', () => {
+      expect(startupCheck.path).toBe('/probes/startup');
+      expect(startupCheck.method).toBe('GET');
+    });
+
+    it('returns 200 when started is true', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await startupCheck.handler();
+
+      expect(response.status).toEqual(200);
+      expect(response.data).toEqual(mockState);
+    });
+
+    it('returns 400 when started is false', async () => {
+      const mockState = {
+        started: false,
+        ready: false,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await startupCheck.handler();
+
+      expect(response.status).toBe(400);
+      expect(response.data).toEqual(mockState);
+    });
+  });
+
+  describe('livenessCheck', () => {
+    it('has the correct route definitions', () => {
+      expect(livenessCheck.path).toBe('/probes/liveness');
+      expect(livenessCheck.method).toBe('GET');
+    });
+
+    it('returns 200 when last touch was less than 10 seconds ago', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date(Date.now() - 9000) // 11 seconds ago
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await livenessCheck.handler();
+
+      expect(response.status).toBe(200);
+      expect(response.data).toEqual(mockState);
+    });
+
+    it('returns 400 when last touch was more than 10 seconds ago', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date(Date.now() - 11000)
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await livenessCheck.handler();
+
+      expect(response.status).toBe(400);
+      expect(response.data).toEqual(mockState);
+    });
+  });
+
+  describe('readinessCheck', () => {
+    it('has the correct route definitions', () => {
+      expect(readinessCheck.path).toBe('/probes/readiness');
+      expect(readinessCheck.method).toBe('GET');
+    });
+
+    it('returns 200 when ready is true', async () => {
+      const mockState = {
+        started: true,
+        ready: true,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await readinessCheck.handler();
+
+      expect(response.status).toBe(200);
+      expect(response.data).toEqual(mockState);
+    });
+
+    it('returns 400 when ready is false', async () => {
+      const mockState = {
+        started: true,
+        ready: false,
+        touched_at: new Date()
+      };
+
+      vi.mocked(container.probes.state).mockReturnValue(mockState);
+
+      const response = await readinessCheck.handler();
+
+      expect(response.status).toBe(400);
+      expect(response.data).toEqual(mockState);
+    });
+  });
+});

package/test/src/setup.ts

@@ -2,6 +2,6 @@ import { container } from '@powersync/lib-services-framework';
 import { beforeAll } from 'vitest';
 
 beforeAll(() => {
-  // Your setup code here
+  // Executes for every test file
   container.registerDefaults();
 });

package/test/src/stream_utils.ts

@@ -0,0 +1,42 @@
+import { OplogEntry } from '@/util/protocol-types.js';
+import { JSONBig } from '@powersync/service-jsonbig';
+
+export function putOp(table: string, data: Record<string, any>): Partial<OplogEntry> {
+  return {
+    op: 'PUT',
+    object_type: table,
+    object_id: data.id,
+    data: JSONBig.stringify(data)
+  };
+}
+
+export function removeOp(table: string, id: string): Partial<OplogEntry> {
+  return {
+    op: 'REMOVE',
+    object_type: table,
+    object_id: id
+  };
+}
+
+export function compareIds(a: OplogEntry, b: OplogEntry) {
+  return a.object_id!.localeCompare(b.object_id!);
+}
+
+export async function oneFromAsync<T>(source: Iterable<T> | AsyncIterable<T>): Promise<T> {
+  const items: T[] = [];
+  for await (const item of source) {
+    items.push(item);
+  }
+  if (items.length != 1) {
+    throw new Error(`One item expected, got: ${items.length}`);
+  }
+  return items[0];
+}
+
+export async function fromAsync<T>(source: Iterable<T> | AsyncIterable<T>): Promise<T[]> {
+  const items: T[] = [];
+  for await (const item of source) {
+    items.push(item);
+  }
+  return items;
+}