@casual-simulation/aux-common 3.0.9 → 3.0.11

package/partitions/test/PartitionTests.js

@@ -1,1548 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { getPartitionState } from '../AuxPartition';
-import { botAdded, createBot, botRemoved, botUpdated, stateUpdatedEvent, hasValue, } from '../../bots';
-import { Subscription } from 'rxjs';
-import { waitAsync } from '../../test/TestHelpers';
-import { takeWhile, bufferCount, skip, } from 'rxjs/operators';
-import { del, edit, edits, insert, preserve, } from '../../aux-format-2';
-import faker from 'faker';
-import { generateRandomEditCases, generateRandomEditParagraphCases, } from '../../test/FuzzingHelpers';
-/**
- * Tests the given partition implementation for various features.
- * @param createPartition A function that creates a new instance of the partition that should be tested.
- * @param testForMergedEdits Whether to test that multiple edit sequences are merged instead of preserved as separate sequences.
- */
-export function testPartitionImplementation(createPartition, testForMergedEdits = false, testConcurrentEdits = false) {
-    let partition;
-    let added;
-    let removed;
-    let updated;
-    let statuses;
-    let updates;
-    let version;
-    let sub;
-    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
-        sub = new Subscription();
-        partition = yield createPartition();
-        added = [];
-        removed = [];
-        updated = [];
-        statuses = [];
-        updates = [];
-        sub.add(partition.onBotsAdded.subscribe((bots) => added.push(...bots)));
-        sub.add(partition.onBotsRemoved.subscribe((ids) => removed.push(...ids)));
-        sub.add(partition.onBotsUpdated.subscribe((updates) => updated.push(...updates)));
-        sub.add(partition.onStateUpdated
-            .pipe(skip(1))
-            .subscribe((u) => updates.push(u)));
-        sub.add(partition.onVersionUpdated.subscribe((v) => (version = v)));
-        sub.add(partition.onStatusUpdated.subscribe((update) => statuses.push(update)));
-    }));
-    afterEach(() => {
-        sub.unsubscribe();
-    });
-    describe('add_bot', () => {
-        it('should be able to add a bot to the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            yield partition.applyEvents([botAdded(bot)]);
-            yield waitAsync();
-            expect(added).toEqual([bot]);
-            expect(updates).toEqual([
-                {
-                    state: {
-                        test: bot,
-                    },
-                    addedBots: ['test'],
-                    removedBots: [],
-                    updatedBots: [],
-                },
-            ]);
-            expect(partition.state).toEqual({
-                test: bot,
-            });
-        }));
-        it('should be able to add multiple bots to the partition at a time', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                abc: 'xyz',
-            });
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            yield waitAsync();
-            expect(added).toEqual([bot1, bot2]);
-            expect(partition.state).toEqual({
-                test: bot1,
-                test2: bot2,
-            });
-        }));
-        it('should issue an event for all the existing bots upon subscription', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                abc: 'xyz',
-            });
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            let added = [];
-            partition.onBotsAdded.subscribe((a) => added.push(...a));
-            expect(added).toEqual([bot1, bot2]);
-            expect(partition.state).toEqual({
-                [bot1.id]: bot1,
-                [bot2.id]: bot2,
-            });
-        }));
-        it('should issue an state updated event for the existing state upon subscription', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                abc: 'xyz',
-            });
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            let updates = [];
-            partition.onStateUpdated.subscribe((e) => updates.push(e));
-            expect(updates).toEqual([
-                {
-                    state: {
-                        test: createBot('test', {
-                            abc: 'def',
-                        }),
-                        test2: createBot('test2', {
-                            abc: 'xyz',
-                        }),
-                    },
-                    addedBots: ['test', 'test2'],
-                    removedBots: [],
-                    updatedBots: [],
-                },
-            ]);
-            expect(partition.state).toEqual({
-                test: bot1,
-                test2: bot2,
-            });
-        }));
-        it('should add bots to the configured space.', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                abc: 'xyz',
-            });
-            let added = [];
-            partition.onBotsAdded.subscribe((a) => added.push(...a));
-            partition.space = 'test';
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            expect(added).toEqual([
-                createBot('test', {
-                    abc: 'def',
-                }, 'test'),
-                createBot('test2', {
-                    abc: 'xyz',
-                }, 'test'),
-            ]);
-            expect(partition.state).toEqual({
-                test: createBot('test', {
-                    abc: 'def',
-                }, 'test'),
-                test2: createBot('test2', {
-                    abc: 'xyz',
-                }, 'test'),
-            });
-        }));
-    });
-    describe('remove_bot', () => {
-        it('should be able to remove a bot from the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([botRemoved('test')]);
-            yield waitAsync();
-            expect(removed).toEqual(['test']);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test: null,
-                    },
-                    addedBots: [],
-                    removedBots: ['test'],
-                    updatedBots: [],
-                },
-            ]);
-            expect(partition.state).toEqual({});
-        }));
-        it('should be able to remove multiple bots from the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                abc: 'xyz',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            yield partition.applyEvents([
-                botRemoved('test2'),
-                botRemoved('test'),
-            ]);
-            yield waitAsync();
-            expect(removed).toEqual(['test2', 'test']);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test: null,
-                        test2: null,
-                    },
-                    addedBots: [],
-                    removedBots: ['test2', 'test'],
-                    updatedBots: [],
-                },
-            ]);
-            expect(partition.state).toEqual({});
-        }));
-        it('should be able to remove a bot that was just added to the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot1), botRemoved('test')]);
-            yield waitAsync();
-            expect(added).toEqual([]);
-            expect(updated).toEqual([]);
-            expect(removed).toEqual([]);
-            expect(partition.state).toEqual({});
-        }));
-    });
-    describe('update_bot', () => {
-        it('should be able to update a bot in the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        abc: 'ghi',
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'ghi',
-                    }),
-                    tags: ['abc'],
-                },
-            ]);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test: {
-                            tags: {
-                                abc: 'ghi',
-                            },
-                        },
-                    },
-                    addedBots: [],
-                    removedBots: [],
-                    updatedBots: ['test'],
-                },
-            ]);
-        }));
-        it('should be able to update multiple bots at the same time', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test1', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                number: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            yield partition.applyEvents([
-                botUpdated('test1', {
-                    tags: {
-                        abc: 'ghi',
-                    },
-                }),
-                botUpdated('test2', {
-                    tags: {
-                        number: 456,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test1', {
-                        abc: 'ghi',
-                    }),
-                    tags: ['abc'],
-                },
-                {
-                    bot: createBot('test2', {
-                        number: 456,
-                    }),
-                    tags: ['number'],
-                },
-            ]);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test1: {
-                            tags: {
-                                abc: 'ghi',
-                            },
-                        },
-                        test2: {
-                            tags: {
-                                number: 456,
-                            },
-                        },
-                    },
-                    addedBots: [],
-                    removedBots: [],
-                    updatedBots: ['test1', 'test2'],
-                },
-            ]);
-        }));
-        it('should report tags that were added to the bot', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        hahaha: true,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'def',
-                        hahaha: true,
-                    }),
-                    tags: ['hahaha'],
-                },
-            ]);
-        }));
-        it('should report tags that were removed from the bot', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        example: null,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'def',
-                    }),
-                    tags: ['example'],
-                },
-            ]);
-        }));
-        it('should ignore updates that dont change any tags', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([botUpdated('test', {})]);
-            yield waitAsync();
-            expect(updated).toEqual([]);
-        }));
-        it('should ignore updates that set tag values to the same value that it is currently at', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        abc: 'def',
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([]);
-        }));
-        it('should support updates to arrays that keep the same array instance', () => __awaiter(this, void 0, void 0, function* () {
-            let arr = [];
-            const bot = createBot('test', {
-                array: arr,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        array: arr,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updates.slice(1)).toEqual([
-                stateUpdatedEvent({
-                    test: {
-                        tags: {
-                            array: arr,
-                        },
-                    },
-                }),
-            ]);
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        array: arr,
-                    }),
-                    tags: ['array'],
-                },
-            ]);
-        }));
-        it('should only report tags that changed', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        abc: 'def',
-                        example: 456,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'def',
-                        example: 456,
-                    }),
-                    tags: ['example'],
-                },
-            ]);
-        }));
-        it('should merge multiple updates to the same bot', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        abc: 'rgb',
-                    },
-                }),
-                botUpdated('test', {
-                    tags: {
-                        example: 456,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'rgb',
-                        example: 456,
-                    }),
-                    tags: ['abc', 'example'],
-                },
-            ]);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test: {
-                            tags: {
-                                abc: 'rgb',
-                                example: 456,
-                            },
-                        },
-                    },
-                    addedBots: [],
-                    removedBots: [],
-                    updatedBots: ['test'],
-                },
-            ]);
-        }));
-        it('should ignore updates to bots that dont exist', () => __awaiter(this, void 0, void 0, function* () {
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        abc: 'def',
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([]);
-        }));
-        let deleteValueCases = [
-            ['null', null],
-            ['undefined', undefined],
-            ['empty string', ''],
-        ];
-        let preserveValueCases = [
-            ['0', 0],
-            ['false', false],
-            ['whitespace', ' '],
-        ];
-        it.each(deleteValueCases)('should delete tags with %s values', (desc, val) => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        example: val,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'def',
-                    }),
-                    tags: ['example'],
-                },
-            ]);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test: {
-                            tags: {
-                                example: null,
-                            },
-                        },
-                    },
-                    addedBots: [],
-                    removedBots: [],
-                    updatedBots: ['test'],
-                },
-            ]);
-        }));
-        it.each(preserveValueCases)('should preserve tags with %s values', (desc, val) => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-                example: 123,
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                botUpdated('test', {
-                    tags: {
-                        example: val,
-                    },
-                }),
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'def',
-                        example: val,
-                    }),
-                    tags: ['example'],
-                },
-            ]);
-            expect(updates.slice(1)).toEqual([
-                {
-                    state: {
-                        test: {
-                            tags: {
-                                example: val,
-                            },
-                        },
-                    },
-                    addedBots: [],
-                    removedBots: [],
-                    updatedBots: ['test'],
-                },
-            ]);
-        }));
-        describe('edits', () => {
-            it('should support inserting text into a tag value', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'def',
-                    })),
-                ]);
-                yield waitAsync();
-                const editVersion = Object.assign({}, version.vector);
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: edit(editVersion, insert('ghi')),
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {
-                        abc: 'ghidef',
-                    }),
-                });
-                expect(updates.slice(1)).toEqual([
-                    stateUpdatedEvent({
-                        test: {
-                            tags: {
-                                abc: edit(version.vector, insert('ghi')),
-                            },
-                        },
-                    }),
-                ]);
-                expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-            }));
-            it('should support deleting text from a tag value', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'def',
-                    })),
-                ]);
-                yield waitAsync();
-                const editVersion = Object.assign({}, version.vector);
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: edit(editVersion, del(2)),
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {
-                        abc: 'f',
-                    }),
-                });
-                expect(updates.slice(1)).toEqual([
-                    stateUpdatedEvent({
-                        test: {
-                            tags: {
-                                abc: edit(version.vector, del(2)),
-                            },
-                        },
-                    }),
-                ]);
-                expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-            }));
-            it('should support deletes in multiple edit sequences', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'abcdefghijklmnop',
-                    })),
-                ]);
-                yield waitAsync();
-                const editVersion = Object.assign({}, version.vector);
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: edits(editVersion, [preserve(3), del(3)], [preserve(6), del(3)]),
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {
-                        abc: 'abcghimnop',
-                    }),
-                });
-                expect(updates.slice(1)).toEqual([
-                    stateUpdatedEvent({
-                        test: {
-                            tags: {
-                                abc: testForMergedEdits
-                                    ? edits(version.vector, [
-                                        preserve(3),
-                                        del(3),
-                                        preserve(3),
-                                        del(3),
-                                    ])
-                                    : edits(version.vector, [preserve(3), del(3)], [preserve(6), del(3)]),
-                            },
-                        },
-                    }),
-                ]);
-                expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-            }));
-            it('should support inserts in multiple edit sequences', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'abcdef',
-                    })),
-                ]);
-                yield waitAsync();
-                const editVersion = Object.assign({}, version.vector);
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: edits(editVersion, [preserve(3), insert('123')], [preserve(9), insert('456')]),
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {
-                        abc: 'abc123def456',
-                    }),
-                });
-                expect(updates.slice(1)).toEqual([
-                    stateUpdatedEvent({
-                        test: {
-                            tags: {
-                                abc: testForMergedEdits
-                                    ? edits(version.vector, [
-                                        preserve(3),
-                                        insert('123'),
-                                        preserve(3),
-                                        insert('456'),
-                                    ])
-                                    : edits(version.vector, [preserve(3), insert('123')], [preserve(9), insert('456')]),
-                            },
-                        },
-                    }),
-                ]);
-                expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-            }));
-            it('should delete tags that have all text deleted', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'abcdef',
-                    })),
-                ]);
-                yield waitAsync();
-                const editVersion = Object.assign({}, version.vector);
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: edits(editVersion, [del(6)]),
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {}),
-                });
-                expect(updates.slice(1)).toEqual([
-                    stateUpdatedEvent({
-                        test: {
-                            tags: {
-                                abc: edits(version.vector, [del(6)]),
-                            },
-                        },
-                    }),
-                ]);
-                expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-            }));
-            const valueCases = [
-                [
-                    'numbers',
-                    123,
-                    edit({}, preserve(1), insert('abc')),
-                    '1abc23',
-                ],
-                [
-                    'booleans',
-                    true,
-                    edit({}, preserve(1), insert('abc')),
-                    'tabcrue',
-                ],
-                [
-                    'objects',
-                    { prop: 'yes' },
-                    edit({}, preserve(1), insert('abc')),
-                    '{abc"prop":"yes"}',
-                ],
-            ];
-            it.each(valueCases)('should support %s', (desc, initial, edit, expected) => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: initial,
-                    })),
-                ]);
-                yield waitAsync();
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: edit,
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {
-                        abc: expected,
-                    }),
-                });
-            }));
-            it('should use a separate site ID for remote edits', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'def',
-                    })),
-                ]);
-                yield waitAsync();
-                const editVersion = Object.assign({}, version.vector);
-                const tagEdit = edit(editVersion, insert('ghi'));
-                tagEdit.isRemote = true;
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {
-                            abc: tagEdit,
-                        },
-                    }),
-                ]);
-                expect(partition.state).toEqual({
-                    test: createBot('test', {
-                        abc: 'ghidef',
-                    }),
-                });
-                const partitionEdit = updates[1].state.test.tags.abc;
-                expect(partitionEdit.version).not.toEqual({
-                    [version.currentSite]: expect.any(Number),
-                });
-                expect(partitionEdit.version).toEqual({
-                    [version.remoteSite]: expect.any(Number),
-                });
-                expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-            }));
-            if (testConcurrentEdits) {
-                describe('concurrent edits', () => {
-                    const cases = [
-                        [
-                            'should support concatenations',
-                            'def',
-                            [
-                                [insert('ghi')],
-                                [preserve(3), insert('jfk')],
-                                [preserve(6), insert('lmn')],
-                            ],
-                            'ghijfklmndef',
-                        ],
-                        [
-                            'should support inserts',
-                            'def',
-                            [
-                                [insert('ghi')],
-                                [preserve(1), insert('jfk')],
-                                [preserve(3), insert('lmn')],
-                            ],
-                            'gjflmnkhidef',
-                        ],
-                        [
-                            'should support deletes',
-                            'def',
-                            [
-                                [insert('ghi')],
-                                [preserve(1), del(2)],
-                                [preserve(1), del(2)],
-                            ],
-                            'gf',
-                        ],
-                    ];
-                    it.each(cases)('%s', (desc, startValue, operations, expected) => __awaiter(this, void 0, void 0, function* () {
-                        yield partition.applyEvents([
-                            botAdded(createBot('test', {
-                                abc: startValue,
-                            })),
-                        ]);
-                        yield waitAsync();
-                        const editVersion = Object.assign({}, version.vector);
-                        const edits = operations.map((ops) => edit(editVersion, ...ops));
-                        for (let e of edits) {
-                            yield partition.applyEvents([
-                                botUpdated('test', {
-                                    tags: {
-                                        abc: e,
-                                    },
-                                }),
-                            ]);
-                        }
-                        expect(partition.state).toEqual({
-                            test: createBot('test', {
-                                abc: expected,
-                            }),
-                        });
-                        expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-                    }));
-                    it('should handle concurrent inserts that rely on each other', () => __awaiter(this, void 0, void 0, function* () {
-                        yield partition.applyEvents([
-                            botAdded(createBot('test', {
-                                abc: `abc\nabc\nabc\nabc`,
-                            })),
-                        ]);
-                        yield waitAsync();
-                        const editVersion = Object.assign({}, version.vector);
-                        let edit = edits(editVersion, [preserve(3), insert('d')], [preserve(8), insert('d')], [preserve(13), insert('d')], [preserve(18), insert('d')]);
-                        yield partition.applyEvents([
-                            botUpdated('test', {
-                                tags: {
-                                    abc: edit,
-                                },
-                            }),
-                        ]);
-                        expect(partition.state).toEqual({
-                            test: createBot('test', {
-                                abc: 'abcd\nabcd\nabcd\nabcd',
-                            }),
-                        });
-                        expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-                    }));
-                    it('should handle local edits while remote edits occur', () => __awaiter(this, void 0, void 0, function* () {
-                        yield partition.applyEvents([
-                            botAdded(createBot('test', {
-                                abc: 'def',
-                            })),
-                        ]);
-                        yield waitAsync();
-                        const editVersion = Object.assign({}, version.vector);
-                        const edit1 = edit(editVersion, insert('111'));
-                        // after: 111def
-                        const edit2 = edit(editVersion, preserve(1), insert('222'));
-                        // after: 122211def
-                        const edit3 = edit(editVersion, preserve(2), insert('333'));
-                        // after: 122213331def
-                        const remoteEdit1 = edit(editVersion, preserve(2), insert('444'));
-                        // TODO: this is probably a bug but I want to wait on this until people
-                        // start having problems.
-                        // BUG: remote edits always see the local edits
-                        // after: 114441def
-                        edit2.isRemote = true;
-                        // final: 122213334441def
-                        yield partition.applyEvents([
-                            botUpdated('test', {
-                                tags: {
-                                    abc: edit1,
-                                },
-                            }),
-                        ]);
-                        yield partition.applyEvents([
-                            botUpdated('test', {
-                                tags: {
-                                    abc: remoteEdit1,
-                                },
-                            }),
-                        ]);
-                        yield partition.applyEvents([
-                            botUpdated('test', {
-                                tags: {
-                                    abc: edit2,
-                                },
-                            }),
-                        ]);
-                        yield partition.applyEvents([
-                            botUpdated('test', {
-                                tags: {
-                                    abc: edit3,
-                                },
-                            }),
-                        ]);
-                        expect(partition.state).toEqual({
-                            test: createBot('test', {
-                                abc: '122213334441def',
-                            }),
-                        });
-                    }));
-                });
-                describe('fuzzing', () => {
-                    faker.seed(95423);
-                    const randomEdits = generateRandomEditCases(25);
-                    const paragraphCases = generateRandomEditParagraphCases(5);
-                    describe.each([...randomEdits, ...paragraphCases])('%s -> %s', (startText, endText, intermediateTexts, edits) => {
-                        const space = 'space';
-                        it('should be able to apply the given edits to produce the final text', () => __awaiter(this, void 0, void 0, function* () {
-                            yield partition.applyEvents([
-                                botAdded(createBot('test', {
-                                    abc: startText,
-                                })),
-                            ]);
-                            for (let i = 0; i < edits.length; i++) {
-                                let edit = edits[i];
-                                let str = intermediateTexts[i];
-                                yield partition.applyEvents([
-                                    botUpdated('test', {
-                                        tags: {
-                                            abc: edit,
-                                        },
-                                    }),
-                                ]);
-                                expect(partition.state).toEqual({
-                                    test: createBot('test', hasValue(str)
-                                        ? {
-                                            abc: str,
-                                        }
-                                        : {}),
-                                });
-                            }
-                            expect(partition.state).toEqual({
-                                test: createBot('test', hasValue(endText)
-                                    ? {
-                                        abc: endText,
-                                    }
-                                    : {}),
-                            });
-                        }));
-                        it('should be able to apply the given edit to tag masks', () => __awaiter(this, void 0, void 0, function* () {
-                            partition.space = space;
-                            yield partition.applyEvents([
-                                botUpdated('test', {
-                                    masks: {
-                                        [space]: {
-                                            abc: startText,
-                                        },
-                                    },
-                                }),
-                            ]);
-                            for (let i = 0; i < edits.length; i++) {
-                                let edit = edits[i];
-                                let str = intermediateTexts[i];
-                                yield partition.applyEvents([
-                                    botUpdated('test', {
-                                        masks: {
-                                            [space]: {
-                                                abc: edit,
-                                            },
-                                        },
-                                    }),
-                                ]);
-                                expect(partition.state).toEqual({
-                                    test: hasValue(str)
-                                        ? {
-                                            masks: {
-                                                [space]: {
-                                                    abc: str,
-                                                },
-                                            },
-                                        }
-                                        : {},
-                                });
-                            }
-                            expect(partition.state).toEqual({
-                                test: hasValue(endText)
-                                    ? {
-                                        masks: {
-                                            [space]: {
-                                                abc: endText,
-                                            },
-                                        },
-                                    }
-                                    : {},
-                            });
-                        }));
-                    });
-                });
-            }
-        });
-        describe('TagMasks', () => {
-            beforeEach(() => {
-                partition.space = 'testSpace';
-            });
-            it('should support tag mask updates for the partition space', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    }),
-                ]);
-                yield waitAsync();
-                expect(partition.state).toEqual({
-                    test: {
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    },
-                });
-                expect(updated).toEqual([]);
-                expect(updates).toEqual([
-                    {
-                        state: {
-                            test: {
-                                masks: {
-                                    [partition.space]: {
-                                        newTag: true,
-                                        abc: 123,
-                                    },
-                                },
-                            },
-                        },
-                        addedBots: [],
-                        removedBots: [],
-                        updatedBots: ['test'],
-                    },
-                ]);
-            }));
-            it('should support tag mask updates on multiple bots at a time', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botUpdated('test1', {
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    }),
-                    botUpdated('test2', {
-                        masks: {
-                            [partition.space]: {
-                                otherTag: true,
-                                num: 123,
-                            },
-                        },
-                    }),
-                ]);
-                yield waitAsync();
-                expect(partition.state).toEqual({
-                    test1: {
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    },
-                    test2: {
-                        masks: {
-                            [partition.space]: {
-                                otherTag: true,
-                                num: 123,
-                            },
-                        },
-                    },
-                });
-                expect(updated).toEqual([]);
-                expect(updates).toEqual([
-                    {
-                        state: {
-                            test1: {
-                                masks: {
-                                    [partition.space]: {
-                                        newTag: true,
-                                        abc: 123,
-                                    },
-                                },
-                            },
-                            test2: {
-                                masks: {
-                                    [partition.space]: {
-                                        otherTag: true,
-                                        num: 123,
-                                    },
-                                },
-                            },
-                        },
-                        addedBots: [],
-                        removedBots: [],
-                        updatedBots: ['test1', 'test2'],
-                    },
-                ]);
-            }));
-            it('should ignore tag mask updates for different partition spaces', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        masks: {
-                            ['different']: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    }),
-                ]);
-                yield waitAsync();
-                expect(partition.state).toEqual({});
-                expect(updated).toEqual([]);
-                expect(updates).toEqual([]);
-            }));
-            it('should support tag mask updates for bots in the same partition', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botAdded(createBot('test', {
-                        abc: 'def',
-                    })),
-                ]);
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    }),
-                ]);
-                yield waitAsync();
-                expect(partition.state).toEqual({
-                    test: {
-                        id: 'test',
-                        space: partition.space,
-                        tags: {
-                            abc: 'def',
-                        },
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                                abc: 123,
-                            },
-                        },
-                    },
-                });
-                expect(updated).toEqual([]);
-                expect(updates.slice(1)).toEqual([
-                    {
-                        state: {
-                            test: {
-                                masks: {
-                                    [partition.space]: {
-                                        newTag: true,
-                                        abc: 123,
-                                    },
-                                },
-                            },
-                        },
-                        addedBots: [],
-                        removedBots: [],
-                        updatedBots: ['test'],
-                    },
-                ]);
-            }));
-            it('should not confuse tag masks and tags when given an empty tags object in an update', () => __awaiter(this, void 0, void 0, function* () {
-                yield partition.applyEvents([
-                    botUpdated('test', {
-                        tags: {},
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                            },
-                        },
-                    }),
-                ]);
-                yield waitAsync();
-                expect(partition.state).toEqual({
-                    test: {
-                        masks: {
-                            [partition.space]: {
-                                newTag: true,
-                            },
-                        },
-                    },
-                });
-                expect(updated).toEqual([]);
-                expect(updates).toEqual([
-                    {
-                        state: {
-                            test: {
-                                masks: {
-                                    [partition.space]: {
-                                        newTag: true,
-                                    },
-                                },
-                            },
-                        },
-                        addedBots: [],
-                        removedBots: [],
-                        updatedBots: ['test'],
-                    },
-                ]);
-            }));
-            describe('edits', () => {
-                it('should support inserting text into a tag mask value', () => __awaiter(this, void 0, void 0, function* () {
-                    yield partition.applyEvents([
-                        botUpdated('test', {
-                            masks: {
-                                testSpace: {
-                                    abc: 'def',
-                                },
-                            },
-                        }),
-                    ]);
-                    yield waitAsync();
-                    yield partition.applyEvents([
-                        botUpdated('test', {
-                            masks: {
-                                testSpace: {
-                                    abc: edit(version.vector, insert('ghi')),
-                                },
-                            },
-                        }),
-                    ]);
-                    yield waitAsync();
-                    expect(partition.state).toEqual({
-                        test: {
-                            masks: {
-                                testSpace: {
-                                    abc: 'ghidef',
-                                },
-                            },
-                        },
-                    });
-                    expect(updated).toEqual([]);
-                    expect(updates.slice(1)).toEqual([
-                        stateUpdatedEvent({
-                            test: {
-                                masks: {
-                                    testSpace: {
-                                        abc: edit(version.vector, insert('ghi')),
-                                    },
-                                },
-                            },
-                        }),
-                    ]);
-                    expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-                }));
-                it('should support deleting text from a tag mask value', () => __awaiter(this, void 0, void 0, function* () {
-                    yield partition.applyEvents([
-                        botUpdated('test', {
-                            masks: {
-                                testSpace: {
-                                    abc: 'def',
-                                },
-                            },
-                        }),
-                    ]);
-                    yield waitAsync();
-                    yield partition.applyEvents([
-                        botUpdated('test', {
-                            masks: {
-                                testSpace: {
-                                    abc: edit(version.vector, del(2)),
-                                },
-                            },
-                        }),
-                    ]);
-                    yield waitAsync();
-                    expect(partition.state).toEqual({
-                        test: {
-                            masks: {
-                                testSpace: {
-                                    abc: 'f',
-                                },
-                            },
-                        },
-                    });
-                    expect(updated).toEqual([]);
-                    expect(updates.slice(1)).toEqual([
-                        stateUpdatedEvent({
-                            test: {
-                                masks: {
-                                    testSpace: {
-                                        abc: edit(version.vector, del(2)),
-                                    },
-                                },
-                            },
-                        }),
-                    ]);
-                    expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-                }));
-                it('should delete tag masks that have all text deleted', () => __awaiter(this, void 0, void 0, function* () {
-                    yield partition.applyEvents([
-                        botUpdated('test', {
-                            masks: {
-                                [partition.space]: {
-                                    newTag: 'value',
-                                },
-                            },
-                        }),
-                    ]);
-                    yield waitAsync();
-                    const editVersion = Object.assign({}, version.vector);
-                    yield partition.applyEvents([
-                        botUpdated('test', {
-                            masks: {
-                                [partition.space]: {
-                                    newTag: edits(editVersion, [del(5)]),
-                                },
-                            },
-                        }),
-                    ]);
-                    expect(partition.state).toEqual({
-                        test: {},
-                    });
-                    expect(updates.slice(1)).toEqual([
-                        stateUpdatedEvent({
-                            test: {
-                                masks: {
-                                    [partition.space]: {
-                                        newTag: edits(version.vector, [del(5)]),
-                                    },
-                                },
-                            },
-                        }),
-                    ]);
-                    expect(Object.keys(version.vector).length).toBeGreaterThan(0);
-                }));
-            });
-        });
-    });
-    describe('apply_state', () => {
-        it('should be able to add a bot to the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            yield partition.applyEvents([
-                {
-                    type: 'apply_state',
-                    state: {
-                        test: bot,
-                    },
-                },
-            ]);
-            yield waitAsync();
-            expect(added).toEqual([bot]);
-        }));
-        it('should be able to update a bot in the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                {
-                    type: 'apply_state',
-                    state: {
-                        test: {
-                            tags: {
-                                abc: 'ghi',
-                            },
-                        },
-                    },
-                },
-            ]);
-            yield waitAsync();
-            expect(updated).toEqual([
-                {
-                    bot: createBot('test', {
-                        abc: 'ghi',
-                    }),
-                    tags: ['abc'],
-                },
-            ]);
-        }));
-        it('should be able to delete a bot in the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot = createBot('test', {
-                abc: 'def',
-            });
-            // Run the bot added and updated
-            // events in separate batches
-            // because partitions may combine the events
-            yield partition.applyEvents([botAdded(bot)]);
-            yield partition.applyEvents([
-                {
-                    type: 'apply_state',
-                    state: {
-                        test: null,
-                    },
-                },
-            ]);
-            yield waitAsync();
-            expect(removed).toEqual(['test']);
-        }));
-    });
-    describe('getPartitionState()', () => {
-        it('should be able to get the state from the partition', () => __awaiter(this, void 0, void 0, function* () {
-            const bot1 = createBot('test', {
-                abc: 'def',
-            });
-            const bot2 = createBot('test2', {
-                abc: 'xyz',
-            });
-            yield partition.applyEvents([botAdded(bot1), botAdded(bot2)]);
-            const state = getPartitionState(partition);
-            expect(state).toEqual({
-                test: bot1,
-                test2: bot2,
-            });
-        }));
-    });
-    describe('connect()', () => {
-        it('should issue connection, authentication, authorization, and sync events in that order', () => __awaiter(this, void 0, void 0, function* () {
-            const promise = partition.onStatusUpdated
-                .pipe(takeWhile((update) => update.type !== 'sync', true), bufferCount(4))
-                .toPromise();
-            partition.connect();
-            const update = yield promise;
-            expect(update).toEqual([
-                {
-                    type: 'connection',
-                    connected: true,
-                },
-                expect.objectContaining({
-                    type: 'authentication',
-                    authenticated: true,
-                }),
-                expect.objectContaining({
-                    type: 'authorization',
-                    authorized: true,
-                }),
-                {
-                    type: 'sync',
-                    synced: true,
-                },
-            ]);
-        }));
-    });
-}
-//# sourceMappingURL=PartitionTests.js.map