@myria/leaderboard-ts-sdk/dist/esm/src/tests/Leaderboard.test.js

Myria Leaderboard typescripts SDK which will manage leaderboard for game developers

import { LeaderboardManager } from '../modules/LeaderboardManager';
import { LeaderboardAPI } from '../core/apis/LeaderboardAPI';
import { EOrderBy, } from '../types/ILeaderboard.types';
import { EnvTypes } from 'myria-core-sdk';
// Mock the LeaderboardAPI class
jest.mock('../core/apis/LeaderboardAPI');
const mockLeaderboardsData = {
    items: [
        {
            name: 'Leaderboard 1',
            description: 'Test leaderboard 1',
            updateScoreStrategy: 'ACCUMULATE',
            gameName: 'Test Game',
            totalPeriods: 10,
            livePeriodInDays: 30,
            availableAt: '2024-01-01T00:00:00Z',
            status: 'active',
            currentPeriod: 1,
            dataPersistenceInDays: 365,
            expireAt: '2025-01-01T00:00:00Z',
            id: 1,
            airdropContractAddress: '',
            daysToNextPeriod: '',
            gameMetadata: {},
            configMetadata: {},
            isApplyRewardAllPeriods: false,
        },
    ],
    meta: {
        totalItems: 1,
        itemCount: 1,
        itemsPerPage: 10,
        totalPages: 1,
        currentPage: 1,
    },
};
const mockApiResponse = {
    status: 'success',
    data: mockLeaderboardsData,
};
describe('LeaderboardManager', () => {
    let leaderboardManager;
    let mockLeaderboardAPI;
    const env = EnvTypes.STAGING; // Example environment
    const developerApiKey = 'Developer_Api_Key';
    beforeEach(() => {
        mockLeaderboardAPI = new LeaderboardAPI(env);
        const leaderboardParams = {
            env: EnvTypes.STAGING,
            apiKey: developerApiKey,
        };
        leaderboardManager = new LeaderboardManager(leaderboardParams);
        leaderboardManager['leaderboardAPI'] = mockLeaderboardAPI;
    });
    afterEach(() => {
        jest.clearAllMocks(); // Reset mocks
    });
    // Get List score by leaderId
    it('should getScoreByLeaderboardId a leaderboard successfully', async () => {
        // Given
        const queryScoreParams = {
            page: 1,
            limit: 10,
            leaderboardId: 1,
            sortingField: 'score',
            orderBy: EOrderBy.DESC,
            filters: {
                period: 1,
                userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e801',
            },
        };
        const queryScoreLeaderboardData = {
            items: [
                {
                    id: 5,
                    userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e801',
                    leaderboardId: 21,
                    period: 1,
                    score: 130,
                    createdAt: '2024-08-12T08:34:32.291Z',
                    updatedAt: '2024-08-16T03:27:59.919Z',
                    rank: 1,
                },
            ],
            meta: {
                totalItems: 1,
                itemCount: 1,
                itemsPerPage: 10,
                totalPages: 1,
                currentPage: 1,
            },
        };
        // Act
        mockLeaderboardAPI.getScoresByLeaderboardId.mockResolvedValue({
            status: 'success',
            data: queryScoreLeaderboardData,
        });
        // Act
        const result = await leaderboardManager.queryScoresByLeaderboardId(queryScoreParams);
        // Assert
        expect(result.data).toEqual(queryScoreLeaderboardData);
    });
    it('should throw an error if leaderboard query fails', async () => {
        // Given
        const queryScoreParams = {
            page: 1,
            limit: 10,
            leaderboardId: 19,
            sortingField: 'score',
            orderBy: EOrderBy.DESC,
            filters: {
                period: 1,
                userId: '2',
            },
        };
        mockLeaderboardAPI.getScoresByLeaderboardId.mockRejectedValue({
            status: 'error',
            data: null,
        });
        // Act & Assert
        await expect(leaderboardManager.queryScoresByLeaderboardId(queryScoreParams)).rejects.toThrow('Failed to query scores');
    });
    it('should validate missing query parameters', async () => {
        const invalidParams = [
            {
                page: 0,
                leaderboardId: 1,
            },
            {
                page: 1,
                leaderboardId: 0,
            },
        ];
        for (const params of invalidParams) {
            await expect(leaderboardManager.queryScoresByLeaderboardId(params)).rejects.toThrow();
        }
    });
    it('should validate missing query filters userId parameters', async () => {
        const invalidParams = [
            {
                page: 1,
                leaderboardId: 21,
                filters: {
                    userId: '',
                    score: 0,
                },
            },
        ];
        for (const params of invalidParams) {
            await expect(leaderboardManager.queryScoresByLeaderboardId(params)).rejects.toThrow();
        }
    });
    // Get list scores by leaderboard id and user id
    it('should getScoreByLeaderboardIdAndUserId a leaderboard successfully', async () => {
        // Given
        const queryScoreParams = {
            leaderboardId: 21,
            userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e801',
            period: 1,
        };
        const queryScoreLeaderboardData = {
            leaderboardId: 21,
            userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e803',
            score: 24,
            period: 1,
            leaderboard: {
                id: 21,
                name: 'weekly-demo-function',
                description: 'Testing weekly-demo-function',
                updateScoreStrategy: 'ACCUMULATE',
                gameName: 'Demo',
                status: 'ACTIVE',
                livePeriodInDays: 7,
                enablePeriodRefresh: false,
                currentPeriod: 1,
                dataPersistenceInDays: 14,
                expireAt: '2024-08-19T08:31:54.891Z',
                availableAt: '2024-08-12T08:31:54.891Z',
                airdropContractAddress: '',
                daysToNextPeriod: '',
                gameMetadata: {},
                configMetadata: {},
                isApplyRewardAllPeriods: false,
            },
            user: {
                userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e803',
                username: '',
                displayName: '',
            },
        };
        // Act
        mockLeaderboardAPI.getScoresByLeaderboardIdAndUserId.mockResolvedValue({
            status: 'success',
            data: queryScoreLeaderboardData,
        });
        // Act
        const result = await leaderboardManager.getScoresByPlayerId(queryScoreParams);
        // Assert
        expect(result.data).toEqual(queryScoreLeaderboardData);
    });
    it('should throw an error if leaderboard id and userId query fails', async () => {
        // Given
        const queryScoreParams = {
            leaderboardId: 19,
            userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e801',
        };
        mockLeaderboardAPI.getScoresByLeaderboardIdAndUserId.mockRejectedValue({
            status: 'error',
            data: null,
        });
        // Act & Assert
        await expect(leaderboardManager.getScoresByPlayerId(queryScoreParams)).rejects.toThrow('Failed to query scores by player id: error');
    });
    it('should validate missing query score by leaderboard and user id parameters', async () => {
        const invalidParams = [
            {
                leaderboardId: 0,
                userId: '0x5eb1a04db9190230f231627c1b673cdb19f77374ff4780158322f23177e801',
            },
            {
                leaderboardId: 21,
                userId: '',
            },
        ];
        for (const params of invalidParams) {
            await expect(leaderboardManager.getScoresByPlayerId(params)).rejects.toThrow();
        }
    });
    // Create leaderboard
    it('should create a leaderboard successfully', async () => {
        // Given
        const leaderboardParams = {
            name: 'Test Leaderboard',
            description: 'A test leaderboard',
            gameName: 'Test Game',
            livePeriodInDays: 10,
            totalPeriods: 5,
            updateScoreStrategy: 'ACCUMULATE',
            availableAt: '',
            enableMetadata: false,
        };
        const leaderboardData = {
            id: 1,
            ...leaderboardParams,
            status: 'ACTIVE',
            currentPeriod: 5,
            dataPersistenceInDays: 10,
            expireAt: '',
            updatedAt: '',
            createdAt: '',
            enablePeriodRefresh: false,
            developerId: '',
            metadata: undefined,
            airdropContractAddress: '',
            daysToNextPeriod: '',
            whitelist: undefined,
            rewards: undefined,
            gameMetadata: {},
            configMetadata: {},
            isApplyRewardAllPeriods: false,
        };
        mockLeaderboardAPI.createLeaderboard.mockResolvedValue({
            status: 'success',
            data: leaderboardData,
        });
        // Act
        const result = await leaderboardManager.createLeaderboard(leaderboardParams);
        // Assert
        expect(result).toEqual(leaderboardData);
        expect(mockLeaderboardAPI.createLeaderboard).toHaveBeenCalledWith(leaderboardParams, developerApiKey);
    });
    it('should throw an error if leaderboard creation fails', async () => {
        // Given
        const leaderboardParams = {
            name: 'Test Leaderboard',
            description: 'A test leaderboard',
            gameName: 'Test Game',
            livePeriodInDays: 10,
            totalPeriods: 5,
            updateScoreStrategy: 'OVERWRITE',
            availableAt: '',
            enableMetadata: false,
        };
        mockLeaderboardAPI.createLeaderboard.mockResolvedValue({
            status: 'error',
            data: null,
        });
        // Act & Assert
        await expect(leaderboardManager.createLeaderboard(leaderboardParams)).rejects.toThrow('Create leaderboard failed: {"status":"error","data":null}');
    });
    it('should validate missing parameters', async () => {
        const invalidParams = [
            {
                name: '',
                description: 'desc',
                gameName: 'game',
                livePeriodInDays: 10,
                totalPeriods: 5,
                updateScoreStrategy: 'ACCUMULATE',
            },
            {
                name: 'name',
                description: '',
                gameName: 'game',
                livePeriodInDays: 10,
                totalPeriods: 5,
                updateScoreStrategy: 'ACCUMULATE',
            },
            {
                name: 'name',
                description: 'desc',
                gameName: '',
                livePeriodInDays: 10,
                totalPeriods: 5,
                updateScoreStrategy: 'ACCUMULATE',
            },
            {
                name: 'name',
                description: 'desc',
                gameName: 'game',
                livePeriodInDays: 0,
                totalPeriods: 5,
                updateScoreStrategy: 'ACCUMULATE',
            },
            {
                name: 'name',
                description: 'desc',
                gameName: 'game',
                livePeriodInDays: 10,
                totalPeriods: 0,
                updateScoreStrategy: 'ACCUMULATE',
            },
            {
                name: 'name',
                description: 'desc',
                gameName: 'game',
                livePeriodInDays: 10,
                totalPeriods: 5,
                updateScoreStrategy: '',
            },
        ];
        for (const params of invalidParams) {
            await expect(leaderboardManager.createLeaderboard(params)).rejects.toThrow();
        }
    });
    // Post score
    it('should postscore a leaderboard successfully', async () => {
        // Given
        const newScoreParams = {
            leaderboardId: 21,
            items: [
                {
                    score: 240,
                    displayName: 'userDisplayname',
                    userId: 'userId',
                    username: 'username',
                },
            ],
        };
        const newScoreLeaderboardData = {
            success: [
                {
                    score: 240,
                    userId: '0x724f337bf0fa934db9aa3ec6dea49b03c54ad3cc',
                    username: 'vule',
                    id: 39,
                    displayName: 'Test',
                },
            ],
            failed: [],
        };
        // Act
        mockLeaderboardAPI.postNewScore.mockResolvedValue({
            status: 'success',
            data: newScoreLeaderboardData,
        });
        // Act
        const result = await leaderboardManager.postPlayerScore(newScoreParams);
        // Assert
        expect(result.data).toEqual(newScoreLeaderboardData);
    });
    it('should throw an error if post score fails', async () => {
        // Given
        const newScoreParams = {
            leaderboardId: 19,
            items: [
                {
                    score: 0,
                    userId: 'userId',
                    displayName: 'username',
                    username: 'username',
                },
            ],
        };
        mockLeaderboardAPI.postNewScore.mockRejectedValue({
            status: 'error',
            data: null,
        });
        // Act & Assert
        await expect(leaderboardManager.postPlayerScore(newScoreParams)).rejects.toThrow('Failed to post score for player');
    });
    it('should validate missing post score parameters', async () => {
        const invalidParams = [
            {
                leaderboardId: 0,
                items: [
                    {
                        score: 20,
                        userId: '0x724f337bF0Fa934dB9aa3ec6dEa49B03c54AD3cc',
                        username: 'username',
                        displayName: 'displayname',
                    },
                ],
            },
            {
                leaderboardId: 21,
                items: [
                    {
                        score: 20,
                        userId: '',
                        username: 'username',
                        displayName: 'displayname',
                    },
                ],
            },
        ];
        for (const params of invalidParams) {
            await expect(leaderboardManager.postPlayerScore(params)).rejects.toThrow();
        }
    });
    it('should retrieve leaderboards successfully', async () => {
        mockLeaderboardAPI.getLeaderboards.mockResolvedValue(mockApiResponse);
        const params = { page: 1, limit: 10 };
        // Act
        const result = await leaderboardManager.getLeaderboards(params);
        // Assert
        expect(mockLeaderboardAPI.getLeaderboards).toHaveBeenCalledWith(params, 'Developer_Api_Key');
        expect(result).toEqual(mockApiResponse);
    });
    it('should throw an error if the API call for retrieve leaderboards fails', async () => {
        const errorMessage = 'Failed to retrieve leaderboard with Params {"page":1,"limit":10}';
        mockLeaderboardAPI.getLeaderboards.mockRejectedValue(new Error(errorMessage));
        const params = { page: 1, limit: 10 };
        // Act & Assert
        await expect(leaderboardManager.getLeaderboards(params)).rejects.toThrow(`Failed to retrieve leaderboard with Params ${JSON.stringify(params)}`);
        expect(mockLeaderboardAPI.getLeaderboards).toHaveBeenCalledWith(params, 'Developer_Api_Key');
    });
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Leaderboard.test.js","sourceRoot":"","sources":["../../../../src/tests/Leaderboard.test.ts"],"names":[],"mappings":"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"}