@cratis/arc 18.0.0

package/queries/for_QueryFor/when_performing/with_abort_controller.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with abort controller', given(a_query_for, context => {
+    let result1: QueryResult<string>;
+    let result2: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    let firstAbortController: AbortController;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        // Setup fetch mock
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+
+        // Call perform first time to establish abort controller
+        result1 = await context.query.perform({ id: 'test-id-1' });
+        firstAbortController = context.query.abortController!;
+
+        // Call perform second time - should abort the first controller
+        result2 = await context.query.perform({ id: 'test-id-2' });
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should create new abort controller on second call', () => {
+        context.query.abortController.should.not.equal(firstAbortController);
+    });
+
+    it('should abort first controller when performing second query', () => {
+        firstAbortController.signal.aborted.should.be.true;
+    });
+
+    it('should return successful results for both calls', () => {
+        result1.isSuccess.should.be.true;
+        result2.isSuccess.should.be.true;
+    });
+
+    it('should call fetch twice', () => {
+        fetchStub.should.have.been.calledTwice;
+    });
+}));

package/queries/for_QueryFor/when_performing/with_enumerable_query.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 { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with enumerable query', given(a_query_for, context => {
+    let result: QueryResult<string[]>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: ['item1', 'item2'],
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        // Setup fetch mock
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.enumerableQuery.setOrigin('https://api.example.com');
+
+        // Call perform with valid arguments
+        result = await context.enumerableQuery.perform({ category: 'test-category' });
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should return array data', () => {
+        result.data.should.deep.equal(['item1', 'item2']);
+    });
+
+    it('should call fetch with correct URL', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.equal('https://api.example.com/api/items/test-category');
+    });
+}));

package/queries/for_QueryFor/when_performing/with_fetch_error.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 { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with fetch error', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+
+    beforeEach(async () => {
+        // Setup fetch mock to reject
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.rejects(new Error('Network error'));
+
+        context.query.setOrigin('https://api.example.com');
+
+        try {
+            // Call perform with valid arguments - should handle the error and return no success
+            result = await context.query.perform({ id: 'test-id' });
+        } catch {
+            // If QueryFor doesn't handle the error, we'll create a default response
+            const noSuccess = { ...QueryResult.noSuccess, data: context.query.defaultValue } as QueryResult<string>;
+            result = noSuccess;
+        }
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return no success result', () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it('should return default value', () => {
+        result.data.should.equal('');
+    });
+
+    it('should return result without data', () => {
+        result.data.should.equal('');
+        result.isSuccess.should.be.false;
+    });
+}));

package/queries/for_QueryFor/when_performing/with_invalid_arguments.ts

@@ -0,0 +1,29 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+import { QueryResult } from '../../QueryResult';
+
+describe('with invalid arguments', given(a_query_for, context => {
+    let result: QueryResult<string>;
+
+    beforeEach(async () => {
+        // Call perform without required arguments
+        result = await context.query.perform();
+    });
+
+    it('should return no success result', () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it('should return default value', () => {
+        result.data.should.equal('');
+    });
+
+    it('should return result without data', () => {
+        // For validation failures, the result doesn't have proper data
+        result.data.should.equal('');
+        result.isSuccess.should.be.false;
+    });
+}));

package/queries/for_QueryFor/when_performing/with_json_parse_error.ts

@@ -0,0 +1,45 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with json parse error', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+
+    beforeEach(async () => {
+        // Setup fetch mock with json parse error
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().rejects(new Error('Invalid JSON')),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+
+        // Call perform with valid arguments
+        result = await context.query.perform({ id: 'test-id' });
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return no success result', () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it('should return default value', () => {
+        result.data.should.equal('');
+    });
+
+    it('should return result without data', () => {
+        result.data.should.equal('');
+        result.isSuccess.should.be.false;
+    });
+}));

package/queries/for_QueryFor/when_performing/with_paging.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 { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+import { Paging } from '../../Paging';
+
+describe('with paging', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        // Setup fetch mock
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+        context.query.paging = new Paging(2, 10); // page 2, 10 items per page
+
+        // Call perform with valid arguments
+        result = await context.query.perform({ id: 'test-id' });
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should call fetch with URL including paging parameters', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.include('page=2');
+        url.should.include('pageSize=10');
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+}));

package/queries/for_QueryFor/when_performing/with_parameter_descriptor_values.ts

@@ -0,0 +1,68 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with parameter descriptor values', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.queryWithParameterDescriptorValues.setOrigin('https://api.example.com');
+        context.queryWithParameterDescriptorValues.setApiBasePath('/api/v1');
+
+        // Set values on the query instance
+        context.queryWithParameterDescriptorValues.filter = 'active';
+        context.queryWithParameterDescriptorValues.limit = 10;
+
+        result = await context.queryWithParameterDescriptorValues.perform();
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should include parameter descriptor values in URL as query string', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.include('filter=active');
+        url.should.include('limit=10');
+    });
+
+    it('should have query string separator in URL', () => {
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.include('?');
+    });
+}));

package/queries/for_QueryFor/when_performing/with_partial_parameter_descriptor_values.ts

@@ -0,0 +1,67 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with partial parameter descriptor values', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.queryWithParameterDescriptorValues.setOrigin('https://api.example.com');
+        context.queryWithParameterDescriptorValues.setApiBasePath('/api/v1');
+
+        // Only set one parameter value, leave the other undefined
+        context.queryWithParameterDescriptorValues.filter = 'active';
+        // limit is not set (undefined)
+
+        result = await context.queryWithParameterDescriptorValues.perform();
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should include only set parameter descriptor values in URL', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.include('filter=active');
+    });
+
+    it('should not include undefined parameter descriptor values in URL', () => {
+        const call = fetchStub.getCall(0);
+        const url = call.args[0].href;
+        url.should.not.include('limit=');
+    });
+}));

package/queries/for_QueryFor/when_performing/with_query_without_required_parameters.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+
+describe('with query without required parameters', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        // Setup fetch mock
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.queryWithoutParams.setOrigin('https://api.example.com');
+
+        // Call perform without any arguments (which is valid for this query)
+        result = await context.queryWithoutParams.perform();
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        result.isSuccess.should.be.true;
+    });
+
+    it('should call fetch with correct URL', () => {
+        fetchStub.should.have.been.calledOnce;
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.equal('https://api.example.com/api/all');
+    });
+}));

package/queries/for_QueryFor/when_performing/with_route_parameters_and_unused_parameters.ts

@@ -0,0 +1,71 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+import { expect } from 'chai';
+
+describe('with route parameters and unused parameters', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+    const mockResponse = {
+        data: 'test-result',
+        isSuccess: true,
+        isAuthorized: true,
+        isValid: true,
+        hasExceptions: false,
+        validationResults: [],
+        exceptionMessages: [],
+        exceptionStackTrace: '',
+        paging: {
+            totalItems: 0,
+            totalPages: 0,
+            page: 0,
+            size: 0
+        }
+    };
+
+    beforeEach(async () => {
+        fetchStub = sinon.stub(global, 'fetch');
+        fetchStub.resolves({
+            json: sinon.stub().resolves(mockResponse),
+            ok: true,
+            status: 200
+        } as unknown as Response);
+
+        context.query.setOrigin('https://api.example.com');
+        context.query.setApiBasePath('/api/v1');
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        result = await context.query.perform({ id: 'test-id', filter: 'active', search: 'query' } as any);
+    });
+
+    afterEach(() => {
+        fetchStub.restore();
+    });
+
+    it('should return successful result', () => {
+        expect(result.isSuccess).to.be.true;
+    });
+    
+    it('should return correct data', () => {
+        expect(result.data).to.equal('test-result');
+    });
+    
+    it('should include route parameter in path', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.include('/test-id');
+    });
+    
+    it('should include unused filter parameter in query string', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.include('filter=active');
+    });
+    
+    it('should include unused search parameter in query string', () => {
+        const call = fetchStub.getCall(0);
+        call.args[0].href.should.include('search=query');
+    });
+}));

package/queries/for_QueryFor/when_performing/with_sorting.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 { a_query_for } from '../given/a_query_for';
+import { given } from '../../../given';
+
+import * as sinon from 'sinon';
+import { QueryResult } from '../../QueryResult';
+import { Sorting } from '../../Sorting';
+import { SortDirection } from '../../SortDirection';
+
+describe('with sorting', given(a_query_for, context => {
+    let result: QueryResult<string>;
+    let fetchStub: sinon.SinonStub;
+                const mockResponse = {
+                data: 'test-result',
+                isSuccess: true,
+                isAuthorized: true,
+                isValid: true,
+                hasExceptions: false,
+                validationResults: [],
+                exceptionMessages: [],
+                exceptionStackTrace: '',
+                paging: {
+                    totalItems: 0,
+                    totalPages: 0,
+                    page: 0,
+                    size: 0
+                }
+            };
+
+    describe('and ascending direction', () => {
+        beforeEach(async () => {
+            // Setup fetch mock
+            fetchStub = sinon.stub(global, 'fetch');
+            fetchStub.resolves({
+                json: sinon.stub().resolves(mockResponse),
+                ok: true,
+                status: 200
+            } as unknown as Response);
+
+            context.query.setOrigin('https://api.example.com');
+            context.query.sorting = new Sorting('name', SortDirection.ascending);
+
+            // Call perform with valid arguments
+            result = await context.query.perform({ id: 'test-id' });
+        });
+
+        afterEach(() => {
+            fetchStub.restore();
+        });
+
+        it('should call fetch with URL including sorting parameters', () => {
+            fetchStub.should.have.been.calledOnce;
+            const call = fetchStub.getCall(0);
+            const url = call.args[0].href;
+            url.should.include('sortBy=name');
+            url.should.include('sortDirection=asc');
+        });
+
+        it('should return successful result', () => {
+            result.isSuccess.should.be.true;
+        });
+    });
+
+    describe('and descending direction', () => {
+        beforeEach(async () => {
+            // Setup fetch mock
+            fetchStub = sinon.stub(global, 'fetch');
+            fetchStub.resolves({
+                json: sinon.stub().resolves(mockResponse),
+                ok: true,
+                status: 200
+            } as unknown as Response);
+
+            context.query.setOrigin('https://api.example.com');
+            context.query.sorting = new Sorting('name', SortDirection.descending);
+
+            // Call perform with valid arguments
+            result = await context.query.perform({ id: 'test-id' });
+        });
+
+        afterEach(() => {
+            fetchStub.restore();
+        });
+
+        it('should call fetch with URL including sorting parameters', () => {
+            fetchStub.should.have.been.calledOnce;
+            const call = fetchStub.getCall(0);
+            const url = call.args[0].href;
+            url.should.include('sortBy=name');
+            url.should.include('sortDirection=desc');
+        });
+
+        it('should return successful result', () => {
+            result.isSuccess.should.be.true;
+        });
+    });
+}));