draft In-memory: run tests with in-memory, add Store.deleteDbFiles() #96

Author: greenrobot-team

.gitlab-ci.yml

@@ -76,6 +76,9 @@ test-generator:linux:x64:
     # Print log for every completed test.
     # Together, this will produce sequential log output, making it easier to attribute native logs.
     - dart test --concurrency=1 --reporter expanded
+    # Run again using in-memory database
+    - export OBX_IN_MEMORY=true
+    - dart test --concurrency=1 --reporter expanded
 
 test-lib:linux:x64:
   extends: .test

objectbox/lib/src/native/store.dart

@@ -484,6 +484,19 @@ class Store implements Finalizable {
     }
   }
 
+  /// Danger zone! This will delete all files in the given directory!
+  ///
+  /// TODO Add docs
+  static void removeDbFiles(String? directoryPath) {
+    final path = _safeDirectoryPath(directoryPath);
+    final cStr = path.toNativeUtf8();
+    try {
+      checkObx(C.remove_db_files(cStr.cast()));
+    } finally {
+      malloc.free(cStr);
+    }
+  }
+
   /// Returns a store reference you can use to create a new store instance with
   /// a single underlying native store. See [Store.fromReference] for more details.
   ByteData get reference => _reference;

objectbox_test/README.md

@@ -20,3 +20,9 @@ Or for better log output (e.g. to attribute native logs to a test):
 # Print log for every completed test.
 dart test --concurrency=1 --reporter expanded
 ```
+
+To run tests using an in-memory database:
+```
+export OBX_IN_MEMORY=true
+dart test
+```

objectbox_test/test/isolates_test.dart

@@ -56,7 +56,7 @@ void main() {
   /// the directory path to attach to an existing store.
   test('single store using attach', () async {
     Store.debugLogs = true;
-    await testUsingStoreFromIsolate(storeCreatorAttach, (env) => env.dir.path);
+    await testUsingStoreFromIsolate(storeCreatorAttach, (env) => env.dbDirPath);
   });
 }
 
@@ -104,7 +104,7 @@ Future<void> testUsingStoreFromIsolate(Store Function(dynamic) storeCreator,
 
   // Pass the store to the isolate
   final env = TestEnv('isolates');
-  expect(Store.isOpen('testdata-isolates'), true);
+  expect(Store.isOpen(env.dbDirPath), true);
 
   expect(await call(storeRefGetter(env)), equals('store set'));
 

objectbox_test/test/store_test.dart

@@ -13,7 +13,7 @@ import 'test_env.dart';
 
 void main() {
   test('store reference', () {
-    final env = TestEnv('store');
+    final env = TestEnv('store-ref');
     final store1 = env.store;
     final store2 = Store.fromReference(getObjectBoxModel(), store1.reference);
     expect(store1, isNot(store2));
@@ -31,19 +31,19 @@ void main() {
   test('store attach fails if same isolate', () {
     final env = TestEnv('store');
     expect(
-        () => Store.attach(getObjectBoxModel(), env.dir.path),
+        () => Store.attach(getObjectBoxModel(), env.dbDirPath),
         throwsA(predicate((UnsupportedError e) =>
             e.message!.contains('Cannot create multiple Store instances'))));
     env.closeAndDelete();
   });
 
   test('store attach remains open if main store closed', () async {
-    final env = TestEnv('store');
+    final env = TestEnv('store-attach');
     final store1 = env.store;
     final receivePort = ReceivePort();
     final received = StreamQueue<dynamic>(receivePort);
     await Isolate.spawn(storeAttachIsolate,
-        StoreAttachIsolateInit(receivePort.sendPort, env.dir.path));
+        StoreAttachIsolateInit(receivePort.sendPort, env.dbDirPath));
     final commandPort = await received.next as SendPort;
 
     // Check native instance pointer is different.
@@ -54,7 +54,7 @@ void main() {
     expect(id, 1);
     // Close original store to test store remains open until all refs closed.
     store1.close();
-    expect(true, Store.isOpen('testdata-store'));
+    expect(Store.isOpen(env.dbDirPath), true);
 
     // Read data with attached store.
     commandPort.send(id);
@@ -65,14 +65,14 @@ void main() {
     // Close attached store, should close store completely.
     commandPort.send(null);
     await received.next;
-    expect(false, Store.isOpen('testdata-store'));
+    expect(Store.isOpen(env.dbDirPath), false);
 
     // Dispose StreamQueue.
     await received.cancel();
   });
 
   test('store attach with configuration', () {
-    final env = TestEnv('store');
+    final env = TestEnv('store-config');
     // Get store config.
     final storeConfig = env.store.configuration();
     expect(storeConfig.id, isNot(0));
@@ -102,18 +102,20 @@ void main() {
   });
 
   test('store is open', () {
-    expect(false, Store.isOpen(''));
-    expect(false, Store.isOpen('testdata-store'));
-    final env = TestEnv('store');
-    expect(false, env.store.isClosed());
-    expect(true, Store.isOpen('testdata-store'));
+    final name = 'store-open';
+    expect(Store.isOpen(''), false);
+    expect(Store.isOpen(TestEnv.testDbDirPath(false, name)), false);
+    expect(Store.isOpen(TestEnv.testDbDirPath(true, name)), false);
+    final env = TestEnv(name);
+    expect(env.store.isClosed(), false);
+    expect(Store.isOpen(env.dbDirPath), true);
     env.closeAndDelete();
-    expect(true, env.store.isClosed());
-    expect(false, Store.isOpen('testdata-store'));
+    expect(env.store.isClosed(), true);
+    expect(Store.isOpen(env.dbDirPath), false);
   });
 
   test('transactions', () {
-    final env = TestEnv('store');
+    final env = TestEnv('store-tx');
     expect(TxMode.values.length, 2);
     for (var mode in TxMode.values) {
       // Returned value falls through.
@@ -143,7 +145,7 @@ void main() {
   });
 
   test('async transactions', () async {
-    final env = TestEnv('store');
+    final env = TestEnv('store-async-tx');
     expect(TxMode.values.length, 2);
     for (var mode in TxMode.values) {
       // Returned value falls through.
@@ -346,7 +348,7 @@ void main() {
   });
 
   test('store run in isolate', () async {
-    final env = TestEnv('store');
+    final env = TestEnv('store-isolate');
     final id = env.box.put(TestEntity(tString: 'foo'));
     final futureResult = env.store.runAsync(_readStringAndRemove, id);
     print('Count in main isolate: ${env.box.count()}');
@@ -357,7 +359,7 @@ void main() {
   });
 
   test('store runAsync returns isolate error', () async {
-    final env = TestEnv('store');
+    final env = TestEnv('store-run-async-isolate');
     try {
       await env.store.runAsync(_producesIsolateError, 'nothing');
       fail("Should throw RemoteError");
@@ -368,7 +370,7 @@ void main() {
   });
 
   test('store runAsync returns callback error', () async {
-    final env = TestEnv('store');
+    final env = TestEnv('store-run-async-callback');
     try {
       await env.store.runAsync(_producesCallbackError, 'nothing');
       fail("Should throw error produced by callback");

objectbox_test/test/test_env.dart

@@ -6,7 +6,11 @@ import 'entity.dart';
 import 'objectbox.g.dart';
 
 class TestEnv {
-  final Directory dir;
+  /// If environment variable OBX_IN_MEMORY=true is set, this will be true.
+  ///
+  /// If tests should be run with an in-memory database, so not using files.
+  final bool isInMemory;
+  final String dbDirPath;
   final Store store;
 
   /// If environment variable TEST_SHORT=1 is set, this will be true.
@@ -15,36 +19,58 @@ class TestEnv {
   /// This was used to speed up valgrind analysis and avoid CI timeouts.
   final bool short;
 
+  static String testDbDirPath(bool inMemory, String name) =>
+      inMemory ? "memory:testdata-$name" : "testdata-$name";
+
   factory TestEnv(String name, {bool? queryCaseSensitive, int? debugFlag}) {
-    final dir = Directory('testdata-$name');
-    if (dir.existsSync()) dir.deleteSync(recursive: true);
+    final inMemory = Platform.environment["OBX_IN_MEMORY"] == "true";
+    if (inMemory) {
+      print("Using in-memory database for testing");
+    }
+    final String dbDirPath = testDbDirPath(inMemory, name);
+    // Ensure there is no leftover data from a previous test failure.
+    _removeDbFiles(inMemory, dbDirPath);
+
     final Store store;
     var modelDefinition = getObjectBoxModel();
     try {
       store = queryCaseSensitive == null
-          ? Store(modelDefinition, directory: dir.path, debugFlags: debugFlag)
+          ? Store(modelDefinition, directory: dbDirPath, debugFlags: debugFlag)
           : Store(modelDefinition,
-              directory: dir.path,
+              directory: dbDirPath,
               debugFlags: debugFlag,
               queriesCaseSensitiveDefault: queryCaseSensitive);
     } catch (ex) {
-      print("$dir exists: ${dir.existsSync()}");
-      print("Store is open in directory: ${Store.isOpen(dir.path)}");
+      if (!inMemory) {
+        final dir = Directory(dbDirPath);
+        print("$dir exists: ${dir.existsSync()}");
+      }
+      print("Store is open: ${Store.isOpen(dbDirPath)}");
       print("Model Info: ${modelDefinition.model.toMap(forModelJson: true)}");
       rethrow;
     }
-    return TestEnv._(
-        dir, store, Platform.environment.containsKey('TEST_SHORT'));
+    return TestEnv._(inMemory, dbDirPath, store,
+        Platform.environment.containsKey('TEST_SHORT'));
   }
 
-  TestEnv._(this.dir, this.store, this.short);
+  TestEnv._(this.isInMemory, this.dbDirPath, this.store, this.short);
 
   Box<TestEntity> get box => store.box();
 
+  /// Call once done with this to clean up.
   void closeAndDelete() {
     store.close();
-    if (dir.existsSync()) {
-      dir.deleteSync(recursive: true);
+    _removeDbFiles(isInMemory, dbDirPath);
+  }
+
+  static void _removeDbFiles(bool isInMemory, String dbDirPath) {
+    // Note: removeDbFiles does not remove the directory, so do it manually.
+    Store.removeDbFiles(dbDirPath);
+    if (!isInMemory) {
+      final dir = Directory(dbDirPath);
+      if (dir.existsSync()) {
+        dir.deleteSync(recursive: true);
+      }
     }
   }
 }