@powersync/service-module-mysql 0.1.6 → 0.1.7

package/test/src/BinlogStreamUtils.ts

@@ -12,33 +12,15 @@ import { MySQLConnectionManager } from '@module/replication/MySQLConnectionManag
 import mysqlPromise from 'mysql2/promise';
 import { readExecutedGtid } from '@module/common/read-executed-gtid.js';
 import { logger } from '@powersync/lib-services-framework';
+import { StorageFactory } from '@core-tests/util.js';
 
 /**
  * Tests operating on the binlog stream need to configure the stream and manage asynchronous
  * replication, which gets a little tricky.
  *
- * This wraps a test in a function that configures all the context, and tears it down afterward.
+ * This wraps all the context required for testing, and tears it down afterward
+ * by using `await using`.
  */
-export function binlogStreamTest(
-  factory: () => Promise<BucketStorageFactory>,
-  test: (context: BinlogStreamTestContext) => Promise<void>
-): () => Promise<void> {
-  return async () => {
-    const f = await factory();
-    const connectionManager = new MySQLConnectionManager(TEST_CONNECTION_OPTIONS, {});
-
-    const connection = await connectionManager.getConnection();
-    await clearTestDb(connection);
-    connection.release();
-    const context = new BinlogStreamTestContext(f, connectionManager);
-    try {
-      await test(context);
-    } finally {
-      await context.dispose();
-    }
-  };
-}
-
 export class BinlogStreamTestContext {
   private _binlogStream?: BinLogStream;
   private abortController = new AbortController();
@@ -46,6 +28,18 @@ export class BinlogStreamTestContext {
   public storage?: SyncRulesBucketStorage;
   private replicationDone = false;
 
+  static async open(factory: StorageFactory, options?: { doNotClear?: boolean }) {
+    const f = await factory({ doNotClear: options?.doNotClear });
+    const connectionManager = new MySQLConnectionManager(TEST_CONNECTION_OPTIONS, {});
+
+    if (!options?.doNotClear) {
+      const connection = await connectionManager.getConnection();
+      await clearTestDb(connection);
+      connection.release();
+    }
+    return new BinlogStreamTestContext(f, connectionManager);
+  }
+
   constructor(
     public factory: BucketStorageFactory,
     public connectionManager: MySQLConnectionManager
@@ -57,6 +51,10 @@ export class BinlogStreamTestContext {
     await this.connectionManager.end();
   }
 
+  [Symbol.asyncDispose]() {
+    return this.dispose();
+  }
+
   get connectionTag() {
     return this.connectionManager.connectionTag;
   }
@@ -67,6 +65,27 @@ export class BinlogStreamTestContext {
     return this.storage!;
   }
 
+  async loadNextSyncRules() {
+    const syncRules = await this.factory.getNextSyncRulesContent();
+    if (syncRules == null) {
+      throw new Error(`Next sync rules not available`);
+    }
+
+    this.storage = this.factory.getInstance(syncRules);
+    return this.storage!;
+  }
+
+  async loadActiveSyncRules() {
+    const syncRules = await this.factory.getActiveSyncRulesContent();
+    if (syncRules == null) {
+      throw new Error(`Active sync rules not available`);
+    }
+
+    this.storage = this.factory.getInstance(syncRules);
+    this.replicationDone = true;
+    return this.storage!;
+  }
+
   get binlogStream(): BinLogStream {
     if (this.storage == null) {
       throw new Error('updateSyncRules() first');

package/test/src/mysql-to-sqlite.test.ts

@@ -200,6 +200,7 @@ INSERT INTO test_data (
 
   test('Date types mappings', async () => {
     await setupTable();
+    // Timezone offset is set on the pool to +00:00
     await connectionManager.query(`
         INSERT INTO test_data(date_col, datetime_col, timestamp_col, time_col, year_col)
         VALUES('2023-03-06', '2023-03-06 15:47', '2023-03-06 15:47', '15:47:00', '2023');
@@ -222,23 +223,40 @@ INSERT INTO test_data (
   test('Date types edge cases mappings', async () => {
     await setupTable();
 
-    await connectionManager.query(`INSERT INTO test_data(timestamp_col) VALUES('1970-01-01 00:00:01')`);
-    await connectionManager.query(`INSERT INTO test_data(timestamp_col) VALUES('2038-01-19 03:14:07.499')`);
-    await connectionManager.query(`INSERT INTO test_data(datetime_col) VALUES('1000-01-01 00:00:00')`);
-    await connectionManager.query(`INSERT INTO test_data(datetime_col) VALUES('9999-12-31 23:59:59.499')`);
-
-    const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
-    const replicatedRows = await getReplicatedRows(4);
-    const expectedResults = [
-      { timestamp_col: '1970-01-01T00:00:01.000Z' },
-      { timestamp_col: '2038-01-19T03:14:07.499Z' },
-      { datetime_col: '1000-01-01T00:00:00.000Z' },
-      { datetime_col: '9999-12-31T23:59:59.499Z' }
-    ];
-
-    for (let i = 0; i < expectedResults.length; i++) {
-      expect(databaseRows[i]).toMatchObject(expectedResults[i]);
-      expect(replicatedRows[i]).toMatchObject(expectedResults[i]);
+    const connection = await connectionManager.getConnection();
+    try {
+      // Disable strict mode, to allow dates such as '2024-00-00'.
+      await connection.query(`SET SESSION sql_mode=''`);
+      await connection.query(`SET SESSION time_zone='+00:00'`);
+
+      await connection.query(`INSERT INTO test_data(timestamp_col) VALUES('1970-01-01 00:00:01')`);
+      await connection.query(`INSERT INTO test_data(timestamp_col) VALUES('2038-01-19 03:14:07.499')`);
+      await connection.query(`INSERT INTO test_data(datetime_col) VALUES('1000-01-01 00:00:00')`);
+      await connection.query(`INSERT INTO test_data(datetime_col) VALUES('9999-12-31 23:59:59.499')`);
+      await connection.query(`INSERT INTO test_data(datetime_col) VALUES('0000-00-00 00:00:00')`);
+      await connection.query(`INSERT INTO test_data(datetime_col) VALUES('2024-00-00 00:00:00')`);
+      // TODO: This has a mismatch between querying directly and with Zongji.
+      // await connection.query(`INSERT INTO test_data(date_col) VALUES('2024-00-00')`);
+
+      const expectedResults = [
+        { timestamp_col: '1970-01-01T00:00:01.000Z' },
+        { timestamp_col: '2038-01-19T03:14:07.499Z' },
+        { datetime_col: '1000-01-01T00:00:00.000Z' },
+        { datetime_col: '9999-12-31T23:59:59.499Z' },
+        { datetime_col: null },
+        { datetime_col: null }
+        // { date_col: '2023-11-30' } or { date_col: null }?
+      ];
+
+      const databaseRows = await getDatabaseRows(connectionManager, 'test_data');
+      const replicatedRows = await getReplicatedRows(expectedResults.length);
+
+      for (let i = 0; i < expectedResults.length; i++) {
+        expect(databaseRows[i]).toMatchObject(expectedResults[i]);
+        expect(replicatedRows[i]).toMatchObject(expectedResults[i]);
+      }
+    } finally {
+      connection.release;
     }
   });
 
@@ -282,8 +300,7 @@ async function getReplicatedRows(expectedTransactionsCount?: number): Promise<Sq
   const zongji = new ZongJi({
     host: TEST_CONNECTION_OPTIONS.hostname,
     user: TEST_CONNECTION_OPTIONS.username,
-    password: TEST_CONNECTION_OPTIONS.password,
-    timeZone: 'Z' // Ensure no auto timezone manipulation of the dates occur
+    password: TEST_CONNECTION_OPTIONS.password
   });
 
   const completionPromise = new Promise<SqliteRow[]>((resolve, reject) => {