TF2-QuickServer/packages/core/src/usecase/CreateServerForClient.test.ts at 808c3c6a233624e71293a6dc3c10bec01fa5587b · sonikro/TF2-QuickServer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
import { describe, it, expect } from 'vitest';
import { mock } from 'vitest-mock-extended';
import { ServerRepository, ServerManagerFactory, ServerManager, IdGenerator } from '@tf2qs/core';
import { CreateServerForClient } from './CreateServerForClient';
import { Region, Server } from '../domain';

describe('CreateServerForClient', () => {
    function makeSut() {
        const serverRepository = mock<ServerRepository>();
        const serverManagerFactory = mock<ServerManagerFactory>();
        const serverManager = mock<ServerManager>();
        const idGenerator = mock<IdGenerator>();

        serverManagerFactory.createServerManager.mockReturnValue(serverManager);
        idGenerator.generate.mockReturnValue('mock-server-id');

        const sut = new CreateServerForClient({
            serverRepository,
            serverManagerFactory,
            idGenerator,
            eventLogger: mock(),
        });

        return { sut, serverRepository, serverManagerFactory, serverManager, idGenerator };
    }

    const baseArgs = {
        region: 'us-east-1' as Region,
        variantName: 'standard-competitive' as Server['variant'],
        clientId: 'client-abc123',
    };

    const deployedServer: Server = {
        serverId: 'server-xyz',
        region: 'us-east-1' as Region,
        variant: 'standard-competitive' as Server['variant'],
        hostIp: '1.2.3.4',
        hostPort: 27015,
        tvIp: '1.2.3.4',
        tvPort: 27020,
        rconPassword: 'rcon123',
        rconAddress: '1.2.3.4:27015',
    };

    describe('execute', () => {
        it('should create a server and return the deployed server', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            // When
            const result = await sut.execute(baseArgs);

            // Then
            expect(result).toEqual(deployedServer);
        });

        it('should use clientId as createdBy when upserting the server', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            // When
            await sut.execute(baseArgs);

            // Then
            expect(serverRepository.upsertServer).toHaveBeenCalledWith(
                expect.objectContaining({ createdBy: 'client-abc123', status: 'pending' })
            );
            expect(serverRepository.upsertServer).toHaveBeenCalledWith(
                expect.objectContaining({ createdBy: 'client-abc123', status: 'ready' })
            );
        });

        it('should pass extraEnvs to deployServer', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            const extraEnvs = { STV_TITLE: 'My Server', HOSTNAME: 'Pickup' };

            // When
            await sut.execute({ ...baseArgs, extraEnvs });

            // Then
            expect(serverManager.deployServer).toHaveBeenCalledWith(
                expect.objectContaining({ extraEnvs })
            );
        });

        it('should pass firstMap to deployServer when provided', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            // When
            await sut.execute({ ...baseArgs, firstMap: 'cp_process_f12' });

            // Then
            expect(serverManager.deployServer).toHaveBeenCalledWith(
                expect.objectContaining({ firstMap: 'cp_process_f12' })
            );
        });

        it('should pass empty extraEnvs to deployServer when not provided', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            // When
            await sut.execute(baseArgs);

            // Then
            expect(serverManager.deployServer).toHaveBeenCalledWith(
                expect.objectContaining({ extraEnvs: {} })
            );
        });

        it.each([
            { region: 'us-east-1', variantName: 'standard-competitive' },
            { region: 'eu-london', variantName: 'standard-competitive' },
            { region: 'sa-saopaulo-1', variantName: 'standard-competitive' },
        ])('should create server manager for region $region', async ({ region, variantName }) => {
            // Given
            const { sut, serverRepository, serverManagerFactory, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            // When
            await sut.execute({ clientId: 'client-abc123', region: region as Region, variantName: variantName as Server['variant'] });

            // Then
            expect(serverManagerFactory.createServerManager).toHaveBeenCalledWith(region);
        });

        it('should not enforce the 1-server-per-user restriction', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockResolvedValue(deployedServer);
            serverRepository.upsertServer.mockResolvedValue();

            // When - two servers created for the same clientId without error
            await sut.execute(baseArgs);
            await sut.execute(baseArgs);

            // Then - no exception thrown, and getAllServersByUserId never called
            expect(serverRepository.getAllServersByUserId).not.toHaveBeenCalled();
        });

        it('should propagate errors from deployServer', async () => {
            // Given
            const { sut, serverRepository, serverManager } = makeSut();
            serverManager.deployServer.mockRejectedValue(new Error('Cloud provider unavailable'));
            serverRepository.upsertServer.mockResolvedValue();

            // When / Then
            await expect(sut.execute(baseArgs)).rejects.toThrow('Cloud provider unavailable');
        });
    });
});