typedrest 0.4.1 → 0.6.0

package/endpoints/generic/CollectionEndpoint.test.ts

@@ -1,215 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { CollectionEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpHeader, HttpStatusCode, HttpMethod } from '../../http';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: CollectionEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new CollectionEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('getById', () => {
-    expect(endpoint.get('x/y').uri).toEqual(new URL('http://localhost/endpoint/x%2Fy'));
-});
-
-test('getByIdWithLinkHeaderRelative', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<children{?id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children?id=1'));
-});
-
-test('getByIdWithLinkHeaderAbsolute', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<http://localhost/children{?id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children?id=1'));
-});
-
-test('getByEntity', () => {
-    expect(endpoint.get(new MockEntity(1, 'test')).uri).toEqual(new URL('http://localhost/endpoint/1'));
-});
-
-test('getByEntityWithLinkHeaderRelative', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<children/{id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children/1'));
-});
-
-test('getByEntityWithLinkHeaderAbsolute', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[]',
-        {
-            headers: {
-                [HttpHeader.Link]: '<http://localhost/children/{id}>; rel=child; templated=true'
-            }
-        }
-    );
-    await endpoint.readAll();
-
-    expect(endpoint.get('1').uri).toEqual(new URL('http://localhost/children/1'));
-});
-
-test('readAll', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[{"id":5,"name":"test1"}, {"id":6,"name":"test2"}]'
-    );
-
-    const result = await endpoint.readAll();
-    expect(result).toEqual([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-});
-
-test('readAllCache', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[{"id":5,"name":"test1"}, {"id":6,"name":"test2"}]',
-        {
-            headers: {
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    const result1 = await endpoint.readAll();
-    expect(result1).toEqual([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfNoneMatch)).toBe('"123abc"');
-            return { status: HttpStatusCode.NotModified };
-        }
-    );
-    const result2 = await endpoint.readAll();
-    expect(result2).toEqual([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-
-    expect(result2).not.toBe(result1); // Should cache response, not deserialized object
-});
-
-test('create', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":0,"name":"test"}');
-            return { body: '{"id":5,"name":"test"}' };
-        }
-    );
-
-    const element = (await endpoint.create(new MockEntity(0, 'test')))!;
-    expect(element!.response).toEqual(new MockEntity(5, 'test'));
-    expect(element.uri).toEqual(new URL('http://localhost/endpoint/5'));
-});
-
-test('createLocation', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":0,"name":"test"}');
-            return {
-                body: '{"id":5,"name":"test"}',
-                headers: {
-                    [HttpHeader.Location]: '/endpoint/new'
-                }
-            };
-        }
-    );
-
-    const element = (await endpoint.create(new MockEntity(0, 'test')))!;
-    expect(element.response).toEqual(new MockEntity(5, 'test'));
-    expect(element.uri).toEqual(new URL('http://localhost/endpoint/new'));
-});
-
-test('createUndefined', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":0,"name":"test"}');
-            return { status: HttpStatusCode.Accepted };
-        }
-    );
-
-    const element = (await endpoint.create(new MockEntity(0, 'test')));
-    expect(element).toBeUndefined();
-});
-
-test('createAll', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Patch && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]');
-            return {};
-        }
-    );
-
-    await endpoint.createAll([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-});
-
-test('setAll', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]');
-            return {};
-        }
-    );
-
-    await endpoint.setAll([new MockEntity(5, 'test1'), new MockEntity(6, 'test2')]);
-});
-
-test('setAllETag', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '[{"id":5,"name":"test1"}, {"id":6,"name":"test2"}]',
-        {
-            headers: { [HttpHeader.ETag]: '"123abc"' }
-        });
-    const result = await endpoint.readAll();
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"123abc"');
-            expect(await req.text()).toBe('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]');
-            return {};
-        }
-    );
-    await endpoint.setAll(result);
-});

package/endpoints/generic/ElementEndpoint.test.ts

@@ -1,262 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { ElementEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpStatusCode, HttpMethod, HttpHeader } from '../../http';
-import { ConcurrencyError } from '../../errors';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: ElementEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new ElementEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('read', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: { [HttpHeader.ContentType]: 'application/json' }
-        });
-
-    const result = await endpoint.read();
-    expect(result).toEqual(new MockEntity(5, 'test'));
-});
-
-test('readCache', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    const result1 = await endpoint.read();
-    expect(result1).toEqual(new MockEntity(5, 'test'));
-
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get('If-None-Match')).toBe('"123abc"');
-            return { status: HttpStatusCode.NotModified };
-        }
-    );
-    const result2 = await endpoint.read();
-    expect(result2).toEqual(new MockEntity(5, 'test'));
-
-    expect(result2).not.toBe(result1); // Should cache response, not deserialized object
-});
-
-test('existsTrue', async () => {
-    fetchMock.mockOnceIf(req => req.method === HttpMethod.Head && req.url === 'http://localhost/endpoint');
-
-    const result = await endpoint.exists();
-    expect(result).toBe(true);
-});
-
-test('existsFalse', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Head && req.url === 'http://localhost/endpoint',
-        async () => {
-            return { status: HttpStatusCode.NotFound };
-        }
-    );
-
-    const result = await endpoint.exists();
-    expect(result).toBe(false);
-});
-
-test('setResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"id":5,"name":"testXXX"}'
-            };
-        }
-    );
-
-    const result = await endpoint.set(new MockEntity(5, 'test'));
-    expect(result).toEqual(new MockEntity(5, 'testXXX'));
-});
-
-test('setNoResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {};
-        }
-    );
-
-    const result = await endpoint.set(new MockEntity(5, 'test'));
-    expect(result).toBeUndefined();
-});
-
-test('setETag', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    const result = await endpoint.read();
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"123abc"');
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {};
-
-        }
-    );
-    await endpoint.set(result);
-});
-
-test('updateRetry', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        async req => {
-            return {
-                headers: {
-                    [HttpHeader.ContentType]: 'application/json',
-                    [HttpHeader.ETag]: '"1"'
-                },
-                body: '{"id":5,"name":"test1"}'
-            };
-        }
-    ).mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"1"');
-            expect(await req.text()).toBe('{"id":5,"name":"testX"}');
-            return { status: HttpStatusCode.PreconditionFailed };
-        }
-    ).mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        async req => {
-            return {
-                headers: {
-                    [HttpHeader.ContentType]: 'application/json',
-                    [HttpHeader.ETag]: '"2"'
-                },
-                body: '{"id":5,"name":"test2"}'
-            };
-        }
-    ).mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"2"');
-            expect(await req.text()).toBe('{"id":5,"name":"testX"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"id":5,"name":"testX"}'
-            };
-        }
-    );
-
-    await endpoint.update(x => x.name = 'testX');
-});
-
-test('updateFail', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        '{"id":5,"name":"test1"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"1"'
-            }
-        }
-    );
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"1"');
-            expect(await req.text()).toBe('{"id":5,"name":"testX"}');
-            return { status: HttpStatusCode.PreconditionFailed };
-        }
-    );
-
-    let errorThrown = false;
-    try {
-        await endpoint.update(x => x.name = 'testX', 0);
-    } catch (err) {
-        errorThrown = err instanceof ConcurrencyError;
-    }
-    expect(errorThrown).toBe(true);
-});
-
-test('mergeResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Patch && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"id":5,"name":"testXXX"}'
-            };
-        }
-    );
-
-    const result = await endpoint.merge(new MockEntity(5, 'test'));
-    expect(result).toEqual(new MockEntity(5, 'testXXX'));
-});
-
-test('mergeNoResult', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Patch && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(await req.text()).toBe('{"id":5,"name":"test"}');
-            return {};
-        }
-    );
-
-    const result = await endpoint.merge(new MockEntity(5, 'test'));
-    expect(result).toBeUndefined();
-});
-
-test('delete', async () => {
-    fetchMock.mockOnceIf(req => req.method === HttpMethod.Delete && req.url === 'http://localhost/endpoint');
-    await endpoint.delete();
-});
-
-test('deleteETag', async () => {
-    fetchMock.mockOnceIf(
-        'http://localhost/endpoint',
-        '{"id":5,"name":"test"}',
-        {
-            headers: {
-                [HttpHeader.ContentType]: 'application/json',
-                [HttpHeader.ETag]: '"123abc"'
-            }
-        }
-    );
-    await endpoint.read();
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Delete && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.IfMatch)).toBe('"123abc"');
-            return {};
-        }
-    );
-    await endpoint.delete();
-});

package/endpoints/generic/IndexerEndpoint.test.ts

@@ -1,12 +0,0 @@
-import { IndexerEndpoint, ElementEndpoint } from '.';
-import { EntryEndpoint } from '..';
-
-let endpoint: IndexerEndpoint<ElementEndpoint<{}>>;
-
-beforeEach(() => {
-    endpoint = new IndexerEndpoint<ElementEndpoint<{}>>(new EntryEndpoint('http://localhost/'), 'endpoint', ElementEndpoint);
-});
-
-test('getById', () => {
-    expect(endpoint.get('x/y').uri).toEqual(new URL('http://localhost/endpoint/x%2Fy'));
-});

package/endpoints/raw/BlobEndpoint.test.ts

@@ -1,52 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { BlobEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpMethod, HttpHeader } from '../../http';
-
-fetchMock.enableMocks();
-let endpoint: BlobEndpoint;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new BlobEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('probe', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Options && req.url === 'http://localhost/endpoint',
-        async () => {
-            return {
-                headers: {
-                    [HttpHeader.Allow]: HttpMethod.Put
-                }
-            };
-        }
-    );
-    await endpoint.probe();
-
-    expect(endpoint.downloadAllowed).toBe(false);
-    expect(endpoint.uploadAllowed).toBe(true);
-});
-
-test('download', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Get && req.url === 'http://localhost/endpoint',
-        'data'
-    );
-
-    await endpoint.download();
-});
-
-test('uploadFrom', async () => {
-    const data = new Blob([new Uint8Array([1, 2, 3])], { type: 'mock/type' });
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Put && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('mock/type');
-            return {};
-        }
-    );
-
-    await endpoint.uploadFrom(data);
-});

package/endpoints/raw/UploadEndpoint.test.ts

@@ -1,47 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { UploadEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpMethod, HttpHeader } from '../../http';
-
-fetchMock.enableMocks();
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-});
-
-test('uploadFromRaw', async () => {
-    const endpoint = new UploadEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-    const data = new Blob([new Uint8Array([1, 2, 3])], { type: 'mock/type' });
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('mock/type');
-            return {};
-        }
-    );
-    await endpoint.uploadFrom(data);
-});
-
-test('uploadFromForm', async () => {
-    const endpoint = new UploadEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint', 'data');
-    const file = new File([new Uint8Array([1, 2, 3])], 'file.dat', { type: 'mock/type' });
-
-    // Spy on FormData.prototype.set to verify what's being set
-    const setSpy = jest.spyOn(FormData.prototype, 'set');
-
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async () => ({})
-    );
-
-    await endpoint.uploadFrom(file);
-
-    // Verify the FormData was populated correctly with file name and type
-    expect(setSpy).toHaveBeenCalledWith('data', file, 'file.dat');
-    const capturedFile = setSpy.mock.calls[0][1] as File;
-    expect(capturedFile.name).toBe('file.dat');
-    expect(capturedFile.type).toBe('mock/type');
-
-    setSpy.mockRestore();
-});

package/endpoints/rpc/ActionEndpoint.test.ts

@@ -1,36 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { ActionEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpMethod, HttpHeader } from '../../http';
-
-fetchMock.enableMocks();
-let endpoint: ActionEndpoint;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new ActionEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('probe', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Options && req.url === 'http://localhost/endpoint',
-        async () => {
-            return {
-                headers: {
-                    [HttpHeader.Allow]: HttpMethod.Post
-                }
-            };
-        }
-    );
-    await endpoint.probe();
-
-    expect(endpoint.invokeAllowed).toBe(true);
-});
-
-test('invoke', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint'
-    );
-
-    await endpoint.invoke();
-});

package/endpoints/rpc/ConsumerEndpoint.test.ts

@@ -1,29 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { ConsumerEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpMethod, HttpHeader } from '../../http';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: ConsumerEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new ConsumerEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('invoke', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"id":1,"name":"input"}');
-            return {};
-        }
-    );
-
-    await endpoint.invoke(new MockEntity(1, 'input'));
-});

package/endpoints/rpc/FunctionEndpoint.test.ts

@@ -1,29 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { FunctionEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpMethod, HttpHeader } from '../../http';
-
-fetchMock.enableMocks();
-let endpoint: FunctionEndpoint<{input: string}, {output: string}>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new FunctionEndpoint(new EntryEndpoint('http://localhost/'), 'endpoint');
-});
-
-test('invoke', async () => {
-    fetchMock.mockOnceIf(
-        req => req.method === HttpMethod.Post && req.url === 'http://localhost/endpoint',
-        async req => {
-            expect(req.headers.get(HttpHeader.ContentType)).toBe('application/json');
-            expect(await req.text()).toBe('{"input":"in"}');
-            return {
-                headers: { [HttpHeader.ContentType]: 'application/json' },
-                body: '{"output":"out"}'
-            };
-        }
-    );
-
-    const result = await endpoint.invoke({input: "in"});
-    expect(result).toEqual({output: "out"});
-});