trade360-nodejs-sdk/dist/test/api/snapshot-api/services/prematch-snapshot.service.spec.js

LSports Trade360 SDK for Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/* eslint-env jest */
const dtos_1 = require("../../../../src/api/common/snapshot/dtos");
const requests_1 = require("../../../../src/api/common/snapshot/requests");
const responses_1 = require("../../../../src/api/common/snapshot/responses");
const errors_1 = require("../../../../src/entities/errors");
// Mock dependencies
class MockMapper {
    constructor() {
        this.map = jest.fn();
    }
}
// Since PreMatchSnapshotApiClientImplementation extends BaseHttpClient, we need to mock the base functionality
jest.mock('@httpClient/base-http-client', () => {
    return {
        BaseHttpClient: jest.fn().mockImplementation(() => {
            return {
                postRequest: jest.fn(),
            };
        }),
    };
});
describe('PreMatchSnapshotApiClientImplementation', () => {
    let prematchSnapshotApiClient;
    let mockMapper;
    let mockPostRequest;
    beforeEach(() => {
        mockMapper = new MockMapper();
        mockPostRequest = jest.fn();
        prematchSnapshotApiClient = {
            getFixtures: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetFixtureRequest);
                return mockPostRequest({
                    route: '/Prematch/GetFixtures',
                    responseBodyType: responses_1.GetFixturesResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getLivescores: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetLivescoreRequest);
                return mockPostRequest({
                    route: '/Prematch/GetScores',
                    responseBodyType: responses_1.GetLivescoreResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getFixtureMarkets: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetMarketRequest);
                return mockPostRequest({
                    route: '/Prematch/GetFixtureMarkets',
                    responseBodyType: responses_1.GetFixtureMarketsResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getEvents: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetEventRequest);
                return mockPostRequest({
                    route: '/Prematch/GetEvents',
                    responseBodyType: responses_1.GetEventsResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightEvents: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightEventRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightEvents',
                    responseBodyType: responses_1.GetOutrightEventsResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightFixtures: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightFixtureRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightFixture',
                    responseBodyType: responses_1.GetOutrightFixtureResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightScores: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightLivescoreRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightScores',
                    responseBodyType: responses_1.GetOutrightScoresResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightFixtureMarkets: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightMarketRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightFixtureMarkets',
                    responseBodyType: responses_1.GetOutrightFixtureMarketsResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightLeagues: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightLeaguesRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightLeagues',
                    responseBodyType: responses_1.GetOutrightLeaguesResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightLeagueMarkets: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightLeagueMarketRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightLeagueMarkets',
                    responseBodyType: responses_1.GetOutrightLeagueMarketsResultElement,
                    requestBody: mappedRequest,
                });
            }),
            getOutrightLeagueEvents: jest.fn(async (requestDto) => {
                const mappedRequest = mockMapper.map(requestDto, requests_1.GetOutrightLeagueEventsRequest);
                return mockPostRequest({
                    route: '/Prematch/GetOutrightLeagueEvents',
                    responseBodyType: responses_1.GetOutrightLeagueEventsResultElement,
                    requestBody: mappedRequest,
                });
            }),
        };
    });
    describe('getFixtures', () => {
        it('should successfully call getFixtures with valid request', async () => {
            const requestDto = new dtos_1.GetFixtureRequestDto();
            const mappedRequest = new requests_1.GetFixtureRequest();
            const expectedResponse = new responses_1.GetFixturesResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getFixtures(requestDto);
            expect(mockMapper.map).toHaveBeenCalledWith(requestDto, requests_1.GetFixtureRequest);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetFixtures',
                responseBodyType: responses_1.GetFixturesResultElement,
                requestBody: mappedRequest,
            });
            expect(result).toBe(expectedResponse);
        });
        it('should handle mapper transformation correctly', async () => {
            const requestDto = new dtos_1.GetFixtureRequestDto();
            const mappedRequest = new requests_1.GetFixtureRequest();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(new responses_1.GetFixturesResultElement());
            await prematchSnapshotApiClient.getFixtures(requestDto);
            expect(mockMapper.map).toHaveBeenCalledWith(requestDto, requests_1.GetFixtureRequest);
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetFixtureRequestDto();
            const error = new errors_1.HttpResponseError('API Error');
            mockMapper.map.mockReturnValue(new requests_1.GetFixtureRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getFixtures(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetFixtureRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetFixtureRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getFixtures(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getLivescores', () => {
        it('should successfully call getLivescores with valid request', async () => {
            const requestDto = new dtos_1.GetLivescoreRequestDto();
            const mappedRequest = new requests_1.GetLivescoreRequest();
            const expectedResponse = new responses_1.GetLivescoreResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getLivescores(requestDto);
            expect(mockMapper.map).toHaveBeenCalledWith(requestDto, requests_1.GetLivescoreRequest);
            expect(result).toBe(expectedResponse);
        });
        it('should propagate mapper errors', async () => {
            const requestDto = new dtos_1.GetLivescoreRequestDto();
            const error = new Error('Mapping Error');
            mockMapper.map.mockImplementation(() => {
                throw error;
            });
            await expect(prematchSnapshotApiClient.getLivescores(requestDto)).rejects.toThrow(error);
            expect(mockPostRequest).not.toHaveBeenCalled();
        });
        it('should handle null response', async () => {
            const requestDto = new dtos_1.GetLivescoreRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetLivescoreRequest());
            mockPostRequest.mockResolvedValue(null);
            const result = await prematchSnapshotApiClient.getLivescores(requestDto);
            expect(result).toBeNull();
        });
        it('should use correct route for livescores', async () => {
            const requestDto = new dtos_1.GetLivescoreRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetLivescoreRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetLivescoreResultElement());
            await prematchSnapshotApiClient.getLivescores(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetScores',
                responseBodyType: responses_1.GetLivescoreResultElement,
                requestBody: expect.any(requests_1.GetLivescoreRequest),
            });
        });
    });
    describe('getFixtureMarkets', () => {
        it('should successfully call getFixtureMarkets with valid request', async () => {
            const requestDto = new dtos_1.GetMarketRequestDto();
            const mappedRequest = new requests_1.GetMarketRequest();
            const expectedResponse = new responses_1.GetFixtureMarketsResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getFixtureMarkets(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should handle empty response data', async () => {
            const requestDto = new dtos_1.GetMarketRequestDto();
            const emptyResponse = new responses_1.GetFixtureMarketsResultElement();
            emptyResponse.data = [];
            mockMapper.map.mockReturnValue(new requests_1.GetMarketRequest());
            mockPostRequest.mockResolvedValue(emptyResponse);
            const result = await prematchSnapshotApiClient.getFixtureMarkets(requestDto);
            expect(result?.data).toEqual([]);
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetMarketRequestDto();
            const error = new errors_1.HttpResponseError('Network Error');
            mockMapper.map.mockReturnValue(new requests_1.GetMarketRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getFixtureMarkets(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetMarketRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetMarketRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getFixtureMarkets(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getEvents', () => {
        it('should successfully call getEvents with valid request', async () => {
            const requestDto = new dtos_1.GetEventRequestDto();
            const mappedRequest = new requests_1.GetEventRequest();
            const expectedResponse = new responses_1.GetEventsResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getEvents(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for events', async () => {
            const requestDto = new dtos_1.GetEventRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetEventRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetEventsResultElement());
            await prematchSnapshotApiClient.getEvents(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetEvents',
                responseBodyType: responses_1.GetEventsResultElement,
                requestBody: expect.any(requests_1.GetEventRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetEventRequestDto();
            const error = new errors_1.HttpResponseError('Server Error');
            mockMapper.map.mockReturnValue(new requests_1.GetEventRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getEvents(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetEventRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetEventRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getEvents(requestDto);
            expect(result).toBeUndefined();
        });
    });
    // NEW OUTRIGHT ENDPOINTS TESTS
    describe('getOutrightEvents', () => {
        it('should successfully call getOutrightEvents with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightEventRequestDto();
            const mappedRequest = new requests_1.GetOutrightEventRequest();
            const expectedResponse = new responses_1.GetOutrightEventsResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightEvents(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright events', async () => {
            const requestDto = new dtos_1.GetOutrightEventRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightEventRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightEventsResultElement());
            await prematchSnapshotApiClient.getOutrightEvents(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightEvents',
                responseBodyType: responses_1.GetOutrightEventsResultElement,
                requestBody: expect.any(requests_1.GetOutrightEventRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightEventRequestDto();
            const error = new errors_1.HttpResponseError('Outright Events Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightEventRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightEvents(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightEventRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightEventRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightEvents(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getOutrightFixtures', () => {
        it('should successfully call getOutrightFixtures with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightFixtureRequestDto();
            const mappedRequest = new requests_1.GetOutrightFixtureRequest();
            const expectedResponse = new responses_1.GetOutrightFixtureResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightFixtures(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright fixtures', async () => {
            const requestDto = new dtos_1.GetOutrightFixtureRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightFixtureRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightFixtureResultElement());
            await prematchSnapshotApiClient.getOutrightFixtures(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightFixture',
                responseBodyType: responses_1.GetOutrightFixtureResultElement,
                requestBody: expect.any(requests_1.GetOutrightFixtureRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightFixtureRequestDto();
            const error = new errors_1.HttpResponseError('Outright Fixtures Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightFixtureRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightFixtures(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightFixtureRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightFixtureRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightFixtures(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getOutrightScores', () => {
        it('should successfully call getOutrightScores with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightLivescoreRequestDto();
            const mappedRequest = new requests_1.GetOutrightLivescoreRequest();
            const expectedResponse = new responses_1.GetOutrightScoresResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightScores(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright scores', async () => {
            const requestDto = new dtos_1.GetOutrightLivescoreRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLivescoreRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightScoresResultElement());
            await prematchSnapshotApiClient.getOutrightScores(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightScores',
                responseBodyType: responses_1.GetOutrightScoresResultElement,
                requestBody: expect.any(requests_1.GetOutrightLivescoreRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightLivescoreRequestDto();
            const error = new errors_1.HttpResponseError('Outright Scores Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLivescoreRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightScores(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightLivescoreRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLivescoreRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightScores(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getOutrightFixtureMarkets', () => {
        it('should successfully call getOutrightFixtureMarkets with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightMarketRequestDto();
            const mappedRequest = new requests_1.GetOutrightMarketRequest();
            const expectedResponse = new responses_1.GetOutrightFixtureMarketsResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightFixtureMarkets(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright fixture markets', async () => {
            const requestDto = new dtos_1.GetOutrightMarketRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightMarketRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightFixtureMarketsResultElement());
            await prematchSnapshotApiClient.getOutrightFixtureMarkets(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightFixtureMarkets',
                responseBodyType: responses_1.GetOutrightFixtureMarketsResultElement,
                requestBody: expect.any(requests_1.GetOutrightMarketRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightMarketRequestDto();
            const error = new errors_1.HttpResponseError('Outright Fixture Markets Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightMarketRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightFixtureMarkets(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightMarketRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightMarketRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightFixtureMarkets(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getOutrightLeagues', () => {
        it('should successfully call getOutrightLeagues with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightLeaguesRequestDto();
            const mappedRequest = new requests_1.GetOutrightLeaguesRequest();
            const expectedResponse = new responses_1.GetOutrightLeaguesResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightLeagues(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright leagues', async () => {
            const requestDto = new dtos_1.GetOutrightLeaguesRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeaguesRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightLeaguesResultElement());
            await prematchSnapshotApiClient.getOutrightLeagues(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightLeagues',
                responseBodyType: responses_1.GetOutrightLeaguesResultElement,
                requestBody: expect.any(requests_1.GetOutrightLeaguesRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightLeaguesRequestDto();
            const error = new errors_1.HttpResponseError('Outright Leagues Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeaguesRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightLeagues(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightLeaguesRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeaguesRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightLeagues(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getOutrightLeagueMarkets', () => {
        it('should successfully call getOutrightLeagueMarkets with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueMarketRequestDto();
            const mappedRequest = new requests_1.GetOutrightLeagueMarketRequest();
            const expectedResponse = new responses_1.GetOutrightLeagueMarketsResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightLeagueMarkets(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright league markets', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueMarketRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeagueMarketRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightLeagueMarketsResultElement());
            await prematchSnapshotApiClient.getOutrightLeagueMarkets(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightLeagueMarkets',
                responseBodyType: responses_1.GetOutrightLeagueMarketsResultElement,
                requestBody: expect.any(requests_1.GetOutrightLeagueMarketRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueMarketRequestDto();
            const error = new errors_1.HttpResponseError('Outright League Markets Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeagueMarketRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightLeagueMarkets(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueMarketRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeagueMarketRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightLeagueMarkets(requestDto);
            expect(result).toBeUndefined();
        });
    });
    describe('getOutrightLeagueEvents', () => {
        it('should successfully call getOutrightLeagueEvents with valid request', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueEventsRequestDto();
            const mappedRequest = new requests_1.GetOutrightLeagueEventsRequest();
            const expectedResponse = new responses_1.GetOutrightLeagueEventsResultElement();
            mockMapper.map.mockReturnValue(mappedRequest);
            mockPostRequest.mockResolvedValue(expectedResponse);
            const result = await prematchSnapshotApiClient.getOutrightLeagueEvents(requestDto);
            expect(result).toBe(expectedResponse);
        });
        it('should use correct route for outright league events', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueEventsRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeagueEventsRequest());
            mockPostRequest.mockResolvedValue(new responses_1.GetOutrightLeagueEventsResultElement());
            await prematchSnapshotApiClient.getOutrightLeagueEvents(requestDto);
            expect(mockPostRequest).toHaveBeenCalledWith({
                route: '/Prematch/GetOutrightLeagueEvents',
                responseBodyType: responses_1.GetOutrightLeagueEventsResultElement,
                requestBody: expect.any(requests_1.GetOutrightLeagueEventsRequest),
            });
        });
        it('should propagate HTTP errors', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueEventsRequestDto();
            const error = new errors_1.HttpResponseError('Outright League Events Error');
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeagueEventsRequest());
            mockPostRequest.mockRejectedValue(error);
            await expect(prematchSnapshotApiClient.getOutrightLeagueEvents(requestDto)).rejects.toThrow(error);
        });
        it('should handle undefined response', async () => {
            const requestDto = new dtos_1.GetOutrightLeagueEventsRequestDto();
            mockMapper.map.mockReturnValue(new requests_1.GetOutrightLeagueEventsRequest());
            mockPostRequest.mockResolvedValue(undefined);
            const result = await prematchSnapshotApiClient.getOutrightLeagueEvents(requestDto);
            expect(result).toBeUndefined();
        });
    });
});
//# sourceMappingURL=prematch-snapshot.service.spec.js.map