Test key-compressed collection change events when object key is added containing square brackets

test/unit/bug-report.test.ts

@@ -16,6 +16,7 @@
     createRxDatabase,
     randomCouchString
 } from '../../plugins/core/index.mjs';
+import { wrappedKeyCompressionStorage } from '../../plugins/key-compression/index.mjs';
 import {
     isNode
 } from '../../plugins/test-utils/index.mjs';
@@ -42,6 +43,7 @@
             version: 0,
             primaryKey: 'passportId',
             type: 'object',
+            keyCompression: true,
             properties: {
                 passportId: {
                     type: 'string',
@@ -57,6 +59,17 @@
                     type: 'integer',
                     minimum: 0,
                     maximum: 150
+                },
+                tags: {
+                    type: 'object',
+                    patternProperties: {
+                        '.*': {
+                            properties: {
+                                name: { type: 'string' },
+                            },
+                            required: ['name'],
+                        }
+                    },
                 }
             }
         };
@@ -74,68 +87,64 @@
              * By calling config.storage.getStorage(),
              * we can ensure that all variations of RxStorage are tested in the CI.
              */
-            storage: config.storage.getStorage(),
+            storage: wrappedKeyCompressionStorage({ storage: config.storage.getStorage() }),
             eventReduce: true,
             ignoreDuplicate: true
         });
         // create a collection
         const collections = await db.addCollections({
             mycollection: {
                 schema: mySchema
-            }
+            },
         });
 
         // insert a document
         await collections.mycollection.insert({
             passportId: 'foobar',
             firstName: 'Bob',
             lastName: 'Kelso',
-            age: 56
-        });
-
-        /**
-         * to simulate the event-propagation over multiple browser-tabs,
-         * we create the same database again
-         */
-        const dbInOtherTab = await createRxDatabase({
-            name,
-            storage: config.storage.getStorage(),
-            eventReduce: true,
-            ignoreDuplicate: true
-        });
-        // create a collection
-        const collectionInOtherTab = await dbInOtherTab.addCollections({
-            mycollection: {
-                schema: mySchema
+            age: 56,
+            tags: {
+                example: 'example',
             }
         });
 
-        // find the document in the other tab
-        const myDocument = await collectionInOtherTab.mycollection
-            .findOne()
-            .where('firstName')
-            .eq('Bob')
-            .exec();
+        // find the document
+        let myDocument = await collections.mycollection.findOne().exec(true);
 
         /*
          * assert things,
          * here your tests should fail to show that there is a bug
          */
-        assert.strictEqual(myDocument.age, 56);
+        assert.strictEqual(myDocument.tags.example, 'example');
 
 
         // you can also wait for events
         const emitted = [];
-        const sub = collectionInOtherTab.mycollection
-            .findOne().$
-            .subscribe(doc => {
-                emitted.push(doc);
-            });
+        const sub = collections.mycollection.$.subscribe((eventData) => {
+            emitted.push(eventData);
+        });
+
+        await myDocument.incrementalModify((docData) => {
+            const newDocData = Object.assign({}, docData);
+            newDocData.tags['[example2]'] = '[example2]';
+            return newDocData;
+        });
+
+        myDocument = await collections.mycollection.findOne().exec(true);
+        const tags = myDocument.toJSON().tags;
+        const expectedTags = {
+            example: 'example',
+            '[example2]': '[example2]',
+        };
+        assert.deepEqual(tags, expectedTags);
+
         await AsyncTestUtil.waitUntil(() => emitted.length === 1);
+        assert.strictEqual(emitted[0].operation, 'UPDATE');
+        assert.deepEqual(emitted[0].documentData.tags, expectedTags);
 
         // clean up afterwards
         sub.unsubscribe();
         db.destroy();
-        dbInOtherTab.destroy();
     });
 });