@cratis/arc 18.4.3 → 18.6.0

package/queries/for_ObservableQueryFor/when_performing/with_valid_arguments.ts

@@ -6,9 +6,12 @@ import { given } from '../../../given';
 import * as sinon from 'sinon';
 import { QueryResult } from '../../QueryResult';
 
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+
 describe('when performing with valid arguments', given(an_observable_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -27,7 +30,9 @@ describe('when performing with valid arguments', given(an_observable_query_for,
     };
 
     beforeEach(async () => {
-        fetchStub = sinon.stub(global, 'fetch');
+        // Setup fetch mock using helper
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -42,7 +47,7 @@ describe('when performing with valid arguments', given(an_observable_query_for,
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryFor/given/a_query_with_validator.ts

@@ -0,0 +1,54 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryFor } from '../../QueryFor';
+import { QueryValidator } from '../../QueryValidator';
+import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+import sinon from 'sinon';
+import '../../../validation/RuleBuilderExtensions';
+
+interface ITestResult {
+    data: string;
+}
+
+interface ITestParams {
+    searchTerm: string;
+    minAge: number;
+}
+
+class TestQueryValidator extends QueryValidator<ITestParams> {
+    constructor() {
+        super();
+        this.ruleFor((c: ITestParams) => c.searchTerm).minLength(3).withMessage('Search term must be at least 3 characters');
+        this.ruleFor((c: ITestParams) => c.minAge).greaterThanOrEqual(0).withMessage('Age must be positive');
+    }
+}
+
+class TestQuery extends QueryFor<ITestResult, ITestParams> {
+    readonly route: string = '/api/test-query';
+    readonly validation = new TestQueryValidator();
+    readonly parameterDescriptors: ParameterDescriptor[] = [];
+    defaultValue: ITestResult = { data: '' };
+    parameters: ITestParams = { searchTerm: '', minAge: 0 };
+    
+    constructor() {
+        super(Object, false);
+    }
+    
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+}
+
+export class a_query_with_validator {
+    query: TestQuery;
+    fetchStub: sinon.SinonStub;
+    fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    constructor() {
+        this.query = new TestQuery();
+        this.fetchHelper = createFetchHelper();
+        this.fetchStub = this.fetchHelper.stubFetch();
+    }
+}

package/queries/for_QueryFor/when_performing/with_abort_controller.ts

@@ -5,12 +5,14 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 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 fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     let firstAbortController: AbortController;
     const mockResponse = {
         data: 'test-result',
@@ -31,7 +33,8 @@ describe('with abort controller', given(a_query_for, context => {
 
     beforeEach(async () => {
         // Setup fetch mock
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -49,11 +52,11 @@ describe('with abort controller', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should create new abort controller on second call', () => {
-        context.query.abortController.should.not.equal(firstAbortController);
+        context.query.abortController!.should.not.equal(firstAbortController);
     });
 
     it('should abort first controller when performing second query', () => {

package/queries/for_QueryFor/when_performing/with_client_validation_failing.ts

@@ -0,0 +1,63 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryFor } from '../../QueryFor';
+import { QueryValidator } from '../../QueryValidator';
+import { QueryResult } from '../../QueryResult';
+import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor';
+import '../../../validation/RuleBuilderExtensions';
+
+interface TestParams {
+    minAge: number;
+}
+
+class TestQueryValidator extends QueryValidator<TestParams> {
+    constructor() {
+        super();
+        this.ruleFor(q => q.minAge).greaterThanOrEqual(0);
+    }
+}
+
+class TestQuery extends QueryFor<string, TestParams> {
+    readonly route = '/test';
+    readonly validation = new TestQueryValidator();
+    readonly parameterDescriptors: ParameterDescriptor[] = [];
+    defaultValue = '';
+    parameters: TestParams = { minAge: -1 };
+
+    constructor() {
+        super(String, false);
+    }
+
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+}
+
+describe("when performing with client validation failing", () => {
+    let query: TestQuery;
+    let result: QueryResult<string>;
+
+    beforeEach(async () => {
+        query = new TestQuery();
+        query.parameters = { minAge: -5 };
+
+        result = await query.perform(query.parameters);
+    });
+
+    it("should_not_be_success", () => {
+        result.isSuccess.should.be.false;
+    });
+
+    it("should_not_be_valid", () => {
+        result.isValid.should.be.false;
+    });
+
+    it("should_have_validation_results", () => {
+        result.validationResults.should.not.be.empty;
+    });
+
+    it("should_have_error_for_minAge", () => {
+        result.validationResults.some(r => r.members.includes('minAge')).should.be.true;
+    });
+});

package/queries/for_QueryFor/when_performing/with_client_validation_failure_and_custom_message.ts

@@ -0,0 +1,28 @@
+// 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_with_validator } from '../given/a_query_with_validator';
+import { given } from '../../../given';
+import { QueryResult } from '../../QueryResult';
+
+describe("when performing with client validation failure and custom message", given(a_query_with_validator, context => {
+    let result: QueryResult<object>;
+
+    beforeEach(async () => {
+        // Set invalid search term (too short)
+        context.query.parameters = { searchTerm: 'ab', minAge: 25 };
+        
+        // Perform should validate client-side and not call the server
+        result = await context.query.perform(context.query.parameters);
+    });
+
+    afterEach(() => {
+        context.fetchStub.restore();
+    });
+
+    it("should_not_call_server", () => context.fetchStub.called.should.be.false);
+    it("should_return_invalid_result", () => result.isValid.should.be.false);
+    it("should_have_validation_error", () => result.validationResults.length.should.equal(1));
+    it("should_have_custom_error_message", () => result.validationResults[0].message.should.equal('Search term must be at least 3 characters'));
+    it("should_have_error_for_searchTerm_property", () => result.validationResults[0].members[0].should.equal('searchTerm'));
+}));

package/queries/for_QueryFor/when_performing/with_client_validation_passing.ts

@@ -0,0 +1,64 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { QueryFor } from '../../QueryFor';
+import { QueryValidator } from '../../QueryValidator';
+import { ParameterDescriptor } from '../../../reflection/ParameterDescriptor';
+import '../../../validation/RuleBuilderExtensions';
+import sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
+
+interface TestParams {
+    minAge: number;
+}
+
+class TestQueryValidator extends QueryValidator<TestParams> {
+    constructor() {
+        super();
+        this.ruleFor(q => q.minAge).greaterThanOrEqual(0);
+    }
+}
+
+class TestQuery extends QueryFor<string, TestParams> {
+    readonly route = '/test';
+    readonly validation = new TestQueryValidator();
+    readonly parameterDescriptors: ParameterDescriptor[] = [];
+    defaultValue = '';
+    parameters: TestParams = { minAge: 0 };
+
+    constructor() {
+        super(String, false);
+    }
+
+    get requiredRequestParameters(): string[] {
+        return [];
+    }
+}
+
+describe("when performing with client validation passing", () => {
+    let query: TestQuery;
+    let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
+
+    beforeEach(() => {
+        query = new TestQuery();
+        query.setOrigin('http://localhost');
+        query.parameters = { minAge: 18 };
+
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
+        fetchStub.resolves({
+            ok: true,
+            json: async () => ({ data: 'result', isSuccess: true, isValid: true })
+        } as Response);
+    });
+
+    afterEach(() => {
+        fetchHelper.restore();
+    });
+
+    it("should_call_server", async () => {
+        await query.perform(query.parameters);
+        fetchStub.should.have.been.called;
+    });
+});

package/queries/for_QueryFor/when_performing/with_enumerable_query.ts

@@ -5,11 +5,13 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with enumerable query', given(a_query_for, context => {
     let result: QueryResult<string[]>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: ['item1', 'item2'],
         isSuccess: true,
@@ -29,7 +31,8 @@ describe('with enumerable query', given(a_query_for, context => {
 
     beforeEach(async () => {
         // Setup fetch mock
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -43,7 +46,7 @@ describe('with enumerable query', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryFor/when_performing/with_fetch_error.ts

@@ -5,15 +5,18 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with fetch error', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
 
     beforeEach(async () => {
         // Setup fetch mock to reject
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.rejects(new Error('Network error'));
 
         context.query.setOrigin('https://api.example.com');
@@ -29,7 +32,7 @@ describe('with fetch error', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return no success result', () => {

package/queries/for_QueryFor/when_performing/with_json_parse_error.ts

@@ -5,15 +5,18 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with json parse error', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
 
     beforeEach(async () => {
-        // Setup fetch mock with json parse error
-        fetchStub = sinon.stub(global, 'fetch');
+        // Setup fetch mock with json parse error using helper
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().rejects(new Error('Invalid JSON')),
             ok: true,
@@ -27,7 +30,7 @@ describe('with json parse error', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return no success result', () => {

package/queries/for_QueryFor/when_performing/with_paging.ts

@@ -5,12 +5,14 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 import { Paging } from '../../Paging';
 
 describe('with paging', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -30,7 +32,8 @@ describe('with paging', given(a_query_for, context => {
 
     beforeEach(async () => {
         // Setup fetch mock
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -45,7 +48,7 @@ describe('with paging', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should call fetch with URL including paging parameters', () => {

package/queries/for_QueryFor/when_performing/with_parameter_descriptor_values.ts

@@ -4,11 +4,13 @@
 import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with parameter descriptor values', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -27,7 +29,8 @@ describe('with parameter descriptor values', given(a_query_for, context => {
     };
 
     beforeEach(async () => {
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -45,7 +48,7 @@ describe('with parameter descriptor values', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryFor/when_performing/with_partial_parameter_descriptor_values.ts

@@ -4,11 +4,13 @@
 import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with partial parameter descriptor values', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -27,7 +29,8 @@ describe('with partial parameter descriptor values', given(a_query_for, context
     };
 
     beforeEach(async () => {
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -45,7 +48,7 @@ describe('with partial parameter descriptor values', given(a_query_for, context
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryFor/when_performing/with_query_without_required_parameters.ts

@@ -5,11 +5,13 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with query without required parameters', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -28,11 +30,8 @@ describe('with query without required parameters', given(a_query_for, context =>
     };
 
     beforeEach(async () => {
-        // Setup fetch mock - restore any existing stub first
-        if ((global.fetch as sinon.SinonStub)?.restore) {
-            (global.fetch as sinon.SinonStub).restore();
-        }
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -46,7 +45,7 @@ describe('with query without required parameters', given(a_query_for, context =>
     });
 
     afterEach(() => {
-        fetchStub?.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryFor/when_performing/with_route_parameters_and_unused_parameters.ts

@@ -4,12 +4,14 @@
 import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 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;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -28,7 +30,8 @@ describe('with route parameters and unused parameters', given(a_query_for, conte
     };
 
     beforeEach(async () => {
-        fetchStub = sinon.stub(global, 'fetch');
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -43,7 +46,7 @@ describe('with route parameters and unused parameters', given(a_query_for, conte
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryFor/when_performing/with_sorting.ts

@@ -5,6 +5,7 @@ import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 import { Sorting } from '../../Sorting';
 import { SortDirection } from '../../SortDirection';
@@ -12,6 +13,7 @@ import { SortDirection } from '../../SortDirection';
 describe('with sorting', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
                 const mockResponse = {
                 data: 'test-result',
                 isSuccess: true,
@@ -32,7 +34,8 @@ describe('with sorting', given(a_query_for, context => {
     describe('and ascending direction', () => {
         beforeEach(async () => {
             // Setup fetch mock
-            fetchStub = sinon.stub(global, 'fetch');
+            fetchHelper = createFetchHelper();
+            fetchStub = fetchHelper.stubFetch();
             fetchStub.resolves({
                 json: sinon.stub().resolves(mockResponse),
                 ok: true,
@@ -47,7 +50,7 @@ describe('with sorting', given(a_query_for, context => {
         });
 
         afterEach(() => {
-            fetchStub.restore();
+            fetchHelper.restore();
         });
 
         it('should call fetch with URL including sorting parameters', () => {
@@ -66,7 +69,8 @@ describe('with sorting', given(a_query_for, context => {
     describe('and descending direction', () => {
         beforeEach(async () => {
             // Setup fetch mock
-            fetchStub = sinon.stub(global, 'fetch');
+            fetchHelper = createFetchHelper();
+            fetchStub = fetchHelper.stubFetch();
             fetchStub.resolves({
                 json: sinon.stub().resolves(mockResponse),
                 ok: true,
@@ -81,7 +85,7 @@ describe('with sorting', given(a_query_for, context => {
         });
 
         afterEach(() => {
-            fetchStub.restore();
+            fetchHelper.restore();
         });
 
         it('should call fetch with URL including sorting parameters', () => {

package/queries/for_QueryFor/when_performing/with_valid_arguments.ts

@@ -4,11 +4,13 @@
 import { a_query_for } from '../given/a_query_for';
 import { given } from '../../../given';
 import * as sinon from 'sinon';
+import { createFetchHelper } from '../../../helpers/fetchHelper';
 import { QueryResult } from '../../QueryResult';
 
 describe('with valid arguments', given(a_query_for, context => {
     let result: QueryResult<string>;
     let fetchStub: sinon.SinonStub;
+    let fetchHelper: { stubFetch: () => sinon.SinonStub; restore: () => void };
     const mockResponse = {
         data: 'test-result',
         isSuccess: true,
@@ -27,8 +29,9 @@ describe('with valid arguments', given(a_query_for, context => {
     };
 
     beforeEach(async () => {
-        // Setup fetch mock
-        fetchStub = sinon.stub(global, 'fetch');
+        // Setup fetch mock using helper
+        fetchHelper = createFetchHelper();
+        fetchStub = fetchHelper.stubFetch();
         fetchStub.resolves({
             json: sinon.stub().resolves(mockResponse),
             ok: true,
@@ -44,7 +47,7 @@ describe('with valid arguments', given(a_query_for, context => {
     });
 
     afterEach(() => {
-        fetchStub.restore();
+        fetchHelper.restore();
     });
 
     it('should return successful result', () => {

package/queries/for_QueryResult/when_asking_has_data/and_it_an_array_with_items.ts

@@ -17,7 +17,7 @@ describe("when asking has data and it is an array with items", () => {
             totalItems: 0,
             totalPages: 0,
             page: 0,
-            items: 0
+            size: 0
         },
         validationResults: [],
         data: [{}, {}]

package/queries/for_QueryResult/when_asking_has_data/and_it_is_defined_instance.ts

@@ -17,7 +17,7 @@ describe("when asking has data and it is defined instance", () => {
             totalItems: 0,
             totalPages: 0,
             page: 0,
-            items: 0
+            size: 0
         },
         validationResults: [],
         data: {}

package/queries/for_QueryResult/when_asking_has_data/and_it_is_empty_array.ts

@@ -17,7 +17,7 @@ describe("when asking has data and it is empty array", () => {
             totalItems: 0,
             totalPages: 0,
             page: 0,
-            items: 0
+            size: 0
         },
         validationResults: [],
         data: []