typedrest 0.5.0 → 0.6.1

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/reactive/Delay.ts

@@ -1,26 +0,0 @@
-/**
- * Waits for a specific amount of time.
- * @param ms The time to wait in milliseconds.
- * @param signal Used to cancel the wait.
- * @returns `true` if the time has elapsed; `false` if the wait was cancelled via the `signal`.
- */
-export function delay(ms: number, signal?: AbortSignal): Promise<boolean> {
-    return new Promise(resolve => {
-        if (signal?.aborted) {
-            resolve(false);
-            return;
-        }
-
-        const onAbort = () => {
-            clearTimeout(timeout);
-            resolve(false);
-        };
-
-        const timeout = setTimeout(() => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve(true);
-        }, ms);
-
-        signal?.addEventListener("abort", onAbort, { once: true });
-    });
-}

package/endpoints/reactive/GenericStreamingCollectionEndpoint.ts

@@ -1,73 +0,0 @@
-import { ElementEndpoint } from "../generic/ElementEndpoint";
-import { GenericCollectionEndpoint } from "../generic/GenericCollectionEndpoint";
-import { PartialResponse } from "../generic/PartialResponse";
-import { delay } from "./Delay";
-import { retryAfter } from "../../http";
-import { RangeNotSatisfiableError } from "../../errors";
-
-/**
- * Endpoint for a collection of `TEntity`s observable as an append-only stream using long-polling.<br>
- * Use {@link StreamingCollectionEndpoint} instead if you wish to use the default {@link ElementEndpoint} type.
- * @typeParam TEntity The type of individual elements in the collection.
- * @typeParam TElementEndpoint The type of {@link ElementEndpoint} to provide for individual `TEntity`s.
- */
-export class GenericStreamingCollectionEndpoint<TEntity, TElementEndpoint extends ElementEndpoint<TEntity>> extends GenericCollectionEndpoint<TEntity, TElementEndpoint> {
-    /**
-     * The interval in milliseconds to wait between polling requests.
-     * Automatically updated whenever the server sends a {@link http!HttpHeader.RetryAfter} header.
-     */
-    pollingInterval = 3000;
-
-    /**
-     * @inheritDoc
-     */
-    protected async handle(response: Response) {
-        await super.handle(response);
-        this.pollingInterval = retryAfter(response) ?? this.pollingInterval;
-    }
-
-    /**
-     * Provides a stream of `TEntity`s, polling the server for elements appended to the collection.
-     * @param startIndex The index of the first element to return. Use a negative value to start with the last `-startIndex` elements ("tail").
-     * @param signal Used to stop polling.
-     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
-     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
-     * @throws {@link errors!HttpError}: Other non-success status code
-     */
-    async *stream(startIndex: number = 0, signal?: AbortSignal): AsyncIterableIterator<TEntity> {
-        let currentStartIndex = startIndex;
-
-        while (!signal?.aborted) {
-            let response: PartialResponse<TEntity>;
-            try {
-                response = (currentStartIndex >= 0)
-                    // Offset
-                    ? await this.readRange(currentStartIndex, undefined, signal)
-                    // Tail
-                    : await this.readRange(undefined, -currentStartIndex, signal);
-            } catch (err) {
-                // Aborting is a regular way of ending the stream, not an error
-                if (signal?.aborted) return;
-                if (!(err instanceof RangeNotSatisfiableError)) throw err;
-
-                // No new data available yet, keep polling
-                if (!await delay(this.pollingInterval, signal)) return;
-                continue;
-            }
-
-            yield* response.elements;
-            if (response.endReached) return;
-
-            // Continue polling for more data
-            if (response.range?.to === undefined) return;
-            currentStartIndex = response.range.to + 1;
-
-            if (!await delay(this.pollingInterval, signal)) return;
-        }
-    }
-
-    /**
-     * Provides a stream of `TEntity`s using {@link stream}.
-     */
-    [Symbol.asyncIterator]() { return this.stream(); }
-}

package/endpoints/reactive/PollingEndpoint.test.ts

@@ -1,84 +0,0 @@
-import fetchMock from 'jest-fetch-mock';
-import { PollingEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpHeader } from '../../http';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: PollingEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new PollingEndpoint<MockEntity>(new EntryEndpoint('http://localhost/'), 'endpoint', x => x.id === 3);
-    endpoint.pollingInterval = 0;
-});
-
-async function collect<T>(stream: AsyncIterable<T>) {
-    const result: T[] = [];
-    for await (const element of stream) result.push(element);
-    return result;
-}
-
-test('stream', async () => {
-    fetchMock.mockResponses(
-        '{"id":1,"name":"test"}',
-        '{"id":2,"name":"test"}',
-        ['{"id":3,"name":"test"}', { headers: { [HttpHeader.RetryAfter]: '42' } }]
-    );
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(1, 'test'),
-        new MockEntity(2, 'test'),
-        new MockEntity(3, 'test')
-    ]);
-    expect(endpoint.pollingInterval).toBe(42000);
-});
-
-test('streamSkipsUnchanged', async () => {
-    fetchMock.mockResponses(
-        '{"id":1,"name":"test"}',
-        '{"id":1,"name":"test"}',
-        '{"id":2,"name":"test"}',
-        '{"id":3,"name":"test"}'
-    );
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(1, 'test'),
-        new MockEntity(2, 'test'),
-        new MockEntity(3, 'test')
-    ]);
-});
-
-test('streamAsyncIterator', async () => {
-    fetchMock.mockResponses('{"id":3,"name":"test"}');
-
-    expect(await collect(endpoint)).toEqual([new MockEntity(3, 'test')]);
-});
-
-test('streamAbort', async () => {
-    fetchMock.mockResponse('{"id":1,"name":"test"}');
-    const controller = new AbortController();
-
-    const result: MockEntity[] = [];
-    for await (const element of endpoint.stream(controller.signal)) {
-        result.push(element);
-        controller.abort();
-    }
-
-    expect(result).toEqual([new MockEntity(1, 'test')]);
-});
-
-test('streamBreak', async () => {
-    fetchMock.mockResponse('{"id":1,"name":"test"}');
-
-    const result: MockEntity[] = [];
-    for await (const element of endpoint.stream()) {
-        result.push(element);
-        break;
-    }
-
-    expect(result).toEqual([new MockEntity(1, 'test')]);
-});

package/endpoints/reactive/SseStreamingEndpoint.test.ts

@@ -1,169 +0,0 @@
-/**
- * NOTE: The jsdom environment does not expose response bodies as streams, so these tests need the node environment.
- * @jest-environment node
- */
-
-import fetchMock from 'jest-fetch-mock';
-import { SseStreamingEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { ConflictError } from '../../errors';
-import { HttpHeader, HttpStatusCode } from '../../http';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let entryEndpoint: EntryEndpoint;
-let endpoint: SseStreamingEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    entryEndpoint = new EntryEndpoint('http://localhost/');
-    endpoint = new SseStreamingEndpoint<MockEntity>(entryEndpoint, 'endpoint');
-    endpoint.autoReconnect = false;
-});
-
-function sseEvent(data: string, type?: string, id?: string) {
-    return (type ? `event: ${type}\n` : '')
-        + (id ? `id: ${id}\n` : '')
-        + `data: ${data}\n\n`;
-}
-
-/**
- * Mocks a response that ends the stream for good.<br>
- * NOTE: Needs a `null` body because a 204 response must not have one.
- */
-function mockNoContentOnce() {
-    fetchMock.mockImplementationOnce(async () => new Response(null, { status: HttpStatusCode.NoContent }));
-}
-
-function requestHeader(index: number, header: HttpHeader) {
-    return new Headers(fetchMock.mock.calls[index][1]?.headers).get(header);
-}
-
-async function collect<T>(stream: AsyncIterable<T>) {
-    const result: T[] = [];
-    for await (const element of stream) result.push(element);
-    return result;
-}
-
-test('stream', async () => {
-    fetchMock.mockResponseOnce(
-        sseEvent('{"id":5,"name":"test1"}')
-        + sseEvent('{"id":6,"name":"test2"}')
-        + sseEvent('{"id":7,"name":"test3"}'));
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(5, 'test1'),
-        new MockEntity(6, 'test2'),
-        new MockEntity(7, 'test3')
-    ]);
-    expect(requestHeader(0, HttpHeader.Accept)).toBe('text/event-stream');
-});
-
-test('streamAsyncIterator', async () => {
-    fetchMock.mockResponseOnce(sseEvent('{"id":5,"name":"test1"}'));
-
-    expect(await collect(endpoint)).toEqual([new MockEntity(5, 'test1')]);
-});
-
-test('streamEventTypeFilter', async () => {
-    endpoint = new SseStreamingEndpoint<MockEntity>(entryEndpoint, 'endpoint', 'update');
-    endpoint.autoReconnect = false;
-
-    fetchMock.mockResponseOnce(
-        sseEvent('{"id":1,"name":"skip"}', 'ignored')
-        + sseEvent('{"id":5,"name":"test1"}', 'update')
-        + sseEvent('{"id":99,"name":"default"}')
-        + sseEvent('{"id":6,"name":"test2"}', 'update'));
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(5, 'test1'),
-        new MockEntity(6, 'test2')
-    ]);
-});
-
-test('streamComments', async () => {
-    fetchMock.mockResponseOnce(': keep-alive\n\n' + sseEvent('{"id":5,"name":"test1"}'));
-
-    expect(await collect(endpoint.stream())).toEqual([new MockEntity(5, 'test1')]);
-});
-
-test('streamMultiLineData', async () => {
-    fetchMock.mockResponseOnce('data: {"id":5,\ndata: "name":"test1"}\n\n');
-
-    expect(await collect(endpoint.stream())).toEqual([new MockEntity(5, 'test1')]);
-});
-
-test('streamCarriageReturns', async () => {
-    fetchMock.mockResponseOnce('data: {"id":5,"name":"test1"}\r\n\r\ndata: {"id":6,"name":"test2"}\r\r');
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(5, 'test1'),
-        new MockEntity(6, 'test2')
-    ]);
-});
-
-test('streamError', async () => {
-    fetchMock.mockResponseOnce('{"message":"my message"}', {
-        status: HttpStatusCode.Conflict,
-        headers: { [HttpHeader.ContentType]: 'application/json' }
-    });
-
-    await expect(collect(endpoint.stream())).rejects.toThrow(new ConflictError('my message', HttpStatusCode.Conflict));
-});
-
-test('streamNoContentCompletes', async () => {
-    endpoint.autoReconnect = true;
-    mockNoContentOnce();
-
-    expect(await collect(endpoint.stream())).toEqual([]);
-});
-
-test('streamReconnectsWithLastEventId', async () => {
-    endpoint.autoReconnect = true;
-    endpoint.defaultReconnectionInterval = 0;
-    fetchMock.mockResponseOnce(sseEvent('{"id":5,"name":"test1"}', undefined, '42'));
-    mockNoContentOnce();
-
-    expect(await collect(endpoint.stream())).toEqual([new MockEntity(5, 'test1')]);
-    expect(requestHeader(0, HttpHeader.LastEventId)).toBeNull();
-    expect(requestHeader(1, HttpHeader.LastEventId)).toBe('42');
-});
-
-test('streamReconnectsOnServerError', async () => {
-    endpoint.autoReconnect = true;
-    endpoint.defaultReconnectionInterval = 0;
-    fetchMock.mockResponseOnce('', { status: 503 });
-    fetchMock.mockResponseOnce(sseEvent('{"id":5,"name":"test1"}'));
-    mockNoContentOnce();
-
-    expect(await collect(endpoint.stream())).toEqual([new MockEntity(5, 'test1')]);
-});
-
-test('streamHonorsRetryField', async () => {
-    endpoint.autoReconnect = true;
-    endpoint.defaultReconnectionInterval = 0;
-    fetchMock.mockResponseOnce('retry: 42\n\n' + sseEvent('{"id":5,"name":"test1"}'));
-    mockNoContentOnce();
-
-    const start = Date.now();
-    expect(await collect(endpoint.stream())).toEqual([new MockEntity(5, 'test1')]);
-    expect(Date.now() - start).toBeGreaterThanOrEqual(42);
-});
-
-test('streamAbort', async () => {
-    endpoint.autoReconnect = true;
-    endpoint.defaultReconnectionInterval = 0;
-    fetchMock.mockResponse(sseEvent('{"id":5,"name":"test1"}'));
-    const controller = new AbortController();
-
-    const result: MockEntity[] = [];
-    for await (const element of endpoint.stream(controller.signal)) {
-        result.push(element);
-        controller.abort();
-    }
-
-    expect(result).toEqual([new MockEntity(5, 'test1')]);
-});

package/endpoints/reactive/SseStreamingEndpoint.ts

@@ -1,115 +0,0 @@
-import { Endpoint } from "../Endpoint";
-import { delay } from "./Delay";
-import { HttpMethod, HttpHeader, HttpStatusCode, SseReader } from "../../http";
-
-const eventStreamMediaType = "text/event-stream";
-
-/**
- * Endpoint for a stream of `TEntity`s using Server-Sent Events (SSE).<br>
- * Sends `Accept: text/event-stream`. By default, transparently reconnects on connection drops or transient errors,
- * honoring the server-supplied `retry:` interval and resuming via the {@link http!HttpHeader.LastEventId} header.
- * @typeParam TEntity The type of individual elements in the stream.
- */
-export class SseStreamingEndpoint<TEntity> extends Endpoint {
-    /**
-     * Creates a new SSE streaming endpoint.
-     * @param referrer The endpoint used to navigate to this one.
-     * @param relativeUri The URI of this endpoint relative to the `referrer`'s. Add a `./` prefix here to imply a trailing slash in the `referrer`'s URI.
-     * @param eventType If set, only events with this `event:` type are provided; others are ignored. Leave unspecified to provide all events.
-     */
-    constructor(referrer: Endpoint, relativeUri: URL | string, private readonly eventType?: string) {
-        super(referrer, relativeUri);
-    }
-
-    /**
-     * Whether to transparently reconnect on connection drops, transient transport errors and 5xx responses.
-     */
-    autoReconnect = true;
-
-    /**
-     * The reconnection interval in milliseconds used when the server has not (yet) supplied one via the SSE `retry:` field.
-     */
-    defaultReconnectionInterval = 3000;
-
-    /**
-     * Provides a stream of `TEntity`s, reconnecting as needed unless {@link autoReconnect} is disabled.
-     * @param signal Used to close the connection.
-     * @throws {@link errors!AuthenticationError}: {@link http!HttpStatusCode.Unauthorized}
-     * @throws {@link errors!AuthorizationError}: {@link http!HttpStatusCode.Forbidden}
-     * @throws {@link errors!NotFoundError}: {@link http!HttpStatusCode.NotFound} or {@link http!HttpStatusCode.Gone}
-     * @throws {@link errors!HttpError}: Other non-success status code
-     */
-    async *stream(signal?: AbortSignal): AsyncIterableIterator<TEntity> {
-        const state = { lastEventId: undefined as string | undefined, reconnectionInterval: this.defaultReconnectionInterval };
-
-        while (!signal?.aborted) {
-            let reconnect: boolean;
-            try {
-                reconnect = yield* this.consumeOnce(state, signal);
-            } catch (err) {
-                // Aborting is a regular way of ending the stream, not an error
-                if (signal?.aborted) return;
-
-                // Transport-level failures are the ones worth retrying; anything else is the server telling us no
-                if (!this.autoReconnect || !SseStreamingEndpoint.isTransient(err)) throw err;
-                reconnect = true;
-            }
-
-            if (!reconnect) return;
-            if (!await delay(state.reconnectionInterval, signal)) return;
-        }
-    }
-
-    /**
-     * Provides a stream of `TEntity`s using {@link stream}.
-     */
-    [Symbol.asyncIterator]() { return this.stream(); }
-
-    /**
-     * Opens a connection and provides events until the stream ends.
-     * @param state Carries the last event id and the reconnection interval over to the next attempt.
-     * @param signal Used to close the connection.
-     * @returns `true` if another connection attempt should be made; `false` if the stream has ended for good.
-     */
-    private async *consumeOnce(state: { lastEventId?: string; reconnectionInterval: number; }, signal?: AbortSignal): AsyncGenerator<TEntity, boolean> {
-        // NOTE: Abort the request when the consumer stops iterating, not just when the caller's signal fires.
-        const controller = new AbortController();
-        const onAbort = () => controller.abort();
-        signal?.addEventListener("abort", onAbort, { once: true });
-        if (signal?.aborted) controller.abort();
-
-        try {
-            const headers = new Headers({ [HttpHeader.Accept]: eventStreamMediaType });
-            if (state.lastEventId) headers.set(HttpHeader.LastEventId, state.lastEventId);
-
-            const response = await this.httpClient.send(this.uri, HttpMethod.Get, controller.signal, headers);
-            if (response.status === HttpStatusCode.NoContent) return false;
-            if (this.autoReconnect && response.status >= 500) return true;
-            await this.handle(response);
-
-            const reader = new SseReader(response);
-            try {
-                for await (const event of reader.events()) {
-                    if (this.eventType !== undefined && event.type !== this.eventType) continue;
-                    yield this.serializer.deserialize<TEntity>(event.data);
-                }
-            } finally {
-                state.lastEventId = reader.lastEventId ?? state.lastEventId;
-                if (reader.reconnectionInterval !== undefined) state.reconnectionInterval = reader.reconnectionInterval;
-            }
-
-            return this.autoReconnect;
-        } finally {
-            signal?.removeEventListener("abort", onAbort);
-            controller.abort();
-        }
-    }
-
-    /**
-     * Determines whether an error is a transport-level failure that may succeed on a retry.
-     * The Fetch API reports these as `TypeError`s, while responses the server actually sent become {@link errors!HttpError}s.
-     */
-    private static isTransient(err: unknown) {
-        return err instanceof TypeError;
-    }
-}

package/endpoints/reactive/StreamingCollectionEndpoint.test.ts

@@ -1,110 +0,0 @@
-/**
- * NOTE: The jsdom environment strips the "Range" request header, so these tests need the node environment.
- * @jest-environment node
- */
-
-import fetchMock from 'jest-fetch-mock';
-import { StreamingCollectionEndpoint } from '.';
-import { EntryEndpoint } from '..';
-import { HttpHeader, HttpStatusCode } from '../../http';
-
-class MockEntity {
-    constructor(public id: number, public name: string) { }
-}
-
-fetchMock.enableMocks();
-let endpoint: StreamingCollectionEndpoint<MockEntity>;
-
-beforeEach(() => {
-    fetchMock.resetMocks();
-    endpoint = new StreamingCollectionEndpoint<MockEntity>(new EntryEndpoint('http://localhost/'), 'endpoint');
-    endpoint.pollingInterval = 0;
-});
-
-function mockRangeOnce(body: string, contentRange?: string, retryAfterHeader?: string) {
-    const headers: { [key: string]: string; } = {};
-    if (contentRange) headers[HttpHeader.ContentRange] = contentRange;
-    if (retryAfterHeader) headers[HttpHeader.RetryAfter] = retryAfterHeader;
-
-    fetchMock.mockResponseOnce(body, { status: HttpStatusCode.PartialContent, headers });
-}
-
-function requestHeader(index: number, header: HttpHeader) {
-    return new Headers(fetchMock.mock.calls[index][1]?.headers).get(header);
-}
-
-async function collect<T>(stream: AsyncIterable<T>) {
-    const result: T[] = [];
-    for await (const element of stream) result.push(element);
-    return result;
-}
-
-test('stream', async () => {
-    mockRangeOnce('[{"id":5,"name":"test1"},{"id":6,"name":"test2"}]', 'elements 0-1/*');
-    mockRangeOnce('[{"id":7,"name":"test3"}]', 'elements 2-2/3', '42');
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(5, 'test1'),
-        new MockEntity(6, 'test2'),
-        new MockEntity(7, 'test3')
-    ]);
-    expect(requestHeader(0, HttpHeader.Range)).toBe('elements=0-');
-    expect(requestHeader(1, HttpHeader.Range)).toBe('elements=2-');
-    expect(endpoint.pollingInterval).toBe(42000);
-});
-
-test('streamOffset', async () => {
-    mockRangeOnce('[{"id":7,"name":"test3"}]', 'elements 2-2/3');
-
-    expect(await collect(endpoint.stream(2))).toEqual([new MockEntity(7, 'test3')]);
-    expect(requestHeader(0, HttpHeader.Range)).toBe('elements=2-');
-});
-
-test('streamTail', async () => {
-    mockRangeOnce('[{"id":7,"name":"test3"}]', 'elements 2-2/3');
-
-    expect(await collect(endpoint.stream(-1))).toEqual([new MockEntity(7, 'test3')]);
-    expect(requestHeader(0, HttpHeader.Range)).toBe('elements=-1');
-});
-
-test('streamAsyncIterator', async () => {
-    mockRangeOnce('[{"id":5,"name":"test1"}]', 'elements 0-0/1');
-
-    expect(await collect(endpoint)).toEqual([new MockEntity(5, 'test1')]);
-});
-
-test('streamKeepsPollingWhileRangeNotSatisfiable', async () => {
-    mockRangeOnce('[{"id":5,"name":"test1"}]', 'elements 0-0/*');
-    fetchMock.mockResponseOnce('', { status: HttpStatusCode.RangeNotSatisfiable });
-    mockRangeOnce('[{"id":6,"name":"test2"}]', 'elements 1-1/2');
-
-    expect(await collect(endpoint.stream())).toEqual([
-        new MockEntity(5, 'test1'),
-        new MockEntity(6, 'test2')
-    ]);
-    expect(requestHeader(1, HttpHeader.Range)).toBe('elements=1-');
-    expect(requestHeader(2, HttpHeader.Range)).toBe('elements=1-');
-});
-
-test('streamEndsWithoutContentRange', async () => {
-    fetchMock.mockResponseOnce('[{"id":5,"name":"test1"}]');
-
-    expect(await collect(endpoint.stream())).toEqual([new MockEntity(5, 'test1')]);
-    expect(fetchMock.mock.calls.length).toBe(1);
-});
-
-test('streamAbort', async () => {
-    fetchMock.mockResponse('[{"id":5,"name":"test1"}]', {
-        status: HttpStatusCode.PartialContent,
-        headers: { [HttpHeader.ContentRange]: 'elements 0-0/*' }
-    });
-    const controller = new AbortController();
-
-    const result: MockEntity[] = [];
-    for await (const element of endpoint.stream(0, controller.signal)) {
-        result.push(element);
-        controller.abort();
-    }
-
-    expect(result).toEqual([new MockEntity(5, 'test1')]);
-});