How to use the @tinkoff/request-core.Status.ERROR function in @tinkoff/request-core

const error = new Error('text');

        requests.forEach((request, index) => {
            const context = new Context({ request });

            context.updateExternalMeta = jest.fn(context.updateExternalMeta.bind(context));
            context.updateInternalMeta = jest.fn(context.updateInternalMeta.bind(context));

            plugin.init(context, next, null);
            expect(context.updateInternalMeta).toHaveBeenCalledWith(metaTypes.CACHE, { key: request.url });
            if (request.url === 'first' && index !== 0) {
                expect(context.updateExternalMeta).toHaveBeenCalledWith(metaTypes.CACHE, { deduplicated: true });
            }
        });
        expect(next).toHaveBeenCalledTimes(2);
        plugin.error(new Context({ error, request: requests[0], status: Status.ERROR }), next, null);
        expect(next).toHaveBeenCalledTimes(5); // 4 requests init + 1 complete
        requests.forEach((request) => {
            expect(next).toHaveBeenCalledWith({ error, status: Status.ERROR, response: null });
        });
    });
});

it('request unknown error', async () => {
        const mockResponse = jest.fn(() => Promise.reject(new TypeError('Failed to fetch')));

        fetch.mockResponse(mockResponse);

        plugin.init(new Context({ request: { url: 'test' } }), next, null);

        await new Promise((res) => {
            next.mockImplementation(res);
        });

        expect(mockResponse).toBeCalled();
        expect(next).toHaveBeenLastCalledWith({
            status: Status.ERROR,
            error: new TypeError('Failed to fetch'),
        });
    });

it('on error validate, change status to error, fallback disabled', () => {
        const request = { a: 1, url: '' };
        const next = jest.fn();
        const plugin = validate({ validator, allowFallback: false });

        context.setState({ request, response: { error: '123' } });

        plugin.complete(context, next, null);
        expect(next).toHaveBeenCalledWith({
            request: { ...request, fallbackCache: false },
            status: Status.ERROR,
            error: new Error('123'),
        });
    });

const init = batch({ makeGroupedRequest, timeout: 123 }).init;
        const next = jest.fn();

        context.setState({ request: requests[0] });
        init(context, next, null);
        context.setState({ request: requests[1] });
        init(context, next, null);
        context.setState({ request: requests[2] });
        init(context, next, null);

        jest.runAllTimers();
        await Promise.resolve();
        expect(next).toHaveBeenCalledTimes(3);
        expect(next).toHaveBeenLastCalledWith({
            error,
            status: Status.ERROR,
        });
    });
});

it('on error validate, change status to error', () => {
        const request = { a: 1, url: '' };
        const next = jest.fn();

        context.setState({ request, response: { error: '123' } });

        plugin.complete(context, next, null);
        expect(next).toHaveBeenCalledWith({
            request,
            status: Status.ERROR,
            error: new Error('123'),
        });
    });

},
                body: JSON.stringify({ a: '1', b: 2 }),
            })
        );

        fetch.mockResponse(mockResponse);

        plugin.init(new Context({ request: { url: 'test' } }), next, null);

        await new Promise((res) => {
            next.mockImplementation(res);
        });

        expect(mockResponse).toBeCalled();
        expect(next).toHaveBeenLastCalledWith({
            status: Status.ERROR,
            error: new Error('Service Unavailable'),
            response: { a: '1', b: 2 },
        });
    });

const abort = (abortOptions?) => {
                    if (ended) {
                        return;
                    }

                    ended = true;
                    controller.abort();

                    next({
                        status: Status.ERROR,
                        error: abortOptions || {},
                    });
                };

const error = validator(state);

        context.updateExternalMeta(VALIDATE, {
            validated: !error,
        });

        if (error) {
            return next({
                error,
                request: allowFallback
                    ? request
                    : {
                          ...request,
                          fallbackCache: false,
                      },
                status: Status.ERROR,
            });
        }

        return next();
    },
    error: (context, next) => {

requests.forEach((request) => {
            expect(next).toHaveBeenCalledWith({ error, status: Status.ERROR, response: null });
        });
    });

init: (context, next) => {
            const state = context.getState();
            const breaker = getBreaker(state);

            if (breaker.shouldThrow()) {
                context.updateExternalMeta(CIRCUIT_BREAKER_META, {
                    open: true,
                });

                return next({
                    status: Status.ERROR,
                    error: breaker.getError(),
                });
            }

            context.updateInternalMeta(CIRCUIT_BREAKER_META, {
                breaker,
            });
            next();
        },
        complete: (context, next) => {