boldsign/tests/unit/teamApi.spec.ts

NodeJS client for boldsign

import { TeamsApi } from '../../api/teamsApi';
import * as sinon from 'sinon';

describe('TeamApi Unit Test', () => {
    let teamApiStub: sinon.SinonStubbedInstance<TeamsApi>;

    beforeEach(() => {
        // Create a stub instance for the TeamsApi
        teamApiStub = sinon.createStubInstance(TeamsApi);

        // Stub the methods (e.g., createTeam, updateTeam) for TeamsApi
        teamApiStub.createTeam = sinon.stub().resolves({ teamId: 'team_id' });
        teamApiStub.updateTeam = sinon.stub().resolves({
            success: true,
            message: 'Team updated successfully',
        });
    });

    afterEach(() => {
        sinon.restore();
    });

    it('should mock and verify createTeam call', async () => {
        const mockTeamCreated = {
            teamId: 'team_id',
        };

        const teamData = {
            name: 'New Team',
            description: 'A test team for Syncfusion',
        };

        teamApiStub.createTeam.resolves(mockTeamCreated);

        const result = await teamApiStub.createTeam(teamData);

        expect(result).toBeDefined();
        expect(result.teamId).toBe('team_id');

        sinon.assert.calledOnceWithExactly(teamApiStub.createTeam, teamData);
    });

    it('should mock and verify getTeamDetails call', async () => {
        const teamId = 'team_id';

        const mockTeamDetails = {
            teamId: 'team_id',
            name: 'Engineering Team',
            description: 'Handles product development',
            members: ['user1', 'user2'],
        };

        teamApiStub.getTeamDetails = sinon.stub().resolves(mockTeamDetails);

        const result = await teamApiStub.getTeamDetails(teamId);

        expect(result).toBeDefined();
        expect(result.teamId).toBe('team_id');
        expect(result.name).toBe('Engineering Team');
        expect(result.members).toContain('user1');
        expect(result.members.length).toBe(2);

        sinon.assert.calledOnceWithExactly(teamApiStub.getTeamDetails, teamId);
    });

    it('should mock and verify listTeams call', async () => {
        const mockListResponse = {
            teams: [
                {
                    teamId: 'team_1',
                    name: 'Engineering',
                    description: 'Handles product development',
                },
                {
                    teamId: 'team_2',
                    name: 'Marketing',
                    description: 'Manages marketing campaigns',
                },
            ],
        };

        teamApiStub.listTeams = sinon.stub().resolves(mockListResponse);

        const result = await teamApiStub.listTeams();

        expect(result).toBeDefined();
        expect(Array.isArray(result.teams)).toBe(true);
        expect(result.teams.length).toBe(2);
        expect(result.teams[0].name).toBe('Engineering');
        expect(result.teams[1].teamId).toBe('team_2');

        sinon.assert.calledOnce(teamApiStub.listTeams);
    });
});