-
Notifications
You must be signed in to change notification settings - Fork 596
/
deployImage-validation-utils.spec.ts
195 lines (180 loc) · 7.44 KB
/
deployImage-validation-utils.spec.ts
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
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
import { cloneDeep } from 'lodash';
import { CREATE_APPLICATION_KEY, UNASSIGNED_KEY } from '@console/topology/src/const';
import { t } from '../../../../../../__mocks__/i18next';
import { mockDeployImageFormData } from '../__mocks__/deployImage-validation-mock';
import { deployValidationSchema } from '../deployImage-validation-utils';
import { serverlessCommonTests } from './serverless-common-tests';
describe('Deploy Image ValidationUtils', () => {
describe('Validation Schema', () => {
it('should validate the form data', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(true));
});
it('should throw an error for required fields if empty', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.name = '';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('Required');
expect(err.type).toBe('required');
});
});
it('should throw an error if name is invalid', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.name = 'app_name';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe(
'Name must consist of lower case alphanumeric characters, hyphens or dots, and must start and end with an alphanumeric character.',
);
});
});
it('should throw an error when no application name given for create application option', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.application.selectedKey = CREATE_APPLICATION_KEY;
mockData.application.name = '';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('Required');
});
});
it('should not throw an error when no application group is chosen', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.application.selectedKey = UNASSIGNED_KEY;
mockData.application.name = '';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(true));
});
it('should not throw an error when allowing either create or no application group set', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.application.selectedKey = '';
mockData.application.name = '';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(true));
});
it('should throw an error if path is invalid', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.route.path = 'path';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('Path must start with /.');
});
});
it('should throw an error if hostname is invalid', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.route.hostname = 'host_name';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe(
'Hostname must consist of lower-case letters, numbers, periods, and hyphens. It must start and end with a letter or number.',
);
});
});
it('should throw an error if request is greater than limit', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.limits.cpu.request = 3;
mockData.limits.cpu.requestUnit = 'm';
mockData.limits.cpu.limit = 2;
mockData.limits.cpu.limitUnit = 'm';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('CPU limit must be greater than or equal to request.');
});
});
it('should throw an error if memory request is greater than limit', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.limits.memory.request = 3;
mockData.limits.memory.requestUnit = 'Gi';
mockData.limits.memory.limit = 3;
mockData.limits.memory.limitUnit = 'Mi';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('Memory limit must be greater than or equal to request.');
});
});
it('request should entered individual without validation of limit field', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.limits.cpu.request = 3;
mockData.limits.cpu.requestUnit = 'm';
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(true));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('');
});
});
it('should throw an error if deployment replicas is not an integer', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.deployment.replicas = 3.2;
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('Replicas must be an integer.');
});
});
it('should throw an error if deployment replicas is less than 0', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.deployment.replicas = -5;
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe('Replicas must be greater than or equal to 0.');
});
});
it('should throw an error if deployment replicas is greater than MAX_SAFE_INTEGER', async () => {
const mockData = cloneDeep(mockDeployImageFormData);
mockData.deployment.replicas = Number.MAX_SAFE_INTEGER + 1;
await deployValidationSchema(t)
.isValid(mockData)
.then((valid) => expect(valid).toEqual(false));
await deployValidationSchema(t)
.validate(mockData)
.catch((err) => {
expect(err.message).toBe(
`Replicas must be lesser than or equal to ${Number.MAX_SAFE_INTEGER}.`,
);
});
});
serverlessCommonTests(mockDeployImageFormData, deployValidationSchema(t));
});
});