@cratis/arc 19.12.0 → 20.1.0

package/queries/for_ObservableQueryConnectionFactory/when_creating/with_hub_mode_and_sse_transport.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 { a_descriptor } from '../given/a_descriptor';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { createObservableQueryConnection } from '../../ObservableQueryConnectionFactory';
+import { SSE_HUB_ROUTE } from '../../ServerSentEventQueryConnection';
+import { MultiplexedObservableQueryConnection, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+import { IObservableQueryConnection } from '../../IObservableQueryConnection';
+
+import * as sinon from 'sinon';
+
+describe('when creating with hub mode and SSE transport', given(a_descriptor, context => {
+    let connection: IObservableQueryConnection<unknown>;
+    let capturedUrl: string;
+
+    beforeEach(() => {
+        Globals.queryDirectMode = false;
+        Globals.queryTransportMethod = QueryTransportMethod.ServerSentEvents;
+
+        const FakeEventSourceConstructor = function (this: EventSource, url: string) {
+            capturedUrl = url;
+            Object.assign(this, {
+                onopen: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                addEventListener: sinon.stub(),
+                removeEventListener: sinon.stub(),
+                readyState: 0,
+            });
+        };
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceConstructor;
+
+        // Also stub fetch for the POST subscribe/unsubscribe calls
+        (globalThis as Record<string, unknown>)['fetch'] = sinon.stub().resolves({ ok: true } as Response);
+
+        connection = createObservableQueryConnection(context.descriptor);
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = context.originalDirectMode;
+        Globals.queryTransportMethod = context.originalTransportMethod;
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        delete (globalThis as Record<string, unknown>)['fetch'];
+        resetSharedMultiplexer();
+    });
+
+    it('should return a MultiplexedObservableQueryConnection', () => {
+        connection.should.be.instanceOf(MultiplexedObservableQueryConnection);
+    });
+
+    it('should target the SSE demultiplexer endpoint when connecting', () => {
+        (connection as MultiplexedObservableQueryConnection<unknown>).connect(sinon.stub());
+        capturedUrl.should.include(SSE_HUB_ROUTE);
+    });
+
+    it('should not include query name in URL', () => {
+        (connection as MultiplexedObservableQueryConnection<unknown>).connect(sinon.stub());
+        capturedUrl.should.not.include('query=');
+    });
+
+    it('should not include the per-query route', () => {
+        (connection as MultiplexedObservableQueryConnection<unknown>).connect(sinon.stub());
+        capturedUrl.should.not.include('/api/test/item-42');
+    });
+}));

package/queries/for_ObservableQueryConnectionFactory/when_creating/with_hub_mode_and_websocket_transport.ts

@@ -0,0 +1,61 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_descriptor } from '../given/a_descriptor';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { createObservableQueryConnection } from '../../ObservableQueryConnectionFactory';
+import { MultiplexedObservableQueryConnection, WS_HUB_ROUTE, resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+import { IObservableQueryConnection } from '../../IObservableQueryConnection';
+
+import * as sinon from 'sinon';
+
+describe('when creating with hub mode and WebSocket transport', given(a_descriptor, context => {
+    let connection: IObservableQueryConnection<unknown>;
+    let originalWebSocket: typeof WebSocket;
+    let capturedUrl: string;
+
+    beforeEach(() => {
+        Globals.queryDirectMode = false;
+        Globals.queryTransportMethod = QueryTransportMethod.WebSocket;
+
+        originalWebSocket = global.WebSocket;
+        (global as Record<string, unknown>).WebSocket = function (url: string) {
+            capturedUrl = url;
+            return {
+                onopen: null,
+                onclose: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                send: sinon.stub(),
+                readyState: 0,
+            };
+        };
+
+        connection = createObservableQueryConnection(context.descriptor);
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = context.originalDirectMode;
+        Globals.queryTransportMethod = context.originalTransportMethod;
+        global.WebSocket = originalWebSocket;
+        sinon.restore();
+        resetSharedMultiplexer();
+    });
+
+    it('should return a MultiplexedObservableQueryConnection', () => {
+        connection.should.be.instanceOf(MultiplexedObservableQueryConnection);
+    });
+
+    it('should target the WebSocket demultiplexer endpoint when connecting', () => {
+        (connection as MultiplexedObservableQueryConnection<unknown>).connect(sinon.stub());
+        capturedUrl.should.include(WS_HUB_ROUTE);
+    });
+
+    it('should not target the per-query route', () => {
+        (connection as MultiplexedObservableQueryConnection<unknown>).connect(sinon.stub());
+        capturedUrl.should.not.include('/api/test/item-42');
+    });
+}));

package/queries/for_ObservableQueryConnectionPool/when_acquiring/with_multiple_slots/and_least_loaded_slot_is_chosen.ts

@@ -0,0 +1,47 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { ObservableQueryConnectionPool } from '../../../ObservableQueryConnectionPool';
+import { IObservableQueryConnection } from '../../../IObservableQueryConnection';
+import { QueryResult } from '../../../QueryResult';
+
+describe('when acquiring from a pool with multiple slots and the least-loaded slot is chosen', () => {
+    let connectStubs: sinon.SinonStub[];
+    let disconnectStubs: sinon.SinonStub[];
+    let pool: ObservableQueryConnectionPool<string>;
+    let cleanups: Array<() => void>;
+
+    beforeEach(() => {
+        connectStubs = [];
+        disconnectStubs = [];
+        cleanups = [];
+
+        pool = new ObservableQueryConnectionPool<string>(3, () => {
+            const connectStub = sinon.stub();
+            const disconnectStub = sinon.stub();
+            connectStubs.push(connectStub);
+            disconnectStubs.push(disconnectStub);
+            return {
+                connect: connectStub,
+                disconnect: disconnectStub,
+                lastPingLatency: 0,
+                averageLatency: 0,
+            } as IObservableQueryConnection<string>;
+        });
+
+        // First subscriber fills slot 0
+        cleanups.push(pool.acquire((_: QueryResult<string>) => _));
+        // Release slot 0 — now it is the least-loaded again
+        cleanups[0]();
+        // Next subscriber should re-use slot 0 (count = 0) not slot 1 (never used but same count)
+        cleanups.push(pool.acquire((_: QueryResult<string>) => _));
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should have created two connections', () => connectStubs.length.should.equal(2));
+    it('should have called connect on both', () => connectStubs.every(s => s.calledOnce).should.be.true);
+});

package/queries/for_ObservableQueryConnectionPool/when_acquiring/with_multiple_slots/and_size_is_zero.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ObservableQueryConnectionPool } from '../../../ObservableQueryConnectionPool';
+import { IObservableQueryConnection } from '../../../IObservableQueryConnection';
+import { QueryResult } from '../../../QueryResult';
+
+describe('when constructing a pool with zero size', () => {
+    let pool: ObservableQueryConnectionPool<string>;
+    let connectCalled: boolean;
+
+    beforeEach(() => {
+        connectCalled = false;
+        const fakeConnection: IObservableQueryConnection<string> = {
+            connect: () => { connectCalled = true; },
+            disconnect: () => {},
+            lastPingLatency: 0,
+            averageLatency: 0,
+        };
+
+        pool = new ObservableQueryConnectionPool<string>(0, () => fakeConnection);
+        pool.acquire((_: QueryResult<string>) => _);
+    });
+
+    it('should fall back to at least one slot and still connect', () => connectCalled.should.be.true);
+});

package/queries/for_ObservableQueryConnectionPool/when_acquiring/with_single_slot/and_one_subscriber.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import sinon from 'sinon';
+import { ObservableQueryConnectionPool } from '../../../ObservableQueryConnectionPool';
+import { IObservableQueryConnection } from '../../../IObservableQueryConnection';
+import { QueryResult } from '../../../QueryResult';
+
+describe('when acquiring from a pool with a single slot', () => {
+    let connectStub: sinon.SinonStub;
+    let disconnectStub: sinon.SinonStub;
+    let pool: ObservableQueryConnectionPool<string>;
+    let cleanup: () => void;
+
+    beforeEach(() => {
+        connectStub = sinon.stub();
+        disconnectStub = sinon.stub();
+
+        const fakeConnection: IObservableQueryConnection<string> = {
+            connect: connectStub,
+            disconnect: disconnectStub,
+            lastPingLatency: 0,
+            averageLatency: 0,
+        };
+
+        pool = new ObservableQueryConnectionPool<string>(1, () => fakeConnection);
+        cleanup = pool.acquire((result: QueryResult<string>) => result);
+    });
+
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    it('should call connect on the underlying connection', () => connectStub.calledOnce.should.be.true);
+    it('should provide a cleanup function', () => (typeof cleanup).should.equal('function'));
+
+    describe('when the cleanup function is invoked', () => {
+        beforeEach(() => {
+            cleanup();
+        });
+
+        it('should disconnect the connection', () => disconnectStub.calledOnce.should.be.true);
+    });
+});

package/queries/for_ObservableQueryFor/when_subscribing/with_direct_mode_and_sse_transport.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 { an_observable_query_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+
+import * as sinon from 'sinon';
+
+describe('when subscribing with direct mode and SSE transport', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+    let capturedUrl: string;
+    let originalQueryDirectMode: boolean;
+    let originalTransportMethod: QueryTransportMethod;
+
+    beforeEach(() => {
+        originalQueryDirectMode = Globals.queryDirectMode;
+        originalTransportMethod = Globals.queryTransportMethod;
+
+        Globals.queryDirectMode = true;
+        Globals.queryTransportMethod = QueryTransportMethod.ServerSentEvents;
+
+        context.query.setOrigin('https://example.com');
+        callback = sinon.stub();
+
+        const FakeEventSourceConstructor = function (this: EventSource, url: string) {
+            capturedUrl = url;
+            Object.assign(this, {
+                onopen: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                addEventListener: sinon.stub(),
+                removeEventListener: sinon.stub(),
+            });
+        };
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceConstructor;
+
+        subscription = context.query.subscribe(callback, { id: 'test-id' });
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = originalQueryDirectMode;
+        Globals.queryTransportMethod = originalTransportMethod;
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+    });
+
+    it('should connect to the per-query SSE URL', () => {
+        capturedUrl.should.include('/api/test/test-id');
+    });
+
+    it('should not connect to the hub SSE endpoint', () => {
+        capturedUrl.should.not.include('/.cratis/queries/sse');
+    });
+
+    it('should not include a query name parameter', () => {
+        capturedUrl.should.not.include('query=');
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_direct_mode_disabled_and_sse_transport.ts

@@ -0,0 +1,70 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { an_observable_query_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { QueryTransportMethod } from '../../QueryTransportMethod';
+import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+import { SSE_HUB_ROUTE } from '../../ServerSentEventQueryConnection';
+import { resetSharedMultiplexer } from '../../ObservableQueryMultiplexer';
+
+import * as sinon from 'sinon';
+
+describe('when subscribing with direct mode disabled and SSE transport', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+    let capturedUrl: string;
+    let originalQueryDirectMode: boolean;
+    let originalTransportMethod: QueryTransportMethod;
+
+    beforeEach(() => {
+        originalQueryDirectMode = Globals.queryDirectMode;
+        originalTransportMethod = Globals.queryTransportMethod;
+        resetSharedMultiplexer();
+
+        Globals.queryDirectMode = false;
+        Globals.queryTransportMethod = QueryTransportMethod.ServerSentEvents;
+
+        context.query.setOrigin('https://example.com');
+        callback = sinon.stub();
+
+        // EventSource doesn't exist in Node.js — inject a fake via globalThis
+        const FakeEventSourceConstructor = function (this: EventSource, url: string) {
+            capturedUrl = url;
+            Object.assign(this, {
+                onopen: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                addEventListener: sinon.stub(),
+                removeEventListener: sinon.stub(),
+            });
+        };
+        (globalThis as Record<string, unknown>)['EventSource'] = FakeEventSourceConstructor;
+
+        subscription = context.query.subscribe(callback, { id: 'test-id' });
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = originalQueryDirectMode;
+        Globals.queryTransportMethod = originalTransportMethod;
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+        delete (globalThis as Record<string, unknown>)['EventSource'];
+        resetSharedMultiplexer();
+    });
+
+    it('should connect to the centralized SSE hub endpoint', () => {
+        capturedUrl.should.include(SSE_HUB_ROUTE);
+    });
+
+    it('should not include query name in URL since subscriptions are done via POST', () => {
+        capturedUrl.should.not.include('query=');
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_direct_mode_enabled.ts

@@ -0,0 +1,57 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { an_observable_query_for } from '../given/an_observable_query_for';
+import { given } from '../../../given';
+import { Globals } from '../../../Globals';
+import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
+
+import * as sinon from 'sinon';
+
+describe('when subscribing with direct mode enabled', given(an_observable_query_for, context => {
+    let callback: sinon.SinonStub;
+    let subscription: ObservableQuerySubscription<string>;
+    let originalWebSocket: typeof WebSocket;
+    let capturedUrl: string;
+    let originalQueryDirectMode: boolean;
+
+    beforeEach(() => {
+        originalQueryDirectMode = Globals.queryDirectMode;
+        Globals.queryDirectMode = true;
+
+        context.query.setOrigin('https://example.com');
+        callback = sinon.stub();
+
+        originalWebSocket = global.WebSocket;
+        (global as Record<string, unknown>).WebSocket = function (url: string) {
+            capturedUrl = url;
+            return {
+                onopen: null,
+                onclose: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                send: sinon.stub(),
+            };
+        };
+
+        subscription = context.query.subscribe(callback, { id: 'test-id' });
+    });
+
+    afterEach(() => {
+        Globals.queryDirectMode = originalQueryDirectMode;
+        if (subscription) {
+            subscription.unsubscribe();
+        }
+        global.WebSocket = originalWebSocket;
+        sinon.restore();
+    });
+
+    it('should connect directly to the per-query WebSocket URL', () => {
+        capturedUrl.should.include('/api/test/test-id');
+    });
+
+    it('should return a subscription', () => {
+        subscription.should.not.be.undefined;
+    });
+}));

package/queries/for_ObservableQueryFor/when_subscribing/with_partially_missing_required_arguments.ts

@@ -10,19 +10,26 @@ import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
 describe('when subscribing with partially missing required arguments', given(an_observable_query_for, context => {
     let callback: sinon.SinonStub;
     let subscription: ObservableQuerySubscription<string>;
-    let webSocketStub: sinon.SinonStub;
+    let originalWebSocket: typeof WebSocket;
+    let webSocketCalled: boolean;
 
     beforeEach(() => {
         context.queryWithMultipleRequiredParameters.setOrigin('https://example.com');
         callback = sinon.stub();
-        webSocketStub = sinon.stub(global, 'WebSocket').callsFake(() => ({
-            onopen: null,
-            onclose: null,
-            onerror: null,
-            onmessage: null,
-            close: sinon.stub(),
-            send: sinon.stub()
-        } as unknown as WebSocket));
+        webSocketCalled = false;
+
+        originalWebSocket = global.WebSocket;
+        (global as Record<string, unknown>).WebSocket = function () {
+            webSocketCalled = true;
+            return {
+                onopen: null,
+                onclose: null,
+                onerror: null,
+                onmessage: null,
+                close: sinon.stub(),
+                send: sinon.stub(),
+            };
+        };
 
         subscription = context.queryWithMultipleRequiredParameters.subscribe(callback, {
             userId: 'user-1',
@@ -34,7 +41,8 @@ describe('when subscribing with partially missing required arguments', given(an_
         if (subscription) {
             subscription.unsubscribe();
         }
-        webSocketStub.restore();
+        global.WebSocket = originalWebSocket;
+        sinon.restore();
     });
 
     it('should return a subscription', () => {
@@ -42,7 +50,7 @@ describe('when subscribing with partially missing required arguments', given(an_
     });
 
     it('should not create a web socket connection', () => {
-        webSocketStub.should.not.have.been.called;
+        webSocketCalled.should.be.false;
     });
 
     it('should call callback immediately with default value', () => {

package/queries/for_ObservableQueryFor/when_subscribing/with_route_and_query_args.ts

@@ -3,6 +3,7 @@
 
 import { an_observable_query_for } from '../given/an_observable_query_for';
 import { given } from '../../../given';
+import { Globals } from '../../../Globals';
 
 import * as sinon from 'sinon';
 import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
@@ -10,15 +11,19 @@ import { ObservableQuerySubscription } from '../../ObservableQuerySubscription';
 describe('when subscribing with route and query args', given(an_observable_query_for, context => {
     let callback: sinon.SinonStub;
     let subscription: ObservableQuerySubscription<string>;
-    let webSocketStub: sinon.SinonStub;
+    let originalWebSocket: typeof WebSocket;
     let capturedUrl: string;
+    let originalDirectMode: boolean;
 
     beforeEach(() => {
+        originalDirectMode = Globals.queryDirectMode;
+        Globals.queryDirectMode = true;
         context.queryWithRouteAndQueryArgs.setOrigin('https://example.com');
         callback = sinon.stub();
 
-        // Stub WebSocket to capture the URL
-        webSocketStub = sinon.stub(global, 'WebSocket').callsFake((url: string) => {
+        // Replace WebSocket to capture the URL
+        originalWebSocket = global.WebSocket;
+        (global as Record<string, unknown>).WebSocket = function (url: string) {
             capturedUrl = url;
             return {
                 onopen: null,
@@ -26,9 +31,9 @@ describe('when subscribing with route and query args', given(an_observable_query
                 onerror: null,
                 onmessage: null,
                 close: sinon.stub(),
-                send: sinon.stub()
-            } as unknown as WebSocket;
-        });
+                send: sinon.stub(),
+            };
+        };
 
         // Subscribe with args that include both route parameter (id) and query parameters (filter, limit)
         subscription = context.queryWithRouteAndQueryArgs.subscribe(callback, {
@@ -39,10 +44,12 @@ describe('when subscribing with route and query args', given(an_observable_query
     });
 
     afterEach(() => {
+        Globals.queryDirectMode = originalDirectMode;
         if (subscription) {
             subscription.unsubscribe();
         }
-        webSocketStub.restore();
+        global.WebSocket = originalWebSocket;
+        sinon.restore();
     });
 
     it('should include route parameter in the path', () => {

package/queries/for_QueryInstanceCache/when_building_key/with_arguments.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when building key for a query with arguments', () => {
+    let cache: QueryInstanceCache;
+    let result: string;
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        result = cache.buildKey('MyQuery', { id: '42', category: 'books' });
+    });
+
+    it('should return key containing the query name', () => result.should.contain('MyQuery::'));
+    it('should serialize arguments as sorted JSON', () => result.should.equal('MyQuery::{"category":"books","id":"42"}'));
+});

package/queries/for_QueryInstanceCache/when_building_key/with_empty_arguments_object.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when building key for a query with an empty arguments object', () => {
+    let cache: QueryInstanceCache;
+    let result: string;
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        result = cache.buildKey('MyQuery', {});
+    });
+
+    it('should produce the same key as no arguments', () => result.should.equal('MyQuery::'));
+});

package/queries/for_QueryInstanceCache/when_building_key/with_same_arguments_different_order.ts

@@ -0,0 +1,18 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when building key for a query with the same arguments in different order', () => {
+    let cache: QueryInstanceCache;
+    let keyA: string;
+    let keyB: string;
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        keyA = cache.buildKey('MyQuery', { z: 1, a: 2 });
+        keyB = cache.buildKey('MyQuery', { a: 2, z: 1 });
+    });
+
+    it('should produce identical keys regardless of property order', () => keyA.should.equal(keyB));
+});

package/queries/for_QueryInstanceCache/when_building_key/without_arguments.ts

@@ -0,0 +1,16 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when building key for a query without arguments', () => {
+    let cache: QueryInstanceCache;
+    let result: string;
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        result = cache.buildKey('MyQuery');
+    });
+
+    it('should return key with empty args suffix', () => result.should.equal('MyQuery::'));
+});

package/queries/for_QueryInstanceCache/when_getting_last_result/with_no_result_stored.ts

@@ -0,0 +1,17 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryInstanceCache } from '../../QueryInstanceCache';
+
+describe('when getting the last result for a key that has no result yet', () => {
+    let cache: QueryInstanceCache;
+    let result: unknown;
+
+    beforeEach(() => {
+        cache = new QueryInstanceCache();
+        cache.getOrCreate('MyQuery::', () => ({}));
+        result = cache.getLastResult('MyQuery::');
+    });
+
+    it('should return undefined', () => (result === undefined).should.be.true);
+});