@powersync/service-core 0.0.0-dev-20241111122558 → 0.0.0-dev-20241119082750

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/sync.test.ts

@@ -1,6 +1,6 @@
 import { SaveOperationTag } from '@/storage/storage-index.js';
 import { RequestTracker } from '@/sync/RequestTracker.js';
-import { streamResponse } from '@/sync/sync.js';
+import { streamResponse, SyncStreamParameters } from '@/sync/sync.js';
 import { StreamingSyncLine } from '@/util/protocol-types.js';
 import { JSONBig } from '@powersync/service-jsonbig';
 import { RequestParameters } from '@powersync/service-sync-rules';
@@ -381,6 +381,67 @@ function defineTests(factory: StorageFactory) {
       })
     });
   });
+
+  test('write checkpoint', async () => {
+    const f = await factory();
+
+    const syncRules = await f.updateSyncRules({
+      content: BASIC_SYNC_RULES
+    });
+
+    const storage = f.getInstance(syncRules);
+    await storage.autoActivate();
+
+    await storage.startBatch(BATCH_OPTIONS, async (batch) => {
+      // <= the managed write checkpoint LSN below
+      await batch.commit('0/1');
+    });
+
+    const checkpoint = await storage.createManagedWriteCheckpoint({
+      user_id: 'test',
+      heads: { '1': '1/0' }
+    });
+
+    const params: SyncStreamParameters = {
+      storage: f,
+      params: {
+        buckets: [],
+        include_checksum: true,
+        raw_data: true
+      },
+      parseOptions: PARSE_OPTIONS,
+      tracker,
+      syncParams: new RequestParameters({ sub: 'test' }, {}),
+      token: { sub: 'test', exp: Date.now() / 1000 + 10 } as any
+    };
+    const stream1 = streamResponse(params);
+    const lines1 = await consumeCheckpointLines(stream1);
+
+    // If write checkpoints are not correctly filtered, this may already
+    // contain the write checkpoint.
+    expect(lines1[0]).toMatchObject({
+      checkpoint: expect.objectContaining({
+        last_op_id: '0',
+        write_checkpoint: undefined
+      })
+    });
+
+    await storage.startBatch(BATCH_OPTIONS, async (batch) => {
+      // must be >= the managed write checkpoint LSN
+      await batch.commit('1/0');
+    });
+
+    // At this point the LSN has advanced, so the write checkpoint should be
+    // included in the next checkpoint message.
+    const stream2 = streamResponse(params);
+    const lines2 = await consumeCheckpointLines(stream2);
+    expect(lines2[0]).toMatchObject({
+      checkpoint: expect.objectContaining({
+        last_op_id: '0',
+        write_checkpoint: `${checkpoint}`
+      })
+    });
+  });
 }
 
 /**

package/test/src/util.ts

@@ -51,7 +51,8 @@ export const PARSE_OPTIONS: ParseSyncRulesOptions = {
 
 export const BATCH_OPTIONS: StartBatchOptions = {
   ...PARSE_OPTIONS,
-  zeroLSN: ZERO_LSN
+  zeroLSN: ZERO_LSN,
+  storeCurrentData: true
 };
 
 export function testRules(content: string): PersistedSyncRulesContent {