loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

[K6 Generator] various enhancements (request body example data extraction, support for generating scenario tests and load tests out of the box, and much more) (#11106)

Browse Source 
* Further K6 OpenAPI generator enhancements

 * request body example data extraction
 * request grouping and ordering
 * response visibility
 * request data extraction for chaining requests

Signed-off-by: Michael H. Siemaszko <mhs@into.software>

* Further K6 OpenAPI generator enhancements

 - regenerated samples

Signed-off-by: Michael H. Siemaszko <mhs@into.software>

* Fix suggested changes by linter

* Fix extra spaces in the template

* Log exception

* Rename function signature to camelCase

* Address comments on Big-O

* Move declaration of variable near the usage

* Add config file for generating k6 script

* Regenerate k6 script

* Regenerate samples

* Fix predicate

* Fix missing import

Co-authored-by: Michael H. Siemaszko <mhs@into.software>
This commit is contained in:
Mostafa Moradian 2021-12-17 03:18:10 +01:00 committed by GitHub
parent 94e3ae10fd
commit fedc54af9a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 1055 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bin/configs/k6.yaml Normal file
View File

@ -0,0 +1,6 @@
generatorName: k6
outputDir: samples/client/petstore/k6
inputSpec: modules/openapi-generator/src/test/resources/3_0/petstore-with-fake-endpoints-models-for-testing.yaml
templateDir: modules/openapi-generator/src/main/resources/k6
additionalProperties:
appName: PetstoreClient

5
modules/openapi-generator/pom.xml
View File

@ -297,6 +297,11 @@
<artifactId>commons-lang3</artifactId>
<version>${commons-lang.version}</version>
</dependency>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>${commons-text.version}</version>
</dependency>
<dependency>
<groupId>commons-cli</groupId>
<artifactId>commons-cli</artifactId>

35
modules/openapi-generator/src/main/java/org/openapitools/codegen/CodegenOperation.java
View File

@ -66,7 +66,11 @@ public class CodegenOperation {
*
* @return true if parameter exists, false otherwise
*/
private static boolean nonempty(List<?> params) {
private static boolean nonEmpty(List<?> params) {
return params != null && params.size() > 0;
}
private static boolean nonEmpty(Map<?, ?> params) {
return params != null && params.size() > 0;
}
@ -76,7 +80,7 @@ public class CodegenOperation {
* @return true if body parameter exists, false otherwise
*/
public boolean getHasBodyParam() {
return nonempty(bodyParams);
return nonEmpty(bodyParams);
}
/**
@ -85,7 +89,7 @@ public class CodegenOperation {
* @return true if query parameter exists, false otherwise
*/
public boolean getHasQueryParams() {
return nonempty(queryParams);
return nonEmpty(queryParams);
}
/**
@ -103,7 +107,7 @@ public class CodegenOperation {
* @return true if header parameter exists, false otherwise
*/
public boolean getHasHeaderParams() {
return nonempty(headerParams);
return nonEmpty(headerParams);
}
/**
@ -112,7 +116,7 @@ public class CodegenOperation {
* @return true if path parameter exists, false otherwise
*/
public boolean getHasPathParams() {
return nonempty(pathParams);
return nonEmpty(pathParams);
}
/**
@ -121,7 +125,7 @@ public class CodegenOperation {
* @return true if any form parameter exists, false otherwise
*/
public boolean getHasFormParams() {
return nonempty(formParams);
return nonEmpty(formParams);
}
/**
@ -139,7 +143,7 @@ public class CodegenOperation {
* @return true if any cookie parameter exists, false otherwise
*/
public boolean getHasCookieParams() {
return nonempty(cookieParams);
return nonEmpty(cookieParams);
}
/**
@ -148,7 +152,7 @@ public class CodegenOperation {
* @return true if any optional parameter exists, false otherwise
*/
public boolean getHasOptionalParams() {
return nonempty(optionalParams);
return nonEmpty(optionalParams);
}
/**
@ -157,7 +161,7 @@ public class CodegenOperation {
* @return true if any optional parameter exists, false otherwise
*/
public boolean getHasRequiredParams() {
return nonempty(requiredParams);
return nonEmpty(requiredParams);
}
/**
@ -166,7 +170,7 @@ public class CodegenOperation {
* @return true if header response exists, false otherwise
*/
public boolean getHasResponseHeaders() {
return nonempty(responseHeaders);
return nonEmpty(responseHeaders);
}
/**
@ -175,7 +179,7 @@ public class CodegenOperation {
* @return true if examples parameter exists, false otherwise
*/
public boolean getHasExamples() {
return nonempty(examples);
return nonEmpty(examples);
}
/**
@ -187,6 +191,15 @@ public class CodegenOperation {
return responses.stream().filter(response -> response.isDefault).findFirst().isPresent();
}
/**
* Check if there's at least one vendor extension
*
* @return true if vendor extensions exists, false otherwise
*/
public boolean getHasVendorExtensions() {
return nonEmpty(vendorExtensions);
}
/**
* Check if act as Restful index method
*

488
modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/K6ClientCodegen.java
View File

@ -28,22 +28,28 @@ import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.OptionalInt;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Map.Entry;
import java.util.stream.Collectors;
import javax.annotation.Nullable;
import com.google.common.collect.ImmutableMap;
import org.apache.commons.lang3.StringEscapeUtils;
import org.apache.commons.text.StringEscapeUtils;
import org.apache.commons.lang3.StringUtils;
import org.openapitools.codegen.CodegenConfig;
import org.openapitools.codegen.CodegenConstants;
import org.openapitools.codegen.CodegenModel;
import org.openapitools.codegen.CodegenOperation;
import org.openapitools.codegen.CodegenParameter;
import org.openapitools.codegen.CodegenProperty;
import org.openapitools.codegen.CodegenResponse;
@ -56,10 +62,13 @@ import org.openapitools.codegen.utils.ModelUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.samskivert.mustache.Mustache;
import com.samskivert.mustache.Mustache.Lambda;
import com.samskivert.mustache.Template;
import io.swagger.v3.core.util.Json;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.Operation;
import io.swagger.v3.oas.models.PathItem;
@ -73,6 +82,24 @@ import io.swagger.v3.oas.models.servers.Server;
public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
// K6 vendor extension - operation grouping - group operations and define their
// ordering, to allow for e.g. scenario testing
private static final String X_OPERATION_GROUPING = "x-k6-openapi-operation-grouping";
// K6 vendor extension - operation response - for now, allows to hide given
// operation response, so that in case of multiple 2xx responses, generated
// script checks only against e.g. code 200 responses
private static final String X_OPERATION_RESPONSE = "x-k6-openapi-operation-response";
private static final String X_OPERATION_RESPONSE_HIDE = "hide";
// K6 vendor extension - extract data from operation - allows to specify path to
// value in body of response which should be extracted and assigned to variable
// for later use by other operations
private static final String X_OPERATION_DATAEXTRACT = "x-k6-openapi-operation-dataextract";
private static final String X_OPERATION_DATAEXTRACT_OPERATION_ID = "operationId"; // denotes ID of operation whose response body contains value to be extracted
private static final String X_OPERATION_DATAEXTRACT_VALUE_PATH = "valuePath"; // denotes path to value in body of response which should be extracted
private static final String X_OPERATION_DATAEXTRACT_PARAMETER_NAME = "parameterName"; // denotes name of parameter to which extracted value should be assigned
public K6ClientCodegen() {
super();
@ -86,6 +113,7 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
String key;
Object value;
boolean hasExample;
boolean initialize;
public Parameter(String key, Object value) {
this.key = key;
@ -98,6 +126,11 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
this.hasExample = hasExample;
}
public Parameter(String key, boolean initialize) {
this.key = key;
this.initialize = initialize;
}
@Override
public int hashCode() {
return key.hashCode();
@ -110,7 +143,32 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
if (obj == null || getClass() != obj.getClass())
return false;
Parameter p = (Parameter) obj;
return key.equals(p.key) && value.equals(p.value) && hasExample == p.hasExample;
return key.equals(p.key) && value.equals(p.value) && hasExample == p.hasExample
&& initialize == p.initialize;
}
}
// Stores information specified in `X_OPERATION_GROUPING` K6 vendor extension
static class OperationGrouping {
String groupName;
int order;
public OperationGrouping(String groupName, int order) {
this.groupName = groupName;
this.order = order;
}
}
// Stores information specified in `X_OPERATION_DATAEXTRACT` K6 vendor extension
static class DataExtractSubstituteParameter {
String operationId;
String valuePath;
String paramName;
public DataExtractSubstituteParameter(String operationId, String valuePath, String paramName) {
this.operationId = operationId;
this.valuePath = valuePath;
this.paramName = paramName;
}
}
@ -138,10 +196,10 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
@SuppressWarnings("unchecked")
Set<String> exampleValues = ((Map<String, Example>) rawValue).values().stream()
.map(x -> quoteExample(
StringEscapeUtils.escapeEcmaScript(
String.valueOf(x.getValue()))))
.collect(Collectors.toCollection(() -> new TreeSet<>()));
.map(x -> quoteExample(
StringEscapeUtils.escapeEcmaScript(
String.valueOf(x.getValue()))))
.collect(Collectors.toCollection(TreeSet::new));
if (!exampleValues.isEmpty()) {
@ -160,11 +218,20 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
quoteExample(
StringEscapeUtils.escapeEcmaScript(
String.valueOf(
((K6ClientCodegen.Parameter) fragment.context()).value))),
((K6ClientCodegen.Parameter) fragment.context()).value))),
";",
" // extracted from 'example' field defined at the parameter level of OpenAPI spec"));
}
// param needs to be initialized for subsequent data extraction - see `X_OPERATION_DATAEXTRACT` K6 vendor extension
} else if (fragment.context() instanceof K6ClientCodegen.Parameter
&& ((K6ClientCodegen.Parameter) fragment.context()).initialize) {
writer.write(String.join("",
"null",
";",
" // parameter initialized for subsequent data extraction"));
} else {
writer.write(noExampleParamValue);
}
@ -231,25 +298,33 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
static class HTTPRequest {
String method;
boolean isDelete;
String path;
@Nullable
List<Parameter> query;
@Nullable
HTTPBody body;
boolean hasBodyExample;
@Nullable
HTTPParameters params;
@Nullable
List<k6Check> k6Checks;
@Nullable
DataExtractSubstituteParameter dataExtract;
public HTTPRequest(String method, String path, @Nullable List<Parameter> query, @Nullable HTTPBody body,
@Nullable HTTPParameters params, @Nullable List<k6Check> k6Checks) {
boolean hasBodyExample, @Nullable HTTPParameters params, @Nullable List<k6Check> k6Checks,
DataExtractSubstituteParameter dataExtract) {
// NOTE: https://k6.io/docs/javascript-api/k6-http/del-url-body-params
this.method = method.equals("delete") ? "del" : method;
this.isDelete = method.equals("delete");
this.path = path;
this.query = query;
this.body = body;
this.hasBodyExample = hasBodyExample;
this.params = params;
this.k6Checks = k6Checks;
this.dataExtract = dataExtract;
}
}
@ -257,11 +332,26 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
String groupName;
Set<Parameter> variables; // query and path parameters
List<HTTPRequest> requests;
private final Map<Integer, HTTPRequest> requestsMap;
public HTTPRequestGroup(String groupName, Set<Parameter> variables, List<HTTPRequest> requests) {
public HTTPRequestGroup(String groupName, Set<Parameter> variables, Map<Integer, HTTPRequest> requestsMap) {
this.groupName = groupName;
this.variables = variables;
this.requests = requests;
this.requestsMap = requestsMap;
this.requests = sortRequests(requestsMap);
}
private void addRequests(Map<Integer, HTTPRequest> moreRequests) {
this.requestsMap.putAll(moreRequests);
this.requests = sortRequests(this.requestsMap);
}
private void addVariables(Set<Parameter> moreVariables) {
this.variables.addAll(moreVariables);
}
private List<HTTPRequest> sortRequests(Map<Integer, HTTPRequest> requestsMap) {
return new ArrayList<>(new TreeMap<>(requestsMap).values());
}
}
@ -398,14 +488,21 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
}
additionalProperties.put(BASE_URL, baseURL);
List<HTTPRequestGroup> requestGroups = new ArrayList<>();
// if data is to be extracted from any of the operations' responses, this has to
// be known prior to executing processing of OpenAPI spec further down
Map<String, DataExtractSubstituteParameter> dataExtractSubstituteParams = getDataExtractSubstituteParameters(
openAPI);
Map<String, HTTPRequestGroup> requestGroups = new HashMap<>();
Set<Parameter> extraParameters = new HashSet<>();
Map<String, Set<Parameter>> pathVariables = new HashMap<>();
for (String path : openAPI.getPaths().keySet()) {
List<HTTPRequest> requests = new ArrayList<>();
Map<Integer, HTTPRequest> requests = new HashMap<>();
Set<Parameter> variables = new HashSet<>();
String groupName = path;
for (Map.Entry<PathItem.HttpMethod, Operation> methodOperation : openAPI.getPaths().get(path).
readOperationsMap().entrySet()) {
List<Parameter> httpParams = new ArrayList<>();
@ -416,11 +513,32 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
final Operation operation = methodOperation.getValue();
final PathItem.HttpMethod method = methodOperation.getKey();
OptionalInt operationGroupingOrder = OptionalInt.empty();
String operationId = operation.getOperationId();
boolean hasRequestBodyExample = false;
// optionally group and order operations - see `X_OPERATION_GROUPING` K6 vendor
// extension
final CodegenOperation cgOperation = super.fromOperation(path, method.name(), operation, null);
Optional<OperationGrouping> operationGrouping = extractOperationGrouping(cgOperation);
if (operationGrouping.isPresent()) {
groupName = operationGrouping.get().groupName;
operationGroupingOrder = OptionalInt.of(operationGrouping.get().order);
}
for (Map.Entry<String, ApiResponse> resp : operation.getResponses().entrySet()) {
String statusData = resp.getKey().equals("default") ? "200" : resp.getKey();
// optionally hide given response - see `X_OPERATION_RESPONSE` K6 vendor
// extension
// i.e. in case of multiple 2xx responses, generated script checks only against
// e.g. code 200 responses
boolean hideOperationResponse = shouldHideOperationResponse(resp.getValue());
int status = Integer.parseInt(statusData);
if (status >= 200 && status < 300) {
if (!hideOperationResponse && (status >= 200 && status < 300)) {
k6Checks.add(new k6Check(status, resp.getValue().getDescription()));
}
}
@ -428,7 +546,7 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
if (hasBodyParameter(openAPI, operation) || hasFormParameter(openAPI, operation)) {
String defaultContentType = hasFormParameter(openAPI, operation) ? "application/x-www-form-urlencoded" : "application/json";
List<String> consumes = new ArrayList<>(getConsumesInfo(openAPI, operation));
String contentTypeValue = consumes == null || consumes.isEmpty() ? defaultContentType : consumes.get(0);
String contentTypeValue = consumes.isEmpty() ? defaultContentType : consumes.get(0);
if (contentTypeValue.equals("*/*"))
contentTypeValue = "application/json";
Parameter contentType = new Parameter("Content-Type", getDoubleQuotedString(contentTypeValue));
@ -436,6 +554,12 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
RequestBody requestBody = ModelUtils.getReferencedRequestBody(openAPI, operation.getRequestBody());
// extract request body example, if present
hasRequestBodyExample = hasRequestBodyExample(requestBody, contentTypeValue);
if (hasRequestBodyExample) {
extractRequestBodyExample(requestBody, contentTypeValue, bodyOrFormParams);
}
for (Map.Entry<String, ApiResponse> responseEntry : operation.getResponses().entrySet()) {
CodegenResponse r = fromResponse(responseEntry.getKey(), responseEntry.getValue());
if (r.baseType != null &&
@ -445,30 +569,34 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
}
}
List<CodegenParameter> formParameters = fromRequestBodyToFormParameters(requestBody, imports);
for (CodegenParameter parameter : formParameters) {
String reference = "";
if (parameter.isModel) {
Schema nestedSchema = ModelUtils.getSchema(openAPI, parameter.baseType);
CodegenModel model = fromModel(parameter.paramName, nestedSchema);
reference = generateNestedModelTemplate(model);
if (parameter.dataType.equals("List")) {
reference = "[" + reference + "]";
// if we have at least one request body example, we do not need to construct these dummies
if (!hasRequestBodyExample) {
List<CodegenParameter> formParameters = fromRequestBodyToFormParameters(requestBody, imports);
for (CodegenParameter parameter : formParameters) {
String reference = "";
if (parameter.isModel) {
Schema nestedSchema = ModelUtils.getSchema(openAPI, parameter.baseType);
CodegenModel model = fromModel(parameter.paramName, nestedSchema);
reference = generateNestedModelTemplate(model);
if (parameter.dataType.equals("List")) {
reference = "[" + reference + "]";
}
}
}
Parameter k6Parameter;
if (parameter.dataType.equals("File")) {
k6Parameter = new Parameter(parameter.paramName,
"http.file(open(\"/path/to/file.bin\", \"b\"), \"test.bin\")");
} else {
k6Parameter = new Parameter(parameter.paramName, !reference.isEmpty() ? reference
: getDoubleQuotedString(parameter.dataType.toLowerCase(Locale.ROOT)));
}
Parameter k6Parameter;
if (parameter.dataType.equals("File")) {
k6Parameter = new Parameter(parameter.paramName,
"http.file(open(\"/path/to/file.bin\", \"b\"), \"test.bin\")");
} else {
k6Parameter = new Parameter(parameter.paramName, !reference.isEmpty() ? reference
: getDoubleQuotedString(parameter.dataType.toLowerCase(Locale.ROOT)));
}
bodyOrFormParams.add(k6Parameter);
bodyOrFormParams.add(k6Parameter);
}
}
}
String accepts = getAccept(openAPI, operation);
String responseType = getDoubleQuotedString(accepts);
@ -507,32 +635,46 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
}
}
} catch (NullPointerException e) {
LOGGER.error(e.getMessage(), e);
}
pathVariables.put(path, variables);
pathVariables.put(groupName, variables);
final HTTPParameters params = new HTTPParameters(null, null, httpParams, null, null, null, null, null,
responseType.length() > 0 ? responseType : null);
assert params.headers != null;
requests.add(new HTTPRequest(method.toString().toLowerCase(Locale.ROOT), path,
// check if data needs to be extracted from response of this operation
Optional<DataExtractSubstituteParameter> dataExtract = getDataExtractSubstituteParameter(
dataExtractSubstituteParams, operationId);
// calculate order for this current request
Integer requestOrder = calculateRequestOrder(operationGroupingOrder, requests.size());
requests.put(requestOrder, new HTTPRequest(method.toString().toLowerCase(Locale.ROOT), path,
queryParams.size() > 0 ? queryParams : null,
bodyOrFormParams.size() > 0 ? new HTTPBody(bodyOrFormParams) : null,
params.headers.size() > 0 ? params : null, k6Checks.size() > 0 ? k6Checks : null));
bodyOrFormParams.size() > 0 ? new HTTPBody(bodyOrFormParams) : null, hasRequestBodyExample,
params.headers.size() > 0 ? params : null, k6Checks.size() > 0 ? k6Checks : null,
dataExtract.orElse(null)));
}
requestGroups.add(new HTTPRequestGroup(path, pathVariables.get(path), requests));
addOrUpdateRequestGroup(requestGroups, groupName, pathVariables.get(groupName), requests);
}
for (HTTPRequestGroup requestGroup : requestGroups) {
for (HTTPRequestGroup requestGroup : requestGroups.values()) {
for (HTTPRequest request : requestGroup.requests) {
if (request.path.contains("/{")) {
request.path = request.path.replace("/{", "/${");
}
}
// any variables not defined yet but used for subsequent data extraction must be
// initialized
initializeDataExtractSubstituteParameters(dataExtractSubstituteParams, requestGroup);
}
additionalProperties.put("requestGroups", requestGroups);
additionalProperties.put("requestGroups", requestGroups.values());
additionalProperties.put("extra", extraParameters);
for (String[] supportingTemplateFile : JAVASCRIPT_SUPPORTING_FILES) {
@ -749,4 +891,268 @@ public class K6ClientCodegen extends DefaultCodegen implements CodegenConfig {
protected ImmutableMap.Builder<String, Lambda> addMustacheLambdas() {
return super.addMustacheLambdas().put("handleParamValue", new ParameterValueLambda());
}
/**
* We're iterating over paths but grouping requests across paths, therefore
* these need to be aggregated.
*
* @param requestGroups
* @param groupName
* @param variables
* @param requests
*/
private void addOrUpdateRequestGroup(Map<String, HTTPRequestGroup> requestGroups, String groupName,
Set<Parameter> variables, Map<Integer, HTTPRequest> requests) {
if (requestGroups.containsKey(groupName)) {
HTTPRequestGroup existingHTTPRequestGroup = requestGroups.get(groupName);
existingHTTPRequestGroup.addRequests(requests);
existingHTTPRequestGroup.addVariables(variables);
} else {
requestGroups.put(groupName, new HTTPRequestGroup(groupName, variables, requests));
}
}
/**
* If `X_OPERATION_DATAEXTRACT` K6 vendor extension is present, extract info
* from it.
*
* @param openAPI
* @return
*/
private Map<String, DataExtractSubstituteParameter> getDataExtractSubstituteParameters(OpenAPI openAPI) {
Map<String, DataExtractSubstituteParameter> dataExtractSubstituteParams = new HashMap<>();
for (String path : openAPI.getPaths().keySet()) {
for (Map.Entry<PathItem.HttpMethod, Operation> methodOperation : openAPI.getPaths().get(path)
.readOperationsMap().entrySet()) {
final PathItem.HttpMethod method = methodOperation.getKey();
final Operation operation = methodOperation.getValue();
final CodegenOperation cgOperation = super.fromOperation(path, method.name(), operation, null);
if (cgOperation.getHasVendorExtensions()
&& cgOperation.vendorExtensions.containsKey(X_OPERATION_DATAEXTRACT)
&& cgOperation.vendorExtensions.get(X_OPERATION_DATAEXTRACT) instanceof java.util.Map) {
Optional<DataExtractSubstituteParameter> dataExtractSubstituteParameter = getDataExtractSubstituteParameter(
(Map<?, ?>) cgOperation.vendorExtensions.get(X_OPERATION_DATAEXTRACT));
// TODO: add support for extracting data for multiple params
dataExtractSubstituteParameter.ifPresent(extractSubstituteParameter -> dataExtractSubstituteParams.put(extractSubstituteParameter.operationId,
extractSubstituteParameter));
}
}
}
return dataExtractSubstituteParams;
}
/**
* Optionally, retrieve information specified in the `X_OPERATION_DATAEXTRACT`
* K6 vendor extension
*
* @param xOperationDataExtractProperties
* @return optional as only returned if all required info is present
*/
private Optional<DataExtractSubstituteParameter> getDataExtractSubstituteParameter(
Map<?, ?> xOperationDataExtractProperties) {
Optional<String> operationId = Optional.empty();
Optional<String> valuePath = Optional.empty();
Optional<String> parameterName = Optional.empty();
for (Map.Entry<?, ?> xOperationDataExtractPropertiesEntry : xOperationDataExtractProperties.entrySet()) {
switch (String.valueOf(xOperationDataExtractPropertiesEntry.getKey())) {
case X_OPERATION_DATAEXTRACT_OPERATION_ID:
operationId = Optional.of(String.valueOf(xOperationDataExtractPropertiesEntry.getValue()));
continue;
case X_OPERATION_DATAEXTRACT_VALUE_PATH:
valuePath = Optional.of(String.valueOf(xOperationDataExtractPropertiesEntry.getValue()));
continue;
case X_OPERATION_DATAEXTRACT_PARAMETER_NAME:
parameterName = Optional.of(String.valueOf(xOperationDataExtractPropertiesEntry.getValue()));
}
}
if (operationId.isPresent() && valuePath.isPresent() && parameterName.isPresent()) {
return Optional
.of(new DataExtractSubstituteParameter(operationId.get(), valuePath.get(), parameterName.get()));
} else {
return Optional.empty();
}
}
/**
* Optionally, retrieve data extraction properties for given operation
*
* @param dataExtractSubstituteParams
* @param operationId
* @return optional as only returned if present for given operation
*/
private Optional<DataExtractSubstituteParameter> getDataExtractSubstituteParameter(
Map<String, DataExtractSubstituteParameter> dataExtractSubstituteParams, String operationId) {
return (!dataExtractSubstituteParams.isEmpty() && dataExtractSubstituteParams.containsKey(operationId))
? Optional.of(dataExtractSubstituteParams.get(operationId))
: Optional.empty();
}
/**
* Optionally, retrieve information specified in the `X_OPERATION_GROUPING` K6
* vendor extension
*
* @param cgOperation
* @return optional as only returned if required info is present
*/
private Optional<OperationGrouping> extractOperationGrouping(CodegenOperation cgOperation) {
Optional<OperationGrouping> operationGrouping = Optional.empty();
if (cgOperation.getHasVendorExtensions() && cgOperation.vendorExtensions.containsKey(X_OPERATION_GROUPING)
&& cgOperation.vendorExtensions.get(X_OPERATION_GROUPING) instanceof java.util.Map) {
Map.Entry<?, ?> operationGroupingEntry = ((Map<?, ?>) cgOperation.vendorExtensions
.get(X_OPERATION_GROUPING)).entrySet().stream().findFirst().get();
return Optional.of(new OperationGrouping(String.valueOf(operationGroupingEntry.getKey()),
Integer.parseInt(String.valueOf(operationGroupingEntry.getValue()))));
}
return operationGrouping;
}
/**
* If `X_OPERATION_RESPONSE` K6 vendor extension is present, check if given
* operation response should be hidden.
*
* @param resp
* @return true if should be hidden, false otherwise
*/
private boolean shouldHideOperationResponse(ApiResponse resp) {
boolean hideOperationResponse = false;
if (Objects.nonNull(resp.getExtensions()) && !resp.getExtensions().isEmpty()
&& resp.getExtensions().containsKey(X_OPERATION_RESPONSE)) {
Map<?, ?> respExtensions = (Map<?, ?>) resp.getExtensions().get(X_OPERATION_RESPONSE);
Entry<?, ?> entry = respExtensions.entrySet().stream().findFirst().orElse(null);
if (entry.getKey().equals(X_OPERATION_RESPONSE_HIDE)) {
return Boolean.parseBoolean(String.valueOf(entry.getValue()));
}
}
return false;
}
/**
* Check if example is present for given request body and content type.
*
* @param requestBody
* @param contentTypeValue
* @return true if present, false otherwise
*/
private boolean hasRequestBodyExample(RequestBody requestBody, String contentTypeValue) {
return (Objects.nonNull(requestBody.getContent()) && requestBody.getContent().containsKey(contentTypeValue)
&& Objects.nonNull(requestBody.getContent().get(contentTypeValue).getExamples())
&& !requestBody.getContent().get(contentTypeValue).getExamples().isEmpty());
}
/**
* Extract example for given request body.
*
* @param requestBody
* @param contentTypeValue
* @param bodyOrFormParams
*/
private void extractRequestBodyExample(RequestBody requestBody, String contentTypeValue,
List<Parameter> bodyOrFormParams) {
Optional<Map.Entry<String, Example>> requestBodyExampleEntry = requestBody.getContent().get(contentTypeValue)
.getExamples().entrySet().stream().findFirst();
if (requestBodyExampleEntry.isPresent()) {
Example requestBodyExample = requestBodyExampleEntry.get().getValue();
try {
JsonNode requestBodyExampleValueJsonNode = Json.mapper()
.readTree(String.valueOf(requestBodyExample.getValue()));
Iterator<Map.Entry<String, JsonNode>> fields = requestBodyExampleValueJsonNode.fields();
while (fields.hasNext()) {
Map.Entry<String, JsonNode> fieldsEntry = fields.next();
JsonNode exampleValueAsJsonNode = fieldsEntry.getValue();
Parameter k6Parameter = new Parameter(fieldsEntry.getKey(),
exampleValueAsJsonNode.isNumber() ? exampleValueAsJsonNode.asText()
: exampleValueAsJsonNode.toString());
bodyOrFormParams.add(k6Parameter);
}
} catch (JsonProcessingException e) {
LOGGER.error(e.getMessage(), e);
}
}
}
/**
* Calculate order for this current request
*
* @param operationGroupingOrder
* @param requestsSize
* @return request order
*/
private Integer calculateRequestOrder(OptionalInt operationGroupingOrder, int requestsSize) {
int requestOrder;
if (operationGroupingOrder.isPresent()) {
requestOrder = operationGroupingOrder.getAsInt() - 1;
} else {
switch (requestsSize) {
case 0:
case 1:
requestOrder = requestsSize;
break;
default:
requestOrder = (requestsSize - 1);
break;
}
}
return requestOrder;
}
//
/**
* Any variables not defined yet but used for subsequent data extraction must be
* initialized
*
* @param dataExtractSubstituteParams
* @param requestGroup
*/
private void initializeDataExtractSubstituteParameters(
Map<String, DataExtractSubstituteParameter> dataExtractSubstituteParams, HTTPRequestGroup requestGroup) {
if (!dataExtractSubstituteParams.isEmpty()) {
Set<String> existingVariablesNames = requestGroup.variables.stream().map(v -> v.key)
.collect(Collectors.toSet());
Set<DataExtractSubstituteParameter> initializeVariables = dataExtractSubstituteParams.values().stream()
.filter(p -> !existingVariablesNames.contains(toVarName(p.paramName))).collect(Collectors.toSet());
for (DataExtractSubstituteParameter initializeVariable : initializeVariables) {
requestGroup.variables.add(new Parameter(toVarName(initializeVariable.paramName), true));
}
}
}
}

82
modules/openapi-generator/src/main/resources/k6/script.mustache vendored
View File

@ -19,48 +19,50 @@ export default function() {
let {{{key}}} = {{#lambda.handleParamValue}}{{value}}{{/lambda.handleParamValue}}
{{/variables}}
{{#requests}}
{{#-first}}
let url = BASE_URL + `{{{path}}}{{=<% %>=}}<%#query%><%#-first%>?<%/-first%><%& key%>=<%& value%><%^-last%>&<%/-last%><%/query%><%={{ }}=%>`;
// Request No. {{-index}}
{{#body}}
// TODO: edit the parameters of the request body.
let body = {{#body}}{{=<% %>=}}{<%#parameters%>"<%& key%>": <%& value%><%^-last%>, <%/-last%><%/parameters%>}<%={{ }}=%>{{/body}};
{{/body}}
{{#params}}
let params = {{#params}}{{=<% %>=}}{headers: {<%# headers%>"<%& key%>": <%& value%><%^-last%>, <%/-last%><%/headers%><%#responseType%>, "Accept": <%& responseType%><%/responseType%>}<%# auth%>, auth: "<%& auth%>"<%/auth%>}<%={{ }}=%>{{/params}};
{{/params}}
let request = http.{{method}}(url{{#body}}, body{{/body}}{{#params}}, params{{/params}});
{{#k6Checks}}
{{=<% %>=}}
check(request, {
"<%& description%>": (r) => r.status === <%& status%>
});
<%={{ }}=%>
{{/k6Checks}}
{{/-first}}
{{^-first}}
// Request No. {{-index}}
{{#body}}
// TODO: edit the parameters of the request body.
body = {{#body}}{{=<% %>=}}{<%#parameters%>"<%& key%>": <%& value%><%^-last%>, <%/-last%><%/parameters%>}<%={{ }}=%>{{/body}};
{{/body}}
{{#params}}
params = {{#params}}{{=<% %>=}}{headers: {<%# headers%>"<%& key%>": <%& value%><%^-last%>, <%/-last%><%/headers%>}<%# auth%>, auth: "<%& auth%>"<%/auth%>}<%={{ }}=%>{{/params}};
{{/params}}
request = http.{{method}}(url{{#body}}, body{{/body}}{{#params}}, params{{/params}});
{{#k6Checks}}
{{=<% %>=}}
check(request, {
"<%& description%>": (r) => r.status === <%& status%>
});
<%={{ }}=%>
{{/k6Checks}}
{{/-first}}
sleep(SLEEP_DURATION);
{{^-last}}
{{/-last}}
// Request No. {{-index}}
{
let url = BASE_URL + `{{{path}}}{{=<% %>=}}<%#query%><%#-first%>?<%/-first%><%& key%>=<%& value%><%^-last%>&<%/-last%><%/query%><%={{ }}=%>`;
{{#body}}
{{^hasBodyExample}}
// TODO: edit the parameters of the request body.
{{/hasBodyExample}}
let body = {{#body}}{{=<% %>=}}{<%#parameters%>"<%& key%>": <%& value%><%^-last%>, <%/-last%><%/parameters%>}<%={{ }}=%>{{/body}};
{{/body}}
{{#params}}
let params = {{#params}}{{=<% %>=}}{headers: {<%# headers%>"<%& key%>": <%& value%><%^-last%>, <%/-last%><%/headers%><%#responseType%>, "Accept": <%& responseType%><%/responseType%>}<%# auth%>, auth: "<%& auth%>"<%/auth%>}<%={{ }}=%>{{/params}};
{{/params}}
{{#isDelete}}
{{#params}}
// this is a DELETE method request - if params are also set, empty body must be passed
let request = http.{{method}}(url, {} {{#params}}, params{{/params}});
{{/params}}
{{^params}}
let request = http.{{method}}(url);
{{/params}}
{{/isDelete}}
{{^isDelete}}
let request = http.{{method}}(url{{#body}}, JSON.stringify(body){{/body}}{{#params}}, params{{/params}});
{{/isDelete}}
{{#k6Checks}}
{{=<% %>=}}
check(request, {
"<%& description%>": (r) => r.status === <%& status%>
});
<%={{ }}=%>
{{/k6Checks}}
{{#dataExtract}}
{{{paramName}}} = JSON.parse(request.body).{{{valuePath}}}; // extract data for subsequent use
{{/dataExtract}}
{{^-last}}
sleep(SLEEP_DURATION);
{{/-last}}
}
{{/requests}}
});
{{/requestGroups}}
}

1
pom.xml
View File

@ -1545,6 +1545,7 @@
<commons-cli.version>1.4</commons-cli.version>
<commons-io.version>2.11.0</commons-io.version>
<commons-lang.version>3.12.0</commons-lang.version>
<commons-text.version>1.9</commons-text.version>
<diffutils.version>1.3.0</diffutils.version>
<generex.version>1.0.2</generex.version>
<git-commit-id-plugin.version>4.9.10</git-commit-id-plugin.version>

2
samples/client/petstore/k6/.openapi-generator/FILES Normal file
View File

@ -0,0 +1,2 @@
README.md
script.js

2
samples/client/petstore/k6/.openapi-generator/VERSION
View File

@ -1 +1 @@
5.3.0-SNAPSHOT
5.3.1-SNAPSHOT

676
samples/client/petstore/k6/script.js
View File

@ -1,204 +1,576 @@
/*
* OpenAPI Petstore
* This is a sample server Petstore server. For this sample, you can use the api key `special-key` to test the authorization filters.
* This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\
*
* OpenAPI spec version: 1.0.0
*
* NOTE: This class is auto generated by OpenAPI Generator.
* https://github.com/OpenAPITools/openapi-generator
*
* OpenAPI generator version: 5.3.0-SNAPSHOT
* OpenAPI generator version: 5.3.1-SNAPSHOT
*/
import http from "k6/http";
import { group, check, sleep } from "k6";
const BASE_URL = "http://petstore.swagger.io/v2";
const BASE_URL = "https://127.0.0.1/no_varaible";
// Sleep duration between successive requests.
// You might want to edit the value of this variable or remove calls to the sleep function on the script.
const SLEEP_DURATION = 0.1;
// Global variables should be initialized.
let booleanGroup = "TODO_EDIT_THE_BOOLEAN_GROUP";
let header1 = "TODO_EDIT_THE_HEADER_1";
let apiKey = "TODO_EDIT_THE_API_KEY";
let requiredBooleanGroup = "TODO_EDIT_THE_REQUIRED_BOOLEAN_GROUP";
let enumHeaderStringArray = "TODO_EDIT_THE_ENUM_HEADER_STRING_ARRAY";
let enumHeaderString = "TODO_EDIT_THE_ENUM_HEADER_STRING";
export default function() {
group("/fake", () => {
let enumQueryInteger = 'TODO_EDIT_THE_ENUM_QUERY_INTEGER'; // specify value as there is no example value for this parameter in OpenAPI spec
let enumQueryString = 'TODO_EDIT_THE_ENUM_QUERY_STRING'; // specify value as there is no example value for this parameter in OpenAPI spec
let enumQueryStringArray = 'TODO_EDIT_THE_ENUM_QUERY_STRING_ARRAY'; // specify value as there is no example value for this parameter in OpenAPI spec
let enumQueryDouble = 'TODO_EDIT_THE_ENUM_QUERY_DOUBLE'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/fake?enum_query_string_array=${enum_query_string_array}&enum_query_string=${enum_query_string}&enum_query_integer=${enum_query_integer}&enum_query_double=${enum_query_double}`;
// TODO: edit the parameters of the request body.
let body = {"enumFormStringArray": "list", "enumFormString": "string"};
let params = {headers: {"Content-Type": "application/x-www-form-urlencoded", "enum_header_string_array": `${enumHeaderStringArray}`, "enum_header_string": `${enumHeaderString}`, "Accept": "application/json"}};
let request = http.get(url, JSON.stringify(body), params);
sleep(SLEEP_DURATION);
}
// Request No. 2
{
let url = BASE_URL + `/fake`;
// TODO: edit the parameters of the request body.
let body = {"client": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.patch(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/outer/boolean", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/outer/boolean`;
let params = {headers: {"Content-Type": "application/json", "Accept": "*/*"}};
let request = http.post(url, params);
check(request, {
"Output boolean": (r) => r.status === 200
});
}
});
group("/another-fake/dummy", () => {
// Request No. 1
{
let url = BASE_URL + `/another-fake/dummy`;
// TODO: edit the parameters of the request body.
let body = {"client": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.patch(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/pet", () => {
let url = BASE_URL + `/pet`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "list", "tags": [{"id": "long", "name": "string"}], "status": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.put(url, body, params);
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/pet`;
// TODO: edit the parameters of the request body.
let body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "set", "tags": "list", "status": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.put(url, JSON.stringify(body), params);
check(request, {
"Successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
}
// Request No. 2
// TODO: edit the parameters of the request body.
body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "list", "tags": [{"id": "long", "name": "string"}], "status": "string"};
params = {headers: {"Content-Type": "application/json"}};
request = http.post(url, body, params);
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/pet`;
// TODO: edit the parameters of the request body.
let body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "set", "tags": "list", "status": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"Successful operation": (r) => r.status === 200
});
}
});
group("/pet/findByStatus", () => {
let status = 'TODO_EDIT_THE_STATUS'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/pet/findByStatus?status=${status}`;
group("/user/{username}", () => {
let username = 'TODO_EDIT_THE_USERNAME'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/pet/findByTags", () => {
let tags = 'TODO_EDIT_THE_TAGS'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/pet/findByTags?tags=${tags}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/pet/{petId}", () => {
let petId = 'TODO_EDIT_THE_PETID'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/pet/${petId}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/user/${username}`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
}
// Request No. 2
// TODO: edit the parameters of the request body.
body = {"name": "string", "status": "string"};
params = {headers: {"Content-Type": "application/x-www-form-urlencoded"}};
request = http.post(url, body, params);
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/user/${username}`;
let request = http.del(url);
// Request No. 3
params = {headers: {"api_key": `${apiKey}`}};
request = http.del(url, params);
sleep(SLEEP_DURATION);
}
});
group("/pet/{petId}/uploadImage", () => {
let petId = 'TODO_EDIT_THE_PETID'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/pet/${petId}/uploadImage`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"additionalMetadata": "string", "file": http.file(open("/path/to/file.bin", "b"), "test.bin")};
let params = {headers: {"Content-Type": "multipart/form-data", "Accept": "application/json"}};
let request = http.post(url, body, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/store/inventory", () => {
let url = BASE_URL + `/store/inventory`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/store/order", () => {
let url = BASE_URL + `/store/order`;
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"id": "long", "petId": "long", "quantity": "integer", "shipDate": "date", "status": "string", "complete": "boolean"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, body, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
});
group("/store/order/{orderId}", () => {
let orderId = 'TODO_EDIT_THE_ORDERID'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/store/order/${orderId}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
// Request No. 2
request = http.del(url);
sleep(SLEEP_DURATION);
});
group("/user", () => {
let url = BASE_URL + `/user`;
group("/fake/body-with-binary", () => {
// Request No. 1
// TODO: edit the parameters of the request body.
let body = {"id": "long", "username": "string", "firstName": "string", "lastName": "string", "email": "string", "password": "string", "phone": "string", "userStatus": "integer"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, body, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/fake/body-with-binary`;
let params = {headers: {"Content-Type": "image/png", "Accept": "application/json"}};
let request = http.put(url, params);
check(request, {
"Success": (r) => r.status === 200
});
}
});
group("/user/createWithArray", () => {
let url = BASE_URL + `/user/createWithArray`;
group("/fake_classname_test", () => {
// Request No. 1
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/fake_classname_test`;
// TODO: edit the parameters of the request body.
let body = {"client": "string"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.patch(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/user/createWithList", () => {
let url = BASE_URL + `/user/createWithList`;
// Request No. 1
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/user/createWithList`;
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/inline-additionalProperties", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/inline-additionalProperties`;
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/store/inventory", () => {
// Request No. 1
{
let url = BASE_URL + `/store/inventory`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/user/login", () => {
let password = 'TODO_EDIT_THE_PASSWORD'; // specify value as there is no example value for this parameter in OpenAPI spec
let username = 'TODO_EDIT_THE_USERNAME'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/user/login?username=${username}&password=${password}`;
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/user/login?username=${username}&password=${password}`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/user/logout", () => {
let url = BASE_URL + `/user/logout`;
group("/fake/outer/composite", () => {
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/fake/outer/composite`;
// TODO: edit the parameters of the request body.
let body = {"myNumber": "bigdecimal", "myString": "string", "myBoolean": "boolean"};
let params = {headers: {"Content-Type": "application/json", "Accept": "*/*"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"Output composite": (r) => r.status === 200
});
}
});
group("/user/{username}", () => {
let username = 'TODO_EDIT_THE_USERNAME'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = BASE_URL + `/user/${username}`;
group("/fake/jsonFormData", () => {
// Request No. 1
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/fake/jsonFormData`;
// TODO: edit the parameters of the request body.
let body = {"param": "string", "param2": "string"};
let params = {headers: {"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"}};
let request = http.get(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/{petId}/uploadImageWithRequiredFile", () => {
let petId = 'TODO_EDIT_THE_PETID'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/fake/${petId}/uploadImageWithRequiredFile`;
// TODO: edit the parameters of the request body.
let body = {"additionalMetadata": "string", "requiredFile": http.file(open("/path/to/file.bin", "b"), "test.bin")};
let params = {headers: {"Content-Type": "multipart/form-data", "Accept": "application/json"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/pet/{petId}", () => {
let petId = 'TODO_EDIT_THE_PETID'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/pet/${petId}`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
}
// Request No. 2
// TODO: edit the parameters of the request body.
body = {"id": "long", "username": "string", "firstName": "string", "lastName": "string", "email": "string", "password": "string", "phone": "string", "userStatus": "integer"};
params = {headers: {"Content-Type": "application/json"}};
request = http.put(url, body, params);
sleep(SLEEP_DURATION);
{
let url = BASE_URL + `/pet/${petId}`;
let params = {headers: {"api_key": `${apiKey}`, "Accept": "application/json"}};
// this is a DELETE method request - if params are also set, empty body must be passed
let request = http.del(url, {} , params);
// Request No. 3
request = http.del(url);
sleep(SLEEP_DURATION);
check(request, {
"Successful operation": (r) => r.status === 200
});
}
});
group("/foo", () => {
// Request No. 1
{
let url = BASE_URL + `/foo`;
let request = http.get(url);
check(request, {
"response": (r) => r.status === 200
});
}
});
group("/fake/outer/string", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/outer/string`;
let params = {headers: {"Content-Type": "application/json", "Accept": "*/*"}};
let request = http.post(url, params);
check(request, {
"Output string": (r) => r.status === 200
});
}
});
group("/fake/test-query-parameters", () => {
let allowEmpty = 'TODO_EDIT_THE_ALLOWEMPTY'; // specify value as there is no example value for this parameter in OpenAPI spec
let ioutil = 'TODO_EDIT_THE_IOUTIL'; // specify value as there is no example value for this parameter in OpenAPI spec
let context = 'TODO_EDIT_THE_CONTEXT'; // specify value as there is no example value for this parameter in OpenAPI spec
let http = 'TODO_EDIT_THE_HTTP'; // specify value as there is no example value for this parameter in OpenAPI spec
let pipe = 'TODO_EDIT_THE_PIPE'; // specify value as there is no example value for this parameter in OpenAPI spec
let language = 'TODO_EDIT_THE_LANGUAGE'; // specify value as there is no example value for this parameter in OpenAPI spec
let url = 'TODO_EDIT_THE_URL'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/fake/test-query-parameters?pipe=${pipe}&ioutil=${ioutil}&http=${http}&url=${url}&context=${context}&language=${language}&allowEmpty=${allowEmpty}`;
let request = http.put(url);
check(request, {
"Success": (r) => r.status === 200
});
}
});
group("/store/order/{order_id}", () => {
let orderId = 'TODO_EDIT_THE_ORDER_ID'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/store/order/${order_id}`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
sleep(SLEEP_DURATION);
}
// Request No. 2
{
let url = BASE_URL + `/store/order/${order_id}`;
let request = http.del(url);
}
});
group("/pet/findByStatus", () => {
let status = 'TODO_EDIT_THE_STATUS'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/pet/findByStatus?status=${status}`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/body-with-query-params", () => {
let query = 'TODO_EDIT_THE_QUERY'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/fake/body-with-query-params?query=${query}`;
// TODO: edit the parameters of the request body.
let body = {"id": "long", "username": "string", "firstName": "string", "lastName": "string", "email": "string", "password": "string", "phone": "string", "userStatus": "integer"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.put(url, JSON.stringify(body), params);
check(request, {
"Success": (r) => r.status === 200
});
}
});
group("/pet/{petId}/uploadImage", () => {
let petId = 'TODO_EDIT_THE_PETID'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/pet/${petId}/uploadImage`;
// TODO: edit the parameters of the request body.
let body = {"additionalMetadata": "string", "file": http.file(open("/path/to/file.bin", "b"), "test.bin")};
let params = {headers: {"Content-Type": "multipart/form-data", "Accept": "application/json"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/http-signature-test", () => {
let query1 = 'TODO_EDIT_THE_QUERY_1'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/fake/http-signature-test?query_1=${query_1}`;
// TODO: edit the parameters of the request body.
let body = {"id": "long", "category": {"id": "long", "name": "string"}, "name": "string", "photoUrls": "set", "tags": "list", "status": "string"};
let params = {headers: {"Content-Type": "application/json", "header_1": `${header1}`, "Accept": "application/json"}};
let request = http.get(url, JSON.stringify(body), params);
check(request, {
"The instance started successfully": (r) => r.status === 200
});
}
});
group("/user", () => {
// Request No. 1
{
let url = BASE_URL + `/user`;
// TODO: edit the parameters of the request body.
let body = {"id": "long", "username": "string", "firstName": "string", "lastName": "string", "email": "string", "password": "string", "phone": "string", "userStatus": "integer"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/property/enum-int", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/property/enum-int`;
// TODO: edit the parameters of the request body.
let body = {"value": "outerenuminteger"};
let params = {headers: {"Content-Type": "application/json", "Accept": "*/*"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"Output enum (int)": (r) => r.status === 200
});
}
});
group("/user/createWithArray", () => {
// Request No. 1
{
let url = BASE_URL + `/user/createWithArray`;
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/body-with-file-schema", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/body-with-file-schema`;
// TODO: edit the parameters of the request body.
let body = {"file": http.file(open("/path/to/file.bin", "b"), "test.bin"), "files": "list"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.put(url, JSON.stringify(body), params);
check(request, {
"Success": (r) => r.status === 200
});
}
});
group("/pet/findByTags", () => {
let tags = 'TODO_EDIT_THE_TAGS'; // specify value as there is no example value for this parameter in OpenAPI spec
// Request No. 1
{
let url = BASE_URL + `/pet/findByTags?tags=${tags}`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/store/order", () => {
// Request No. 1
{
let url = BASE_URL + `/store/order`;
// TODO: edit the parameters of the request body.
let body = {"id": "long", "petId": "long", "quantity": "integer", "shipDate": "date", "status": "string", "complete": "boolean"};
let params = {headers: {"Content-Type": "application/json", "Accept": "application/json"}};
let request = http.post(url, JSON.stringify(body), params);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/user/logout", () => {
// Request No. 1
{
let url = BASE_URL + `/user/logout`;
let request = http.get(url);
check(request, {
"successful operation": (r) => r.status === 200
});
}
});
group("/fake/health", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/health`;
let request = http.get(url);
check(request, {
"The instance started successfully": (r) => r.status === 200
});
}
});
group("/fake/outer/number", () => {
// Request No. 1
{
let url = BASE_URL + `/fake/outer/number`;
let params = {headers: {"Content-Type": "application/json", "Accept": "*/*"}};
let request = http.post(url, params);
check(request, {
"Output number": (r) => r.status === 200
});
}
});
}