@meloqa/mcp-server 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +97 -0
- package/dist/client.js +89 -0
- package/dist/client.js.map +1 -0
- package/dist/index.js +20 -0
- package/dist/index.js.map +1 -0
- package/dist/server.js +62 -0
- package/dist/server.js.map +1 -0
- package/dist/tools.generated.js +3080 -0
- package/dist/tools.generated.js.map +1 -0
- package/dist/types.js +2 -0
- package/dist/types.js.map +1 -0
- package/package.json +56 -0
- package/spec/openapi.json +10713 -0
|
@@ -0,0 +1,3080 @@
|
|
|
1
|
+
// AUTO-GENERATED — do not edit by hand. Run `npm run gen` to regenerate.
|
|
2
|
+
// Source: spec/openapi.json
|
|
3
|
+
//
|
|
4
|
+
// 83 tools generated from the meloQA Public API v1 spec.
|
|
5
|
+
export const tools = [
|
|
6
|
+
{
|
|
7
|
+
name: "bug_environments_list",
|
|
8
|
+
description: "List environments for a project\n\nTag: Bug Environments",
|
|
9
|
+
inputSchema: {
|
|
10
|
+
"type": "object",
|
|
11
|
+
"properties": {
|
|
12
|
+
"projectId": {
|
|
13
|
+
"type": "string",
|
|
14
|
+
"format": "uuid",
|
|
15
|
+
"description": "Filter environments by project"
|
|
16
|
+
}
|
|
17
|
+
},
|
|
18
|
+
"additionalProperties": false,
|
|
19
|
+
"required": [
|
|
20
|
+
"projectId"
|
|
21
|
+
]
|
|
22
|
+
},
|
|
23
|
+
request: (input) => {
|
|
24
|
+
const req = { method: "GET", path: "/v1/bug-environments" };
|
|
25
|
+
const query = {};
|
|
26
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
27
|
+
query["projectId"] = String(input.projectId);
|
|
28
|
+
if (Object.keys(query).length > 0)
|
|
29
|
+
req.query = query;
|
|
30
|
+
return req;
|
|
31
|
+
},
|
|
32
|
+
},
|
|
33
|
+
{
|
|
34
|
+
name: "bug_folders_create",
|
|
35
|
+
description: "Create bug folder\n\nTag: Bug Folders",
|
|
36
|
+
inputSchema: {
|
|
37
|
+
"type": "object",
|
|
38
|
+
"properties": {
|
|
39
|
+
"name": {
|
|
40
|
+
"type": "string"
|
|
41
|
+
},
|
|
42
|
+
"projectId": {
|
|
43
|
+
"type": "string",
|
|
44
|
+
"format": "uuid"
|
|
45
|
+
},
|
|
46
|
+
"parentId": {
|
|
47
|
+
"type": "string",
|
|
48
|
+
"format": "uuid"
|
|
49
|
+
},
|
|
50
|
+
"order": {
|
|
51
|
+
"type": "integer"
|
|
52
|
+
}
|
|
53
|
+
},
|
|
54
|
+
"additionalProperties": false,
|
|
55
|
+
"required": [
|
|
56
|
+
"name",
|
|
57
|
+
"projectId"
|
|
58
|
+
]
|
|
59
|
+
},
|
|
60
|
+
request: (input) => {
|
|
61
|
+
const req = { method: "POST", path: "/v1/bug-folders" };
|
|
62
|
+
const body = {};
|
|
63
|
+
if (input.name !== undefined)
|
|
64
|
+
body["name"] = input.name;
|
|
65
|
+
if (input.projectId !== undefined)
|
|
66
|
+
body["projectId"] = input.projectId;
|
|
67
|
+
if (input.parentId !== undefined)
|
|
68
|
+
body["parentId"] = input.parentId;
|
|
69
|
+
if (input.order !== undefined)
|
|
70
|
+
body["order"] = input.order;
|
|
71
|
+
req.body = body;
|
|
72
|
+
return req;
|
|
73
|
+
},
|
|
74
|
+
},
|
|
75
|
+
{
|
|
76
|
+
name: "bug_folders_delete",
|
|
77
|
+
description: "Delete bug folder\n\nTag: Bug Folders",
|
|
78
|
+
inputSchema: {
|
|
79
|
+
"type": "object",
|
|
80
|
+
"properties": {
|
|
81
|
+
"id": {
|
|
82
|
+
"type": "string",
|
|
83
|
+
"format": "uuid",
|
|
84
|
+
"description": "Bug Folder ID"
|
|
85
|
+
}
|
|
86
|
+
},
|
|
87
|
+
"additionalProperties": false,
|
|
88
|
+
"required": [
|
|
89
|
+
"id"
|
|
90
|
+
]
|
|
91
|
+
},
|
|
92
|
+
request: (input) => {
|
|
93
|
+
const req = { method: "DELETE", path: `/v1/bug-folders/${encodeURIComponent(String(input.id))}` };
|
|
94
|
+
return req;
|
|
95
|
+
},
|
|
96
|
+
},
|
|
97
|
+
{
|
|
98
|
+
name: "bug_folders_get",
|
|
99
|
+
description: "Get bug folder by ID\n\nTag: Bug Folders",
|
|
100
|
+
inputSchema: {
|
|
101
|
+
"type": "object",
|
|
102
|
+
"properties": {
|
|
103
|
+
"id": {
|
|
104
|
+
"type": "string",
|
|
105
|
+
"format": "uuid",
|
|
106
|
+
"description": "Bug Folder ID"
|
|
107
|
+
}
|
|
108
|
+
},
|
|
109
|
+
"additionalProperties": false,
|
|
110
|
+
"required": [
|
|
111
|
+
"id"
|
|
112
|
+
]
|
|
113
|
+
},
|
|
114
|
+
request: (input) => {
|
|
115
|
+
const req = { method: "GET", path: `/v1/bug-folders/${encodeURIComponent(String(input.id))}` };
|
|
116
|
+
return req;
|
|
117
|
+
},
|
|
118
|
+
},
|
|
119
|
+
{
|
|
120
|
+
name: "bug_folders_list",
|
|
121
|
+
description: "List bug folders\n\nTag: Bug Folders",
|
|
122
|
+
inputSchema: {
|
|
123
|
+
"type": "object",
|
|
124
|
+
"properties": {
|
|
125
|
+
"projectId": {
|
|
126
|
+
"type": "string",
|
|
127
|
+
"format": "uuid",
|
|
128
|
+
"description": "Filter folders by project"
|
|
129
|
+
},
|
|
130
|
+
"parentId": {
|
|
131
|
+
"type": "string",
|
|
132
|
+
"format": "uuid",
|
|
133
|
+
"description": "Filter by parent folder"
|
|
134
|
+
}
|
|
135
|
+
},
|
|
136
|
+
"additionalProperties": false,
|
|
137
|
+
"required": [
|
|
138
|
+
"projectId"
|
|
139
|
+
]
|
|
140
|
+
},
|
|
141
|
+
request: (input) => {
|
|
142
|
+
const req = { method: "GET", path: "/v1/bug-folders" };
|
|
143
|
+
const query = {};
|
|
144
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
145
|
+
query["projectId"] = String(input.projectId);
|
|
146
|
+
if (input.parentId !== undefined && input.parentId !== null)
|
|
147
|
+
query["parentId"] = String(input.parentId);
|
|
148
|
+
if (Object.keys(query).length > 0)
|
|
149
|
+
req.query = query;
|
|
150
|
+
return req;
|
|
151
|
+
},
|
|
152
|
+
},
|
|
153
|
+
{
|
|
154
|
+
name: "bug_folders_update",
|
|
155
|
+
description: "Update bug folder\n\nTag: Bug Folders",
|
|
156
|
+
inputSchema: {
|
|
157
|
+
"type": "object",
|
|
158
|
+
"properties": {
|
|
159
|
+
"id": {
|
|
160
|
+
"type": "string",
|
|
161
|
+
"format": "uuid",
|
|
162
|
+
"description": "Bug Folder ID"
|
|
163
|
+
},
|
|
164
|
+
"name": {
|
|
165
|
+
"type": "string"
|
|
166
|
+
},
|
|
167
|
+
"parentId": {
|
|
168
|
+
"type": [
|
|
169
|
+
"string",
|
|
170
|
+
"null"
|
|
171
|
+
],
|
|
172
|
+
"format": "uuid"
|
|
173
|
+
},
|
|
174
|
+
"order": {
|
|
175
|
+
"type": "integer"
|
|
176
|
+
}
|
|
177
|
+
},
|
|
178
|
+
"additionalProperties": false,
|
|
179
|
+
"required": [
|
|
180
|
+
"id"
|
|
181
|
+
]
|
|
182
|
+
},
|
|
183
|
+
request: (input) => {
|
|
184
|
+
const req = { method: "PATCH", path: `/v1/bug-folders/${encodeURIComponent(String(input.id))}` };
|
|
185
|
+
const body = {};
|
|
186
|
+
if (input.name !== undefined)
|
|
187
|
+
body["name"] = input.name;
|
|
188
|
+
if (input.parentId !== undefined)
|
|
189
|
+
body["parentId"] = input.parentId;
|
|
190
|
+
if (input.order !== undefined)
|
|
191
|
+
body["order"] = input.order;
|
|
192
|
+
req.body = body;
|
|
193
|
+
return req;
|
|
194
|
+
},
|
|
195
|
+
},
|
|
196
|
+
{
|
|
197
|
+
name: "bug_priorities_list",
|
|
198
|
+
description: "List all bug priority levels\n\nTag: Bug Priorities",
|
|
199
|
+
inputSchema: {
|
|
200
|
+
"type": "object",
|
|
201
|
+
"properties": {},
|
|
202
|
+
"additionalProperties": false
|
|
203
|
+
},
|
|
204
|
+
request: (input) => {
|
|
205
|
+
const req = { method: "GET", path: "/v1/bug-priorities" };
|
|
206
|
+
return req;
|
|
207
|
+
},
|
|
208
|
+
},
|
|
209
|
+
{
|
|
210
|
+
name: "bug_statuses_list",
|
|
211
|
+
description: "List all bug statuses\n\nTag: Bug Statuses",
|
|
212
|
+
inputSchema: {
|
|
213
|
+
"type": "object",
|
|
214
|
+
"properties": {},
|
|
215
|
+
"additionalProperties": false
|
|
216
|
+
},
|
|
217
|
+
request: (input) => {
|
|
218
|
+
const req = { method: "GET", path: "/v1/bug-statuses" };
|
|
219
|
+
return req;
|
|
220
|
+
},
|
|
221
|
+
},
|
|
222
|
+
{
|
|
223
|
+
name: "bug_types_list",
|
|
224
|
+
description: "List bug types for a project\n\nTag: Bug Types",
|
|
225
|
+
inputSchema: {
|
|
226
|
+
"type": "object",
|
|
227
|
+
"properties": {
|
|
228
|
+
"projectId": {
|
|
229
|
+
"type": "string",
|
|
230
|
+
"format": "uuid",
|
|
231
|
+
"description": "Filter bug types by project"
|
|
232
|
+
}
|
|
233
|
+
},
|
|
234
|
+
"additionalProperties": false,
|
|
235
|
+
"required": [
|
|
236
|
+
"projectId"
|
|
237
|
+
]
|
|
238
|
+
},
|
|
239
|
+
request: (input) => {
|
|
240
|
+
const req = { method: "GET", path: "/v1/bug-types" };
|
|
241
|
+
const query = {};
|
|
242
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
243
|
+
query["projectId"] = String(input.projectId);
|
|
244
|
+
if (Object.keys(query).length > 0)
|
|
245
|
+
req.query = query;
|
|
246
|
+
return req;
|
|
247
|
+
},
|
|
248
|
+
},
|
|
249
|
+
{
|
|
250
|
+
name: "bugs_attachments_create",
|
|
251
|
+
description: "Create bug attachment (returns presigned upload URL)\n\nTag: Bug Attachments\n\nCria o registro do anexo (uploaded=false) e retorna uma presigned URL S3 (PUT, 300s). Faça o PUT do arquivo na `uploadUrl` e depois confirme com PATCH /v1/bugs/:id/attachments/:attachmentId.",
|
|
252
|
+
inputSchema: {
|
|
253
|
+
"type": "object",
|
|
254
|
+
"properties": {
|
|
255
|
+
"id": {
|
|
256
|
+
"type": "string",
|
|
257
|
+
"format": "uuid",
|
|
258
|
+
"description": "Bug ID"
|
|
259
|
+
},
|
|
260
|
+
"fileName": {
|
|
261
|
+
"type": "string"
|
|
262
|
+
},
|
|
263
|
+
"size": {
|
|
264
|
+
"type": "integer",
|
|
265
|
+
"description": "Tamanho em bytes"
|
|
266
|
+
},
|
|
267
|
+
"type": {
|
|
268
|
+
"type": "string",
|
|
269
|
+
"description": "MIME type"
|
|
270
|
+
},
|
|
271
|
+
"md5": {
|
|
272
|
+
"type": "string"
|
|
273
|
+
}
|
|
274
|
+
},
|
|
275
|
+
"additionalProperties": false,
|
|
276
|
+
"required": [
|
|
277
|
+
"id",
|
|
278
|
+
"fileName",
|
|
279
|
+
"size",
|
|
280
|
+
"type",
|
|
281
|
+
"md5"
|
|
282
|
+
]
|
|
283
|
+
},
|
|
284
|
+
request: (input) => {
|
|
285
|
+
const req = { method: "POST", path: `/v1/bugs/${encodeURIComponent(String(input.id))}/attachments` };
|
|
286
|
+
const body = {};
|
|
287
|
+
if (input.fileName !== undefined)
|
|
288
|
+
body["fileName"] = input.fileName;
|
|
289
|
+
if (input.size !== undefined)
|
|
290
|
+
body["size"] = input.size;
|
|
291
|
+
if (input.type !== undefined)
|
|
292
|
+
body["type"] = input.type;
|
|
293
|
+
if (input.md5 !== undefined)
|
|
294
|
+
body["md5"] = input.md5;
|
|
295
|
+
req.body = body;
|
|
296
|
+
return req;
|
|
297
|
+
},
|
|
298
|
+
},
|
|
299
|
+
{
|
|
300
|
+
name: "bugs_attachments_delete",
|
|
301
|
+
description: "Delete bug attachment\n\nTag: Bug Attachments\n\nRemove o anexo (registro + arquivo no S3).",
|
|
302
|
+
inputSchema: {
|
|
303
|
+
"type": "object",
|
|
304
|
+
"properties": {
|
|
305
|
+
"id": {
|
|
306
|
+
"type": "string",
|
|
307
|
+
"format": "uuid",
|
|
308
|
+
"description": "Bug ID"
|
|
309
|
+
},
|
|
310
|
+
"attachmentId": {
|
|
311
|
+
"type": "string",
|
|
312
|
+
"format": "uuid",
|
|
313
|
+
"description": "Attachment ID"
|
|
314
|
+
}
|
|
315
|
+
},
|
|
316
|
+
"additionalProperties": false,
|
|
317
|
+
"required": [
|
|
318
|
+
"id",
|
|
319
|
+
"attachmentId"
|
|
320
|
+
]
|
|
321
|
+
},
|
|
322
|
+
request: (input) => {
|
|
323
|
+
const req = { method: "DELETE", path: `/v1/bugs/${encodeURIComponent(String(input.id))}/attachments/${encodeURIComponent(String(input.attachmentId))}` };
|
|
324
|
+
return req;
|
|
325
|
+
},
|
|
326
|
+
},
|
|
327
|
+
{
|
|
328
|
+
name: "bugs_attachments_list",
|
|
329
|
+
description: "List bug attachments\n\nTag: Bug Attachments\n\nLista os anexos do bug. Itens com `uploaded=true` trazem `downloadUrl` (presigned, 300s).",
|
|
330
|
+
inputSchema: {
|
|
331
|
+
"type": "object",
|
|
332
|
+
"properties": {
|
|
333
|
+
"id": {
|
|
334
|
+
"type": "string",
|
|
335
|
+
"format": "uuid",
|
|
336
|
+
"description": "Bug ID"
|
|
337
|
+
}
|
|
338
|
+
},
|
|
339
|
+
"additionalProperties": false,
|
|
340
|
+
"required": [
|
|
341
|
+
"id"
|
|
342
|
+
]
|
|
343
|
+
},
|
|
344
|
+
request: (input) => {
|
|
345
|
+
const req = { method: "GET", path: `/v1/bugs/${encodeURIComponent(String(input.id))}/attachments` };
|
|
346
|
+
return req;
|
|
347
|
+
},
|
|
348
|
+
},
|
|
349
|
+
{
|
|
350
|
+
name: "bugs_attachments_update",
|
|
351
|
+
description: "Confirm bug attachment upload\n\nTag: Bug Attachments\n\nMarca o anexo como enviado (`uploaded=true`) após o PUT no S3.",
|
|
352
|
+
inputSchema: {
|
|
353
|
+
"type": "object",
|
|
354
|
+
"properties": {
|
|
355
|
+
"id": {
|
|
356
|
+
"type": "string",
|
|
357
|
+
"format": "uuid",
|
|
358
|
+
"description": "Bug ID"
|
|
359
|
+
},
|
|
360
|
+
"attachmentId": {
|
|
361
|
+
"type": "string",
|
|
362
|
+
"format": "uuid",
|
|
363
|
+
"description": "Attachment ID"
|
|
364
|
+
}
|
|
365
|
+
},
|
|
366
|
+
"additionalProperties": false,
|
|
367
|
+
"required": [
|
|
368
|
+
"id",
|
|
369
|
+
"attachmentId"
|
|
370
|
+
]
|
|
371
|
+
},
|
|
372
|
+
request: (input) => {
|
|
373
|
+
const req = { method: "PATCH", path: `/v1/bugs/${encodeURIComponent(String(input.id))}/attachments/${encodeURIComponent(String(input.attachmentId))}` };
|
|
374
|
+
return req;
|
|
375
|
+
},
|
|
376
|
+
},
|
|
377
|
+
{
|
|
378
|
+
name: "bugs_create",
|
|
379
|
+
description: "Create bug\n\nTag: Bugs",
|
|
380
|
+
inputSchema: {
|
|
381
|
+
"type": "object",
|
|
382
|
+
"properties": {
|
|
383
|
+
"name": {
|
|
384
|
+
"type": "string"
|
|
385
|
+
},
|
|
386
|
+
"projectId": {
|
|
387
|
+
"type": "string",
|
|
388
|
+
"format": "uuid"
|
|
389
|
+
},
|
|
390
|
+
"statusId": {
|
|
391
|
+
"type": "string",
|
|
392
|
+
"format": "uuid"
|
|
393
|
+
},
|
|
394
|
+
"description": {
|
|
395
|
+
"type": "string"
|
|
396
|
+
},
|
|
397
|
+
"projectPlatformId": {
|
|
398
|
+
"type": "string",
|
|
399
|
+
"format": "uuid"
|
|
400
|
+
},
|
|
401
|
+
"environmentId": {
|
|
402
|
+
"type": "string",
|
|
403
|
+
"format": "uuid"
|
|
404
|
+
},
|
|
405
|
+
"type": {
|
|
406
|
+
"type": "string"
|
|
407
|
+
},
|
|
408
|
+
"priority": {
|
|
409
|
+
"type": "string",
|
|
410
|
+
"enum": [
|
|
411
|
+
"FIRST",
|
|
412
|
+
"SECOND",
|
|
413
|
+
"THIRD",
|
|
414
|
+
"FOURTH",
|
|
415
|
+
"FIFTH"
|
|
416
|
+
],
|
|
417
|
+
"description": "FIRST=Critical, SECOND=High, THIRD=Medium, FOURTH=Low, FIFTH=Trivial"
|
|
418
|
+
},
|
|
419
|
+
"assignedTo": {
|
|
420
|
+
"type": "string",
|
|
421
|
+
"format": "uuid"
|
|
422
|
+
},
|
|
423
|
+
"folderId": {
|
|
424
|
+
"type": "string",
|
|
425
|
+
"format": "uuid"
|
|
426
|
+
}
|
|
427
|
+
},
|
|
428
|
+
"additionalProperties": false,
|
|
429
|
+
"required": [
|
|
430
|
+
"name",
|
|
431
|
+
"projectId",
|
|
432
|
+
"statusId"
|
|
433
|
+
]
|
|
434
|
+
},
|
|
435
|
+
request: (input) => {
|
|
436
|
+
const req = { method: "POST", path: "/v1/bugs" };
|
|
437
|
+
const body = {};
|
|
438
|
+
if (input.name !== undefined)
|
|
439
|
+
body["name"] = input.name;
|
|
440
|
+
if (input.projectId !== undefined)
|
|
441
|
+
body["projectId"] = input.projectId;
|
|
442
|
+
if (input.statusId !== undefined)
|
|
443
|
+
body["statusId"] = input.statusId;
|
|
444
|
+
if (input.description !== undefined)
|
|
445
|
+
body["description"] = input.description;
|
|
446
|
+
if (input.projectPlatformId !== undefined)
|
|
447
|
+
body["projectPlatformId"] = input.projectPlatformId;
|
|
448
|
+
if (input.environmentId !== undefined)
|
|
449
|
+
body["environmentId"] = input.environmentId;
|
|
450
|
+
if (input.type !== undefined)
|
|
451
|
+
body["type"] = input.type;
|
|
452
|
+
if (input.priority !== undefined)
|
|
453
|
+
body["priority"] = input.priority;
|
|
454
|
+
if (input.assignedTo !== undefined)
|
|
455
|
+
body["assignedTo"] = input.assignedTo;
|
|
456
|
+
if (input.folderId !== undefined)
|
|
457
|
+
body["folderId"] = input.folderId;
|
|
458
|
+
req.body = body;
|
|
459
|
+
return req;
|
|
460
|
+
},
|
|
461
|
+
},
|
|
462
|
+
{
|
|
463
|
+
name: "bugs_delete",
|
|
464
|
+
description: "Delete bug\n\nTag: Bugs",
|
|
465
|
+
inputSchema: {
|
|
466
|
+
"type": "object",
|
|
467
|
+
"properties": {
|
|
468
|
+
"id": {
|
|
469
|
+
"type": "string",
|
|
470
|
+
"format": "uuid",
|
|
471
|
+
"description": "Bug ID"
|
|
472
|
+
}
|
|
473
|
+
},
|
|
474
|
+
"additionalProperties": false,
|
|
475
|
+
"required": [
|
|
476
|
+
"id"
|
|
477
|
+
]
|
|
478
|
+
},
|
|
479
|
+
request: (input) => {
|
|
480
|
+
const req = { method: "DELETE", path: `/v1/bugs/${encodeURIComponent(String(input.id))}` };
|
|
481
|
+
return req;
|
|
482
|
+
},
|
|
483
|
+
},
|
|
484
|
+
{
|
|
485
|
+
name: "bugs_get",
|
|
486
|
+
description: "Get bug by ID\n\nTag: Bugs",
|
|
487
|
+
inputSchema: {
|
|
488
|
+
"type": "object",
|
|
489
|
+
"properties": {
|
|
490
|
+
"id": {
|
|
491
|
+
"type": "string",
|
|
492
|
+
"format": "uuid",
|
|
493
|
+
"description": "Bug ID"
|
|
494
|
+
}
|
|
495
|
+
},
|
|
496
|
+
"additionalProperties": false,
|
|
497
|
+
"required": [
|
|
498
|
+
"id"
|
|
499
|
+
]
|
|
500
|
+
},
|
|
501
|
+
request: (input) => {
|
|
502
|
+
const req = { method: "GET", path: `/v1/bugs/${encodeURIComponent(String(input.id))}` };
|
|
503
|
+
return req;
|
|
504
|
+
},
|
|
505
|
+
},
|
|
506
|
+
{
|
|
507
|
+
name: "bugs_list",
|
|
508
|
+
description: "List bugs\n\nTag: Bugs\n\nAt least one query parameter is required: **projectId** or **folderId**.",
|
|
509
|
+
inputSchema: {
|
|
510
|
+
"type": "object",
|
|
511
|
+
"properties": {
|
|
512
|
+
"projectId": {
|
|
513
|
+
"type": "string",
|
|
514
|
+
"format": "uuid",
|
|
515
|
+
"description": "Filter by project. At least one of projectId or folderId is required."
|
|
516
|
+
},
|
|
517
|
+
"folderId": {
|
|
518
|
+
"type": "string",
|
|
519
|
+
"format": "uuid",
|
|
520
|
+
"description": "Filter by folder. At least one of projectId or folderId is required."
|
|
521
|
+
}
|
|
522
|
+
},
|
|
523
|
+
"additionalProperties": false
|
|
524
|
+
},
|
|
525
|
+
request: (input) => {
|
|
526
|
+
const req = { method: "GET", path: "/v1/bugs" };
|
|
527
|
+
const query = {};
|
|
528
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
529
|
+
query["projectId"] = String(input.projectId);
|
|
530
|
+
if (input.folderId !== undefined && input.folderId !== null)
|
|
531
|
+
query["folderId"] = String(input.folderId);
|
|
532
|
+
if (Object.keys(query).length > 0)
|
|
533
|
+
req.query = query;
|
|
534
|
+
return req;
|
|
535
|
+
},
|
|
536
|
+
},
|
|
537
|
+
{
|
|
538
|
+
name: "bugs_update",
|
|
539
|
+
description: "Update bug\n\nTag: Bugs",
|
|
540
|
+
inputSchema: {
|
|
541
|
+
"type": "object",
|
|
542
|
+
"properties": {
|
|
543
|
+
"id": {
|
|
544
|
+
"type": "string",
|
|
545
|
+
"format": "uuid",
|
|
546
|
+
"description": "Bug ID"
|
|
547
|
+
},
|
|
548
|
+
"name": {
|
|
549
|
+
"type": "string"
|
|
550
|
+
},
|
|
551
|
+
"statusId": {
|
|
552
|
+
"type": "string",
|
|
553
|
+
"format": "uuid"
|
|
554
|
+
},
|
|
555
|
+
"description": {
|
|
556
|
+
"type": [
|
|
557
|
+
"string",
|
|
558
|
+
"null"
|
|
559
|
+
]
|
|
560
|
+
},
|
|
561
|
+
"projectPlatformId": {
|
|
562
|
+
"type": [
|
|
563
|
+
"string",
|
|
564
|
+
"null"
|
|
565
|
+
],
|
|
566
|
+
"format": "uuid"
|
|
567
|
+
},
|
|
568
|
+
"environmentId": {
|
|
569
|
+
"type": [
|
|
570
|
+
"string",
|
|
571
|
+
"null"
|
|
572
|
+
],
|
|
573
|
+
"format": "uuid"
|
|
574
|
+
},
|
|
575
|
+
"type": {
|
|
576
|
+
"type": [
|
|
577
|
+
"string",
|
|
578
|
+
"null"
|
|
579
|
+
]
|
|
580
|
+
},
|
|
581
|
+
"priority": {
|
|
582
|
+
"type": "string",
|
|
583
|
+
"enum": [
|
|
584
|
+
"FIRST",
|
|
585
|
+
"SECOND",
|
|
586
|
+
"THIRD",
|
|
587
|
+
"FOURTH",
|
|
588
|
+
"FIFTH"
|
|
589
|
+
],
|
|
590
|
+
"description": "FIRST=Critical, SECOND=High, THIRD=Medium, FOURTH=Low, FIFTH=Trivial"
|
|
591
|
+
},
|
|
592
|
+
"assignedTo": {
|
|
593
|
+
"type": [
|
|
594
|
+
"string",
|
|
595
|
+
"null"
|
|
596
|
+
],
|
|
597
|
+
"format": "uuid"
|
|
598
|
+
},
|
|
599
|
+
"folderId": {
|
|
600
|
+
"type": [
|
|
601
|
+
"string",
|
|
602
|
+
"null"
|
|
603
|
+
],
|
|
604
|
+
"format": "uuid"
|
|
605
|
+
}
|
|
606
|
+
},
|
|
607
|
+
"additionalProperties": false,
|
|
608
|
+
"required": [
|
|
609
|
+
"id"
|
|
610
|
+
]
|
|
611
|
+
},
|
|
612
|
+
request: (input) => {
|
|
613
|
+
const req = { method: "PATCH", path: `/v1/bugs/${encodeURIComponent(String(input.id))}` };
|
|
614
|
+
const body = {};
|
|
615
|
+
if (input.name !== undefined)
|
|
616
|
+
body["name"] = input.name;
|
|
617
|
+
if (input.statusId !== undefined)
|
|
618
|
+
body["statusId"] = input.statusId;
|
|
619
|
+
if (input.description !== undefined)
|
|
620
|
+
body["description"] = input.description;
|
|
621
|
+
if (input.projectPlatformId !== undefined)
|
|
622
|
+
body["projectPlatformId"] = input.projectPlatformId;
|
|
623
|
+
if (input.environmentId !== undefined)
|
|
624
|
+
body["environmentId"] = input.environmentId;
|
|
625
|
+
if (input.type !== undefined)
|
|
626
|
+
body["type"] = input.type;
|
|
627
|
+
if (input.priority !== undefined)
|
|
628
|
+
body["priority"] = input.priority;
|
|
629
|
+
if (input.assignedTo !== undefined)
|
|
630
|
+
body["assignedTo"] = input.assignedTo;
|
|
631
|
+
if (input.folderId !== undefined)
|
|
632
|
+
body["folderId"] = input.folderId;
|
|
633
|
+
req.body = body;
|
|
634
|
+
return req;
|
|
635
|
+
},
|
|
636
|
+
},
|
|
637
|
+
{
|
|
638
|
+
name: "cycle_folders_create",
|
|
639
|
+
description: "Create cycle folder\n\nTag: Cycle Folders",
|
|
640
|
+
inputSchema: {
|
|
641
|
+
"type": "object",
|
|
642
|
+
"properties": {
|
|
643
|
+
"name": {
|
|
644
|
+
"type": "string"
|
|
645
|
+
},
|
|
646
|
+
"projectId": {
|
|
647
|
+
"type": "string",
|
|
648
|
+
"format": "uuid"
|
|
649
|
+
},
|
|
650
|
+
"parentId": {
|
|
651
|
+
"type": "string",
|
|
652
|
+
"format": "uuid"
|
|
653
|
+
},
|
|
654
|
+
"order": {
|
|
655
|
+
"type": "integer"
|
|
656
|
+
}
|
|
657
|
+
},
|
|
658
|
+
"additionalProperties": false,
|
|
659
|
+
"required": [
|
|
660
|
+
"name",
|
|
661
|
+
"projectId"
|
|
662
|
+
]
|
|
663
|
+
},
|
|
664
|
+
request: (input) => {
|
|
665
|
+
const req = { method: "POST", path: "/v1/cycle-folders" };
|
|
666
|
+
const body = {};
|
|
667
|
+
if (input.name !== undefined)
|
|
668
|
+
body["name"] = input.name;
|
|
669
|
+
if (input.projectId !== undefined)
|
|
670
|
+
body["projectId"] = input.projectId;
|
|
671
|
+
if (input.parentId !== undefined)
|
|
672
|
+
body["parentId"] = input.parentId;
|
|
673
|
+
if (input.order !== undefined)
|
|
674
|
+
body["order"] = input.order;
|
|
675
|
+
req.body = body;
|
|
676
|
+
return req;
|
|
677
|
+
},
|
|
678
|
+
},
|
|
679
|
+
{
|
|
680
|
+
name: "cycle_folders_delete",
|
|
681
|
+
description: "Delete cycle folder\n\nTag: Cycle Folders",
|
|
682
|
+
inputSchema: {
|
|
683
|
+
"type": "object",
|
|
684
|
+
"properties": {
|
|
685
|
+
"id": {
|
|
686
|
+
"type": "string",
|
|
687
|
+
"format": "uuid",
|
|
688
|
+
"description": "Cycle Folder ID"
|
|
689
|
+
}
|
|
690
|
+
},
|
|
691
|
+
"additionalProperties": false,
|
|
692
|
+
"required": [
|
|
693
|
+
"id"
|
|
694
|
+
]
|
|
695
|
+
},
|
|
696
|
+
request: (input) => {
|
|
697
|
+
const req = { method: "DELETE", path: `/v1/cycle-folders/${encodeURIComponent(String(input.id))}` };
|
|
698
|
+
return req;
|
|
699
|
+
},
|
|
700
|
+
},
|
|
701
|
+
{
|
|
702
|
+
name: "cycle_folders_get",
|
|
703
|
+
description: "Get cycle folder by ID\n\nTag: Cycle Folders",
|
|
704
|
+
inputSchema: {
|
|
705
|
+
"type": "object",
|
|
706
|
+
"properties": {
|
|
707
|
+
"id": {
|
|
708
|
+
"type": "string",
|
|
709
|
+
"format": "uuid",
|
|
710
|
+
"description": "Cycle Folder ID"
|
|
711
|
+
}
|
|
712
|
+
},
|
|
713
|
+
"additionalProperties": false,
|
|
714
|
+
"required": [
|
|
715
|
+
"id"
|
|
716
|
+
]
|
|
717
|
+
},
|
|
718
|
+
request: (input) => {
|
|
719
|
+
const req = { method: "GET", path: `/v1/cycle-folders/${encodeURIComponent(String(input.id))}` };
|
|
720
|
+
return req;
|
|
721
|
+
},
|
|
722
|
+
},
|
|
723
|
+
{
|
|
724
|
+
name: "cycle_folders_list",
|
|
725
|
+
description: "List cycle folders\n\nTag: Cycle Folders",
|
|
726
|
+
inputSchema: {
|
|
727
|
+
"type": "object",
|
|
728
|
+
"properties": {
|
|
729
|
+
"projectId": {
|
|
730
|
+
"type": "string",
|
|
731
|
+
"format": "uuid",
|
|
732
|
+
"description": "Filter folders by project"
|
|
733
|
+
},
|
|
734
|
+
"parentId": {
|
|
735
|
+
"type": "string",
|
|
736
|
+
"format": "uuid",
|
|
737
|
+
"description": "Filter by parent folder"
|
|
738
|
+
}
|
|
739
|
+
},
|
|
740
|
+
"additionalProperties": false,
|
|
741
|
+
"required": [
|
|
742
|
+
"projectId"
|
|
743
|
+
]
|
|
744
|
+
},
|
|
745
|
+
request: (input) => {
|
|
746
|
+
const req = { method: "GET", path: "/v1/cycle-folders" };
|
|
747
|
+
const query = {};
|
|
748
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
749
|
+
query["projectId"] = String(input.projectId);
|
|
750
|
+
if (input.parentId !== undefined && input.parentId !== null)
|
|
751
|
+
query["parentId"] = String(input.parentId);
|
|
752
|
+
if (Object.keys(query).length > 0)
|
|
753
|
+
req.query = query;
|
|
754
|
+
return req;
|
|
755
|
+
},
|
|
756
|
+
},
|
|
757
|
+
{
|
|
758
|
+
name: "cycle_folders_update",
|
|
759
|
+
description: "Update cycle folder\n\nTag: Cycle Folders",
|
|
760
|
+
inputSchema: {
|
|
761
|
+
"type": "object",
|
|
762
|
+
"properties": {
|
|
763
|
+
"id": {
|
|
764
|
+
"type": "string",
|
|
765
|
+
"format": "uuid",
|
|
766
|
+
"description": "Cycle Folder ID"
|
|
767
|
+
},
|
|
768
|
+
"name": {
|
|
769
|
+
"type": "string"
|
|
770
|
+
},
|
|
771
|
+
"parentId": {
|
|
772
|
+
"type": [
|
|
773
|
+
"string",
|
|
774
|
+
"null"
|
|
775
|
+
],
|
|
776
|
+
"format": "uuid"
|
|
777
|
+
},
|
|
778
|
+
"order": {
|
|
779
|
+
"type": "integer"
|
|
780
|
+
}
|
|
781
|
+
},
|
|
782
|
+
"additionalProperties": false,
|
|
783
|
+
"required": [
|
|
784
|
+
"id"
|
|
785
|
+
]
|
|
786
|
+
},
|
|
787
|
+
request: (input) => {
|
|
788
|
+
const req = { method: "PATCH", path: `/v1/cycle-folders/${encodeURIComponent(String(input.id))}` };
|
|
789
|
+
const body = {};
|
|
790
|
+
if (input.name !== undefined)
|
|
791
|
+
body["name"] = input.name;
|
|
792
|
+
if (input.parentId !== undefined)
|
|
793
|
+
body["parentId"] = input.parentId;
|
|
794
|
+
if (input.order !== undefined)
|
|
795
|
+
body["order"] = input.order;
|
|
796
|
+
req.body = body;
|
|
797
|
+
return req;
|
|
798
|
+
},
|
|
799
|
+
},
|
|
800
|
+
{
|
|
801
|
+
name: "cycle_statuses_list",
|
|
802
|
+
description: "List all cycle statuses\n\nTag: Cycle Statuses",
|
|
803
|
+
inputSchema: {
|
|
804
|
+
"type": "object",
|
|
805
|
+
"properties": {},
|
|
806
|
+
"additionalProperties": false
|
|
807
|
+
},
|
|
808
|
+
request: (input) => {
|
|
809
|
+
const req = { method: "GET", path: "/v1/cycle-statuses" };
|
|
810
|
+
return req;
|
|
811
|
+
},
|
|
812
|
+
},
|
|
813
|
+
{
|
|
814
|
+
name: "cycles_create",
|
|
815
|
+
description: "Create cycle\n\nTag: Cycles",
|
|
816
|
+
inputSchema: {
|
|
817
|
+
"type": "object",
|
|
818
|
+
"properties": {
|
|
819
|
+
"name": {
|
|
820
|
+
"type": "string"
|
|
821
|
+
},
|
|
822
|
+
"projectId": {
|
|
823
|
+
"type": "string",
|
|
824
|
+
"format": "uuid"
|
|
825
|
+
},
|
|
826
|
+
"description": {
|
|
827
|
+
"type": "string"
|
|
828
|
+
},
|
|
829
|
+
"statusId": {
|
|
830
|
+
"type": "string",
|
|
831
|
+
"format": "uuid"
|
|
832
|
+
},
|
|
833
|
+
"folderId": {
|
|
834
|
+
"type": "string",
|
|
835
|
+
"format": "uuid"
|
|
836
|
+
},
|
|
837
|
+
"startAt": {
|
|
838
|
+
"type": "string",
|
|
839
|
+
"format": "date-time"
|
|
840
|
+
},
|
|
841
|
+
"endAt": {
|
|
842
|
+
"type": "string",
|
|
843
|
+
"format": "date-time"
|
|
844
|
+
},
|
|
845
|
+
"type": {
|
|
846
|
+
"type": "string",
|
|
847
|
+
"enum": [
|
|
848
|
+
"MANY",
|
|
849
|
+
"ONE"
|
|
850
|
+
]
|
|
851
|
+
},
|
|
852
|
+
"observations": {
|
|
853
|
+
"type": "string"
|
|
854
|
+
}
|
|
855
|
+
},
|
|
856
|
+
"additionalProperties": false,
|
|
857
|
+
"required": [
|
|
858
|
+
"name",
|
|
859
|
+
"projectId"
|
|
860
|
+
]
|
|
861
|
+
},
|
|
862
|
+
request: (input) => {
|
|
863
|
+
const req = { method: "POST", path: "/v1/cycles" };
|
|
864
|
+
const body = {};
|
|
865
|
+
if (input.name !== undefined)
|
|
866
|
+
body["name"] = input.name;
|
|
867
|
+
if (input.projectId !== undefined)
|
|
868
|
+
body["projectId"] = input.projectId;
|
|
869
|
+
if (input.description !== undefined)
|
|
870
|
+
body["description"] = input.description;
|
|
871
|
+
if (input.statusId !== undefined)
|
|
872
|
+
body["statusId"] = input.statusId;
|
|
873
|
+
if (input.folderId !== undefined)
|
|
874
|
+
body["folderId"] = input.folderId;
|
|
875
|
+
if (input.startAt !== undefined)
|
|
876
|
+
body["startAt"] = input.startAt;
|
|
877
|
+
if (input.endAt !== undefined)
|
|
878
|
+
body["endAt"] = input.endAt;
|
|
879
|
+
if (input.type !== undefined)
|
|
880
|
+
body["type"] = input.type;
|
|
881
|
+
if (input.observations !== undefined)
|
|
882
|
+
body["observations"] = input.observations;
|
|
883
|
+
req.body = body;
|
|
884
|
+
return req;
|
|
885
|
+
},
|
|
886
|
+
},
|
|
887
|
+
{
|
|
888
|
+
name: "cycles_delete",
|
|
889
|
+
description: "Delete cycle\n\nTag: Cycles",
|
|
890
|
+
inputSchema: {
|
|
891
|
+
"type": "object",
|
|
892
|
+
"properties": {
|
|
893
|
+
"id": {
|
|
894
|
+
"type": "string",
|
|
895
|
+
"format": "uuid",
|
|
896
|
+
"description": "Cycle ID"
|
|
897
|
+
}
|
|
898
|
+
},
|
|
899
|
+
"additionalProperties": false,
|
|
900
|
+
"required": [
|
|
901
|
+
"id"
|
|
902
|
+
]
|
|
903
|
+
},
|
|
904
|
+
request: (input) => {
|
|
905
|
+
const req = { method: "DELETE", path: `/v1/cycles/${encodeURIComponent(String(input.id))}` };
|
|
906
|
+
return req;
|
|
907
|
+
},
|
|
908
|
+
},
|
|
909
|
+
{
|
|
910
|
+
name: "cycles_get",
|
|
911
|
+
description: "Get cycle by ID\n\nTag: Cycles",
|
|
912
|
+
inputSchema: {
|
|
913
|
+
"type": "object",
|
|
914
|
+
"properties": {
|
|
915
|
+
"id": {
|
|
916
|
+
"type": "string",
|
|
917
|
+
"format": "uuid",
|
|
918
|
+
"description": "Cycle ID"
|
|
919
|
+
}
|
|
920
|
+
},
|
|
921
|
+
"additionalProperties": false,
|
|
922
|
+
"required": [
|
|
923
|
+
"id"
|
|
924
|
+
]
|
|
925
|
+
},
|
|
926
|
+
request: (input) => {
|
|
927
|
+
const req = { method: "GET", path: `/v1/cycles/${encodeURIComponent(String(input.id))}` };
|
|
928
|
+
return req;
|
|
929
|
+
},
|
|
930
|
+
},
|
|
931
|
+
{
|
|
932
|
+
name: "cycles_list",
|
|
933
|
+
description: "List cycles\n\nTag: Cycles\n\nAt least one query parameter is required: **projectId** or **folderId**.",
|
|
934
|
+
inputSchema: {
|
|
935
|
+
"type": "object",
|
|
936
|
+
"properties": {
|
|
937
|
+
"projectId": {
|
|
938
|
+
"type": "string",
|
|
939
|
+
"format": "uuid",
|
|
940
|
+
"description": "Filter by project. At least one of projectId or folderId is required."
|
|
941
|
+
},
|
|
942
|
+
"folderId": {
|
|
943
|
+
"type": "string",
|
|
944
|
+
"format": "uuid",
|
|
945
|
+
"description": "Filter by folder. At least one of projectId or folderId is required."
|
|
946
|
+
}
|
|
947
|
+
},
|
|
948
|
+
"additionalProperties": false
|
|
949
|
+
},
|
|
950
|
+
request: (input) => {
|
|
951
|
+
const req = { method: "GET", path: "/v1/cycles" };
|
|
952
|
+
const query = {};
|
|
953
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
954
|
+
query["projectId"] = String(input.projectId);
|
|
955
|
+
if (input.folderId !== undefined && input.folderId !== null)
|
|
956
|
+
query["folderId"] = String(input.folderId);
|
|
957
|
+
if (Object.keys(query).length > 0)
|
|
958
|
+
req.query = query;
|
|
959
|
+
return req;
|
|
960
|
+
},
|
|
961
|
+
},
|
|
962
|
+
{
|
|
963
|
+
name: "cycles_update",
|
|
964
|
+
description: "Update cycle\n\nTag: Cycles",
|
|
965
|
+
inputSchema: {
|
|
966
|
+
"type": "object",
|
|
967
|
+
"properties": {
|
|
968
|
+
"id": {
|
|
969
|
+
"type": "string",
|
|
970
|
+
"format": "uuid",
|
|
971
|
+
"description": "Cycle ID"
|
|
972
|
+
},
|
|
973
|
+
"name": {
|
|
974
|
+
"type": "string"
|
|
975
|
+
},
|
|
976
|
+
"description": {
|
|
977
|
+
"type": [
|
|
978
|
+
"string",
|
|
979
|
+
"null"
|
|
980
|
+
]
|
|
981
|
+
},
|
|
982
|
+
"statusId": {
|
|
983
|
+
"type": "string",
|
|
984
|
+
"format": "uuid"
|
|
985
|
+
},
|
|
986
|
+
"folderId": {
|
|
987
|
+
"type": [
|
|
988
|
+
"string",
|
|
989
|
+
"null"
|
|
990
|
+
],
|
|
991
|
+
"format": "uuid"
|
|
992
|
+
},
|
|
993
|
+
"startAt": {
|
|
994
|
+
"type": [
|
|
995
|
+
"string",
|
|
996
|
+
"null"
|
|
997
|
+
],
|
|
998
|
+
"format": "date-time"
|
|
999
|
+
},
|
|
1000
|
+
"endAt": {
|
|
1001
|
+
"type": [
|
|
1002
|
+
"string",
|
|
1003
|
+
"null"
|
|
1004
|
+
],
|
|
1005
|
+
"format": "date-time"
|
|
1006
|
+
},
|
|
1007
|
+
"type": {
|
|
1008
|
+
"type": "string",
|
|
1009
|
+
"enum": [
|
|
1010
|
+
"MANY",
|
|
1011
|
+
"ONE"
|
|
1012
|
+
]
|
|
1013
|
+
},
|
|
1014
|
+
"observations": {
|
|
1015
|
+
"type": [
|
|
1016
|
+
"string",
|
|
1017
|
+
"null"
|
|
1018
|
+
]
|
|
1019
|
+
}
|
|
1020
|
+
},
|
|
1021
|
+
"additionalProperties": false,
|
|
1022
|
+
"required": [
|
|
1023
|
+
"id"
|
|
1024
|
+
]
|
|
1025
|
+
},
|
|
1026
|
+
request: (input) => {
|
|
1027
|
+
const req = { method: "PATCH", path: `/v1/cycles/${encodeURIComponent(String(input.id))}` };
|
|
1028
|
+
const body = {};
|
|
1029
|
+
if (input.name !== undefined)
|
|
1030
|
+
body["name"] = input.name;
|
|
1031
|
+
if (input.description !== undefined)
|
|
1032
|
+
body["description"] = input.description;
|
|
1033
|
+
if (input.statusId !== undefined)
|
|
1034
|
+
body["statusId"] = input.statusId;
|
|
1035
|
+
if (input.folderId !== undefined)
|
|
1036
|
+
body["folderId"] = input.folderId;
|
|
1037
|
+
if (input.startAt !== undefined)
|
|
1038
|
+
body["startAt"] = input.startAt;
|
|
1039
|
+
if (input.endAt !== undefined)
|
|
1040
|
+
body["endAt"] = input.endAt;
|
|
1041
|
+
if (input.type !== undefined)
|
|
1042
|
+
body["type"] = input.type;
|
|
1043
|
+
if (input.observations !== undefined)
|
|
1044
|
+
body["observations"] = input.observations;
|
|
1045
|
+
req.body = body;
|
|
1046
|
+
return req;
|
|
1047
|
+
},
|
|
1048
|
+
},
|
|
1049
|
+
{
|
|
1050
|
+
name: "executions_attachments_create",
|
|
1051
|
+
description: "Create execution attachment (returns presigned upload URL)\n\nTag: Execution Attachments\n\nCria o registro do anexo (uploaded=false) e retorna uma presigned URL S3 (PUT, 300s). Faça o PUT do arquivo na `uploadUrl` e depois confirme com PATCH /v1/executions/:id/attachments/:attachmentId.",
|
|
1052
|
+
inputSchema: {
|
|
1053
|
+
"type": "object",
|
|
1054
|
+
"properties": {
|
|
1055
|
+
"id": {
|
|
1056
|
+
"type": "string",
|
|
1057
|
+
"format": "uuid",
|
|
1058
|
+
"description": "Execution ID"
|
|
1059
|
+
},
|
|
1060
|
+
"fileName": {
|
|
1061
|
+
"type": "string"
|
|
1062
|
+
},
|
|
1063
|
+
"size": {
|
|
1064
|
+
"type": "integer",
|
|
1065
|
+
"description": "Tamanho em bytes"
|
|
1066
|
+
},
|
|
1067
|
+
"type": {
|
|
1068
|
+
"type": "string",
|
|
1069
|
+
"description": "MIME type"
|
|
1070
|
+
},
|
|
1071
|
+
"md5": {
|
|
1072
|
+
"type": "string"
|
|
1073
|
+
}
|
|
1074
|
+
},
|
|
1075
|
+
"additionalProperties": false,
|
|
1076
|
+
"required": [
|
|
1077
|
+
"id",
|
|
1078
|
+
"fileName",
|
|
1079
|
+
"size",
|
|
1080
|
+
"type",
|
|
1081
|
+
"md5"
|
|
1082
|
+
]
|
|
1083
|
+
},
|
|
1084
|
+
request: (input) => {
|
|
1085
|
+
const req = { method: "POST", path: `/v1/executions/${encodeURIComponent(String(input.id))}/attachments` };
|
|
1086
|
+
const body = {};
|
|
1087
|
+
if (input.fileName !== undefined)
|
|
1088
|
+
body["fileName"] = input.fileName;
|
|
1089
|
+
if (input.size !== undefined)
|
|
1090
|
+
body["size"] = input.size;
|
|
1091
|
+
if (input.type !== undefined)
|
|
1092
|
+
body["type"] = input.type;
|
|
1093
|
+
if (input.md5 !== undefined)
|
|
1094
|
+
body["md5"] = input.md5;
|
|
1095
|
+
req.body = body;
|
|
1096
|
+
return req;
|
|
1097
|
+
},
|
|
1098
|
+
},
|
|
1099
|
+
{
|
|
1100
|
+
name: "executions_attachments_delete",
|
|
1101
|
+
description: "Delete execution attachment\n\nTag: Execution Attachments\n\nRemove o anexo (registro + arquivo no S3).",
|
|
1102
|
+
inputSchema: {
|
|
1103
|
+
"type": "object",
|
|
1104
|
+
"properties": {
|
|
1105
|
+
"id": {
|
|
1106
|
+
"type": "string",
|
|
1107
|
+
"format": "uuid",
|
|
1108
|
+
"description": "Execution ID"
|
|
1109
|
+
},
|
|
1110
|
+
"attachmentId": {
|
|
1111
|
+
"type": "string",
|
|
1112
|
+
"format": "uuid",
|
|
1113
|
+
"description": "Attachment ID"
|
|
1114
|
+
}
|
|
1115
|
+
},
|
|
1116
|
+
"additionalProperties": false,
|
|
1117
|
+
"required": [
|
|
1118
|
+
"id",
|
|
1119
|
+
"attachmentId"
|
|
1120
|
+
]
|
|
1121
|
+
},
|
|
1122
|
+
request: (input) => {
|
|
1123
|
+
const req = { method: "DELETE", path: `/v1/executions/${encodeURIComponent(String(input.id))}/attachments/${encodeURIComponent(String(input.attachmentId))}` };
|
|
1124
|
+
return req;
|
|
1125
|
+
},
|
|
1126
|
+
},
|
|
1127
|
+
{
|
|
1128
|
+
name: "executions_attachments_list",
|
|
1129
|
+
description: "List execution attachments\n\nTag: Execution Attachments\n\nLista os anexos da execução. Itens com `uploaded=true` trazem `downloadUrl` (presigned, 300s).",
|
|
1130
|
+
inputSchema: {
|
|
1131
|
+
"type": "object",
|
|
1132
|
+
"properties": {
|
|
1133
|
+
"id": {
|
|
1134
|
+
"type": "string",
|
|
1135
|
+
"format": "uuid",
|
|
1136
|
+
"description": "Execution ID"
|
|
1137
|
+
}
|
|
1138
|
+
},
|
|
1139
|
+
"additionalProperties": false,
|
|
1140
|
+
"required": [
|
|
1141
|
+
"id"
|
|
1142
|
+
]
|
|
1143
|
+
},
|
|
1144
|
+
request: (input) => {
|
|
1145
|
+
const req = { method: "GET", path: `/v1/executions/${encodeURIComponent(String(input.id))}/attachments` };
|
|
1146
|
+
return req;
|
|
1147
|
+
},
|
|
1148
|
+
},
|
|
1149
|
+
{
|
|
1150
|
+
name: "executions_attachments_update",
|
|
1151
|
+
description: "Confirm execution attachment upload\n\nTag: Execution Attachments\n\nMarca o anexo como enviado (`uploaded=true`) após o PUT no S3.",
|
|
1152
|
+
inputSchema: {
|
|
1153
|
+
"type": "object",
|
|
1154
|
+
"properties": {
|
|
1155
|
+
"id": {
|
|
1156
|
+
"type": "string",
|
|
1157
|
+
"format": "uuid",
|
|
1158
|
+
"description": "Execution ID"
|
|
1159
|
+
},
|
|
1160
|
+
"attachmentId": {
|
|
1161
|
+
"type": "string",
|
|
1162
|
+
"format": "uuid",
|
|
1163
|
+
"description": "Attachment ID"
|
|
1164
|
+
}
|
|
1165
|
+
},
|
|
1166
|
+
"additionalProperties": false,
|
|
1167
|
+
"required": [
|
|
1168
|
+
"id",
|
|
1169
|
+
"attachmentId"
|
|
1170
|
+
]
|
|
1171
|
+
},
|
|
1172
|
+
request: (input) => {
|
|
1173
|
+
const req = { method: "PATCH", path: `/v1/executions/${encodeURIComponent(String(input.id))}/attachments/${encodeURIComponent(String(input.attachmentId))}` };
|
|
1174
|
+
return req;
|
|
1175
|
+
},
|
|
1176
|
+
},
|
|
1177
|
+
{
|
|
1178
|
+
name: "executions_create",
|
|
1179
|
+
description: "Create execution\n\nTag: Executions\n\nThe `state` field is system-managed and is silently ignored if sent in the body. Use `/v1/executions-run`, `/v1/executions-pause` and `/v1/executions-finish` to drive transitions.",
|
|
1180
|
+
inputSchema: {
|
|
1181
|
+
"type": "object",
|
|
1182
|
+
"properties": {
|
|
1183
|
+
"testsCycleId": {
|
|
1184
|
+
"type": "string",
|
|
1185
|
+
"format": "uuid"
|
|
1186
|
+
},
|
|
1187
|
+
"testCaseId": {
|
|
1188
|
+
"type": "string",
|
|
1189
|
+
"format": "uuid"
|
|
1190
|
+
},
|
|
1191
|
+
"projectId": {
|
|
1192
|
+
"type": "string",
|
|
1193
|
+
"format": "uuid"
|
|
1194
|
+
},
|
|
1195
|
+
"projectPlatformId": {
|
|
1196
|
+
"type": "string",
|
|
1197
|
+
"format": "uuid"
|
|
1198
|
+
},
|
|
1199
|
+
"expectedResult": {
|
|
1200
|
+
"type": "string"
|
|
1201
|
+
},
|
|
1202
|
+
"observation": {
|
|
1203
|
+
"type": "string"
|
|
1204
|
+
},
|
|
1205
|
+
"assignedTo": {
|
|
1206
|
+
"type": "string",
|
|
1207
|
+
"format": "uuid"
|
|
1208
|
+
},
|
|
1209
|
+
"statusId": {
|
|
1210
|
+
"type": "string",
|
|
1211
|
+
"format": "uuid"
|
|
1212
|
+
},
|
|
1213
|
+
"order": {
|
|
1214
|
+
"type": "integer"
|
|
1215
|
+
}
|
|
1216
|
+
},
|
|
1217
|
+
"additionalProperties": false,
|
|
1218
|
+
"required": [
|
|
1219
|
+
"testsCycleId",
|
|
1220
|
+
"testCaseId",
|
|
1221
|
+
"projectId"
|
|
1222
|
+
]
|
|
1223
|
+
},
|
|
1224
|
+
request: (input) => {
|
|
1225
|
+
const req = { method: "POST", path: "/v1/executions" };
|
|
1226
|
+
const body = {};
|
|
1227
|
+
if (input.testsCycleId !== undefined)
|
|
1228
|
+
body["testsCycleId"] = input.testsCycleId;
|
|
1229
|
+
if (input.testCaseId !== undefined)
|
|
1230
|
+
body["testCaseId"] = input.testCaseId;
|
|
1231
|
+
if (input.projectId !== undefined)
|
|
1232
|
+
body["projectId"] = input.projectId;
|
|
1233
|
+
if (input.projectPlatformId !== undefined)
|
|
1234
|
+
body["projectPlatformId"] = input.projectPlatformId;
|
|
1235
|
+
if (input.expectedResult !== undefined)
|
|
1236
|
+
body["expectedResult"] = input.expectedResult;
|
|
1237
|
+
if (input.observation !== undefined)
|
|
1238
|
+
body["observation"] = input.observation;
|
|
1239
|
+
if (input.assignedTo !== undefined)
|
|
1240
|
+
body["assignedTo"] = input.assignedTo;
|
|
1241
|
+
if (input.statusId !== undefined)
|
|
1242
|
+
body["statusId"] = input.statusId;
|
|
1243
|
+
if (input.order !== undefined)
|
|
1244
|
+
body["order"] = input.order;
|
|
1245
|
+
req.body = body;
|
|
1246
|
+
return req;
|
|
1247
|
+
},
|
|
1248
|
+
},
|
|
1249
|
+
{
|
|
1250
|
+
name: "executions_delete",
|
|
1251
|
+
description: "Delete execution\n\nTag: Executions",
|
|
1252
|
+
inputSchema: {
|
|
1253
|
+
"type": "object",
|
|
1254
|
+
"properties": {
|
|
1255
|
+
"id": {
|
|
1256
|
+
"type": "string",
|
|
1257
|
+
"format": "uuid",
|
|
1258
|
+
"description": "Execution ID"
|
|
1259
|
+
}
|
|
1260
|
+
},
|
|
1261
|
+
"additionalProperties": false,
|
|
1262
|
+
"required": [
|
|
1263
|
+
"id"
|
|
1264
|
+
]
|
|
1265
|
+
},
|
|
1266
|
+
request: (input) => {
|
|
1267
|
+
const req = { method: "DELETE", path: `/v1/executions/${encodeURIComponent(String(input.id))}` };
|
|
1268
|
+
return req;
|
|
1269
|
+
},
|
|
1270
|
+
},
|
|
1271
|
+
{
|
|
1272
|
+
name: "executions_finish",
|
|
1273
|
+
description: "Finish an execution\n\nTag: Executions\n\nSets the execution state to `DONE` and records `executedAt` and `executedBy`. Allowed only when the current state is `IN_PROGRESS` — returns 400 for `WAITING`, `PAUSED` or `DONE`, when its parent tests cycle is `FINISHED`, or when the execution's `statusId` is still \"Em aberto\" (`NOT_EXECUTED`) — a verdict must be set first.",
|
|
1274
|
+
inputSchema: {
|
|
1275
|
+
"type": "object",
|
|
1276
|
+
"properties": {
|
|
1277
|
+
"id": {
|
|
1278
|
+
"type": "string",
|
|
1279
|
+
"format": "uuid"
|
|
1280
|
+
}
|
|
1281
|
+
},
|
|
1282
|
+
"additionalProperties": false,
|
|
1283
|
+
"required": [
|
|
1284
|
+
"id"
|
|
1285
|
+
]
|
|
1286
|
+
},
|
|
1287
|
+
request: (input) => {
|
|
1288
|
+
const req = { method: "POST", path: "/v1/executions-finish" };
|
|
1289
|
+
const body = {};
|
|
1290
|
+
if (input.id !== undefined)
|
|
1291
|
+
body["id"] = input.id;
|
|
1292
|
+
req.body = body;
|
|
1293
|
+
return req;
|
|
1294
|
+
},
|
|
1295
|
+
},
|
|
1296
|
+
{
|
|
1297
|
+
name: "executions_get",
|
|
1298
|
+
description: "Get execution by ID\n\nTag: Executions",
|
|
1299
|
+
inputSchema: {
|
|
1300
|
+
"type": "object",
|
|
1301
|
+
"properties": {
|
|
1302
|
+
"id": {
|
|
1303
|
+
"type": "string",
|
|
1304
|
+
"format": "uuid",
|
|
1305
|
+
"description": "Execution ID"
|
|
1306
|
+
}
|
|
1307
|
+
},
|
|
1308
|
+
"additionalProperties": false,
|
|
1309
|
+
"required": [
|
|
1310
|
+
"id"
|
|
1311
|
+
]
|
|
1312
|
+
},
|
|
1313
|
+
request: (input) => {
|
|
1314
|
+
const req = { method: "GET", path: `/v1/executions/${encodeURIComponent(String(input.id))}` };
|
|
1315
|
+
return req;
|
|
1316
|
+
},
|
|
1317
|
+
},
|
|
1318
|
+
{
|
|
1319
|
+
name: "executions_list",
|
|
1320
|
+
description: "List executions\n\nTag: Executions",
|
|
1321
|
+
inputSchema: {
|
|
1322
|
+
"type": "object",
|
|
1323
|
+
"properties": {
|
|
1324
|
+
"testCaseId": {
|
|
1325
|
+
"type": "string",
|
|
1326
|
+
"format": "uuid",
|
|
1327
|
+
"description": "Filter by test case."
|
|
1328
|
+
},
|
|
1329
|
+
"testsCycleId": {
|
|
1330
|
+
"type": "string",
|
|
1331
|
+
"format": "uuid",
|
|
1332
|
+
"description": "Filter by tests cycle."
|
|
1333
|
+
},
|
|
1334
|
+
"projectId": {
|
|
1335
|
+
"type": "string",
|
|
1336
|
+
"format": "uuid",
|
|
1337
|
+
"description": "Filter by project."
|
|
1338
|
+
}
|
|
1339
|
+
},
|
|
1340
|
+
"additionalProperties": false
|
|
1341
|
+
},
|
|
1342
|
+
request: (input) => {
|
|
1343
|
+
const req = { method: "GET", path: "/v1/executions" };
|
|
1344
|
+
const query = {};
|
|
1345
|
+
if (input.testCaseId !== undefined && input.testCaseId !== null)
|
|
1346
|
+
query["testCaseId"] = String(input.testCaseId);
|
|
1347
|
+
if (input.testsCycleId !== undefined && input.testsCycleId !== null)
|
|
1348
|
+
query["testsCycleId"] = String(input.testsCycleId);
|
|
1349
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
1350
|
+
query["projectId"] = String(input.projectId);
|
|
1351
|
+
if (Object.keys(query).length > 0)
|
|
1352
|
+
req.query = query;
|
|
1353
|
+
return req;
|
|
1354
|
+
},
|
|
1355
|
+
},
|
|
1356
|
+
{
|
|
1357
|
+
name: "executions_pause",
|
|
1358
|
+
description: "Pause an execution\n\nTag: Executions\n\nSets the execution state to `PAUSED`. Allowed only when the current state is `IN_PROGRESS` — returns 400 for `WAITING`, `PAUSED` or `DONE`, or when its parent tests cycle is `FINISHED`.",
|
|
1359
|
+
inputSchema: {
|
|
1360
|
+
"type": "object",
|
|
1361
|
+
"properties": {
|
|
1362
|
+
"id": {
|
|
1363
|
+
"type": "string",
|
|
1364
|
+
"format": "uuid"
|
|
1365
|
+
}
|
|
1366
|
+
},
|
|
1367
|
+
"additionalProperties": false,
|
|
1368
|
+
"required": [
|
|
1369
|
+
"id"
|
|
1370
|
+
]
|
|
1371
|
+
},
|
|
1372
|
+
request: (input) => {
|
|
1373
|
+
const req = { method: "POST", path: "/v1/executions-pause" };
|
|
1374
|
+
const body = {};
|
|
1375
|
+
if (input.id !== undefined)
|
|
1376
|
+
body["id"] = input.id;
|
|
1377
|
+
req.body = body;
|
|
1378
|
+
return req;
|
|
1379
|
+
},
|
|
1380
|
+
},
|
|
1381
|
+
{
|
|
1382
|
+
name: "executions_run",
|
|
1383
|
+
description: "Start running an execution\n\nTag: Executions\n\nSets the execution state to `IN_PROGRESS`. Allowed only when the current state is `WAITING` or `PAUSED`. Returns 400 when the execution is already `IN_PROGRESS` or `DONE`, or when its parent tests cycle is `FINISHED`.",
|
|
1384
|
+
inputSchema: {
|
|
1385
|
+
"type": "object",
|
|
1386
|
+
"properties": {
|
|
1387
|
+
"id": {
|
|
1388
|
+
"type": "string",
|
|
1389
|
+
"format": "uuid"
|
|
1390
|
+
}
|
|
1391
|
+
},
|
|
1392
|
+
"additionalProperties": false,
|
|
1393
|
+
"required": [
|
|
1394
|
+
"id"
|
|
1395
|
+
]
|
|
1396
|
+
},
|
|
1397
|
+
request: (input) => {
|
|
1398
|
+
const req = { method: "POST", path: "/v1/executions-run" };
|
|
1399
|
+
const body = {};
|
|
1400
|
+
if (input.id !== undefined)
|
|
1401
|
+
body["id"] = input.id;
|
|
1402
|
+
req.body = body;
|
|
1403
|
+
return req;
|
|
1404
|
+
},
|
|
1405
|
+
},
|
|
1406
|
+
{
|
|
1407
|
+
name: "executions_update",
|
|
1408
|
+
description: "Update execution\n\nTag: Executions\n\nExecutions in `state: DONE` are read-only and cannot be updated through this endpoint (public V1 only — the internal API does not enforce this guard). The `state` field itself is system-managed and is silently ignored if sent in the body — use `/v1/executions-run`, `/v1/executions-pause` and `/v1/executions-finish` instead.",
|
|
1409
|
+
inputSchema: {
|
|
1410
|
+
"type": "object",
|
|
1411
|
+
"properties": {
|
|
1412
|
+
"id": {
|
|
1413
|
+
"type": "string",
|
|
1414
|
+
"format": "uuid",
|
|
1415
|
+
"description": "Execution ID"
|
|
1416
|
+
},
|
|
1417
|
+
"projectPlatformId": {
|
|
1418
|
+
"type": [
|
|
1419
|
+
"string",
|
|
1420
|
+
"null"
|
|
1421
|
+
],
|
|
1422
|
+
"format": "uuid"
|
|
1423
|
+
},
|
|
1424
|
+
"expectedResult": {
|
|
1425
|
+
"type": [
|
|
1426
|
+
"string",
|
|
1427
|
+
"null"
|
|
1428
|
+
]
|
|
1429
|
+
},
|
|
1430
|
+
"observation": {
|
|
1431
|
+
"type": [
|
|
1432
|
+
"string",
|
|
1433
|
+
"null"
|
|
1434
|
+
]
|
|
1435
|
+
},
|
|
1436
|
+
"assignedTo": {
|
|
1437
|
+
"type": [
|
|
1438
|
+
"string",
|
|
1439
|
+
"null"
|
|
1440
|
+
],
|
|
1441
|
+
"format": "uuid"
|
|
1442
|
+
},
|
|
1443
|
+
"statusId": {
|
|
1444
|
+
"type": "string",
|
|
1445
|
+
"format": "uuid"
|
|
1446
|
+
},
|
|
1447
|
+
"order": {
|
|
1448
|
+
"type": "integer"
|
|
1449
|
+
}
|
|
1450
|
+
},
|
|
1451
|
+
"additionalProperties": false,
|
|
1452
|
+
"required": [
|
|
1453
|
+
"id"
|
|
1454
|
+
]
|
|
1455
|
+
},
|
|
1456
|
+
request: (input) => {
|
|
1457
|
+
const req = { method: "PATCH", path: `/v1/executions/${encodeURIComponent(String(input.id))}` };
|
|
1458
|
+
const body = {};
|
|
1459
|
+
if (input.projectPlatformId !== undefined)
|
|
1460
|
+
body["projectPlatformId"] = input.projectPlatformId;
|
|
1461
|
+
if (input.expectedResult !== undefined)
|
|
1462
|
+
body["expectedResult"] = input.expectedResult;
|
|
1463
|
+
if (input.observation !== undefined)
|
|
1464
|
+
body["observation"] = input.observation;
|
|
1465
|
+
if (input.assignedTo !== undefined)
|
|
1466
|
+
body["assignedTo"] = input.assignedTo;
|
|
1467
|
+
if (input.statusId !== undefined)
|
|
1468
|
+
body["statusId"] = input.statusId;
|
|
1469
|
+
if (input.order !== undefined)
|
|
1470
|
+
body["order"] = input.order;
|
|
1471
|
+
req.body = body;
|
|
1472
|
+
return req;
|
|
1473
|
+
},
|
|
1474
|
+
},
|
|
1475
|
+
{
|
|
1476
|
+
name: "links_batch_create",
|
|
1477
|
+
description: "Link one entity to multiple entities at once\n\nTag: Links\n\nCreates one record per target. Operation is atomic — if any record fails, none are created. **Paid-plan only:** free-plan organizations receive 403.",
|
|
1478
|
+
inputSchema: {
|
|
1479
|
+
"type": "object",
|
|
1480
|
+
"properties": {
|
|
1481
|
+
"entityAType": {
|
|
1482
|
+
"type": "string",
|
|
1483
|
+
"enum": [
|
|
1484
|
+
"test-case",
|
|
1485
|
+
"test-cycle",
|
|
1486
|
+
"bug",
|
|
1487
|
+
"execution"
|
|
1488
|
+
],
|
|
1489
|
+
"description": "The entity currently being viewed"
|
|
1490
|
+
},
|
|
1491
|
+
"entityAId": {
|
|
1492
|
+
"type": "string",
|
|
1493
|
+
"format": "uuid"
|
|
1494
|
+
},
|
|
1495
|
+
"targets": {
|
|
1496
|
+
"type": "array",
|
|
1497
|
+
"minItems": 1,
|
|
1498
|
+
"items": {
|
|
1499
|
+
"type": "object",
|
|
1500
|
+
"required": [
|
|
1501
|
+
"entityBType",
|
|
1502
|
+
"entityBId"
|
|
1503
|
+
],
|
|
1504
|
+
"properties": {
|
|
1505
|
+
"entityBType": {
|
|
1506
|
+
"type": "string",
|
|
1507
|
+
"enum": [
|
|
1508
|
+
"test-case",
|
|
1509
|
+
"test-cycle",
|
|
1510
|
+
"bug",
|
|
1511
|
+
"execution"
|
|
1512
|
+
],
|
|
1513
|
+
"description": "The entity being linked"
|
|
1514
|
+
},
|
|
1515
|
+
"entityBId": {
|
|
1516
|
+
"type": "string",
|
|
1517
|
+
"format": "uuid"
|
|
1518
|
+
}
|
|
1519
|
+
}
|
|
1520
|
+
}
|
|
1521
|
+
}
|
|
1522
|
+
},
|
|
1523
|
+
"additionalProperties": false,
|
|
1524
|
+
"required": [
|
|
1525
|
+
"entityAType",
|
|
1526
|
+
"entityAId",
|
|
1527
|
+
"targets"
|
|
1528
|
+
]
|
|
1529
|
+
},
|
|
1530
|
+
request: (input) => {
|
|
1531
|
+
const req = { method: "POST", path: "/v1/links/batch" };
|
|
1532
|
+
const body = {};
|
|
1533
|
+
if (input.entityAType !== undefined)
|
|
1534
|
+
body["entityAType"] = input.entityAType;
|
|
1535
|
+
if (input.entityAId !== undefined)
|
|
1536
|
+
body["entityAId"] = input.entityAId;
|
|
1537
|
+
if (input.targets !== undefined)
|
|
1538
|
+
body["targets"] = input.targets;
|
|
1539
|
+
req.body = body;
|
|
1540
|
+
return req;
|
|
1541
|
+
},
|
|
1542
|
+
},
|
|
1543
|
+
{
|
|
1544
|
+
name: "links_create",
|
|
1545
|
+
description: "Create a link between two entities\n\nTag: Links\n\nCreates a directional link between two entities.\n\n**entityA** is the entity currently open or being edited — its ID is stored in the corresponding foreign key field.\n**entityB** is the entity being linked to entityA — its type is stored in `type` and its ID in `meloQaLinkedId`.\n\n**Example use case:** A user is editing a bug and opens the link panel to attach a test case.\nTo replicate this action via the API, set `entityAType` to `bug` and `entityAId` to the ID of the open bug,\nthen set `entityBType` to `test-case` and `entityBId` to the ID of the selected test case.\n\nThe same logic applies regardless of which entity type is open: always pass the entity being viewed as **entityA**\nand the entity being attached as **entityB**.\n\n**Paid-plan only:** this endpoint requires the organization to have an active subscription. Free-plan organizations receive 403.",
|
|
1546
|
+
inputSchema: {
|
|
1547
|
+
"type": "object",
|
|
1548
|
+
"properties": {
|
|
1549
|
+
"entityAType": {
|
|
1550
|
+
"type": "string",
|
|
1551
|
+
"enum": [
|
|
1552
|
+
"test-case",
|
|
1553
|
+
"test-cycle",
|
|
1554
|
+
"bug",
|
|
1555
|
+
"execution"
|
|
1556
|
+
],
|
|
1557
|
+
"description": "The entity currently being viewed"
|
|
1558
|
+
},
|
|
1559
|
+
"entityAId": {
|
|
1560
|
+
"type": "string",
|
|
1561
|
+
"format": "uuid"
|
|
1562
|
+
},
|
|
1563
|
+
"entityBType": {
|
|
1564
|
+
"type": "string",
|
|
1565
|
+
"enum": [
|
|
1566
|
+
"test-case",
|
|
1567
|
+
"test-cycle",
|
|
1568
|
+
"bug",
|
|
1569
|
+
"execution"
|
|
1570
|
+
],
|
|
1571
|
+
"description": "The entity being linked to entityA"
|
|
1572
|
+
},
|
|
1573
|
+
"entityBId": {
|
|
1574
|
+
"type": "string",
|
|
1575
|
+
"format": "uuid"
|
|
1576
|
+
}
|
|
1577
|
+
},
|
|
1578
|
+
"additionalProperties": false,
|
|
1579
|
+
"required": [
|
|
1580
|
+
"entityAType",
|
|
1581
|
+
"entityAId",
|
|
1582
|
+
"entityBType",
|
|
1583
|
+
"entityBId"
|
|
1584
|
+
]
|
|
1585
|
+
},
|
|
1586
|
+
request: (input) => {
|
|
1587
|
+
const req = { method: "POST", path: "/v1/links" };
|
|
1588
|
+
const body = {};
|
|
1589
|
+
if (input.entityAType !== undefined)
|
|
1590
|
+
body["entityAType"] = input.entityAType;
|
|
1591
|
+
if (input.entityAId !== undefined)
|
|
1592
|
+
body["entityAId"] = input.entityAId;
|
|
1593
|
+
if (input.entityBType !== undefined)
|
|
1594
|
+
body["entityBType"] = input.entityBType;
|
|
1595
|
+
if (input.entityBId !== undefined)
|
|
1596
|
+
body["entityBId"] = input.entityBId;
|
|
1597
|
+
req.body = body;
|
|
1598
|
+
return req;
|
|
1599
|
+
},
|
|
1600
|
+
},
|
|
1601
|
+
{
|
|
1602
|
+
name: "links_delete",
|
|
1603
|
+
description: "Remove a link\n\nTag: Links\n\n**Paid-plan only:** free-plan organizations receive 403.",
|
|
1604
|
+
inputSchema: {
|
|
1605
|
+
"type": "object",
|
|
1606
|
+
"properties": {
|
|
1607
|
+
"id": {
|
|
1608
|
+
"type": "string",
|
|
1609
|
+
"format": "uuid",
|
|
1610
|
+
"description": "Link ID"
|
|
1611
|
+
}
|
|
1612
|
+
},
|
|
1613
|
+
"additionalProperties": false,
|
|
1614
|
+
"required": [
|
|
1615
|
+
"id"
|
|
1616
|
+
]
|
|
1617
|
+
},
|
|
1618
|
+
request: (input) => {
|
|
1619
|
+
const req = { method: "DELETE", path: `/v1/links/${encodeURIComponent(String(input.id))}` };
|
|
1620
|
+
return req;
|
|
1621
|
+
},
|
|
1622
|
+
},
|
|
1623
|
+
{
|
|
1624
|
+
name: "links_list",
|
|
1625
|
+
description: "List links for an entity\n\nTag: Links\n\nReturns all entities linked to the given entity, regardless of which side of the link it was created from.\n\n**Example use case:** A user opens a bug and the UI needs to display its linked items panel.\nPass `entityType=bug` and `entityId` as the ID of the open bug to retrieve all entities attached to it.\n\nThe response includes links where the given entity appears as either **entityA** (the entity that was open when the link was created)\nor **entityB** (the entity that was attached). Both directions are returned in a single call.",
|
|
1626
|
+
inputSchema: {
|
|
1627
|
+
"type": "object",
|
|
1628
|
+
"properties": {
|
|
1629
|
+
"entityType": {
|
|
1630
|
+
"type": "string",
|
|
1631
|
+
"enum": [
|
|
1632
|
+
"test-case",
|
|
1633
|
+
"test-cycle",
|
|
1634
|
+
"bug",
|
|
1635
|
+
"execution"
|
|
1636
|
+
],
|
|
1637
|
+
"description": "Valid values: `test-case`, `test-cycle`, `bug`, `execution`"
|
|
1638
|
+
},
|
|
1639
|
+
"entityId": {
|
|
1640
|
+
"type": "string",
|
|
1641
|
+
"format": "uuid"
|
|
1642
|
+
}
|
|
1643
|
+
},
|
|
1644
|
+
"additionalProperties": false,
|
|
1645
|
+
"required": [
|
|
1646
|
+
"entityType",
|
|
1647
|
+
"entityId"
|
|
1648
|
+
]
|
|
1649
|
+
},
|
|
1650
|
+
request: (input) => {
|
|
1651
|
+
const req = { method: "GET", path: "/v1/links" };
|
|
1652
|
+
const query = {};
|
|
1653
|
+
if (input.entityType !== undefined && input.entityType !== null)
|
|
1654
|
+
query["entityType"] = String(input.entityType);
|
|
1655
|
+
if (input.entityId !== undefined && input.entityId !== null)
|
|
1656
|
+
query["entityId"] = String(input.entityId);
|
|
1657
|
+
if (Object.keys(query).length > 0)
|
|
1658
|
+
req.query = query;
|
|
1659
|
+
return req;
|
|
1660
|
+
},
|
|
1661
|
+
},
|
|
1662
|
+
{
|
|
1663
|
+
name: "location_countries_list",
|
|
1664
|
+
description: "List all location countries\n\nTag: Location Countries",
|
|
1665
|
+
inputSchema: {
|
|
1666
|
+
"type": "object",
|
|
1667
|
+
"properties": {},
|
|
1668
|
+
"additionalProperties": false
|
|
1669
|
+
},
|
|
1670
|
+
request: (input) => {
|
|
1671
|
+
const req = { method: "GET", path: "/v1/location-countries" };
|
|
1672
|
+
return req;
|
|
1673
|
+
},
|
|
1674
|
+
},
|
|
1675
|
+
{
|
|
1676
|
+
name: "organizations_get",
|
|
1677
|
+
description: "Get organization by ID\n\nTag: Organizations",
|
|
1678
|
+
inputSchema: {
|
|
1679
|
+
"type": "object",
|
|
1680
|
+
"properties": {
|
|
1681
|
+
"id": {
|
|
1682
|
+
"type": "string",
|
|
1683
|
+
"format": "uuid",
|
|
1684
|
+
"description": "Organization ID"
|
|
1685
|
+
}
|
|
1686
|
+
},
|
|
1687
|
+
"additionalProperties": false,
|
|
1688
|
+
"required": [
|
|
1689
|
+
"id"
|
|
1690
|
+
]
|
|
1691
|
+
},
|
|
1692
|
+
request: (input) => {
|
|
1693
|
+
const req = { method: "GET", path: `/v1/organizations/${encodeURIComponent(String(input.id))}` };
|
|
1694
|
+
return req;
|
|
1695
|
+
},
|
|
1696
|
+
},
|
|
1697
|
+
{
|
|
1698
|
+
name: "organizations_list",
|
|
1699
|
+
description: "List organizations\n\nTag: Organizations",
|
|
1700
|
+
inputSchema: {
|
|
1701
|
+
"type": "object",
|
|
1702
|
+
"properties": {},
|
|
1703
|
+
"additionalProperties": false
|
|
1704
|
+
},
|
|
1705
|
+
request: (input) => {
|
|
1706
|
+
const req = { method: "GET", path: "/v1/organizations" };
|
|
1707
|
+
return req;
|
|
1708
|
+
},
|
|
1709
|
+
},
|
|
1710
|
+
{
|
|
1711
|
+
name: "organizations_members_list",
|
|
1712
|
+
description: "List members of an organization\n\nTag: Organizations",
|
|
1713
|
+
inputSchema: {
|
|
1714
|
+
"type": "object",
|
|
1715
|
+
"properties": {
|
|
1716
|
+
"id": {
|
|
1717
|
+
"type": "string",
|
|
1718
|
+
"format": "uuid",
|
|
1719
|
+
"description": "Organization ID"
|
|
1720
|
+
}
|
|
1721
|
+
},
|
|
1722
|
+
"additionalProperties": false,
|
|
1723
|
+
"required": [
|
|
1724
|
+
"id"
|
|
1725
|
+
]
|
|
1726
|
+
},
|
|
1727
|
+
request: (input) => {
|
|
1728
|
+
const req = { method: "GET", path: `/v1/organizations/${encodeURIComponent(String(input.id))}/members` };
|
|
1729
|
+
return req;
|
|
1730
|
+
},
|
|
1731
|
+
},
|
|
1732
|
+
{
|
|
1733
|
+
name: "organizations_update",
|
|
1734
|
+
description: "Update organization\n\nTag: Organizations\n\nThe `employeeQuantity` field accepts one of the following values: `1 a 10`, `11 a 50`, `51 a 100`, `100+`. Send `null` to clear the value.",
|
|
1735
|
+
inputSchema: {
|
|
1736
|
+
"type": "object",
|
|
1737
|
+
"properties": {
|
|
1738
|
+
"id": {
|
|
1739
|
+
"type": "string",
|
|
1740
|
+
"format": "uuid",
|
|
1741
|
+
"description": "Organization ID"
|
|
1742
|
+
},
|
|
1743
|
+
"name": {
|
|
1744
|
+
"type": "string"
|
|
1745
|
+
},
|
|
1746
|
+
"ownerId": {
|
|
1747
|
+
"type": "string",
|
|
1748
|
+
"format": "uuid",
|
|
1749
|
+
"description": "Transfer ownership (ADMINISTRATOR only)"
|
|
1750
|
+
},
|
|
1751
|
+
"companyName": {
|
|
1752
|
+
"type": [
|
|
1753
|
+
"string",
|
|
1754
|
+
"null"
|
|
1755
|
+
]
|
|
1756
|
+
},
|
|
1757
|
+
"employeeQuantity": {
|
|
1758
|
+
"type": [
|
|
1759
|
+
"string",
|
|
1760
|
+
"null"
|
|
1761
|
+
],
|
|
1762
|
+
"enum": [
|
|
1763
|
+
"1 a 10",
|
|
1764
|
+
"11 a 50",
|
|
1765
|
+
"51 a 100",
|
|
1766
|
+
"100+"
|
|
1767
|
+
]
|
|
1768
|
+
},
|
|
1769
|
+
"location": {
|
|
1770
|
+
"type": [
|
|
1771
|
+
"string",
|
|
1772
|
+
"null"
|
|
1773
|
+
]
|
|
1774
|
+
},
|
|
1775
|
+
"companySegment": {
|
|
1776
|
+
"type": [
|
|
1777
|
+
"string",
|
|
1778
|
+
"null"
|
|
1779
|
+
]
|
|
1780
|
+
},
|
|
1781
|
+
"pictureUrl": {
|
|
1782
|
+
"type": [
|
|
1783
|
+
"string",
|
|
1784
|
+
"null"
|
|
1785
|
+
]
|
|
1786
|
+
},
|
|
1787
|
+
"locationCountryId": {
|
|
1788
|
+
"type": [
|
|
1789
|
+
"string",
|
|
1790
|
+
"null"
|
|
1791
|
+
]
|
|
1792
|
+
}
|
|
1793
|
+
},
|
|
1794
|
+
"additionalProperties": false,
|
|
1795
|
+
"required": [
|
|
1796
|
+
"id"
|
|
1797
|
+
]
|
|
1798
|
+
},
|
|
1799
|
+
request: (input) => {
|
|
1800
|
+
const req = { method: "PATCH", path: `/v1/organizations/${encodeURIComponent(String(input.id))}` };
|
|
1801
|
+
const body = {};
|
|
1802
|
+
if (input.name !== undefined)
|
|
1803
|
+
body["name"] = input.name;
|
|
1804
|
+
if (input.ownerId !== undefined)
|
|
1805
|
+
body["ownerId"] = input.ownerId;
|
|
1806
|
+
if (input.companyName !== undefined)
|
|
1807
|
+
body["companyName"] = input.companyName;
|
|
1808
|
+
if (input.employeeQuantity !== undefined)
|
|
1809
|
+
body["employeeQuantity"] = input.employeeQuantity;
|
|
1810
|
+
if (input.location !== undefined)
|
|
1811
|
+
body["location"] = input.location;
|
|
1812
|
+
if (input.companySegment !== undefined)
|
|
1813
|
+
body["companySegment"] = input.companySegment;
|
|
1814
|
+
if (input.pictureUrl !== undefined)
|
|
1815
|
+
body["pictureUrl"] = input.pictureUrl;
|
|
1816
|
+
if (input.locationCountryId !== undefined)
|
|
1817
|
+
body["locationCountryId"] = input.locationCountryId;
|
|
1818
|
+
req.body = body;
|
|
1819
|
+
return req;
|
|
1820
|
+
},
|
|
1821
|
+
},
|
|
1822
|
+
{
|
|
1823
|
+
name: "project_pictures_list",
|
|
1824
|
+
description: "List available project pictures\n\nTag: Projects",
|
|
1825
|
+
inputSchema: {
|
|
1826
|
+
"type": "object",
|
|
1827
|
+
"properties": {},
|
|
1828
|
+
"additionalProperties": false
|
|
1829
|
+
},
|
|
1830
|
+
request: (input) => {
|
|
1831
|
+
const req = { method: "GET", path: "/v1/project-pictures" };
|
|
1832
|
+
return req;
|
|
1833
|
+
},
|
|
1834
|
+
},
|
|
1835
|
+
{
|
|
1836
|
+
name: "project_platforms_list",
|
|
1837
|
+
description: "List platforms for a project\n\nTag: Project Platforms",
|
|
1838
|
+
inputSchema: {
|
|
1839
|
+
"type": "object",
|
|
1840
|
+
"properties": {
|
|
1841
|
+
"projectId": {
|
|
1842
|
+
"type": "string",
|
|
1843
|
+
"format": "uuid",
|
|
1844
|
+
"description": "Filter platforms by project"
|
|
1845
|
+
}
|
|
1846
|
+
},
|
|
1847
|
+
"additionalProperties": false,
|
|
1848
|
+
"required": [
|
|
1849
|
+
"projectId"
|
|
1850
|
+
]
|
|
1851
|
+
},
|
|
1852
|
+
request: (input) => {
|
|
1853
|
+
const req = { method: "GET", path: "/v1/project-platforms" };
|
|
1854
|
+
const query = {};
|
|
1855
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
1856
|
+
query["projectId"] = String(input.projectId);
|
|
1857
|
+
if (Object.keys(query).length > 0)
|
|
1858
|
+
req.query = query;
|
|
1859
|
+
return req;
|
|
1860
|
+
},
|
|
1861
|
+
},
|
|
1862
|
+
{
|
|
1863
|
+
name: "projects_create",
|
|
1864
|
+
description: "Create project\n\nTag: Projects\n\nValidation rules:\n- `name` must not exceed 20 characters.\n- `description` must not exceed 250 characters.\n- `projectPictureUrl` must reference a project picture predefined by the meloQA API — list the available IDs via `GET /v1/project-pictures`.",
|
|
1865
|
+
inputSchema: {
|
|
1866
|
+
"type": "object",
|
|
1867
|
+
"properties": {
|
|
1868
|
+
"name": {
|
|
1869
|
+
"type": "string",
|
|
1870
|
+
"maxLength": 20
|
|
1871
|
+
},
|
|
1872
|
+
"organizationId": {
|
|
1873
|
+
"type": "string",
|
|
1874
|
+
"format": "uuid"
|
|
1875
|
+
},
|
|
1876
|
+
"projectPictureUrl": {
|
|
1877
|
+
"type": "string",
|
|
1878
|
+
"format": "uuid",
|
|
1879
|
+
"description": "ID of a project picture — get available IDs from GET /v1/project-pictures"
|
|
1880
|
+
},
|
|
1881
|
+
"description": {
|
|
1882
|
+
"type": "string",
|
|
1883
|
+
"maxLength": 250
|
|
1884
|
+
},
|
|
1885
|
+
"testCaseTypeId": {
|
|
1886
|
+
"type": "string",
|
|
1887
|
+
"format": "uuid"
|
|
1888
|
+
}
|
|
1889
|
+
},
|
|
1890
|
+
"additionalProperties": false,
|
|
1891
|
+
"required": [
|
|
1892
|
+
"name",
|
|
1893
|
+
"organizationId",
|
|
1894
|
+
"projectPictureUrl"
|
|
1895
|
+
]
|
|
1896
|
+
},
|
|
1897
|
+
request: (input) => {
|
|
1898
|
+
const req = { method: "POST", path: "/v1/projects" };
|
|
1899
|
+
const body = {};
|
|
1900
|
+
if (input.name !== undefined)
|
|
1901
|
+
body["name"] = input.name;
|
|
1902
|
+
if (input.organizationId !== undefined)
|
|
1903
|
+
body["organizationId"] = input.organizationId;
|
|
1904
|
+
if (input.projectPictureUrl !== undefined)
|
|
1905
|
+
body["projectPictureUrl"] = input.projectPictureUrl;
|
|
1906
|
+
if (input.description !== undefined)
|
|
1907
|
+
body["description"] = input.description;
|
|
1908
|
+
if (input.testCaseTypeId !== undefined)
|
|
1909
|
+
body["testCaseTypeId"] = input.testCaseTypeId;
|
|
1910
|
+
req.body = body;
|
|
1911
|
+
return req;
|
|
1912
|
+
},
|
|
1913
|
+
},
|
|
1914
|
+
{
|
|
1915
|
+
name: "projects_delete",
|
|
1916
|
+
description: "Delete project\n\nTag: Projects",
|
|
1917
|
+
inputSchema: {
|
|
1918
|
+
"type": "object",
|
|
1919
|
+
"properties": {
|
|
1920
|
+
"id": {
|
|
1921
|
+
"type": "string",
|
|
1922
|
+
"format": "uuid",
|
|
1923
|
+
"description": "Project ID"
|
|
1924
|
+
}
|
|
1925
|
+
},
|
|
1926
|
+
"additionalProperties": false,
|
|
1927
|
+
"required": [
|
|
1928
|
+
"id"
|
|
1929
|
+
]
|
|
1930
|
+
},
|
|
1931
|
+
request: (input) => {
|
|
1932
|
+
const req = { method: "DELETE", path: `/v1/projects/${encodeURIComponent(String(input.id))}` };
|
|
1933
|
+
return req;
|
|
1934
|
+
},
|
|
1935
|
+
},
|
|
1936
|
+
{
|
|
1937
|
+
name: "projects_execution_statuses_list",
|
|
1938
|
+
description: "List execution statuses available in a project\n\nTag: Projects\n\nReturns the execution statuses that can be assigned to executions in this project. Includes both the system-wide defaults (`projectId: null`, `isDefault: true`) and any project-specific statuses created for it. Use the `id` of an entry as `statusId` when creating or updating an execution.",
|
|
1939
|
+
inputSchema: {
|
|
1940
|
+
"type": "object",
|
|
1941
|
+
"properties": {
|
|
1942
|
+
"id": {
|
|
1943
|
+
"type": "string",
|
|
1944
|
+
"format": "uuid",
|
|
1945
|
+
"description": "Project ID"
|
|
1946
|
+
}
|
|
1947
|
+
},
|
|
1948
|
+
"additionalProperties": false,
|
|
1949
|
+
"required": [
|
|
1950
|
+
"id"
|
|
1951
|
+
]
|
|
1952
|
+
},
|
|
1953
|
+
request: (input) => {
|
|
1954
|
+
const req = { method: "GET", path: `/v1/projects/${encodeURIComponent(String(input.id))}/execution-statuses` };
|
|
1955
|
+
return req;
|
|
1956
|
+
},
|
|
1957
|
+
},
|
|
1958
|
+
{
|
|
1959
|
+
name: "projects_get",
|
|
1960
|
+
description: "Get project by ID\n\nTag: Projects",
|
|
1961
|
+
inputSchema: {
|
|
1962
|
+
"type": "object",
|
|
1963
|
+
"properties": {
|
|
1964
|
+
"id": {
|
|
1965
|
+
"type": "string",
|
|
1966
|
+
"format": "uuid",
|
|
1967
|
+
"description": "Project ID"
|
|
1968
|
+
}
|
|
1969
|
+
},
|
|
1970
|
+
"additionalProperties": false,
|
|
1971
|
+
"required": [
|
|
1972
|
+
"id"
|
|
1973
|
+
]
|
|
1974
|
+
},
|
|
1975
|
+
request: (input) => {
|
|
1976
|
+
const req = { method: "GET", path: `/v1/projects/${encodeURIComponent(String(input.id))}` };
|
|
1977
|
+
return req;
|
|
1978
|
+
},
|
|
1979
|
+
},
|
|
1980
|
+
{
|
|
1981
|
+
name: "projects_list",
|
|
1982
|
+
description: "List projects\n\nTag: Projects\n\nReturns only projects the authenticated user has effective access to (i.e. is a project member of).",
|
|
1983
|
+
inputSchema: {
|
|
1984
|
+
"type": "object",
|
|
1985
|
+
"properties": {},
|
|
1986
|
+
"additionalProperties": false
|
|
1987
|
+
},
|
|
1988
|
+
request: (input) => {
|
|
1989
|
+
const req = { method: "GET", path: "/v1/projects" };
|
|
1990
|
+
return req;
|
|
1991
|
+
},
|
|
1992
|
+
},
|
|
1993
|
+
{
|
|
1994
|
+
name: "projects_members_list",
|
|
1995
|
+
description: "List members of a project\n\nTag: Projects\n\nReturns the active (non-deleted) members of the project. The caller must be a member of the project.",
|
|
1996
|
+
inputSchema: {
|
|
1997
|
+
"type": "object",
|
|
1998
|
+
"properties": {
|
|
1999
|
+
"id": {
|
|
2000
|
+
"type": "string",
|
|
2001
|
+
"format": "uuid",
|
|
2002
|
+
"description": "Project ID"
|
|
2003
|
+
}
|
|
2004
|
+
},
|
|
2005
|
+
"additionalProperties": false,
|
|
2006
|
+
"required": [
|
|
2007
|
+
"id"
|
|
2008
|
+
]
|
|
2009
|
+
},
|
|
2010
|
+
request: (input) => {
|
|
2011
|
+
const req = { method: "GET", path: `/v1/projects/${encodeURIComponent(String(input.id))}/members` };
|
|
2012
|
+
return req;
|
|
2013
|
+
},
|
|
2014
|
+
},
|
|
2015
|
+
{
|
|
2016
|
+
name: "projects_test_case_custom_fields_list",
|
|
2017
|
+
description: "List custom field definitions for test cases of a project\n\nTag: Projects\n\nReturns the custom field schema configured for test cases in the project. Use the `id` of each entry as `projectCustomFieldId` when reading or writing test case custom field values.",
|
|
2018
|
+
inputSchema: {
|
|
2019
|
+
"type": "object",
|
|
2020
|
+
"properties": {
|
|
2021
|
+
"id": {
|
|
2022
|
+
"type": "string",
|
|
2023
|
+
"format": "uuid",
|
|
2024
|
+
"description": "Project ID"
|
|
2025
|
+
}
|
|
2026
|
+
},
|
|
2027
|
+
"additionalProperties": false,
|
|
2028
|
+
"required": [
|
|
2029
|
+
"id"
|
|
2030
|
+
]
|
|
2031
|
+
},
|
|
2032
|
+
request: (input) => {
|
|
2033
|
+
const req = { method: "GET", path: `/v1/projects/${encodeURIComponent(String(input.id))}/test-case-custom-fields` };
|
|
2034
|
+
return req;
|
|
2035
|
+
},
|
|
2036
|
+
},
|
|
2037
|
+
{
|
|
2038
|
+
name: "projects_update",
|
|
2039
|
+
description: "Update project\n\nTag: Projects\n\nValidation rules:\n- `name` must not exceed 20 characters.\n- `description` must not exceed 250 characters.\n- `projectPictureUrl` must reference a project picture predefined by the meloQA API — list the available IDs via `GET /v1/project-pictures`.",
|
|
2040
|
+
inputSchema: {
|
|
2041
|
+
"type": "object",
|
|
2042
|
+
"properties": {
|
|
2043
|
+
"id": {
|
|
2044
|
+
"type": "string",
|
|
2045
|
+
"format": "uuid",
|
|
2046
|
+
"description": "Project ID"
|
|
2047
|
+
},
|
|
2048
|
+
"name": {
|
|
2049
|
+
"type": "string",
|
|
2050
|
+
"maxLength": 20
|
|
2051
|
+
},
|
|
2052
|
+
"description": {
|
|
2053
|
+
"type": [
|
|
2054
|
+
"string",
|
|
2055
|
+
"null"
|
|
2056
|
+
],
|
|
2057
|
+
"maxLength": 250
|
|
2058
|
+
},
|
|
2059
|
+
"projectPictureUrl": {
|
|
2060
|
+
"type": "string",
|
|
2061
|
+
"format": "uuid",
|
|
2062
|
+
"description": "ID of a project picture — get available IDs from GET /v1/project-pictures"
|
|
2063
|
+
},
|
|
2064
|
+
"testCaseTypeId": {
|
|
2065
|
+
"type": [
|
|
2066
|
+
"string",
|
|
2067
|
+
"null"
|
|
2068
|
+
],
|
|
2069
|
+
"format": "uuid"
|
|
2070
|
+
},
|
|
2071
|
+
"isArchived": {
|
|
2072
|
+
"type": "boolean"
|
|
2073
|
+
}
|
|
2074
|
+
},
|
|
2075
|
+
"additionalProperties": false,
|
|
2076
|
+
"required": [
|
|
2077
|
+
"id"
|
|
2078
|
+
]
|
|
2079
|
+
},
|
|
2080
|
+
request: (input) => {
|
|
2081
|
+
const req = { method: "PATCH", path: `/v1/projects/${encodeURIComponent(String(input.id))}` };
|
|
2082
|
+
const body = {};
|
|
2083
|
+
if (input.name !== undefined)
|
|
2084
|
+
body["name"] = input.name;
|
|
2085
|
+
if (input.description !== undefined)
|
|
2086
|
+
body["description"] = input.description;
|
|
2087
|
+
if (input.projectPictureUrl !== undefined)
|
|
2088
|
+
body["projectPictureUrl"] = input.projectPictureUrl;
|
|
2089
|
+
if (input.testCaseTypeId !== undefined)
|
|
2090
|
+
body["testCaseTypeId"] = input.testCaseTypeId;
|
|
2091
|
+
if (input.isArchived !== undefined)
|
|
2092
|
+
body["isArchived"] = input.isArchived;
|
|
2093
|
+
req.body = body;
|
|
2094
|
+
return req;
|
|
2095
|
+
},
|
|
2096
|
+
},
|
|
2097
|
+
{
|
|
2098
|
+
name: "tags_create",
|
|
2099
|
+
description: "Create tag\n\nTag: Tags",
|
|
2100
|
+
inputSchema: {
|
|
2101
|
+
"type": "object",
|
|
2102
|
+
"properties": {
|
|
2103
|
+
"name": {
|
|
2104
|
+
"type": "string"
|
|
2105
|
+
},
|
|
2106
|
+
"color": {
|
|
2107
|
+
"type": "string"
|
|
2108
|
+
},
|
|
2109
|
+
"projectId": {
|
|
2110
|
+
"type": "string",
|
|
2111
|
+
"format": "uuid"
|
|
2112
|
+
}
|
|
2113
|
+
},
|
|
2114
|
+
"additionalProperties": false,
|
|
2115
|
+
"required": [
|
|
2116
|
+
"name",
|
|
2117
|
+
"projectId"
|
|
2118
|
+
]
|
|
2119
|
+
},
|
|
2120
|
+
request: (input) => {
|
|
2121
|
+
const req = { method: "POST", path: "/v1/tags" };
|
|
2122
|
+
const body = {};
|
|
2123
|
+
if (input.name !== undefined)
|
|
2124
|
+
body["name"] = input.name;
|
|
2125
|
+
if (input.color !== undefined)
|
|
2126
|
+
body["color"] = input.color;
|
|
2127
|
+
if (input.projectId !== undefined)
|
|
2128
|
+
body["projectId"] = input.projectId;
|
|
2129
|
+
req.body = body;
|
|
2130
|
+
return req;
|
|
2131
|
+
},
|
|
2132
|
+
},
|
|
2133
|
+
{
|
|
2134
|
+
name: "tags_delete",
|
|
2135
|
+
description: "Delete tag\n\nTag: Tags",
|
|
2136
|
+
inputSchema: {
|
|
2137
|
+
"type": "object",
|
|
2138
|
+
"properties": {
|
|
2139
|
+
"id": {
|
|
2140
|
+
"type": "string",
|
|
2141
|
+
"format": "uuid",
|
|
2142
|
+
"description": "Tag ID"
|
|
2143
|
+
}
|
|
2144
|
+
},
|
|
2145
|
+
"additionalProperties": false,
|
|
2146
|
+
"required": [
|
|
2147
|
+
"id"
|
|
2148
|
+
]
|
|
2149
|
+
},
|
|
2150
|
+
request: (input) => {
|
|
2151
|
+
const req = { method: "DELETE", path: `/v1/tags/${encodeURIComponent(String(input.id))}` };
|
|
2152
|
+
return req;
|
|
2153
|
+
},
|
|
2154
|
+
},
|
|
2155
|
+
{
|
|
2156
|
+
name: "tags_get",
|
|
2157
|
+
description: "Get tag by ID\n\nTag: Tags",
|
|
2158
|
+
inputSchema: {
|
|
2159
|
+
"type": "object",
|
|
2160
|
+
"properties": {
|
|
2161
|
+
"id": {
|
|
2162
|
+
"type": "string",
|
|
2163
|
+
"format": "uuid",
|
|
2164
|
+
"description": "Tag ID"
|
|
2165
|
+
}
|
|
2166
|
+
},
|
|
2167
|
+
"additionalProperties": false,
|
|
2168
|
+
"required": [
|
|
2169
|
+
"id"
|
|
2170
|
+
]
|
|
2171
|
+
},
|
|
2172
|
+
request: (input) => {
|
|
2173
|
+
const req = { method: "GET", path: `/v1/tags/${encodeURIComponent(String(input.id))}` };
|
|
2174
|
+
return req;
|
|
2175
|
+
},
|
|
2176
|
+
},
|
|
2177
|
+
{
|
|
2178
|
+
name: "tags_list",
|
|
2179
|
+
description: "List tags\n\nTag: Tags",
|
|
2180
|
+
inputSchema: {
|
|
2181
|
+
"type": "object",
|
|
2182
|
+
"properties": {
|
|
2183
|
+
"projectId": {
|
|
2184
|
+
"type": "string",
|
|
2185
|
+
"format": "uuid",
|
|
2186
|
+
"description": "Filter tags by project"
|
|
2187
|
+
}
|
|
2188
|
+
},
|
|
2189
|
+
"additionalProperties": false,
|
|
2190
|
+
"required": [
|
|
2191
|
+
"projectId"
|
|
2192
|
+
]
|
|
2193
|
+
},
|
|
2194
|
+
request: (input) => {
|
|
2195
|
+
const req = { method: "GET", path: "/v1/tags" };
|
|
2196
|
+
const query = {};
|
|
2197
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
2198
|
+
query["projectId"] = String(input.projectId);
|
|
2199
|
+
if (Object.keys(query).length > 0)
|
|
2200
|
+
req.query = query;
|
|
2201
|
+
return req;
|
|
2202
|
+
},
|
|
2203
|
+
},
|
|
2204
|
+
{
|
|
2205
|
+
name: "tags_update",
|
|
2206
|
+
description: "Update tag\n\nTag: Tags",
|
|
2207
|
+
inputSchema: {
|
|
2208
|
+
"type": "object",
|
|
2209
|
+
"properties": {
|
|
2210
|
+
"id": {
|
|
2211
|
+
"type": "string",
|
|
2212
|
+
"format": "uuid",
|
|
2213
|
+
"description": "Tag ID"
|
|
2214
|
+
},
|
|
2215
|
+
"name": {
|
|
2216
|
+
"type": "string"
|
|
2217
|
+
},
|
|
2218
|
+
"color": {
|
|
2219
|
+
"type": [
|
|
2220
|
+
"string",
|
|
2221
|
+
"null"
|
|
2222
|
+
]
|
|
2223
|
+
}
|
|
2224
|
+
},
|
|
2225
|
+
"additionalProperties": false,
|
|
2226
|
+
"required": [
|
|
2227
|
+
"id"
|
|
2228
|
+
]
|
|
2229
|
+
},
|
|
2230
|
+
request: (input) => {
|
|
2231
|
+
const req = { method: "PATCH", path: `/v1/tags/${encodeURIComponent(String(input.id))}` };
|
|
2232
|
+
const body = {};
|
|
2233
|
+
if (input.name !== undefined)
|
|
2234
|
+
body["name"] = input.name;
|
|
2235
|
+
if (input.color !== undefined)
|
|
2236
|
+
body["color"] = input.color;
|
|
2237
|
+
req.body = body;
|
|
2238
|
+
return req;
|
|
2239
|
+
},
|
|
2240
|
+
},
|
|
2241
|
+
{
|
|
2242
|
+
name: "test_case_folders_create",
|
|
2243
|
+
description: "Create test case folder\n\nTag: Test Case Folders\n\nFolder hierarchy is limited to **3 sub-levels** below the project root. Creating a folder under a parent that is already at the 3rd sub-level returns 400.",
|
|
2244
|
+
inputSchema: {
|
|
2245
|
+
"type": "object",
|
|
2246
|
+
"properties": {
|
|
2247
|
+
"name": {
|
|
2248
|
+
"type": "string"
|
|
2249
|
+
},
|
|
2250
|
+
"projectId": {
|
|
2251
|
+
"type": "string",
|
|
2252
|
+
"format": "uuid"
|
|
2253
|
+
},
|
|
2254
|
+
"parentId": {
|
|
2255
|
+
"type": "string",
|
|
2256
|
+
"format": "uuid"
|
|
2257
|
+
},
|
|
2258
|
+
"order": {
|
|
2259
|
+
"type": "integer"
|
|
2260
|
+
}
|
|
2261
|
+
},
|
|
2262
|
+
"additionalProperties": false,
|
|
2263
|
+
"required": [
|
|
2264
|
+
"name",
|
|
2265
|
+
"projectId"
|
|
2266
|
+
]
|
|
2267
|
+
},
|
|
2268
|
+
request: (input) => {
|
|
2269
|
+
const req = { method: "POST", path: "/v1/test-case-folders" };
|
|
2270
|
+
const body = {};
|
|
2271
|
+
if (input.name !== undefined)
|
|
2272
|
+
body["name"] = input.name;
|
|
2273
|
+
if (input.projectId !== undefined)
|
|
2274
|
+
body["projectId"] = input.projectId;
|
|
2275
|
+
if (input.parentId !== undefined)
|
|
2276
|
+
body["parentId"] = input.parentId;
|
|
2277
|
+
if (input.order !== undefined)
|
|
2278
|
+
body["order"] = input.order;
|
|
2279
|
+
req.body = body;
|
|
2280
|
+
return req;
|
|
2281
|
+
},
|
|
2282
|
+
},
|
|
2283
|
+
{
|
|
2284
|
+
name: "test_case_folders_delete",
|
|
2285
|
+
description: "Delete test case folder\n\nTag: Test Case Folders\n\nRemoves the folder and hard-deletes every test case it contained, matching the meloQA front-end behavior. Child folders are removed in the same operation.",
|
|
2286
|
+
inputSchema: {
|
|
2287
|
+
"type": "object",
|
|
2288
|
+
"properties": {
|
|
2289
|
+
"id": {
|
|
2290
|
+
"type": "string",
|
|
2291
|
+
"format": "uuid",
|
|
2292
|
+
"description": "Test Case Folder ID"
|
|
2293
|
+
}
|
|
2294
|
+
},
|
|
2295
|
+
"additionalProperties": false,
|
|
2296
|
+
"required": [
|
|
2297
|
+
"id"
|
|
2298
|
+
]
|
|
2299
|
+
},
|
|
2300
|
+
request: (input) => {
|
|
2301
|
+
const req = { method: "DELETE", path: `/v1/test-case-folders/${encodeURIComponent(String(input.id))}` };
|
|
2302
|
+
return req;
|
|
2303
|
+
},
|
|
2304
|
+
},
|
|
2305
|
+
{
|
|
2306
|
+
name: "test_case_folders_get",
|
|
2307
|
+
description: "Get test case folder by ID\n\nTag: Test Case Folders",
|
|
2308
|
+
inputSchema: {
|
|
2309
|
+
"type": "object",
|
|
2310
|
+
"properties": {
|
|
2311
|
+
"id": {
|
|
2312
|
+
"type": "string",
|
|
2313
|
+
"format": "uuid",
|
|
2314
|
+
"description": "Test Case Folder ID"
|
|
2315
|
+
}
|
|
2316
|
+
},
|
|
2317
|
+
"additionalProperties": false,
|
|
2318
|
+
"required": [
|
|
2319
|
+
"id"
|
|
2320
|
+
]
|
|
2321
|
+
},
|
|
2322
|
+
request: (input) => {
|
|
2323
|
+
const req = { method: "GET", path: `/v1/test-case-folders/${encodeURIComponent(String(input.id))}` };
|
|
2324
|
+
return req;
|
|
2325
|
+
},
|
|
2326
|
+
},
|
|
2327
|
+
{
|
|
2328
|
+
name: "test_case_folders_list",
|
|
2329
|
+
description: "List test case folders\n\nTag: Test Case Folders",
|
|
2330
|
+
inputSchema: {
|
|
2331
|
+
"type": "object",
|
|
2332
|
+
"properties": {
|
|
2333
|
+
"projectId": {
|
|
2334
|
+
"type": "string",
|
|
2335
|
+
"format": "uuid",
|
|
2336
|
+
"description": "Filter folders by project"
|
|
2337
|
+
},
|
|
2338
|
+
"parentId": {
|
|
2339
|
+
"type": "string",
|
|
2340
|
+
"format": "uuid",
|
|
2341
|
+
"description": "Filter by parent folder"
|
|
2342
|
+
}
|
|
2343
|
+
},
|
|
2344
|
+
"additionalProperties": false,
|
|
2345
|
+
"required": [
|
|
2346
|
+
"projectId"
|
|
2347
|
+
]
|
|
2348
|
+
},
|
|
2349
|
+
request: (input) => {
|
|
2350
|
+
const req = { method: "GET", path: "/v1/test-case-folders" };
|
|
2351
|
+
const query = {};
|
|
2352
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
2353
|
+
query["projectId"] = String(input.projectId);
|
|
2354
|
+
if (input.parentId !== undefined && input.parentId !== null)
|
|
2355
|
+
query["parentId"] = String(input.parentId);
|
|
2356
|
+
if (Object.keys(query).length > 0)
|
|
2357
|
+
req.query = query;
|
|
2358
|
+
return req;
|
|
2359
|
+
},
|
|
2360
|
+
},
|
|
2361
|
+
{
|
|
2362
|
+
name: "test_case_folders_update",
|
|
2363
|
+
description: "Update test case folder\n\nTag: Test Case Folders\n\nWhen `parentId` is changed, the folder is moved together with its whole subtree. The resulting hierarchy must not exceed **3 sub-levels** below the project root — otherwise the request is rejected with 400.",
|
|
2364
|
+
inputSchema: {
|
|
2365
|
+
"type": "object",
|
|
2366
|
+
"properties": {
|
|
2367
|
+
"id": {
|
|
2368
|
+
"type": "string",
|
|
2369
|
+
"format": "uuid",
|
|
2370
|
+
"description": "Test Case Folder ID"
|
|
2371
|
+
},
|
|
2372
|
+
"name": {
|
|
2373
|
+
"type": "string"
|
|
2374
|
+
},
|
|
2375
|
+
"parentId": {
|
|
2376
|
+
"type": [
|
|
2377
|
+
"string",
|
|
2378
|
+
"null"
|
|
2379
|
+
],
|
|
2380
|
+
"format": "uuid"
|
|
2381
|
+
},
|
|
2382
|
+
"order": {
|
|
2383
|
+
"type": "integer"
|
|
2384
|
+
}
|
|
2385
|
+
},
|
|
2386
|
+
"additionalProperties": false,
|
|
2387
|
+
"required": [
|
|
2388
|
+
"id"
|
|
2389
|
+
]
|
|
2390
|
+
},
|
|
2391
|
+
request: (input) => {
|
|
2392
|
+
const req = { method: "PATCH", path: `/v1/test-case-folders/${encodeURIComponent(String(input.id))}` };
|
|
2393
|
+
const body = {};
|
|
2394
|
+
if (input.name !== undefined)
|
|
2395
|
+
body["name"] = input.name;
|
|
2396
|
+
if (input.parentId !== undefined)
|
|
2397
|
+
body["parentId"] = input.parentId;
|
|
2398
|
+
if (input.order !== undefined)
|
|
2399
|
+
body["order"] = input.order;
|
|
2400
|
+
req.body = body;
|
|
2401
|
+
return req;
|
|
2402
|
+
},
|
|
2403
|
+
},
|
|
2404
|
+
{
|
|
2405
|
+
name: "test_case_statuses_list",
|
|
2406
|
+
description: "List all test case statuses\n\nTag: Test Case Statuses",
|
|
2407
|
+
inputSchema: {
|
|
2408
|
+
"type": "object",
|
|
2409
|
+
"properties": {},
|
|
2410
|
+
"additionalProperties": false
|
|
2411
|
+
},
|
|
2412
|
+
request: (input) => {
|
|
2413
|
+
const req = { method: "GET", path: "/v1/test-case-statuses" };
|
|
2414
|
+
return req;
|
|
2415
|
+
},
|
|
2416
|
+
},
|
|
2417
|
+
{
|
|
2418
|
+
name: "test_case_types_list",
|
|
2419
|
+
description: "List all test case types\n\nTag: Test Case Types",
|
|
2420
|
+
inputSchema: {
|
|
2421
|
+
"type": "object",
|
|
2422
|
+
"properties": {},
|
|
2423
|
+
"additionalProperties": false
|
|
2424
|
+
},
|
|
2425
|
+
request: (input) => {
|
|
2426
|
+
const req = { method: "GET", path: "/v1/test-case-types" };
|
|
2427
|
+
return req;
|
|
2428
|
+
},
|
|
2429
|
+
},
|
|
2430
|
+
{
|
|
2431
|
+
name: "test_cases_archived_list",
|
|
2432
|
+
description: "List archived test cases\n\nTag: Test Cases\n\nReturns only archived test cases (`statusId === ARCHIVED`). At least one of **projectId** or **folderId** is required.",
|
|
2433
|
+
inputSchema: {
|
|
2434
|
+
"type": "object",
|
|
2435
|
+
"properties": {
|
|
2436
|
+
"projectId": {
|
|
2437
|
+
"type": "string",
|
|
2438
|
+
"format": "uuid",
|
|
2439
|
+
"description": "Filter by project. At least one of projectId or folderId is required."
|
|
2440
|
+
},
|
|
2441
|
+
"folderId": {
|
|
2442
|
+
"type": "string",
|
|
2443
|
+
"format": "uuid",
|
|
2444
|
+
"description": "Filter by folder. At least one of projectId or folderId is required."
|
|
2445
|
+
}
|
|
2446
|
+
},
|
|
2447
|
+
"additionalProperties": false
|
|
2448
|
+
},
|
|
2449
|
+
request: (input) => {
|
|
2450
|
+
const req = { method: "GET", path: "/v1/test-cases/archived" };
|
|
2451
|
+
const query = {};
|
|
2452
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
2453
|
+
query["projectId"] = String(input.projectId);
|
|
2454
|
+
if (input.folderId !== undefined && input.folderId !== null)
|
|
2455
|
+
query["folderId"] = String(input.folderId);
|
|
2456
|
+
if (Object.keys(query).length > 0)
|
|
2457
|
+
req.query = query;
|
|
2458
|
+
return req;
|
|
2459
|
+
},
|
|
2460
|
+
},
|
|
2461
|
+
{
|
|
2462
|
+
name: "test_cases_attachments_create",
|
|
2463
|
+
description: "Create test case attachment (returns presigned upload URL)\n\nTag: Test Case Attachments\n\nCria o registro do anexo (uploaded=false) e retorna uma presigned URL S3 (PUT, 300s). Faça o PUT do arquivo na `uploadUrl` e depois confirme com PATCH /v1/test-cases/:id/attachments/:attachmentId.",
|
|
2464
|
+
inputSchema: {
|
|
2465
|
+
"type": "object",
|
|
2466
|
+
"properties": {
|
|
2467
|
+
"id": {
|
|
2468
|
+
"type": "string",
|
|
2469
|
+
"format": "uuid",
|
|
2470
|
+
"description": "Test Case ID"
|
|
2471
|
+
},
|
|
2472
|
+
"fileName": {
|
|
2473
|
+
"type": "string"
|
|
2474
|
+
},
|
|
2475
|
+
"size": {
|
|
2476
|
+
"type": "integer",
|
|
2477
|
+
"description": "Tamanho em bytes"
|
|
2478
|
+
},
|
|
2479
|
+
"type": {
|
|
2480
|
+
"type": "string",
|
|
2481
|
+
"description": "MIME type"
|
|
2482
|
+
},
|
|
2483
|
+
"md5": {
|
|
2484
|
+
"type": "string"
|
|
2485
|
+
}
|
|
2486
|
+
},
|
|
2487
|
+
"additionalProperties": false,
|
|
2488
|
+
"required": [
|
|
2489
|
+
"id",
|
|
2490
|
+
"fileName",
|
|
2491
|
+
"size",
|
|
2492
|
+
"type",
|
|
2493
|
+
"md5"
|
|
2494
|
+
]
|
|
2495
|
+
},
|
|
2496
|
+
request: (input) => {
|
|
2497
|
+
const req = { method: "POST", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}/attachments` };
|
|
2498
|
+
const body = {};
|
|
2499
|
+
if (input.fileName !== undefined)
|
|
2500
|
+
body["fileName"] = input.fileName;
|
|
2501
|
+
if (input.size !== undefined)
|
|
2502
|
+
body["size"] = input.size;
|
|
2503
|
+
if (input.type !== undefined)
|
|
2504
|
+
body["type"] = input.type;
|
|
2505
|
+
if (input.md5 !== undefined)
|
|
2506
|
+
body["md5"] = input.md5;
|
|
2507
|
+
req.body = body;
|
|
2508
|
+
return req;
|
|
2509
|
+
},
|
|
2510
|
+
},
|
|
2511
|
+
{
|
|
2512
|
+
name: "test_cases_attachments_delete",
|
|
2513
|
+
description: "Delete test case attachment\n\nTag: Test Case Attachments\n\nRemove o anexo (registro + arquivo no S3).",
|
|
2514
|
+
inputSchema: {
|
|
2515
|
+
"type": "object",
|
|
2516
|
+
"properties": {
|
|
2517
|
+
"id": {
|
|
2518
|
+
"type": "string",
|
|
2519
|
+
"format": "uuid",
|
|
2520
|
+
"description": "Test Case ID"
|
|
2521
|
+
},
|
|
2522
|
+
"attachmentId": {
|
|
2523
|
+
"type": "string",
|
|
2524
|
+
"format": "uuid",
|
|
2525
|
+
"description": "Attachment ID"
|
|
2526
|
+
}
|
|
2527
|
+
},
|
|
2528
|
+
"additionalProperties": false,
|
|
2529
|
+
"required": [
|
|
2530
|
+
"id",
|
|
2531
|
+
"attachmentId"
|
|
2532
|
+
]
|
|
2533
|
+
},
|
|
2534
|
+
request: (input) => {
|
|
2535
|
+
const req = { method: "DELETE", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}/attachments/${encodeURIComponent(String(input.attachmentId))}` };
|
|
2536
|
+
return req;
|
|
2537
|
+
},
|
|
2538
|
+
},
|
|
2539
|
+
{
|
|
2540
|
+
name: "test_cases_attachments_list",
|
|
2541
|
+
description: "List test case attachments\n\nTag: Test Case Attachments\n\nLista os anexos do test case. Itens com `uploaded=true` trazem `downloadUrl` (presigned, 300s).",
|
|
2542
|
+
inputSchema: {
|
|
2543
|
+
"type": "object",
|
|
2544
|
+
"properties": {
|
|
2545
|
+
"id": {
|
|
2546
|
+
"type": "string",
|
|
2547
|
+
"format": "uuid",
|
|
2548
|
+
"description": "Test Case ID"
|
|
2549
|
+
}
|
|
2550
|
+
},
|
|
2551
|
+
"additionalProperties": false,
|
|
2552
|
+
"required": [
|
|
2553
|
+
"id"
|
|
2554
|
+
]
|
|
2555
|
+
},
|
|
2556
|
+
request: (input) => {
|
|
2557
|
+
const req = { method: "GET", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}/attachments` };
|
|
2558
|
+
return req;
|
|
2559
|
+
},
|
|
2560
|
+
},
|
|
2561
|
+
{
|
|
2562
|
+
name: "test_cases_attachments_update",
|
|
2563
|
+
description: "Confirm test case attachment upload\n\nTag: Test Case Attachments\n\nMarca o anexo como enviado (`uploaded=true`) após o PUT no S3.",
|
|
2564
|
+
inputSchema: {
|
|
2565
|
+
"type": "object",
|
|
2566
|
+
"properties": {
|
|
2567
|
+
"id": {
|
|
2568
|
+
"type": "string",
|
|
2569
|
+
"format": "uuid",
|
|
2570
|
+
"description": "Test Case ID"
|
|
2571
|
+
},
|
|
2572
|
+
"attachmentId": {
|
|
2573
|
+
"type": "string",
|
|
2574
|
+
"format": "uuid",
|
|
2575
|
+
"description": "Attachment ID"
|
|
2576
|
+
}
|
|
2577
|
+
},
|
|
2578
|
+
"additionalProperties": false,
|
|
2579
|
+
"required": [
|
|
2580
|
+
"id",
|
|
2581
|
+
"attachmentId"
|
|
2582
|
+
]
|
|
2583
|
+
},
|
|
2584
|
+
request: (input) => {
|
|
2585
|
+
const req = { method: "PATCH", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}/attachments/${encodeURIComponent(String(input.attachmentId))}` };
|
|
2586
|
+
return req;
|
|
2587
|
+
},
|
|
2588
|
+
},
|
|
2589
|
+
{
|
|
2590
|
+
name: "test_cases_create",
|
|
2591
|
+
description: "Create test case\n\nTag: Test Cases",
|
|
2592
|
+
inputSchema: {
|
|
2593
|
+
"type": "object",
|
|
2594
|
+
"properties": {
|
|
2595
|
+
"name": {
|
|
2596
|
+
"type": "string"
|
|
2597
|
+
},
|
|
2598
|
+
"projectId": {
|
|
2599
|
+
"type": "string",
|
|
2600
|
+
"format": "uuid"
|
|
2601
|
+
},
|
|
2602
|
+
"type": {
|
|
2603
|
+
"type": "string",
|
|
2604
|
+
"format": "uuid",
|
|
2605
|
+
"description": "Test case type ID — use GET /v1/test-case-types"
|
|
2606
|
+
},
|
|
2607
|
+
"statusId": {
|
|
2608
|
+
"type": "string",
|
|
2609
|
+
"format": "uuid",
|
|
2610
|
+
"description": "Test case status ID — use GET /v1/test-case-statuses"
|
|
2611
|
+
},
|
|
2612
|
+
"description": {
|
|
2613
|
+
"type": "string"
|
|
2614
|
+
},
|
|
2615
|
+
"preRequirements": {
|
|
2616
|
+
"type": "string"
|
|
2617
|
+
},
|
|
2618
|
+
"expectedResult": {
|
|
2619
|
+
"type": "string"
|
|
2620
|
+
},
|
|
2621
|
+
"scenario": {
|
|
2622
|
+
"type": "string"
|
|
2623
|
+
},
|
|
2624
|
+
"folderId": {
|
|
2625
|
+
"type": "string",
|
|
2626
|
+
"format": "uuid"
|
|
2627
|
+
},
|
|
2628
|
+
"order": {
|
|
2629
|
+
"type": "integer"
|
|
2630
|
+
},
|
|
2631
|
+
"automation": {
|
|
2632
|
+
"type": "string",
|
|
2633
|
+
"enum": [
|
|
2634
|
+
"NOT_AUTOMATED",
|
|
2635
|
+
"AUTOMATED"
|
|
2636
|
+
]
|
|
2637
|
+
},
|
|
2638
|
+
"automated": {
|
|
2639
|
+
"type": "string",
|
|
2640
|
+
"enum": [
|
|
2641
|
+
"NO",
|
|
2642
|
+
"IN_PROGRESS",
|
|
2643
|
+
"YES"
|
|
2644
|
+
],
|
|
2645
|
+
"description": "Estado de automatização exibido na UI. Se omitido, é derivado de `automation` (AUTOMATED→YES, senão NO)."
|
|
2646
|
+
},
|
|
2647
|
+
"specificationTime": {
|
|
2648
|
+
"type": "integer"
|
|
2649
|
+
},
|
|
2650
|
+
"automatizationTime": {
|
|
2651
|
+
"type": "integer"
|
|
2652
|
+
},
|
|
2653
|
+
"bddRawText": {
|
|
2654
|
+
"type": "string"
|
|
2655
|
+
},
|
|
2656
|
+
"customFields": {
|
|
2657
|
+
"type": "array",
|
|
2658
|
+
"description": "Values for the project's custom fields. Discover the available fields and their `id`s via `GET /v1/projects/{projectId}/test-case-custom-fields`.\n\nEach item targets one custom field by `projectCustomFieldId`. Send **`value`** for free-form fields (text, number, …) or **`selectId`** for select-type fields (must reference one of `selects[].id` returned by the listing endpoint). Exactly one of `value`/`selectId` must be provided per item.\n\nOn `POST` the items create the values for the new test case. On `PATCH` each item is upserted by `(testCaseId, projectCustomFieldId)`: existing values are replaced, missing fields are created, and fields not mentioned in the array are left untouched.\n\n**Required fields rule:** every project custom field with `isRequired: true` and `isEnabled: true` must end up with a value. On `POST` they must be present in this array; on `PATCH` they must be either present here or already filled on the test case (otherwise the request is rejected with 400).\n\n**Disabled fields:** entries that target a custom field with `isEnabled: false` are silently ignored — the field is no longer in use, so the value is neither persisted nor counted toward the required-field rule.",
|
|
2659
|
+
"items": {
|
|
2660
|
+
"type": "object",
|
|
2661
|
+
"required": [
|
|
2662
|
+
"projectCustomFieldId"
|
|
2663
|
+
],
|
|
2664
|
+
"properties": {
|
|
2665
|
+
"projectCustomFieldId": {
|
|
2666
|
+
"type": "string",
|
|
2667
|
+
"format": "uuid",
|
|
2668
|
+
"description": "ID returned by GET /v1/projects/{projectId}/test-case-custom-fields."
|
|
2669
|
+
},
|
|
2670
|
+
"value": {
|
|
2671
|
+
"type": [
|
|
2672
|
+
"string",
|
|
2673
|
+
"null"
|
|
2674
|
+
],
|
|
2675
|
+
"description": "Used for non-select fields."
|
|
2676
|
+
},
|
|
2677
|
+
"selectId": {
|
|
2678
|
+
"type": [
|
|
2679
|
+
"string",
|
|
2680
|
+
"null"
|
|
2681
|
+
],
|
|
2682
|
+
"format": "uuid",
|
|
2683
|
+
"description": "Used for select-type fields. Must be one of `selects[].id`."
|
|
2684
|
+
}
|
|
2685
|
+
}
|
|
2686
|
+
}
|
|
2687
|
+
},
|
|
2688
|
+
"steps": {
|
|
2689
|
+
"type": "array",
|
|
2690
|
+
"description": "Test case steps. The required shape depends on the test case type — list the available types and their IDs via `GET /v1/test-case-types` and pass the chosen `id` as `type` in the body. The four built-in types behave as follows:\n\n- **BDD**: at least 1 step required. Each step has `description` (required), `gherkinKeyword` (optional, defaults to `given`), and `data` (optional). `expectedResult` on the step is rejected — the BDD outcome is expressed by the `then` keyword.\n- **EXPECTED_RESULT_PER_STEP**: at least 1 step required. Each step has `description` and `expectedResult` (both required); `data` is optional. `gherkinKeyword` is rejected.\n- **GENERAL_EXEPECTED_RESULT**: steps are optional. When provided, each step has `description` (required) and `data` (optional). `expectedResult` on the test case (top-level) is required.\n- **NO_STEP**: steps are rejected. `expectedResult` on the test case is required.\n\nOn `POST` the steps are created with the new test case. On `PATCH` sending `steps` replaces the existing list (soft-deletes old steps and creates new ones). Omit `steps` from the body to leave them untouched.",
|
|
2691
|
+
"items": {
|
|
2692
|
+
"type": "object",
|
|
2693
|
+
"required": [
|
|
2694
|
+
"description"
|
|
2695
|
+
],
|
|
2696
|
+
"properties": {
|
|
2697
|
+
"description": {
|
|
2698
|
+
"type": "string",
|
|
2699
|
+
"description": "Step description. Required for every type."
|
|
2700
|
+
},
|
|
2701
|
+
"expectedResult": {
|
|
2702
|
+
"type": "string",
|
|
2703
|
+
"description": "Required for EXPECTED_RESULT_PER_STEP. Rejected for BDD/NO_STEP/GENERAL_EXEPECTED_RESULT."
|
|
2704
|
+
},
|
|
2705
|
+
"data": {
|
|
2706
|
+
"type": "string",
|
|
2707
|
+
"description": "Optional input data — accepted for BDD, EXPECTED_RESULT_PER_STEP and GENERAL_EXEPECTED_RESULT. Rejected for NO_STEP."
|
|
2708
|
+
},
|
|
2709
|
+
"gherkinKeyword": {
|
|
2710
|
+
"type": "string",
|
|
2711
|
+
"enum": [
|
|
2712
|
+
"given",
|
|
2713
|
+
"and",
|
|
2714
|
+
"when",
|
|
2715
|
+
"then",
|
|
2716
|
+
"but"
|
|
2717
|
+
],
|
|
2718
|
+
"description": "BDD only — defaults to `given`. Rejected for other types."
|
|
2719
|
+
}
|
|
2720
|
+
}
|
|
2721
|
+
}
|
|
2722
|
+
}
|
|
2723
|
+
},
|
|
2724
|
+
"additionalProperties": false,
|
|
2725
|
+
"required": [
|
|
2726
|
+
"name",
|
|
2727
|
+
"projectId",
|
|
2728
|
+
"type",
|
|
2729
|
+
"statusId"
|
|
2730
|
+
]
|
|
2731
|
+
},
|
|
2732
|
+
request: (input) => {
|
|
2733
|
+
const req = { method: "POST", path: "/v1/test-cases" };
|
|
2734
|
+
const body = {};
|
|
2735
|
+
if (input.name !== undefined)
|
|
2736
|
+
body["name"] = input.name;
|
|
2737
|
+
if (input.projectId !== undefined)
|
|
2738
|
+
body["projectId"] = input.projectId;
|
|
2739
|
+
if (input.type !== undefined)
|
|
2740
|
+
body["type"] = input.type;
|
|
2741
|
+
if (input.statusId !== undefined)
|
|
2742
|
+
body["statusId"] = input.statusId;
|
|
2743
|
+
if (input.description !== undefined)
|
|
2744
|
+
body["description"] = input.description;
|
|
2745
|
+
if (input.preRequirements !== undefined)
|
|
2746
|
+
body["preRequirements"] = input.preRequirements;
|
|
2747
|
+
if (input.expectedResult !== undefined)
|
|
2748
|
+
body["expectedResult"] = input.expectedResult;
|
|
2749
|
+
if (input.scenario !== undefined)
|
|
2750
|
+
body["scenario"] = input.scenario;
|
|
2751
|
+
if (input.folderId !== undefined)
|
|
2752
|
+
body["folderId"] = input.folderId;
|
|
2753
|
+
if (input.order !== undefined)
|
|
2754
|
+
body["order"] = input.order;
|
|
2755
|
+
if (input.automation !== undefined)
|
|
2756
|
+
body["automation"] = input.automation;
|
|
2757
|
+
if (input.automated !== undefined)
|
|
2758
|
+
body["automated"] = input.automated;
|
|
2759
|
+
if (input.specificationTime !== undefined)
|
|
2760
|
+
body["specificationTime"] = input.specificationTime;
|
|
2761
|
+
if (input.automatizationTime !== undefined)
|
|
2762
|
+
body["automatizationTime"] = input.automatizationTime;
|
|
2763
|
+
if (input.bddRawText !== undefined)
|
|
2764
|
+
body["bddRawText"] = input.bddRawText;
|
|
2765
|
+
if (input.customFields !== undefined)
|
|
2766
|
+
body["customFields"] = input.customFields;
|
|
2767
|
+
if (input.steps !== undefined)
|
|
2768
|
+
body["steps"] = input.steps;
|
|
2769
|
+
req.body = body;
|
|
2770
|
+
return req;
|
|
2771
|
+
},
|
|
2772
|
+
},
|
|
2773
|
+
{
|
|
2774
|
+
name: "test_cases_delete",
|
|
2775
|
+
description: "Delete test case\n\nTag: Test Cases",
|
|
2776
|
+
inputSchema: {
|
|
2777
|
+
"type": "object",
|
|
2778
|
+
"properties": {
|
|
2779
|
+
"id": {
|
|
2780
|
+
"type": "string",
|
|
2781
|
+
"format": "uuid",
|
|
2782
|
+
"description": "Test Case ID"
|
|
2783
|
+
}
|
|
2784
|
+
},
|
|
2785
|
+
"additionalProperties": false,
|
|
2786
|
+
"required": [
|
|
2787
|
+
"id"
|
|
2788
|
+
]
|
|
2789
|
+
},
|
|
2790
|
+
request: (input) => {
|
|
2791
|
+
const req = { method: "DELETE", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}` };
|
|
2792
|
+
return req;
|
|
2793
|
+
},
|
|
2794
|
+
},
|
|
2795
|
+
{
|
|
2796
|
+
name: "test_cases_get",
|
|
2797
|
+
description: "Get test case by ID\n\nTag: Test Cases",
|
|
2798
|
+
inputSchema: {
|
|
2799
|
+
"type": "object",
|
|
2800
|
+
"properties": {
|
|
2801
|
+
"id": {
|
|
2802
|
+
"type": "string",
|
|
2803
|
+
"format": "uuid",
|
|
2804
|
+
"description": "Test Case ID"
|
|
2805
|
+
}
|
|
2806
|
+
},
|
|
2807
|
+
"additionalProperties": false,
|
|
2808
|
+
"required": [
|
|
2809
|
+
"id"
|
|
2810
|
+
]
|
|
2811
|
+
},
|
|
2812
|
+
request: (input) => {
|
|
2813
|
+
const req = { method: "GET", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}` };
|
|
2814
|
+
return req;
|
|
2815
|
+
},
|
|
2816
|
+
},
|
|
2817
|
+
{
|
|
2818
|
+
name: "test_cases_list",
|
|
2819
|
+
description: "List test cases\n\nTag: Test Cases\n\nAt least one query parameter is required: **projectId** or **folderId**. Archived test cases (`statusId === ARCHIVED`) are excluded — use `GET /v1/test-cases/archived` to list those.",
|
|
2820
|
+
inputSchema: {
|
|
2821
|
+
"type": "object",
|
|
2822
|
+
"properties": {
|
|
2823
|
+
"projectId": {
|
|
2824
|
+
"type": "string",
|
|
2825
|
+
"format": "uuid",
|
|
2826
|
+
"description": "Filter by project. At least one of projectId or folderId is required."
|
|
2827
|
+
},
|
|
2828
|
+
"folderId": {
|
|
2829
|
+
"type": "string",
|
|
2830
|
+
"format": "uuid",
|
|
2831
|
+
"description": "Filter by folder. At least one of projectId or folderId is required."
|
|
2832
|
+
}
|
|
2833
|
+
},
|
|
2834
|
+
"additionalProperties": false
|
|
2835
|
+
},
|
|
2836
|
+
request: (input) => {
|
|
2837
|
+
const req = { method: "GET", path: "/v1/test-cases" };
|
|
2838
|
+
const query = {};
|
|
2839
|
+
if (input.projectId !== undefined && input.projectId !== null)
|
|
2840
|
+
query["projectId"] = String(input.projectId);
|
|
2841
|
+
if (input.folderId !== undefined && input.folderId !== null)
|
|
2842
|
+
query["folderId"] = String(input.folderId);
|
|
2843
|
+
if (Object.keys(query).length > 0)
|
|
2844
|
+
req.query = query;
|
|
2845
|
+
return req;
|
|
2846
|
+
},
|
|
2847
|
+
},
|
|
2848
|
+
{
|
|
2849
|
+
name: "test_cases_unarchive",
|
|
2850
|
+
description: "Unarchive test case\n\nTag: Test Cases\n\nRestores an archived test case (`statusId === ARCHIVED`) into the folder specified by `folderId`. The status returns to whatever it was before archiving (`statusBeforeId`); when no previous status is recorded the test case falls back to `FINISHED`.",
|
|
2851
|
+
inputSchema: {
|
|
2852
|
+
"type": "object",
|
|
2853
|
+
"properties": {
|
|
2854
|
+
"id": {
|
|
2855
|
+
"type": "string",
|
|
2856
|
+
"format": "uuid",
|
|
2857
|
+
"description": "Test Case ID"
|
|
2858
|
+
},
|
|
2859
|
+
"folderId": {
|
|
2860
|
+
"type": "string",
|
|
2861
|
+
"format": "uuid",
|
|
2862
|
+
"description": "Target folder. Must belong to the same project as the test case and must not be a trash folder."
|
|
2863
|
+
}
|
|
2864
|
+
},
|
|
2865
|
+
"additionalProperties": false,
|
|
2866
|
+
"required": [
|
|
2867
|
+
"id",
|
|
2868
|
+
"folderId"
|
|
2869
|
+
]
|
|
2870
|
+
},
|
|
2871
|
+
request: (input) => {
|
|
2872
|
+
const req = { method: "POST", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}/unarchive` };
|
|
2873
|
+
const body = {};
|
|
2874
|
+
if (input.folderId !== undefined)
|
|
2875
|
+
body["folderId"] = input.folderId;
|
|
2876
|
+
req.body = body;
|
|
2877
|
+
return req;
|
|
2878
|
+
},
|
|
2879
|
+
},
|
|
2880
|
+
{
|
|
2881
|
+
name: "test_cases_update",
|
|
2882
|
+
description: "Update test case\n\nTag: Test Cases\n\nArchived test cases (`statusId === ARCHIVED`) are read-only and cannot be updated through this endpoint.",
|
|
2883
|
+
inputSchema: {
|
|
2884
|
+
"type": "object",
|
|
2885
|
+
"properties": {
|
|
2886
|
+
"id": {
|
|
2887
|
+
"type": "string",
|
|
2888
|
+
"format": "uuid",
|
|
2889
|
+
"description": "Test Case ID"
|
|
2890
|
+
},
|
|
2891
|
+
"name": {
|
|
2892
|
+
"type": "string"
|
|
2893
|
+
},
|
|
2894
|
+
"type": {
|
|
2895
|
+
"type": "string",
|
|
2896
|
+
"format": "uuid"
|
|
2897
|
+
},
|
|
2898
|
+
"description": {
|
|
2899
|
+
"type": [
|
|
2900
|
+
"string",
|
|
2901
|
+
"null"
|
|
2902
|
+
]
|
|
2903
|
+
},
|
|
2904
|
+
"preRequirements": {
|
|
2905
|
+
"type": [
|
|
2906
|
+
"string",
|
|
2907
|
+
"null"
|
|
2908
|
+
]
|
|
2909
|
+
},
|
|
2910
|
+
"expectedResult": {
|
|
2911
|
+
"type": [
|
|
2912
|
+
"string",
|
|
2913
|
+
"null"
|
|
2914
|
+
]
|
|
2915
|
+
},
|
|
2916
|
+
"scenario": {
|
|
2917
|
+
"type": [
|
|
2918
|
+
"string",
|
|
2919
|
+
"null"
|
|
2920
|
+
]
|
|
2921
|
+
},
|
|
2922
|
+
"statusId": {
|
|
2923
|
+
"type": "string",
|
|
2924
|
+
"format": "uuid"
|
|
2925
|
+
},
|
|
2926
|
+
"folderId": {
|
|
2927
|
+
"type": [
|
|
2928
|
+
"string",
|
|
2929
|
+
"null"
|
|
2930
|
+
],
|
|
2931
|
+
"format": "uuid"
|
|
2932
|
+
},
|
|
2933
|
+
"order": {
|
|
2934
|
+
"type": "integer"
|
|
2935
|
+
},
|
|
2936
|
+
"automation": {
|
|
2937
|
+
"type": [
|
|
2938
|
+
"string",
|
|
2939
|
+
"null"
|
|
2940
|
+
],
|
|
2941
|
+
"enum": [
|
|
2942
|
+
"NOT_AUTOMATED",
|
|
2943
|
+
"AUTOMATED"
|
|
2944
|
+
]
|
|
2945
|
+
},
|
|
2946
|
+
"automated": {
|
|
2947
|
+
"type": "string",
|
|
2948
|
+
"enum": [
|
|
2949
|
+
"NO",
|
|
2950
|
+
"IN_PROGRESS",
|
|
2951
|
+
"YES"
|
|
2952
|
+
],
|
|
2953
|
+
"description": "Estado de automatização exibido na UI. Se omitido, é derivado de `automation` (AUTOMATED→YES, senão NO)."
|
|
2954
|
+
},
|
|
2955
|
+
"specificationTime": {
|
|
2956
|
+
"type": "integer"
|
|
2957
|
+
},
|
|
2958
|
+
"automatizationTime": {
|
|
2959
|
+
"type": "integer"
|
|
2960
|
+
},
|
|
2961
|
+
"bddRawText": {
|
|
2962
|
+
"type": [
|
|
2963
|
+
"string",
|
|
2964
|
+
"null"
|
|
2965
|
+
]
|
|
2966
|
+
},
|
|
2967
|
+
"customFields": {
|
|
2968
|
+
"type": "array",
|
|
2969
|
+
"description": "Values for the project's custom fields. Discover the available fields and their `id`s via `GET /v1/projects/{projectId}/test-case-custom-fields`.\n\nEach item targets one custom field by `projectCustomFieldId`. Send **`value`** for free-form fields (text, number, …) or **`selectId`** for select-type fields (must reference one of `selects[].id` returned by the listing endpoint). Exactly one of `value`/`selectId` must be provided per item.\n\nOn `POST` the items create the values for the new test case. On `PATCH` each item is upserted by `(testCaseId, projectCustomFieldId)`: existing values are replaced, missing fields are created, and fields not mentioned in the array are left untouched.\n\n**Required fields rule:** every project custom field with `isRequired: true` and `isEnabled: true` must end up with a value. On `POST` they must be present in this array; on `PATCH` they must be either present here or already filled on the test case (otherwise the request is rejected with 400).\n\n**Disabled fields:** entries that target a custom field with `isEnabled: false` are silently ignored — the field is no longer in use, so the value is neither persisted nor counted toward the required-field rule.",
|
|
2970
|
+
"items": {
|
|
2971
|
+
"type": "object",
|
|
2972
|
+
"required": [
|
|
2973
|
+
"projectCustomFieldId"
|
|
2974
|
+
],
|
|
2975
|
+
"properties": {
|
|
2976
|
+
"projectCustomFieldId": {
|
|
2977
|
+
"type": "string",
|
|
2978
|
+
"format": "uuid",
|
|
2979
|
+
"description": "ID returned by GET /v1/projects/{projectId}/test-case-custom-fields."
|
|
2980
|
+
},
|
|
2981
|
+
"value": {
|
|
2982
|
+
"type": [
|
|
2983
|
+
"string",
|
|
2984
|
+
"null"
|
|
2985
|
+
],
|
|
2986
|
+
"description": "Used for non-select fields."
|
|
2987
|
+
},
|
|
2988
|
+
"selectId": {
|
|
2989
|
+
"type": [
|
|
2990
|
+
"string",
|
|
2991
|
+
"null"
|
|
2992
|
+
],
|
|
2993
|
+
"format": "uuid",
|
|
2994
|
+
"description": "Used for select-type fields. Must be one of `selects[].id`."
|
|
2995
|
+
}
|
|
2996
|
+
}
|
|
2997
|
+
}
|
|
2998
|
+
},
|
|
2999
|
+
"steps": {
|
|
3000
|
+
"type": "array",
|
|
3001
|
+
"description": "Test case steps. The required shape depends on the test case type — list the available types and their IDs via `GET /v1/test-case-types` and pass the chosen `id` as `type` in the body. The four built-in types behave as follows:\n\n- **BDD**: at least 1 step required. Each step has `description` (required), `gherkinKeyword` (optional, defaults to `given`), and `data` (optional). `expectedResult` on the step is rejected — the BDD outcome is expressed by the `then` keyword.\n- **EXPECTED_RESULT_PER_STEP**: at least 1 step required. Each step has `description` and `expectedResult` (both required); `data` is optional. `gherkinKeyword` is rejected.\n- **GENERAL_EXEPECTED_RESULT**: steps are optional. When provided, each step has `description` (required) and `data` (optional). `expectedResult` on the test case (top-level) is required.\n- **NO_STEP**: steps are rejected. `expectedResult` on the test case is required.\n\nOn `POST` the steps are created with the new test case. On `PATCH` sending `steps` replaces the existing list (soft-deletes old steps and creates new ones). Omit `steps` from the body to leave them untouched.",
|
|
3002
|
+
"items": {
|
|
3003
|
+
"type": "object",
|
|
3004
|
+
"required": [
|
|
3005
|
+
"description"
|
|
3006
|
+
],
|
|
3007
|
+
"properties": {
|
|
3008
|
+
"description": {
|
|
3009
|
+
"type": "string",
|
|
3010
|
+
"description": "Step description. Required for every type."
|
|
3011
|
+
},
|
|
3012
|
+
"expectedResult": {
|
|
3013
|
+
"type": "string",
|
|
3014
|
+
"description": "Required for EXPECTED_RESULT_PER_STEP. Rejected for BDD/NO_STEP/GENERAL_EXEPECTED_RESULT."
|
|
3015
|
+
},
|
|
3016
|
+
"data": {
|
|
3017
|
+
"type": "string",
|
|
3018
|
+
"description": "Optional input data — accepted for BDD, EXPECTED_RESULT_PER_STEP and GENERAL_EXEPECTED_RESULT. Rejected for NO_STEP."
|
|
3019
|
+
},
|
|
3020
|
+
"gherkinKeyword": {
|
|
3021
|
+
"type": "string",
|
|
3022
|
+
"enum": [
|
|
3023
|
+
"given",
|
|
3024
|
+
"and",
|
|
3025
|
+
"when",
|
|
3026
|
+
"then",
|
|
3027
|
+
"but"
|
|
3028
|
+
],
|
|
3029
|
+
"description": "BDD only — defaults to `given`. Rejected for other types."
|
|
3030
|
+
}
|
|
3031
|
+
}
|
|
3032
|
+
}
|
|
3033
|
+
}
|
|
3034
|
+
},
|
|
3035
|
+
"additionalProperties": false,
|
|
3036
|
+
"required": [
|
|
3037
|
+
"id"
|
|
3038
|
+
]
|
|
3039
|
+
},
|
|
3040
|
+
request: (input) => {
|
|
3041
|
+
const req = { method: "PATCH", path: `/v1/test-cases/${encodeURIComponent(String(input.id))}` };
|
|
3042
|
+
const body = {};
|
|
3043
|
+
if (input.name !== undefined)
|
|
3044
|
+
body["name"] = input.name;
|
|
3045
|
+
if (input.type !== undefined)
|
|
3046
|
+
body["type"] = input.type;
|
|
3047
|
+
if (input.description !== undefined)
|
|
3048
|
+
body["description"] = input.description;
|
|
3049
|
+
if (input.preRequirements !== undefined)
|
|
3050
|
+
body["preRequirements"] = input.preRequirements;
|
|
3051
|
+
if (input.expectedResult !== undefined)
|
|
3052
|
+
body["expectedResult"] = input.expectedResult;
|
|
3053
|
+
if (input.scenario !== undefined)
|
|
3054
|
+
body["scenario"] = input.scenario;
|
|
3055
|
+
if (input.statusId !== undefined)
|
|
3056
|
+
body["statusId"] = input.statusId;
|
|
3057
|
+
if (input.folderId !== undefined)
|
|
3058
|
+
body["folderId"] = input.folderId;
|
|
3059
|
+
if (input.order !== undefined)
|
|
3060
|
+
body["order"] = input.order;
|
|
3061
|
+
if (input.automation !== undefined)
|
|
3062
|
+
body["automation"] = input.automation;
|
|
3063
|
+
if (input.automated !== undefined)
|
|
3064
|
+
body["automated"] = input.automated;
|
|
3065
|
+
if (input.specificationTime !== undefined)
|
|
3066
|
+
body["specificationTime"] = input.specificationTime;
|
|
3067
|
+
if (input.automatizationTime !== undefined)
|
|
3068
|
+
body["automatizationTime"] = input.automatizationTime;
|
|
3069
|
+
if (input.bddRawText !== undefined)
|
|
3070
|
+
body["bddRawText"] = input.bddRawText;
|
|
3071
|
+
if (input.customFields !== undefined)
|
|
3072
|
+
body["customFields"] = input.customFields;
|
|
3073
|
+
if (input.steps !== undefined)
|
|
3074
|
+
body["steps"] = input.steps;
|
|
3075
|
+
req.body = body;
|
|
3076
|
+
return req;
|
|
3077
|
+
},
|
|
3078
|
+
}
|
|
3079
|
+
];
|
|
3080
|
+
//# sourceMappingURL=tools.generated.js.map
|