Expand performance tests; add hard limits.

Author: rkistner

dart/test/perf_test.dart

@@ -8,7 +8,17 @@ import 'utils/native_test_utils.dart';
 import 'utils/tracking_vfs.dart';
 import './schema_test.dart' show schema;
 
-void main() {
+// These test how many filesystem reads and writes are performed during sync_local.
+// The real world performane of filesystem operations depend a lot on the specific system.
+// For example, on native desktop systems, the performance of temporary filesystem storage could
+// be close to memory performance. However, on web and mobile, (temporary) filesystem operations
+// could drastically slow down performance. So rather than only testing the real time for these
+// queries, we count the number of filesystem operations.
+void testFilesystemOperations(
+    {bool unique = true,
+    int count = 200000,
+    int alreadyApplied = 10000,
+    int buckets = 10}) {
   late TrackingFileSystem vfs;
   late CommonDatabase db;
 
@@ -31,38 +41,40 @@ void main() {
 
   setUp(() {
     db.execute('SELECT powersync_replace_schema(?)', [json.encode(schema)]);
+    // Generate dummy data
+    // We can replace this with actual similated download operations later
     db.execute('''
 BEGIN TRANSACTION;
 
 WITH RECURSIVE generate_rows(n) AS (
     SELECT 1
     UNION ALL
-    SELECT n + 1 FROM generate_rows WHERE n < 200000
+    SELECT n + 1 FROM generate_rows WHERE n < $count
 )
 INSERT INTO ps_oplog (bucket, op_id, row_type, row_id, key, data, hash)
 SELECT 
-    (n % 10), -- Generate 10 different buckets
+    (n % $buckets), -- Generate n different buckets
     n,
     'assets',
-    uuid(),
+    ${unique ? 'uuid()' : "'duplicated_id'"},
     uuid(),
     '{"description": "' || n || '", "make": "test", "model": "this is just filler data. this is just filler data. this is just filler data. this is just filler data. this is just filler data. this is just filler data. this is just filler data. "}',
     (n * 17) % 1000000000 -- Some pseudo-random hash
     
 FROM generate_rows;
 
-WITH RECURSIVE generate_rows(n) AS (
+WITH RECURSIVE generate_bucket_rows(n) AS (
     SELECT 1
     UNION ALL
-    SELECT n + 1 FROM generate_rows WHERE n < 10
+    SELECT n + 1 FROM generate_bucket_rows WHERE n < $buckets
 )
 INSERT INTO ps_buckets (id, name, last_applied_op)
 SELECT 
-    (n % 10),
+    (n % $buckets),
     'bucket' || n,
-    10000
+    $alreadyApplied -- simulate a percentage of operations previously applied
     
-FROM generate_rows;
+FROM generate_bucket_rows;
 
 COMMIT;
 ''');
@@ -76,6 +88,11 @@ COMMIT;
     db.select('insert into powersync_operations(op, data) values(?, ?)',
         ['sync_local', '']);
     print('${timer.elapsed.inMilliseconds}ms ${vfs.stats()}');
+
+    // These are fairly generous limits, to catch significant regressions only.
+    expect(vfs.tempWrites, lessThan(count / 50));
+    expect(timer.elapsed,
+        lessThan(Duration(milliseconds: 100 + (count / 50).round())));
   });
 
   test('sync_local (partial)', () {
@@ -88,5 +105,30 @@ COMMIT;
       })
     ]);
     print('${timer.elapsed.inMilliseconds}ms ${vfs.stats()}');
+    expect(vfs.tempWrites, lessThan(count / 50));
+    expect(timer.elapsed,
+        lessThan(Duration(milliseconds: 100 + (count / 50).round())));
+  });
+}
+
+main() {
+  group('test filesystem operations with unique ids', () {
+    testFilesystemOperations(
+        unique: true, count: 500000, alreadyApplied: 10000, buckets: 10);
+  });
+  group('test filesytem operations with duplicate ids', () {
+    // If this takes more than a couple of milliseconds to complete, there is a performance bug
+    testFilesystemOperations(
+        unique: false, count: 5000, alreadyApplied: 1000, buckets: 10);
+  });
+
+  group('test filesystem operations with a small number of changes', () {
+    testFilesystemOperations(
+        unique: true, count: 100000, alreadyApplied: 95000, buckets: 10);
+  });
+
+  group('test filesystem operations with a large number of buckets', () {
+    testFilesystemOperations(
+        unique: true, count: 100000, alreadyApplied: 10000, buckets: 1000);
   });
 }