argo-cd

1
import * as React from 'react';
2
import * as renderer from 'react-test-renderer';
3
import {Application, HealthStatus, HealthStatuses, OperationPhases, ResourceResult, ResultCodes, SyncStatuses} from '../../shared/models';
4
import {ComparisonStatusIcon, getAppOperationState, getOperationType, HealthStatusIcon, OperationState, ResourceResultIcon} from './utils';
5

6
const zero = new Date(0).toISOString();
7

8
test('getAppOperationState.DeletionTimestamp', () => {
9
    const state = getAppOperationState({metadata: {deletionTimestamp: zero}} as Application);
10

11
    expect(state).toStrictEqual({phase: OperationPhases.Running, startedAt: zero});
12
});
13

14
test('getAppOperationState.Operation', () => {
15
    const state = getAppOperationState({metadata: {}, operation: {}} as Application);
16

17
    expect(state.phase).toBe(OperationPhases.Running);
18
    expect(state.startedAt).toBeDefined();
19
    expect(state.operation).toStrictEqual({sync: {}});
20
});
21

22
test('getAppOperationState.Status', () => {
23
    const state = getAppOperationState({
24
        metadata: {},
25
        status: {operationState: {phase: OperationPhases.Error, startedAt: zero}}
26
    } as Application);
27

28
    expect(state.phase).toBe(OperationPhases.Error);
29
});
30

31
test('getOperationType.Delete', () => {
32
    const state = getOperationType({metadata: {deletionTimestamp: zero.toString()}} as Application);
33

34
    expect(state).toBe('Delete');
35
});
36

37
test('getOperationType.Sync.Operation', () => {
38
    const state = getOperationType({metadata: {}, operation: {sync: {}}} as Application);
39

40
    expect(state).toBe('Sync');
41
});
42

43
test('getOperationType.DeleteAndRecentSync', () => {
44
    const state = getOperationType({metadata: {deletionTimestamp: '123'}, status: {operationState: {operation: {sync: {}}}}} as Application);
45

46
    expect(state).toBe('Delete');
47
});
48

49
test('getOperationType.Sync.Status', () => {
50
    const state = getOperationType({metadata: {}, status: {operationState: {operation: {sync: {}}}}} as Application);
51

52
    expect(state).toBe('Sync');
53
});
54

55
test('getOperationType.Unknown', () => {
56
    const state = getOperationType({metadata: {}, status: {}} as Application);
57

58
    expect(state).toBe('Unknown');
59
});
60

61
test('OperationState.undefined', () => {
62
    const tree = renderer.create(<OperationState app={{metadata: {}, status: {}} as Application} />).toJSON();
63

64
    expect(tree).toMatchSnapshot();
65
});
66

67
test('OperationState.quiet', () => {
68
    const tree = renderer.create(<OperationState app={{metadata: {}, status: {operationState: {}}} as Application} quiet={true} />).toJSON();
69

70
    expect(tree).toMatchSnapshot();
71
});
72

73
test('OperationState.Unknown', () => {
74
    const tree = renderer.create(<OperationState app={{metadata: {}, status: {operationState: {}}} as Application} />).toJSON();
75

76
    expect(tree).toMatchSnapshot();
77
});
78

79
test('OperationState.Deleting', () => {
80
    const tree = renderer.create(<OperationState app={{metadata: {deletionTimestamp: zero}, status: {operationState: {}}} as Application} />).toJSON();
81

82
    expect(tree).toMatchSnapshot();
83
});
84

85
test('OperationState.Sync OK', () => {
86
    const tree = renderer
87
        .create(<OperationState app={{metadata: {}, status: {operationState: {operation: {sync: {}}, phase: OperationPhases.Succeeded}}} as Application} />)
88
        .toJSON();
89

90
    expect(tree).toMatchSnapshot();
91
});
92

93
test('OperationState.Sync error', () => {
94
    const tree = renderer.create(<OperationState app={{metadata: {}, status: {operationState: {operation: {sync: {}}, phase: OperationPhases.Error}}} as Application} />).toJSON();
95

96
    expect(tree).toMatchSnapshot();
97
});
98

99
test('OperationState.Sync failed', () => {
100
    const tree = renderer.create(<OperationState app={{metadata: {}, status: {operationState: {operation: {sync: {}}, phase: OperationPhases.Failed}}} as Application} />).toJSON();
101

102
    expect(tree).toMatchSnapshot();
103
});
104

105
test('OperationState.Syncing', () => {
106
    const tree = renderer
107
        .create(<OperationState app={{metadata: {}, status: {operationState: {operation: {sync: {}}, phase: OperationPhases.Running}}} as Application} />)
108
        .toJSON();
109

110
    expect(tree).toMatchSnapshot();
111
});
112

113
test('ComparisonStatusIcon.Synced', () => {
114
    const tree = renderer.create(<ComparisonStatusIcon status={SyncStatuses.Synced} />).toJSON();
115

116
    expect(tree).toMatchSnapshot();
117
});
118

119
test('ComparisonStatusIcon.OutOfSync', () => {
120
    const tree = renderer.create(<ComparisonStatusIcon status={SyncStatuses.OutOfSync} />).toJSON();
121

122
    expect(tree).toMatchSnapshot();
123
});
124

125
test('ComparisonStatusIcon.Unknown', () => {
126
    const tree = renderer.create(<ComparisonStatusIcon status={SyncStatuses.Unknown} />).toJSON();
127

128
    expect(tree).toMatchSnapshot();
129
});
130

131
test('HealthStatusIcon.Unknown', () => {
132
    const tree = renderer.create(<HealthStatusIcon state={{status: HealthStatuses.Unknown} as HealthStatus} />).toJSON();
133

134
    expect(tree).toMatchSnapshot();
135
});
136
test('HealthStatusIcon.Progressing', () => {
137
    const tree = renderer.create(<HealthStatusIcon state={{status: HealthStatuses.Progressing} as HealthStatus} />).toJSON();
138

139
    expect(tree).toMatchSnapshot();
140
});
141

142
test('HealthStatusIcon.Suspended', () => {
143
    const tree = renderer.create(<HealthStatusIcon state={{status: HealthStatuses.Suspended} as HealthStatus} />).toJSON();
144

145
    expect(tree).toMatchSnapshot();
146
});
147

148
test('HealthStatusIcon.Healthy', () => {
149
    const tree = renderer.create(<HealthStatusIcon state={{status: HealthStatuses.Healthy} as HealthStatus} />).toJSON();
150

151
    expect(tree).toMatchSnapshot();
152
});
153

154
test('HealthStatusIcon.Degraded', () => {
155
    const tree = renderer.create(<HealthStatusIcon state={{status: HealthStatuses.Degraded} as HealthStatus} />).toJSON();
156

157
    expect(tree).toMatchSnapshot();
158
});
159
test('HealthStatusIcon.Missing', () => {
160
    const tree = renderer.create(<HealthStatusIcon state={{status: HealthStatuses.Missing} as HealthStatus} />).toJSON();
161

162
    expect(tree).toMatchSnapshot();
163
});
164

165
test('ResourceResultIcon.Synced', () => {
166
    const tree = renderer.create(<ResourceResultIcon resource={{status: ResultCodes.Synced, message: 'my-message'} as ResourceResult} />).toJSON();
167

168
    expect(tree).toMatchSnapshot();
169
});
170

171
test('ResourceResultIcon.Pruned', () => {
172
    const tree = renderer.create(<ResourceResultIcon resource={{status: ResultCodes.Pruned} as ResourceResult} />).toJSON();
173

174
    expect(tree).toMatchSnapshot();
175
});
176

177
test('ResourceResultIcon.SyncFailed', () => {
178
    const tree = renderer.create(<ResourceResultIcon resource={{status: ResultCodes.SyncFailed} as ResourceResult} />).toJSON();
179

180
    expect(tree).toMatchSnapshot();
181
});
182

183
test('ResourceResultIcon.Hook.Running', () => {
184
    const tree = renderer
185
        .create(
186
            <ResourceResultIcon
187
                resource={
188
                    {
189
                        hookType: 'Sync',
190
                        hookPhase: OperationPhases.Running,
191
                        message: 'my-message'
192
                    } as ResourceResult
193
                }
194
            />
195
        )
196
        .toJSON();
197

198
    expect(tree).toMatchSnapshot();
199
});
200

201
test('ResourceResultIcon.Hook.Failed', () => {
202
    const tree = renderer.create(<ResourceResultIcon resource={{hookType: 'Sync', hookPhase: OperationPhases.Failed} as ResourceResult} />).toJSON();
203

204
    expect(tree).toMatchSnapshot();
205
});
206

207
test('ResourceResultIcon.Hook.Error', () => {
208
    const tree = renderer.create(<ResourceResultIcon resource={{hookType: 'Sync', hookPhase: OperationPhases.Error} as ResourceResult} />).toJSON();
209

210
    expect(tree).toMatchSnapshot();
211
});
212

213
test('ResourceResultIcon.Hook.Succeeded', () => {
214
    const tree = renderer.create(<ResourceResultIcon resource={{hookType: 'Sync', hookPhase: OperationPhases.Succeeded} as ResourceResult} />).toJSON();
215

216
    expect(tree).toMatchSnapshot();
217
});
218

219
test('ResourceResultIcon.Hook.Terminating', () => {
220
    const tree = renderer.create(<ResourceResultIcon resource={{hookType: 'Sync', hookPhase: OperationPhases.Terminating} as ResourceResult} />).toJSON();
221

222
    expect(tree).toMatchSnapshot();
223
});
224