@cratis/chronicle 6.47.0 → 6.49.0

package/readModels/for_ReadModelWatcher/when_a_stream_cannot_recover.spec.ts

@@ -0,0 +1,86 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { chai, describe, it } from 'vitest';
+import { ConnectionLifecycle } from '../../connection/ConnectionLifecycle.js';
+import { ReadModelWatcher } from '../ReadModelWatcher.js';
+import { a_kernel_stream } from './given/a_kernel_stream.js';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe('when a read model stream cannot recover', () => {
+    it.each([3, 7, 16])('should terminate on non-transport status %s', async code => {
+        const context = new a_watched_read_model();
+        await context.connect();
+        const watcher = context.readModels.createWatcher(context.model, { resume: true });
+        const failure = { code };
+        const readiness = watcher.subscribed.catch(error => error);
+        const next = watcher[Symbol.asyncIterator]().next().catch(error => error);
+        try {
+            context.streams[0].fail(failure);
+            (await readiness).should.equal(failure);
+            (await next).should.equal(failure);
+            await context.disconnect();
+            await context.connect();
+            context.streams.should.have.lengthOf(1);
+        } finally { watcher.dispose(); }
+    });
+
+    it('should not retry a transport-coded compliance or conversion failure', async () => {
+        const lifecycle = new ConnectionLifecycle();
+        await lifecycle.connected(error => { throw error; });
+        const stream = new a_kernel_stream();
+        const failure = { code: 14 };
+        let opened = 0;
+        const watcher = new ReadModelWatcher(() => { opened++; return stream; }, async () => { throw failure; }, new AbortController().signal, lifecycle, { resume: true });
+        const readiness = watcher.subscribed.catch(error => error);
+        const next = watcher.next().catch(error => error);
+        try {
+            stream.send({ ReadModel: '{}' });
+            (await readiness).should.equal(failure);
+            (await next).should.equal(failure);
+            await lifecycle.disconnected(error => { throw error; });
+            await lifecycle.connected(error => { throw error; });
+            opened.should.equal(1);
+        } finally { watcher.dispose(); }
+    });
+
+    it.each([false, true])('should retain completed standalone changes until consumed or disposed (disposed: %s)', async disposed => {
+        const stream = new a_kernel_stream();
+        const watcher = new ReadModelWatcher(() => stream, async change => ({
+            namespace: change.Namespace, key: change.ModelKey, readModel: {}, removed: false
+        }), new AbortController().signal);
+        try {
+            stream.send({ Subscribed: true });
+            stream.send({ ModelKey: 'first' });
+            stream.send({ ModelKey: 'second' });
+            stream.end();
+            await watcher.subscribed;
+            await new Promise<void>(resolve => setImmediate(resolve));
+            if (disposed) watcher.dispose();
+            else {
+                (await watcher.next()).value.key.should.equal('first');
+                (await watcher.next()).value.key.should.equal('second');
+            }
+            (await watcher.next()).done!.should.be.true;
+        } finally { watcher.dispose(); }
+    });
+
+    it.each([false, true])('should end a standalone stream cleanly (acknowledged: %s)', async acknowledged => {
+        const stream = new a_kernel_stream();
+        const watcher = new ReadModelWatcher(() => stream, async () => { throw new Error('Unexpected data'); }, new AbortController().signal);
+        try {
+            if (acknowledged) {
+                stream.send({ Subscribed: true });
+                await watcher.subscribed;
+            }
+            const readiness = watcher.subscribed.catch(error => error);
+            const next = watcher.next();
+            stream.end();
+            (await next).done!.should.be.true;
+            if (!acknowledged) (await readiness).message.should.contain('before subscription acknowledgment');
+            else await readiness;
+        } finally { watcher.dispose(); }
+    });
+});

package/readModels/for_ReadModelWatcher/when_applying_backpressure.spec.ts

@@ -0,0 +1,80 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe('when applying read model watch backpressure', () => {
+    let context: a_watched_read_model;
+    beforeEach(async () => {
+        context = new a_watched_read_model();
+        await context.connect();
+    });
+    afterEach(() => context.readModels.dispose());
+
+    it('should pause a created watcher for a slow consumer and deliver more than the buffer limit without failure', async () => {
+        const iterator = context.readModels.createWatcher(context.model)[Symbol.asyncIterator]();
+        const stream = context.streams[0];
+        stream.send({ Subscribed: true });
+        for (let index = 0; index < 2050; index++) stream.send({ ModelKey: `${index}`, ReadModel: '{}' });
+        await context.flush();
+        stream.pulls.should.equal(1025); // One acknowledgment and 1,024 buffered changes.
+        stream.signal.aborted.should.be.false;
+        (await iterator.next()).value.key.should.equal('0');
+        await context.flush();
+        stream.pulls.should.equal(1026);
+        for (let index = 1; index < 2050; index++) {
+            (await iterator.next()).value.key.should.equal(`${index}`);
+        }
+        stream.end();
+        (await iterator.next()).done!.should.be.true;
+    });
+
+    it('should reach acknowledgment with a full pre-acknowledgment buffer then pause until consumption', async () => {
+        const watcher = context.readModels.createWatcher(context.model);
+        const stream = context.streams[0];
+        for (let index = 0; index < 1024; index++) stream.send({ ModelKey: `${index}`, ReadModel: '{}' });
+        stream.send({ Subscribed: true });
+        stream.send({ ModelKey: 'after', ReadModel: '{}' });
+        await watcher.subscribed;
+        await context.flush();
+        stream.pulls.should.equal(1025);
+        const iterator = watcher[Symbol.asyncIterator]();
+        for (let index = 0; index < 1024; index++) (await iterator.next()).value.key.should.equal(`${index}`);
+        (await iterator.next()).value.key.should.equal('after');
+    });
+
+    it('should cancel a paused read on disposal', async () => {
+        const watcher = context.readModels.createWatcher(context.model);
+        const stream = context.streams[0];
+        stream.send({ Subscribed: true });
+        for (let index = 0; index < 1024; index++) stream.send({ ReadModel: '{}' });
+        await context.flush();
+        watcher.dispose();
+        await context.flush();
+        stream.closed.should.be.true;
+        stream.signal.aborted.should.be.true;
+        stream.pulls.should.equal(1025);
+        (await watcher[Symbol.asyncIterator]().next()).done!.should.be.true;
+    });
+
+    it('should read eagerly again until each resumed stream acknowledges even with a full buffer', async () => {
+        const watcher = context.readModels.createWatcher(context.model, { resume: true });
+        context.streams[0].send({ Subscribed: true });
+        for (let index = 0; index < 1024; index++) context.streams[0].send({ ModelKey: `${index}`, ReadModel: '{}' });
+        await context.flush();
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        context.streams[1].send({ ModelKey: 'resumed', ReadModel: '{}' });
+        await watcher.subscribed;
+        await context.flush();
+        context.streams[0].closed.should.be.true;
+        context.streams[1].pulls.should.equal(1);
+        const iterator = watcher[Symbol.asyncIterator]();
+        for (let index = 0; index < 1024; index++) (await iterator.next()).value.key.should.equal(`${index}`);
+        (await iterator.next()).value.key.should.equal('resumed');
+    });
+});

package/readModels/for_ReadModelWatcher/when_failing_with_buffered_changes.spec.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe.each(['transport', 'stream', 'connection'] as const)('when a read model watcher has buffered changes before a terminal %s failure', kind => {
+    let context: a_watched_read_model;
+    beforeEach(async () => {
+        context = new a_watched_read_model();
+        await context.connect();
+    });
+    afterEach(() => context.readModels.dispose());
+
+    it.each([false, true])('should drain received changes before rejecting with the original error (acknowledged: %s)', async acknowledged => {
+        const watcher = context.readModels.createWatcher(context.model, { resume: kind !== 'transport' });
+        const readiness = watcher.subscribed.catch(error => error);
+        const stream = context.streams[0];
+        if (acknowledged) {
+            stream.send({ Subscribed: true });
+            await readiness;
+        }
+        stream.send({ ModelKey: 'first', ReadModel: '{"id":"first"}' });
+        stream.send({ ModelKey: 'second', ReadModel: '{"id":"second"}' });
+        await context.flush();
+        const failure = Object.assign(new Error('terminal failure'), { code: kind === 'transport' ? 14 : 7 });
+        if (kind === 'connection') await context.lifecycle.failed(failure, error => { throw error; });
+        else stream.fail(failure);
+        await context.flush();
+        if (!acknowledged) (await readiness).should.equal(failure);
+        stream.signal.aborted.should.be.true;
+        const iterator = watcher[Symbol.asyncIterator]();
+        (await iterator.next()).value.should.contain({ key: 'first' });
+        (await iterator.next()).value.should.contain({ key: 'second' });
+        (await iterator.next().catch(error => error)).should.equal(failure);
+    });
+});

package/readModels/for_ReadModelWatcher/when_not_opting_into_resume.spec.ts

@@ -0,0 +1,62 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe.each(['watch', 'createWatcher'] as const)('when %s has not opted into resumption', method => {
+    let context: a_watched_read_model;
+    beforeEach(async () => {
+        vi.useFakeTimers();
+        context = new a_watched_read_model();
+        await context.connect();
+    });
+    afterEach(() => {
+        context.readModels.dispose();
+        vi.useRealTimers();
+    });
+
+    it.each([1, 4, 13, 14])('should reject iteration with the original transport error for status %s', async code => {
+        const iterator = context.readModels[method](context.model)[Symbol.asyncIterator]();
+        const next = iterator.next().catch(error => error);
+        context.streams[0].send({ Subscribed: true });
+        await vi.advanceTimersByTimeAsync(0);
+        const failure = Object.assign(new Error('transport failed'), { code });
+        // A keep-alive disconnect arriving first must not replace the watch stream error.
+        await context.disconnect();
+        context.streams[0].closed.should.be.false;
+        context.streams[0].fail(failure);
+        (await next).should.equal(failure);
+        await context.connect();
+        await vi.advanceTimersByTimeAsync(1000);
+        context.streams.should.have.lengthOf(1);
+    });
+
+    it('should complete iteration without restarting after stream completion', async () => {
+        const iterator = context.readModels[method](context.model)[Symbol.asyncIterator]();
+        const next = iterator.next();
+        context.streams[0].send({ Subscribed: true });
+        context.streams[0].send({ ModelKey: 'received', ReadModel: '{}' });
+        context.streams[0].end();
+        await vi.advanceTimersByTimeAsync(1000);
+        (await next).value.key.should.equal('received');
+        (await iterator.next()).done!.should.be.true;
+        context.streams.should.have.lengthOf(1);
+    });
+
+    it('should stop opting into resumption after the last callback is removed', async () => {
+        const watcher = context.readModels.createWatcher(context.model);
+        const unsubscribe = watcher.onResubscribed(() => {});
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        unsubscribe();
+        const failure = { code: 14 };
+        const next = watcher[Symbol.asyncIterator]().next().catch(error => error);
+        context.streams[0].fail(failure);
+        (await next).should.equal(failure);
+        await vi.advanceTimersByTimeAsync(1000);
+        context.streams.should.have.lengthOf(1);
+    });
+});

package/readModels/for_ReadModelWatcher/when_notifying_resubscription.spec.ts

@@ -0,0 +1,128 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it, vi } from 'vitest';
+import type { IReadModelWatcher } from '../IReadModelWatcher.js';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe('when notifying read model resubscription', () => {
+    let context: a_watched_read_model;
+    let watcher: IReadModelWatcher<{ id: string }>;
+    beforeEach(async () => {
+        context = new a_watched_read_model();
+        await context.connect();
+        watcher = context.readModels.createWatcher(context.model);
+    });
+    afterEach(() => context.readModels.dispose());
+
+    it('should notify once per acknowledged resubscription and ignore duplicate markers', async () => {
+        const callback = vi.fn();
+        watcher.onResubscribed(callback);
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        for (let generation = 1; generation <= 2; generation++) {
+            await context.disconnect();
+            await context.connect();
+            callback.mock.calls.should.have.lengthOf(generation - 1);
+            context.streams[generation].send({ Subscribed: true });
+            context.streams[generation].send({ Subscribed: true });
+            await context.flush();
+            callback.mock.calls.should.have.lengthOf(generation);
+        }
+    });
+
+    it('should not notify for the first acknowledgment after an unacknowledged disconnect', async () => {
+        const callback = vi.fn();
+        watcher.onResubscribed(callback);
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        await watcher.subscribed;
+        await context.flush();
+        callback.mock.calls.should.have.lengthOf(0);
+    });
+
+    it('should unregister callbacks idempotently without removing other callbacks', async () => {
+        const removed = vi.fn();
+        const remaining = vi.fn();
+        const unsubscribe = watcher.onResubscribed(removed);
+        watcher.onResubscribed(remaining);
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        unsubscribe();
+        unsubscribe();
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        await context.flush();
+        removed.mock.calls.should.have.lengthOf(0);
+        remaining.mock.calls.should.have.lengthOf(1);
+    });
+
+    it('should await refresh callbacks in registration order before delivering resumed changes', async () => {
+        let finishRefresh!: () => void;
+        const refresh = new Promise<void>(resolve => { finishRefresh = resolve; });
+        const calls: string[] = [];
+        watcher.onResubscribed(async () => {
+            calls.push('refresh');
+            await refresh;
+        });
+        watcher.onResubscribed(() => { calls.push('refreshed'); });
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        const next = watcher[Symbol.asyncIterator]().next().then(change => {
+            calls.push('change');
+            return change;
+        });
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        context.streams[1].send({ ModelKey: 'new', ReadModel: '{}' });
+        await context.flush();
+        calls.should.deep.equal(['refresh']);
+        finishRefresh();
+        (await next).value.key.should.equal('new');
+        calls.should.deep.equal(['refresh', 'refreshed', 'change']);
+    });
+
+    it.each([false, true])('should fail iteration on a callback failure even with a transport code (async: %s)', async asynchronous => {
+        const failure = { code: 14 };
+        watcher.onResubscribed(() => {
+            if (asynchronous) return Promise.reject(failure);
+            throw failure;
+        });
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        const next = watcher[Symbol.asyncIterator]().next().catch(error => error);
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        (await next).should.equal(failure);
+        context.streams[1].signal.aborted.should.be.true;
+        await context.disconnect();
+        await context.connect();
+        context.streams.should.have.lengthOf(2);
+    });
+
+    it('should stop notifying callbacks when disposed during a refresh', async () => {
+        const remaining = vi.fn();
+        watcher.onResubscribed(() => watcher.dispose());
+        watcher.onResubscribed(remaining);
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        const next = watcher[Symbol.asyncIterator]().next();
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        (await next).done!.should.be.true;
+        await context.flush();
+        remaining.mock.calls.should.have.lengthOf(0);
+        const unsubscribe = watcher.onResubscribed(remaining);
+        unsubscribe();
+        await context.disconnect();
+        await context.connect();
+        context.streams.should.have.lengthOf(2);
+    });
+});

package/readModels/for_ReadModelWatcher/when_opting_into_overflow.spec.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe('when opting into watch overflow failure', () => {
+    let context: a_watched_read_model;
+    beforeEach(async () => {
+        context = new a_watched_read_model();
+        await context.connect();
+    });
+    afterEach(() => context.readModels.dispose());
+
+    it.each([false, true])('should fail instead of dropping changes above the explicit limit (acknowledged: %s)', async acknowledged => {
+        const watcher = context.readModels.createWatcher(context.model, { maxBuffered: 2, resume: true });
+        const readiness = watcher.subscribed.catch(error => error);
+        if (acknowledged) {
+            context.streams[0].send({ Subscribed: true });
+            await readiness;
+        }
+        for (let index = 0; index < 3; index++) context.streams[0].send({ ReadModel: '{}' });
+        await context.flush();
+        const failure = await watcher[Symbol.asyncIterator]().next().catch(error => error);
+        failure.message.should.contain('buffer exceeded 2 changes');
+        if (!acknowledged) (await readiness).should.equal(failure);
+        context.streams[0].signal.aborted.should.be.true;
+        await context.disconnect();
+        await context.connect();
+        context.streams.should.have.lengthOf(1);
+    });
+
+    it.each([0, -1, 1.5, Infinity, NaN, Number.MAX_SAFE_INTEGER + 1])('should reject an invalid limit %s before opening a stream', maxBuffered => {
+        (() => context.readModels.createWatcher(context.model, { maxBuffered })).should.throw(RangeError);
+        context.streams.should.have.lengthOf(0);
+    });
+});

package/readModels/for_ReadModelWatcher/when_receiving_changes.spec.ts

@@ -0,0 +1,69 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Guid } from '@cratis/fundamentals';
+import { ReadModelChangeType as ContractChangeType } from '@cratis/chronicle.contracts';
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import { toContractsGuid } from '../../connection/Guid.js';
+import type { IReadModelWatcher } from '../IReadModelWatcher.js';
+import { ReadModelChangeType } from '../ReadModelChangeType.js';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe('when receiving read model changes', () => {
+    let context: a_watched_read_model;
+    let watcher: IReadModelWatcher<{ id: string }>;
+    beforeEach(async () => {
+        context = new a_watched_read_model();
+        await context.connect();
+        watcher = context.readModels.createWatcher(context.model);
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+    });
+    afterEach(() => watcher.dispose());
+
+    for (const [contractKind, kind] of [
+        [ContractChangeType.Added, ReadModelChangeType.Added],
+        [ContractChangeType.Modified, ReadModelChangeType.Modified],
+        [ContractChangeType.Removed, ReadModelChangeType.Removed],
+        [ContractChangeType.UNRECOGNIZED, ReadModelChangeType.Modified]
+    ]) {
+        it(`should preserve ${ContractChangeType[contractKind]} changes and their triggering context`, async () => {
+            const removed = contractKind === ContractChangeType.Removed;
+            const occurred = '2026-06-07T08:09:10.123Z';
+            const correlationId = '12345678-1234-5678-9abc-123456789abc';
+            context.streams[0].send({ Namespace: 'tenant', ModelKey: 'one', ReadModel: removed ? '' : '{"id":"one"}',
+                Removed: removed, ChangeType: contractKind, EventSequenceNumber: 9007199254740997n,
+                CorrelationId: toContractsGuid(Guid.as(correlationId)), Occurred: { Value: occurred } });
+            const change = (await watcher[Symbol.asyncIterator]().next()).value;
+            change.namespace.should.equal('tenant');
+            change.key.should.equal('one');
+            change.removed.should.equal(removed);
+            change.readModel.should.be.instanceOf(context.model);
+            change.changeType.should.equal(kind);
+            change.changeContext.should.deep.equal({ eventStore: 'store', namespace: 'tenant',
+                sequenceNumber: 9007199254740997n, correlationId, occurred: new Date(occurred) });
+        });
+    }
+
+    it('should leave absent timestamp and correlation metadata absent', async () => {
+        context.streams[0].send({ ReadModel: '{}' });
+        const change = (await watcher[Symbol.asyncIterator]().next()).value;
+        (change.changeContext.occurred === undefined).should.be.true;
+        (change.changeContext.correlationId === undefined).should.be.true;
+    });
+
+    it.each(['', 'not a timestamp'])('should leave an empty or invalid timestamp (%s) absent', async value => {
+        context.streams[0].send({ ReadModel: '{}', Occurred: { Value: value } });
+        const change = (await watcher[Symbol.asyncIterator]().next()).value;
+        (change.changeContext.occurred === undefined).should.be.true;
+    });
+
+    it('should surface a deserialization failure and stop the stream', async () => {
+        const next = watcher[Symbol.asyncIterator]().next().catch(error => error);
+        context.streams[0].send({ ReadModel: 'not json' });
+        (await next).should.be.instanceOf(SyntaxError);
+        context.streams[0].signal.aborted.should.be.true;
+    });
+});

package/readModels/for_ReadModelWatcher/when_reconnecting.spec.ts

@@ -0,0 +1,99 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { afterEach, beforeEach, chai, describe, it } from 'vitest';
+import type { IReadModelWatcher } from '../IReadModelWatcher.js';
+import { a_watched_read_model } from './given/a_watched_read_model.js';
+
+chai.should();
+
+describe('when reconnecting a read model watcher', () => {
+    let context: a_watched_read_model;
+    let watcher: IReadModelWatcher<{ id: string }>;
+    beforeEach(async () => {
+        context = new a_watched_read_model();
+        await context.connect();
+        watcher = context.readModels.createWatcher(context.model, { resume: true });
+    });
+    afterEach(() => context.readModels.dispose());
+
+    it('should replace resolved readiness at disconnect and continue the same iterator after a fresh acknowledgment', async () => {
+        context.streams[0].send({ Subscribed: true });
+        const firstReadiness = watcher.subscribed;
+        await firstReadiness;
+        const iterator = watcher[Symbol.asyncIterator]();
+        const next = iterator.next();
+        await context.disconnect();
+        context.streams[0].signal.aborted.should.be.true;
+        watcher.subscribed.should.not.equal(firstReadiness);
+        let ready = false;
+        void watcher.subscribed.then(() => { ready = true; });
+        await context.connect();
+        await context.flush();
+        ready.should.be.false;
+        context.streams[1].send({ Subscribed: true });
+        await watcher.subscribed;
+        ready.should.be.true;
+        context.streams[1].send({ ModelKey: 'new', ReadModel: '{"id":"new"}' });
+        (await next).value.key.should.equal('new');
+    });
+
+    it('should preserve still pending readiness across a disconnect before acknowledgment', async () => {
+        const pending = watcher.subscribed;
+        await context.disconnect();
+        watcher.subscribed.should.equal(pending);
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        await pending;
+    });
+
+    it('should deliver buffered changes from the previous connection before new changes', async () => {
+        context.streams[0].send({ Subscribed: true });
+        context.streams[0].send({ ModelKey: 'old', ReadModel: '{"id":"old"}' });
+        await watcher.subscribed;
+        await context.flush();
+        await context.disconnect();
+        await context.connect();
+        context.streams[1].send({ Subscribed: true });
+        context.streams[1].send({ ModelKey: 'new', ReadModel: '{"id":"new"}' });
+        const iterator = watcher[Symbol.asyncIterator]();
+        (await iterator.next()).value.key.should.equal('old');
+        (await iterator.next()).value.key.should.equal('new');
+    });
+
+    it('should acknowledge a new subscription before consuming its buffered changes', async () => {
+        context.streams[0].send({ Subscribed: true });
+        await watcher.subscribed;
+        const iterator = watcher[Symbol.asyncIterator]();
+        await context.disconnect();
+        const readiness = watcher.subscribed;
+        await context.connect();
+        context.streams[1].send({ ModelKey: 'new', ReadModel: '{"id":"new"}' });
+        context.streams[1].send({ Subscribed: true });
+        await readiness;
+        (await iterator.next()).value.key.should.equal('new');
+    });
+
+    it('should not create duplicate streams for repeated connected notifications', async () => {
+        await context.connect();
+        context.streams.should.have.lengthOf(1);
+    });
+
+    it('should not restart a disposed watcher', async () => {
+        watcher.dispose();
+        await context.disconnect();
+        await context.connect();
+        context.streams.should.have.lengthOf(1);
+    });
+
+    it('should defer opening a watcher created while disconnected', async () => {
+        watcher.dispose();
+        await context.disconnect();
+        watcher = context.readModels.createWatcher(context.model);
+        context.streams.should.have.lengthOf(1);
+        await context.connect();
+        context.streams.should.have.lengthOf(2);
+        context.streams[1].send({ Subscribed: true });
+        await watcher.subscribed;
+    });
+});