ApiRoute

The node is used for the specific endpoint description. Its interface is smilar to the one of a RequestStep node. No surprises, in both cases we deal with HTTP requests.
The main features of an ApiRoute node are:
Describing request HTTP headers, query parameters, body parameters and response HTTP codes, HTTP headers and body parameters;
Using types for describing every header, query parameter, and body parameter. Supported types: string, number, integer, boolean, array, and object;
Describing every entity;
Describing a number of request body parameters (based on content-type);
Describing a number of possible responses;
Creating a request out of the description;
Autocompletion of URLs, HTTP headers, query and body parameters in RequestStep nodes.
Interface Overview
To create an ApiRoute node right-click in the ApiFolder node and choose Add node -> ApiRoute.
An ApiRoute node in the project tree
This is how it looks like in the project tree:
An ApiRoute node in the project tree
The icon of these nodes is the HTTP method name. An ApiRoute node has the following context menu:
The ApiRoute context menu
Rename. Change the node name.
Duplicate. Make a copy of the node. The new node will be named NodeName [Copy [number]].
Remove node. Use it to delete the node.
Show in explorer. Open the folder with the node in the file manager.
The ApiRoute Tab Interface
The ApiRoute node tab looks like this:
The ApiRoute tab
General Request Parameters
Look a little closer at the top part of the tab:
The top part of the ApiRoute node tab
In the screenshot you can see the following parts of the interface.
1.HTTP method. The list of available methods is identical to the one of RequestStep nodes.
2.URL with the variables mechanism support.
3.The Variables dialog button.
4.The button to create a request out of the current API description.
5.The request description (text).
Request parameters description area
At the bottom left of the screen you can see the request description area. There are 3 tabs - Headers, Query parameters, and Body, that you can use to edit HTTP headers, query parameters, and request body parameters accordingly.
Let's look at the Headers tab. You can see that it is a table with the following fields:
Header name;
Header value type (as described above);
Description.
All possible standard operations are supported.
The Query Parameters tab is used for editing query parameters, and it is functually identical to the Headers tab.
As mentioned before, in an ApiRoute node you can describe several bodies for a single request. For example, a single endpoint can take the data both with the application/json and application/xml Content-Type. There are several different content-type tabs on the Body tab:
The Body tab of the request description interface
In the screenshot you can see the following parts of the interface:
1.The button that edits the current content-type value. If you click on it, you'll see a text box instead, where you can enter your content-type value.
2.Delete the request body button.
3.Add the request body button.
4.The current content-type of the node.
5.The request body editing area.
The request body editing area changes according to the content-type value:  if the content-type isapplication/x-www-form-urlencoded ormultipart/form-data, then the editing area looks like a table (like in the Headers tab), otherwise it has the text representation like in the screenshot above. The description format is OpenAPI in this case.
Request parameters description area
There is a response editing panel at the bottom right of the ApiRoute tab interface. As mentioned before, TestMace allows you to describe several responses for a single endpoint. Look at the interface:
The server response editing area
There is a separate tab for each response. On these tabs you can edit response codes, descriptions, and even response HTTP headers and bodies. The interface is similar to ones in the request area.
Integration with RequestStep nodes
TestMace provides integration with ApiRoute nodes in RequestStep nodes. The integration is implemented in autocompletion of URLs, HTTP headers, query parameters, RequestStep nodes' request body parameters. Autocompletion works for all ApiRoute nodes URLs, but for other parameters the following algorithm is applied:
Take the RequestStep node method and URL;
Find all ApiRoute nodes with this method and URL;
Run the specified parameter (e. g. an HTTP header) search among the ApiRoute nodes.
File Representation
An ApiRoute node is a folder with the node name, containing the index.yml file with the following format:
1
{
2
  "type": "object",
3
  "properties": {
4
    "type": {
5
      "description": "Type of ApiRoute node",
6
      "const": "ApiRoute",
7
      "type": "string"
8
    },
9
    "url": {
10
      "type": "string",
11
      "default": ""
12
    },
13
    "method": {
14
      "$ref": "#/definitions/RequestMethod"
15
    },
16
    "description": {
17
      "type": "string",
18
      "default": ""
19
    },
20
    "requests": {
21
      "$ref": "#/definitions/ApiRequests",
22
      "description": "List of requests"
23
    },
24
    "responses": {
25
      "description": "List of responses",
26
      "type": "array",
27
      "items": {
28
        "$ref": "#/definitions/ResponseParameters"
29
      },
30
      "default": []
31
    },
32
    "children": {
33
      "description": "List of children names",
34
      "type": "array",
35
      "items": {
36
        "type": "string"
37
      },
38
      "default": []
39
    },
40
    "variables": {
41
      "$ref": "#/definitions/NodeVariables",
42
      "description": "Node variables dictionary"
43
    },
44
    "name": {
45
      "description": "Node name",
46
      "type": "string"
47
    }
48
  },
49
  "required": [
50
    "children",
51
    "description",
52
    "method",
53
    "name",
54
    "requests",
55
    "responses",
56
    "type",
57
    "url",
58
    "variables"
59
  ],
60
  "definitions": {
61
    "RequestMethod": {
62
      "enum": [
63
        "DELETE",
64
        "GET",
65
        "OPTIONS",
66
        "PATCH",
67
        "POST",
68
        "PUT"
69
      ],
70
      "type": "string"
71
    },
72
    "ApiRequests": {
73
      "type": "object",
74
      "properties": {
75
        "queryParameters": {
76
          "description": "List of query parameters",
77
          "type": "array",
78
          "items": {
79
            "$ref": "#/definitions/QueryParameter"
80
          }
81
        },
82
        "headers": {
83
          "description": "List of headers",
84
          "type": "array",
85
          "items": {
86
            "$ref": "#/definitions/QueryParameter"
87
          }
88
        },
89
        "cookies": {
90
          "description": "List of cookies",
91
          "type": "array",
92
          "items": {
93
            "$ref": "#/definitions/QueryParameter"
94
          }
95
        },
96
        "bodies": {
97
          "description": "List of bodies",
98
          "type": "array",
99
          "items": {
100
            "$ref": "#/definitions/RequestParameters"
101
          },
102
          "default": []
103
        }
104
      },
105
      "required": [
106
        "bodies",
107
        "cookies",
108
        "headers",
109
        "queryParameters"
110
      ]
111
    },
112
    "QueryParameter": {
113
      "type": "object",
114
      "properties": {
115
        "name": {
116
          "type": "string"
117
        },
118
        "type": {
119
          "enum": [
120
            "array",
121
            "boolean",
122
            "integer",
123
            "number",
124
            "object",
125
            "string"
126
          ],
127
          "type": "string"
128
        },
129
        "description": {
130
          "type": "string"
131
        }
132
      },
133
      "required": [
134
        "name",
135
        "type"
136
      ]
137
    },
138
    "RequestParameters": {
139
      "type": "object",
140
      "properties": {
141
        "contentType": {
142
          "type": "string"
143
        },
144
        "schema": {
145
          "anyOf": [
146
            {
147
              "$ref": "#/definitions/SchemaRef"
148
            },
149
            {
150
              "$ref": "#/definitions/OneOf"
151
            },
152
            {
153
              "$ref": "#/definitions/AllOf"
154
            },
155
            {
156
              "$ref": "#/definitions/AnyOf"
157
            },
158
            {
159
              "$ref": "#/definitions/ObjectMember"
160
            },
161
            {
162
              "$ref": "#/definitions/ArrayMember"
163
            },
164
            {
165
              "$ref": "#/definitions/ScalarMember"
166
            }
167
          ]
168
        }
169
      },
170
      "required": [
171
        "contentType",
172
        "schema"
173
      ]
174
    },
175
    "SchemaRef": {
176
      "type": "object",
177
      "properties": {
178
        "$ref": {
179
          "type": "string"
180
        }
181
      },
182
      "required": [
183
        "$ref"
184
      ]
185
    },
186
    "OneOf": {
187
      "type": "object",
188
      "properties": {
189
        "oneOf": {
190
          "type": "array",
191
          "items": {
192
            "anyOf": [
193
              {
194
                "$ref": "#/definitions/SchemaRef"
195
              },
196
              {
197
                "$ref": "#/definitions/OneOf"
198
              },
199
              {
200
                "$ref": "#/definitions/AllOf"
201
              },
202
              {
203
                "$ref": "#/definitions/AnyOf"
204
              },
205
              {
206
                "$ref": "#/definitions/ObjectMember"
207
              },
208
              {
209
                "$ref": "#/definitions/ArrayMember"
210
              },
211
              {
212
                "$ref": "#/definitions/ScalarMember"
213
              }
214
            ]
215
          }
216
        }
217
      },
218
      "required": [
219
        "oneOf"
220
      ]
221
    },
222
    "AllOf": {
223
      "type": "object",
224
      "properties": {
225
        "allOf": {
226
          "type": "array",
227
          "items": {
228
            "anyOf": [
229
              {
230
                "$ref": "#/definitions/SchemaRef"
231
              },
232
              {
233
                "$ref": "#/definitions/OneOf"
234
              },
235
              {
236
                "$ref": "#/definitions/AllOf"
237
              },
238
              {
239
                "$ref": "#/definitions/AnyOf"
240
              },
241
              {
242
                "$ref": "#/definitions/ObjectMember"
243
              },
244
              {
245
                "$ref": "#/definitions/ArrayMember"
246
              },
247
              {
248
                "$ref": "#/definitions/ScalarMember"
249
              }
250
            ]
251
          }
252
        }
253
      },
254
      "required": [
255
        "allOf"
256
      ]
257
    },
258
    "AnyOf": {
259
      "type": "object",
260
      "properties": {
261
        "anyOf": {
262
          "type": "array",
263
          "items": {
264
            "anyOf": [
265
              {
266
                "$ref": "#/definitions/SchemaRef"
267
              },
268
              {
269
                "$ref": "#/definitions/OneOf"
270
              },
271
              {
272
                "$ref": "#/definitions/AllOf"
273
              },
274
              {
275
                "$ref": "#/definitions/AnyOf"
276
              },
277
              {
278
                "$ref": "#/definitions/ObjectMember"
279
              },
280
              {
281
                "$ref": "#/definitions/ArrayMember"
282
              },
283
              {
284
                "$ref": "#/definitions/ScalarMember"
285
              }
286
            ]
287
          }
288
        }
289
      },
290
      "required": [
291
        "anyOf"
292
      ]
293
    },
294
    "ObjectMember": {
295
      "type": "object",
296
      "properties": {
297
        "type": {
298
          "type": "string",
299
          "enum": [
300
            "object"
301
          ]
302
        },
303
        "properties": {
304
          "$ref": "#/definitions/SchemaMember"
305
        },
306
        "required": {
307
          "type": "boolean"
308
        },
309
        "additionalProperties": {
310
          "$ref": "#/definitions/ScalarMember"
311
        },
312
        "description": {
313
          "type": "string"
314
        }
315
      },
316
      "required": [
317
        "type"
318
      ]
319
    },
320
    "SchemaMember": {
321
      "type": "object",
322
      "additionalProperties": {
323
        "anyOf": [
324
          {
325
            "$ref": "#/definitions/SchemaRef"
326
          },
327
          {
328
            "$ref": "#/definitions/OneOf"
329
          },
330
          {
331
            "$ref": "#/definitions/AllOf"
332
          },
333
          {
334
            "$ref": "#/definitions/AnyOf"
335
          },
336
          {
337
            "$ref": "#/definitions/ObjectMember"
338
          },
339
          {
340
            "$ref": "#/definitions/ArrayMember"
341
          },
342
          {
343
            "$ref": "#/definitions/ScalarMember"
344
          }
345
        ]
346
      }
347
    },
348
    "ArrayMember": {
349
      "type": "object",
350
      "properties": {
351
        "type": {
352
          "type": "string",
353
          "enum": [
354
            "array"
355
          ]
356
        },
357
        "items": {
358
          "anyOf": [
359
            {
360
              "$ref": "#/definitions/SchemaRef"
361
            },
362
            {
363
              "$ref": "#/definitions/OneOf"
364
            },
365
            {
366
              "$ref": "#/definitions/AllOf"
367
            },
368
            {
369
              "$ref": "#/definitions/AnyOf"
370
            },
371
            {
372
              "$ref": "#/definitions/ObjectMember"
373
            },
374
            {
375
              "$ref": "#/definitions/ArrayMember"
376
            },
377
            {
378
              "$ref": "#/definitions/ScalarMember"
379
            }
380
          ]
381
        },
382
        "description": {
383
          "type": "string"
384
        }
385
      },
386
      "required": [
387
        "items",
388
        "type"
389
      ]
390
    },
391
    "ScalarMember": {
392
      "type": "object",
393
      "properties": {
394
        "type": {
395
          "$ref": "#/definitions/ScalarSchemaType"
396
        },
397
        "description": {
398
          "type": "string"
399
        }
400
      },
401
      "required": [
402
        "type"
403
      ]
404
    },
405
    "ScalarSchemaType": {
406
      "enum": [
407
        "boolean",
408
        "integer",
409
        "number",
410
        "string"
411
      ],
412
      "type": "string"
413
    },
414
    "ResponseParameters": {
415
      "type": "object",
416
      "properties": {
417
        "code": {
418
          "description": "Http-code (e.g. 200, 404)",
419
          "type": "string"
420
        },
421
        "description": {
422
          "type": "string"
423
        },
424
        "headers": {
425
          "type": "array",
426
          "items": {
427
            "$ref": "#/definitions/QueryParameter"
428
          }
429
        },
430
        "content": {
431
          "$ref": "#/definitions/RequestParameters",
432
          "description": "Response body"
433
        }
434
      },
435
      "required": [
436
        "code",
437
        "content"
438
      ]
439
    },
440
    "NodeVariables": {
441
      "type": "object",
442
      "additionalProperties": {
443
        "type": "string"
444
      }
445
    }
446
  },
447
  "$schema": "http://json-schema.org/draft-07/schema#"
448
}
Copied!
​
ApiFolder
API Description Import
Last modified 2yr ago
Copy link
Contents
Interface Overview
An ApiRoute node in the project tree
The ApiRoute Tab Interface
Integration with RequestStep nodes
File Representation