e) {
42 | return e.getValue() instanceof String
43 | ? value.replaceFirst(e.getKey(), (String)e.getValue())
44 | : e.getValue();
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/DataTransformer.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | /**
4 | *
5 | * Standard data transform, must not depends on ModelTransfomer
6 | *
7 | * @author u$f
8 | * @since 1.0
9 | *
10 | */
11 | @FunctionalInterface
12 | public interface DataTransformer extends PolymorphicType {
13 |
14 | Object transform(Object value);
15 | }
16 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/DisconnectedAssertionExecutor.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.lang.System.currentTimeMillis;
4 | import static org.usf.assertapi.core.Utils.sizeOf;
5 |
6 | import org.springframework.web.client.RestTemplate;
7 | import org.usf.assertapi.core.ClientResponseWrapper.HttpRequestWrapper;
8 | import org.usf.assertapi.core.Utils.EmptyValueException;
9 |
10 | public final class DisconnectedAssertionExecutor extends ConnectedAssertionExecutor {
11 |
12 | public DisconnectedAssertionExecutor(RestTemplate latestReleaseTemp) {
13 | super(null, latestReleaseTemp);
14 | }
15 |
16 | @Override
17 | ClientResponseWrapper runStable(ApiRequest api) {
18 | var res = api.response();
19 | if(res == null) {
20 | throw new EmptyValueException("ApiRequest", "staticResponse");
21 | }
22 | var ms = currentTimeMillis();
23 | var body = loadBody(res);
24 | if(body != res.getBody()) {
25 | res = (StaticResponse) res.setBody(body);
26 | }
27 | var exe = new ExecutionInfo(ms, currentTimeMillis(), res.getStatus(), sizeOf(res.getBody()));
28 | return new HttpRequestWrapper(res, exe);
29 | }
30 |
31 | }
32 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ExecutionConfig.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.util.Objects.requireNonNullElse;
4 |
5 | import lombok.Getter;
6 | import lombok.ToString;
7 |
8 | /**
9 | *
10 | * @author u$f
11 | * @since 1.0
12 | *
13 | */
14 | @Getter
15 | @ToString
16 | public final class ExecutionConfig {
17 |
18 | static final ExecutionConfig DEFAULT_CONFIG = new ExecutionConfig(null, null);
19 |
20 | private boolean enabled;
21 | private final boolean parallel;
22 |
23 | public ExecutionConfig(Boolean enable, Boolean parallel) {
24 | this.enabled = requireNonNullElse(enable, true);
25 | this.parallel = requireNonNullElse(parallel, true);
26 | }
27 |
28 | public ExecutionConfig disable() {
29 | this.enabled = false;
30 | return this;
31 | }
32 |
33 | public ExecutionConfig enable() {
34 | this.enabled = true;
35 | return this;
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ExecutionInfo.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import lombok.Getter;
4 | import lombok.RequiredArgsConstructor;
5 |
6 | /**
7 | *
8 | * @author u$f
9 | * @since 1.0
10 | *
11 | */
12 | @Getter
13 | @RequiredArgsConstructor
14 | public final class ExecutionInfo {
15 |
16 | //mass transfer, must be light
17 | private final long start;
18 | private final long end;
19 | private final int status;
20 | private final int size;
21 |
22 | public long elapsedTime() {
23 | return end - start;
24 | }
25 |
26 | @Override
27 | public String toString() {
28 | return status + " : " + size + "o transferred in " + elapsedTime() + "ms";
29 | }
30 | }
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/HeadersComparator.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.util.List;
4 | import java.util.Map;
5 |
6 | public class HeadersComparator implements ModelComparator>> {
7 |
8 | //filter [include|exclude]
9 |
10 | @Override
11 | public CompareResult compare(Map> expected, Map> actual) {
12 | return null;
13 | }
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/HttpRequest.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL;
4 | import static java.util.Optional.ofNullable;
5 | import static java.util.function.Predicate.not;
6 | import static org.usf.assertapi.core.Utils.isEmpty;
7 |
8 | import java.net.URI;
9 | import java.util.List;
10 | import java.util.Map;
11 |
12 | import com.fasterxml.jackson.annotation.JsonInclude;
13 | import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
14 | import com.fasterxml.jackson.databind.annotation.JsonSerialize;
15 |
16 | import lombok.AccessLevel;
17 | import lombok.Getter;
18 | import lombok.Setter;
19 |
20 | /**
21 | *
22 | * @author u$f
23 | * @since 1.0
24 | *
25 | */
26 | @Getter
27 | @JsonInclude(NON_NULL)
28 | public class HttpRequest {
29 |
30 | static final String DEFAULT_URI = "";
31 | static final String DEFAULT_METHOD = "GET";
32 | static final int DEFAULT_STATUS = 200;
33 |
34 | private String uri = DEFAULT_URI;
35 | private String method = DEFAULT_METHOD;
36 | private Map> headers;
37 | private byte[] body;
38 | private String lazyBody;
39 | //lazyBody => SELFT (null) | local(filename) | remote(UID) resource
40 |
41 | @Setter(AccessLevel.PACKAGE)
42 | private URI location; //must be injected after deserialization
43 |
44 | public HttpRequest setUri(String uri) {
45 | this.uri = ofNullable(uri).map(String::trim).orElse(DEFAULT_URI);
46 | return this;
47 | }
48 |
49 | public HttpRequest setMethod(String method) {
50 | this.method = ofNullable(method).map(String::trim).filter(not(String::isEmpty)).map(String::toUpperCase).orElse(DEFAULT_METHOD);
51 | return this;
52 | }
53 |
54 | public HttpRequest setHeaders(Map> headers) {
55 | this.headers = headers;
56 | return this;
57 | }
58 |
59 | @JsonDeserialize(using = StringBytesDeserializer.class)
60 | public HttpRequest setBody(byte[] body){
61 | this.body = body;
62 | return this;
63 | }
64 |
65 | @JsonSerialize(using = StringBytesSerializer.class )
66 | public byte[] getBody(){
67 | return body;
68 | }
69 |
70 | public HttpRequest setLazyBody(String lazyBody) {
71 | this.lazyBody = lazyBody;
72 | return this;
73 | }
74 |
75 |
76 | public String bodyAsString() {
77 | return ofNullable(body).map(String::new).orElse(null);
78 | }
79 |
80 | public String firstHeader(String title) {
81 | if(!isEmpty(headers)) {
82 | var header = headers.get(title);
83 | if(!isEmpty(header)) {
84 | return header.get(0);
85 | }
86 | }
87 | return null;
88 | }
89 |
90 | @Override
91 | public String toString() {
92 | return toRequestUri();
93 | }
94 |
95 | public String toRequestUri() {
96 | return new StringBuilder(50)
97 | .append("[").append(method).append("] ")
98 | .append(uri).toString();
99 | }
100 |
101 | }
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/JsonDataComparator.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static com.jayway.jsonpath.Configuration.defaultConfiguration;
4 | import static com.jayway.jsonpath.JsonPath.using;
5 | import static com.jayway.jsonpath.Option.SUPPRESS_EXCEPTIONS;
6 | import static java.util.Objects.requireNonNullElse;
7 | import static org.skyscreamer.jsonassert.JSONAssert.assertEquals;
8 | import static org.usf.assertapi.core.ReleaseTarget.LATEST;
9 | import static org.usf.assertapi.core.ReleaseTarget.STABLE;
10 | import static org.usf.assertapi.core.Utils.flow;
11 | import static org.usf.assertapi.core.Utils.isEmpty;
12 |
13 | import java.util.stream.Stream;
14 |
15 | import org.json.JSONException;
16 |
17 | import com.fasterxml.jackson.annotation.JsonTypeName;
18 | import com.jayway.jsonpath.DocumentContext;
19 | import com.jayway.jsonpath.ParseContext;
20 |
21 | import lombok.Getter;
22 |
23 | /**
24 | *
25 | * @author u$f
26 | * @since 1.0
27 | *
28 | */
29 | @Getter
30 | @JsonTypeName("JSON")
31 | public final class JsonDataComparator implements ModelComparator {
32 |
33 | static final ParseContext jsonParser = using(defaultConfiguration().addOptions(SUPPRESS_EXCEPTIONS));
34 |
35 | private final boolean strict;
36 | private final AbstractModelTransformer[] transformers;
37 |
38 | public JsonDataComparator(Boolean strict, AbstractModelTransformer[] transformers) {
39 | this.strict = requireNonNullElse(strict, true);
40 | this.transformers = transformers;
41 | }
42 |
43 | @Override
44 | public CompareResult compare(String expected, String actual) {
45 | if(!isEmpty(transformers)) {
46 | expected = transform(expected, STABLE);
47 | actual = transform(actual, LATEST);
48 | }
49 | try {
50 | assertEquals(expected, actual, strict);
51 | return new CompareResult(expected, actual, true);
52 | } catch (AssertionError e) {
53 | return new CompareResult(expected, actual, false);
54 | } catch (JSONException e) {
55 | throw new ApiAssertionRuntimeException("error while parsing JSON content", e);
56 | }
57 | }
58 |
59 | @SuppressWarnings("unchecked")
60 | private final String transform(String resp, ReleaseTarget target){
61 | if(resp != null) {
62 | var arr = Stream.of(transformers)
63 | .filter(t-> t.matchTarget(target))
64 | .toArray(AbstractModelTransformer[]::new);
65 | if(arr.length > 0) {
66 | return flow(jsonParser.parse(resp), AbstractModelTransformer::transform, (AbstractModelTransformer[]) arr).jsonString();
67 | }
68 | }
69 | return resp;
70 | }
71 | }
72 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/JsonDataMapper.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static com.jayway.jsonpath.JsonPath.compile;
4 | import static org.usf.assertapi.core.PolymorphicType.jsonTypeName;
5 | import static org.usf.assertapi.core.Utils.flow;
6 | import static org.usf.assertapi.core.Utils.requireNonEmpty;
7 |
8 | import java.util.Map;
9 |
10 | import com.fasterxml.jackson.annotation.JsonTypeName;
11 | import com.jayway.jsonpath.DocumentContext;
12 | import com.jayway.jsonpath.JsonPath;
13 |
14 | /**
15 | *
16 | * @author u$f
17 | * @since 1.0
18 | *
19 | */
20 | @JsonTypeName("JSON_DATA_MAPPER")
21 | public class JsonDataMapper extends AbstractModelTransformer {
22 |
23 | final JsonPath path;
24 | final DataTransformer[] transformers;
25 |
26 | public JsonDataMapper(ReleaseTarget[] applyOn, String path, DataTransformer[] transformers, Map map) {
27 | super(applyOn);
28 | this.path = compile(requireNonEmpty(path, jsonTypeName(this.getClass()), "path"));
29 | this.transformers = map == null
30 | ? requireNonEmpty(transformers, jsonTypeName(this.getClass()), "transformers")
31 | : new DataTransformer[] {new DataMapper(map, null)}; //default transformer @see JsonUnwrapped
32 | }
33 |
34 | @Override
35 | public DocumentContext transform(DocumentContext json) {
36 | return json.map(path, (o, c)-> flow(o, DataTransformer::transform, transformers));
37 | }
38 |
39 | @Override
40 | public String toString() {
41 | return super.toString() + " " + path.getPath();
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/JsonKeyMapper.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static com.jayway.jsonpath.JsonPath.compile;
4 | import static org.usf.assertapi.core.PolymorphicType.jsonTypeName;
5 | import static org.usf.assertapi.core.Utils.requireNonEmpty;
6 |
7 | import java.util.Map;
8 |
9 | import com.fasterxml.jackson.annotation.JsonTypeName;
10 | import com.jayway.jsonpath.DocumentContext;
11 | import com.jayway.jsonpath.JsonPath;
12 |
13 | /**
14 | *
15 | * @author u$f
16 | * @since 1.0
17 | *
18 | */
19 | @JsonTypeName("JSON_KEY_MAPPER")
20 | public final class JsonKeyMapper extends AbstractModelTransformer {
21 |
22 | private final JsonPath path; //to object
23 | private final Map map;
24 |
25 | public JsonKeyMapper(ReleaseTarget[] applyOn, String path, Map map) {
26 | super(applyOn);
27 | this.path = compile(requireNonEmpty(path, jsonTypeName(this.getClass()), "path"));
28 | this.map = requireNonEmpty(map, jsonTypeName(this.getClass()), "Map");
29 | }
30 |
31 | @Override
32 | public DocumentContext transform(DocumentContext json) {
33 | map.entrySet().forEach(e-> json.renameKey(path, e.getKey(), e.getValue())); //require string value
34 | return json;
35 | }
36 | }
37 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/JsonPathFilter.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.util.stream.Collectors.toList;
4 | import static org.usf.assertapi.core.PolymorphicType.jsonTypeName;
5 | import static org.usf.assertapi.core.Utils.requireNonEmpty;
6 |
7 | import java.util.List;
8 | import java.util.stream.Stream;
9 |
10 | import com.fasterxml.jackson.annotation.JsonTypeName;
11 | import com.jayway.jsonpath.DocumentContext;
12 | import com.jayway.jsonpath.JsonPath;
13 |
14 | /**
15 | *
16 | * @author u$f
17 | * @since 1.0
18 | *
19 | */
20 | @JsonTypeName("JSON_PATH_FILTER")
21 | public final class JsonPathFilter extends AbstractModelTransformer {
22 |
23 | private final List paths; //exclude | include ?
24 |
25 | public JsonPathFilter(ReleaseTarget[] applyOn, String[] paths) {
26 | super(applyOn);
27 | this.paths = Stream.of(requireNonEmpty(paths, jsonTypeName(this.getClass()), "paths"))
28 | .map(JsonPath::compile)
29 | .collect(toList());
30 | }
31 |
32 | @Override
33 | public DocumentContext transform(DocumentContext json) {
34 | paths.forEach(json::delete);
35 | return json;
36 | }
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/JsonPathMover.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static com.jayway.jsonpath.JsonPath.compile;
4 | import static java.util.Objects.requireNonNullElse;
5 | import static org.usf.assertapi.core.JsonDataComparator.jsonParser;
6 | import static org.usf.assertapi.core.JsonPathMover.Action.PUT;
7 | import static org.usf.assertapi.core.JsonPathMover.Action.SET;
8 | import static org.usf.assertapi.core.PolymorphicType.jsonTypeName;
9 | import static org.usf.assertapi.core.Utils.isJsonArray;
10 | import static org.usf.assertapi.core.Utils.isJsonObject;
11 | import static org.usf.assertapi.core.Utils.requireNonEmpty;
12 |
13 | import java.util.Map;
14 |
15 | import com.fasterxml.jackson.annotation.JsonTypeName;
16 | import com.jayway.jsonpath.DocumentContext;
17 | import com.jayway.jsonpath.JsonPath;
18 |
19 | import net.minidev.json.JSONArray;
20 |
21 | @JsonTypeName("JSON_PATH_MOVER")
22 | public class JsonPathMover extends AbstractModelTransformer {
23 |
24 | private final JsonPath fromPath;
25 | private final JsonPath toPath;
26 | private final Action action;
27 | private final String key;
28 |
29 | public JsonPathMover(ReleaseTarget[] applyOn, String from, String to, Action action, String key) {
30 | super(applyOn);
31 | this.fromPath = compile(from);
32 | this.toPath = compile(to);
33 | this.action = requireNonNullElse(action, SET);
34 | this.key = action == PUT ? requireNonEmpty(key, jsonTypeName(this.getClass()), "key") : null; //else unused key
35 | }
36 |
37 | @Override
38 | public DocumentContext transform(DocumentContext json) {
39 | switch (action) {
40 | case SET : return setOrigin(json);
41 | case ADD : return addOrigin(json);
42 | case PUT : return putOrigin(json);
43 | case MERGE: return mergeOrigin(json);
44 | default: throw new UnsupportedOperationException("unsupported action " + action);
45 | }
46 | }
47 |
48 | private DocumentContext setOrigin(DocumentContext json) { //warn key
49 | var origin = json.read(fromPath);
50 | if(toPath.getPath().equals("$")) {//root
51 | return jsonParser.parse(origin);
52 | }
53 | else {
54 | json.set(toPath, origin);
55 | return json.delete(fromPath);
56 | }
57 | }
58 |
59 | private DocumentContext addOrigin(DocumentContext json) {
60 | if(isJsonArray(json.read(toPath))) {
61 | json.add(toPath, json.read(fromPath));
62 | return json.delete(fromPath);
63 | }
64 | throw new IllegalArgumentException(toPath.getPath() + " : is not array");
65 | }
66 |
67 | private DocumentContext putOrigin(DocumentContext json) {
68 | if(isJsonObject(json.read(toPath))) {
69 | json.put(toPath, key, json.read(fromPath));
70 | return json.delete(fromPath);
71 | }
72 | throw new IllegalArgumentException(toPath.getPath() + " : is not object");
73 | }
74 |
75 | private DocumentContext mergeOrigin(DocumentContext json) {
76 | var origin = json.read(fromPath);
77 | var target = json.read(toPath);
78 | if(isJsonArray(target)) {
79 | if(isJsonArray(origin)) {
80 | ((JSONArray)origin).forEach(o-> json.add(toPath, o)); //filter items ==> Array[path]
81 | }
82 | else if(isJsonObject(origin)) {
83 | throw new UnsupportedOperationException("cannot merge object " + fromPath.getPath() + " with array " + toPath.getPath());
84 | }
85 | else {
86 | throw expectArray(fromPath);
87 | }
88 | }
89 | else if(isJsonObject(target)) {
90 | if(isJsonObject(origin)) {
91 | ((Map)origin).entrySet()
92 | .forEach(e-> json.put(toPath, e.getKey(), e.getValue()));//filter fields ==> Map
93 | }
94 | else if(isJsonArray(origin)) {
95 | throw new UnsupportedOperationException("cannot merge array " + fromPath.getPath() + " with object " + toPath.getPath());
96 | }
97 | else {
98 | throw expectObject(toPath);
99 | }
100 | }
101 | else {
102 | throw expectArrayOrObject(toPath);
103 | }
104 | return json.delete(fromPath);
105 | }
106 |
107 | private static IllegalAccessError expectObject(JsonPath path) {
108 | return new IllegalAccessError(path.getPath() + " is not an object");
109 | }
110 |
111 | private static IllegalAccessError expectArray(JsonPath path) {
112 | return new IllegalAccessError(path.getPath() + " is not an array");
113 | }
114 |
115 | private IllegalAccessError expectArrayOrObject(JsonPath path) {
116 | return new IllegalAccessError(path.getPath() + " must be an object or array");
117 | }
118 |
119 | public enum Action {
120 | SET, PUT, ADD, MERGE;
121 | }
122 |
123 | }
124 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ModelComparator.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import lombok.Getter;
4 | import lombok.RequiredArgsConstructor;
5 |
6 | /**
7 | *
8 | * @author u$f
9 | * @since 1.0
10 | *
11 | */
12 | @FunctionalInterface
13 | public interface ModelComparator extends PolymorphicType {
14 |
15 | CompareResult compare(T expected, T actual);
16 |
17 | @Getter
18 | @RequiredArgsConstructor
19 | final class CompareResult {
20 | private final Object expected;
21 | private final Object actual;
22 | private final boolean equals;
23 | }
24 | }
25 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ModelTransformer.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | @FunctionalInterface
4 | public interface ModelTransformer extends PolymorphicType {
5 |
6 | T transform(T model);
7 |
8 | }
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/PolymorphicType.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.util.Optional.ofNullable;
4 | import static java.util.regex.Pattern.compile;
5 |
6 | import com.fasterxml.jackson.annotation.JsonTypeInfo;
7 | import com.fasterxml.jackson.annotation.JsonTypeName;
8 |
9 | import lombok.NonNull;
10 |
11 | /**
12 | *
13 | * @author u$f
14 | * @since 1.0
15 | *
16 | */
17 | @JsonTypeInfo(
18 | use = JsonTypeInfo.Id.NAME,
19 | include = JsonTypeInfo.As.PROPERTY,
20 | property = "@type")
21 | public interface PolymorphicType {
22 |
23 | static String jsonTypeName(@NonNull Class type) {
24 | return ofNullable(type.getAnnotation(JsonTypeName.class))
25 | .map(JsonTypeName::value)
26 | .orElse(null);
27 | }
28 |
29 | static String toSnakeCase(Class clazz) {
30 | return compile("([A-Z])([a-z0-9]*)")
31 | .matcher(clazz.getSimpleName())
32 | .replaceAll(m-> m.start() == 0 ? "$1$2" : "_$1$2");
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ReleaseTarget.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | /**
4 | *
5 | * @author u$f
6 | * @since 1.0
7 | *
8 | */
9 | public enum ReleaseTarget {
10 |
11 | STABLE, LATEST;
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ResponseComparator.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.lang.String.format;
4 | import static java.lang.String.valueOf;
5 | import static java.util.concurrent.Executors.newFixedThreadPool;
6 | import static org.usf.assertapi.core.ApiAssertionError.skippedAssertionError;
7 | import static org.usf.assertapi.core.ApiAssertionError.wasSkipped;
8 | import static org.usf.assertapi.core.ComparisonStage.CONTENT_TYPE;
9 | import static org.usf.assertapi.core.ComparisonStage.ELAPSED_TIME;
10 | import static org.usf.assertapi.core.ComparisonStage.HEADER_CONTENT;
11 | import static org.usf.assertapi.core.ComparisonStage.HTTP_CODE;
12 | import static org.usf.assertapi.core.ComparisonStage.RESPONSE_CONTENT;
13 | import static org.usf.assertapi.core.ComparisonStatus.ERROR;
14 | import static org.usf.assertapi.core.ComparisonStatus.FAIL;
15 | import static org.usf.assertapi.core.ComparisonStatus.OK;
16 | import static org.usf.assertapi.core.ComparisonStatus.SKIP;
17 |
18 | import java.util.Arrays;
19 | import java.util.List;
20 | import java.util.Map;
21 | import java.util.Objects;
22 | import java.util.concurrent.ExecutorService;
23 | import java.util.concurrent.Future;
24 | import java.util.function.Supplier;
25 | import java.util.stream.Stream;
26 |
27 | import lombok.AccessLevel;
28 | import lombok.Getter;
29 | import lombok.NonNull;
30 | import lombok.Setter;
31 | import lombok.extern.slf4j.Slf4j;
32 |
33 | /**
34 | *
35 | * @author u$f
36 | * @since 1.0
37 | *
38 | */
39 | @Getter
40 | @Slf4j(topic = "org.usf.assertapi.core.ApiAssertion")
41 | public class ResponseComparator {
42 |
43 | @Setter(AccessLevel.PACKAGE)
44 | private ApiExecutor executor;
45 | ComparisonStage currentStage;
46 |
47 | private static ExecutorService es;
48 |
49 | public Future assertAsync(@NonNull Supplier> queries) {
50 | return executor().submit(()-> assertAll(queries.get()));
51 | }
52 |
53 | public void assertAll(Stream stream) {
54 | stream.forEach(q->{
55 | try {
56 | assertApi(q);
57 | }
58 | catch(Exception | AssertionError e) {/* do nothing exception already logged */}
59 | });
60 | }
61 |
62 | public final void assertApi(ApiRequest api) {
63 | this.currentStage = null; //important : init starting stage
64 | try {
65 | before(api);
66 | assumeEnabled(api.getExecution().isEnabled());
67 | var pair = executor.exchange(api); //
68 | assertElapsedTime(pair.getExpected().getRequestExecution(), pair.getActual().getRequestExecution());
69 | assertStatusCode(pair.getExpected().getStatusCodeValue(), pair.getActual().getStatusCodeValue());
70 | assertContentType(pair.getExpected().getContentTypeValue(), pair.getActual().getContentTypeValue());
71 | assertHeaders(pair.getExpected().getHeaders(), pair.getActual().getHeaders());
72 | if(pair.getExpected().isTextCompatible()) {
73 | var eCont = pair.getExpected().getResponseBodyAsString();
74 | var aCont = pair.getActual().getResponseBodyAsString();
75 | if(pair.getExpected().isJsonCompatible()) {
76 | assertJsonContent(eCont, aCont, api.comparator(pair.getExpected().getStatusCodeValue()));
77 | }
78 | else {
79 | assertTextContent(eCont, aCont);
80 | }
81 | }
82 | else {
83 | assertByteContent(pair.getExpected().getResponseBodyAsByteArray(), pair.getActual().getResponseBodyAsByteArray());
84 | }
85 | finish(OK);
86 | }
87 | catch (Exception | AssertionError e) {
88 | assertionFail(e);
89 | }
90 | }
91 |
92 | public void before(ApiRequest api) {
93 | logApiComparaison("START <" + api + ">");
94 | logApiComparaison("URL ", api.stable().toRequestUri(), api.latest().toRequestUri(), false);
95 | }
96 |
97 | public void assumeEnabled(boolean enabled) {
98 | if(!enabled) {
99 | throw skippedAssertionError("api assertion skipped");
100 | }
101 | }
102 |
103 | public void assertElapsedTime(ExecutionInfo stableReleaseExec, ExecutionInfo latestReleaseExec) {
104 | this.currentStage = ELAPSED_TIME;
105 | logApiComparaison("elapsedTime", stableReleaseExec.elapsedTime() + "ms", latestReleaseExec.elapsedTime() + "ms", false);
106 | logApiComparaison("contentSize", stableReleaseExec.getSize() + "o", latestReleaseExec.getSize() + "o", false);
107 | }
108 |
109 | public void assertStatusCode(int expected, int actual) {
110 | this.currentStage = HTTP_CODE;
111 | logApiComparaison("statusCode", expected, actual, false);
112 | if(expected != actual) {
113 | throw failNotEqual(expected, actual);
114 | }
115 | }
116 |
117 | public void assertContentType(String expected, String actual) {
118 | this.currentStage = CONTENT_TYPE;
119 | logApiComparaison("mediaType", expected, actual, false);
120 | if(!Objects.equals(expected, actual)) {
121 | throw failNotEqual(expected, actual);
122 | }
123 | }
124 |
125 | public void assertHeaders(Map> expected, Map> actual) {
126 | this.currentStage = HEADER_CONTENT;
127 | logApiComparaison("headers", expected, actual, true);
128 | }
129 |
130 | public void assertByteContent(byte[] expected, byte[] actual) {
131 | this.currentStage = RESPONSE_CONTENT;
132 | logApiComparaison("byteContent", expected, actual, true); //just reference
133 | if(!Arrays.equals(expected, actual)) {
134 | throw failNotEqual(Arrays.toString(expected), Arrays.toString(actual));
135 | }
136 | }
137 |
138 | public void assertTextContent(String expected, String actual) {
139 | this.currentStage = RESPONSE_CONTENT;
140 | logApiComparaison("textContent", expected, actual, true);
141 | if(!Objects.equals(expected, actual)) {
142 | throw failNotEqual(expected, actual);
143 | }
144 | }
145 |
146 | public void assertJsonContent(String expected, String actual, ModelComparator config) {
147 | this.currentStage = RESPONSE_CONTENT;
148 | logApiComparaison("jsonContent", expected, actual, true);
149 | var cr = castConfig(config, JsonDataComparator.class, ()-> new JsonDataComparator(null, null)).compare(expected, actual);
150 | if(expected != cr.getExpected() || actual != cr.getActual()) {
151 | logApiComparaison("newContent", cr.getExpected(), cr.getActual(), true);
152 | }
153 | if(!cr.isEquals()) {
154 | throw failNotEqual(cr.getExpected(), cr.getActual()); //format JSON => easy-to-compare !
155 | }
156 | }
157 |
158 | public void assertionFail(Throwable t) {
159 | log.error("Testing API fail : ", t);
160 | if(t instanceof AssertionError) {
161 | finish(wasSkipped(t) ? SKIP : FAIL);
162 | throw (AssertionError) t;
163 | }
164 | finish(ERROR);
165 | if(t instanceof RuntimeException) {
166 | throw (RuntimeException) t;
167 | }
168 | throw new ApiAssertionRuntimeException("Error while testing api", t);
169 | }
170 |
171 | public void finish(ComparisonStatus status) {
172 | logApiComparaison("TEST " + status);
173 | }
174 |
175 | protected AssertionError failNotEqual(Object expected, Object actual) {
176 | return new ApiAssertionError(expected, actual,
177 | format("%s : stable=%s ~ latest=%s", currentStage, valueOf(expected), valueOf(actual))); //body size ? binary ?
178 | }
179 |
180 | static > T castConfig(ModelComparator obj, Class expectedClass, Supplier orElseGet){
181 | if(obj == null) {
182 | return orElseGet.get();
183 | }
184 | if(expectedClass.isInstance(obj)) {
185 | return expectedClass.cast(obj);
186 | }
187 | throw new ApiAssertionRuntimeException("mismatch API configuration");
188 | }
189 |
190 | private static void logApiComparaison(String msg) {
191 | log.info("================== Comparing API : {} ==================", msg);
192 | }
193 |
194 | private static void logApiComparaison(String stage, Object expected, Object actual, boolean multiLine) {
195 | String format = format("%-15s", "("+stage+")");
196 | if(multiLine) {
197 | log.info("Comparing API {} : stable={}", format, expected);
198 | log.info("Comparing API {} : latest={}", format, actual);
199 | }
200 | else {
201 | log.info("Comparing API {} : stable={} ~ latest={}", format, expected, actual);
202 | }
203 | }
204 |
205 | private static ExecutorService executor() {
206 | if(es == null) {
207 | es = newFixedThreadPool(10); //conf
208 | }
209 | return es;
210 | }
211 | }
212 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ResponseComparatorProxy.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.util.List;
4 | import java.util.Map;
5 | import java.util.function.BiConsumer;
6 |
7 | import lombok.RequiredArgsConstructor;
8 | import lombok.extern.slf4j.Slf4j;
9 |
10 | /**
11 | * @version 1.0
12 | * @author u$f
13 | *
14 | */
15 | @RequiredArgsConstructor
16 | @Slf4j(topic = "org.usf.assertapi.core.ApiAssertion")
17 | public class ResponseComparatorProxy extends ResponseComparator {
18 |
19 | private final ResponseComparator comparator;
20 | private final BiConsumer tracer;
21 |
22 | private ApiRequest currentApi;
23 | private ExecutionInfo stableReleaseExec;
24 | private ExecutionInfo latestReleaseExec;
25 |
26 | @Override
27 | void setExecutor(ApiExecutor executor) {
28 | comparator.setExecutor(executor);
29 | }
30 |
31 | @Override
32 | public void before(ApiRequest api) {
33 | this.currentApi = api; //current API
34 | comparator.before(api);
35 | }
36 |
37 | @Override
38 | public void assertElapsedTime(ExecutionInfo stableReleaseExec, ExecutionInfo latestReleaseExec) {
39 | this.stableReleaseExec = stableReleaseExec;
40 | this.latestReleaseExec = latestReleaseExec;
41 | comparator.assertElapsedTime(stableReleaseExec, latestReleaseExec);
42 | }
43 |
44 | @Override
45 | public void assumeEnabled(boolean enabled) {
46 | comparator.assumeEnabled(enabled);
47 | }
48 |
49 | @Override
50 | public void assertStatusCode(int expected, int actual) {
51 | comparator.assertStatusCode(expected, actual);
52 | }
53 |
54 | @Override
55 | public void assertContentType(String expected, String actual) {
56 | comparator.assertContentType(expected, actual);
57 | }
58 |
59 | @Override
60 | public void assertHeaders(Map> expected, Map> actual) {
61 | comparator.assertHeaders(expected, actual);
62 | }
63 |
64 | @Override
65 | public void assertByteContent(byte[] expected, byte[] actual) {
66 | comparator.assertByteContent(expected, actual);
67 | }
68 |
69 | @Override
70 | public void assertTextContent(String expected, String actual) {
71 | comparator.assertTextContent(expected, actual);
72 | }
73 |
74 | @Override
75 | public void assertJsonContent(String expected, String actual, ModelComparator config) {
76 | comparator.assertJsonContent(expected, actual, config);
77 | }
78 |
79 | @Override
80 | public void assertionFail(Throwable t) {
81 | comparator.assertionFail(t);
82 | }
83 |
84 | @Override
85 | public void finish(ComparisonStatus status) {
86 | var result = new ComparisonResult(
87 | stableReleaseExec,
88 | latestReleaseExec,
89 | status, getCurrentStage());
90 | try {
91 | tracer.accept(currentApi, result);
92 | }
93 | catch(Exception e) {
94 | log.warn("cannot trace {} => {} : {}", currentApi, result, e.getMessage());
95 | }
96 | comparator.finish(status);
97 | }
98 |
99 | @Override
100 | public ComparisonStage getCurrentStage() {
101 | return comparator.getCurrentStage();
102 | }
103 |
104 | }
105 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/RestTemplateBuilder.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.util.Optional.ofNullable;
4 | import static org.usf.assertapi.core.ClientAuthenticator.ServerAuthMethod.BASIC;
5 | import static org.usf.assertapi.core.ClientAuthenticator.ServerAuthMethod.BEARER;
6 |
7 | import java.util.Map;
8 | import java.util.NoSuchElementException;
9 |
10 | import org.springframework.web.client.RestTemplate;
11 |
12 | import lombok.AccessLevel;
13 | import lombok.NoArgsConstructor;
14 |
15 | /**
16 | *
17 | * @author u$f
18 | * @since 1.0
19 | *
20 | */
21 | @NoArgsConstructor(access = AccessLevel.PRIVATE)
22 | public final class RestTemplateBuilder {
23 |
24 | static final Map> defaultAuthenticators = Map.of(//unmodifiable
25 | BASIC.name(), BasicClientAuthenticator.class,
26 | BEARER.name(), BearerClientAuthenticator.class);
27 |
28 | public static RestTemplate build(ServerConfig conf) {
29 | return build(conf, defaultAuthenticators);
30 | }
31 |
32 | public static RestTemplate build(ServerConfig conf, Map> clientAuthenticatorMap) {
33 | var rt = build(conf.buildRootUrl());
34 | var method = ofNullable(conf.getAuth()).map(ServerAuth::getAuthMethod).orElse(null);
35 | if(method != null) {
36 | var clazz = clientAuthenticatorMap.get(method);
37 | if(clazz == null) {
38 | throw new NoSuchElementException("no such class for " + method);
39 | }
40 | var auth = newInstance(clazz);
41 | rt.getClientHttpRequestInitializers().add(req-> auth.authorization(req, conf));
42 | }
43 | return rt;
44 | }
45 |
46 | public static RestTemplate build(String url) {
47 | var rt = new RestTemplate();
48 | RootUriTemplateHandler.addTo(rt, url);
49 | return rt;
50 | }
51 |
52 | private static ClientAuthenticator newInstance(Class clazz) {
53 | try {
54 | return clazz.getDeclaredConstructor().newInstance();
55 | } catch (Exception e) {
56 | throw new IllegalArgumentException("error while instantiating " + clazz.getName(), e);
57 | }
58 | }
59 |
60 | }
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/RootUriTemplateHandler.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.net.URI;
4 | import java.util.Map;
5 |
6 | import org.springframework.util.Assert;
7 | import org.springframework.util.StringUtils;
8 | import org.springframework.web.client.RestTemplate;
9 | import org.springframework.web.util.DefaultUriBuilderFactory;
10 | import org.springframework.web.util.UriTemplateHandler;
11 |
12 | /**
13 | *
14 | * @author u$f
15 | * @since 1.0
16 | *
17 | */
18 | public class RootUriTemplateHandler implements UriTemplateHandler {
19 |
20 | private final String rootUri;
21 |
22 | private final UriTemplateHandler handler;
23 |
24 | protected RootUriTemplateHandler(UriTemplateHandler handler) {
25 | Assert.notNull(handler, "Handler must not be null");
26 | this.rootUri = null;
27 | this.handler = handler;
28 | }
29 |
30 | /**
31 | * Create a new {@link RootUriTemplateHandler} instance.
32 | * @param rootUri the root URI to be used to prefix relative URLs
33 | */
34 | public RootUriTemplateHandler(String rootUri) {
35 | this(rootUri, new DefaultUriBuilderFactory());
36 | }
37 |
38 | /**
39 | * Create a new {@link RootUriTemplateHandler} instance.
40 | * @param rootUri the root URI to be used to prefix relative URLs
41 | * @param handler the delegate handler
42 | */
43 | public RootUriTemplateHandler(String rootUri, UriTemplateHandler handler) {
44 | Assert.notNull(rootUri, "RootUri must not be null");
45 | Assert.notNull(handler, "Handler must not be null");
46 | this.rootUri = rootUri;
47 | this.handler = handler;
48 | }
49 |
50 | @Override
51 | public URI expand(String uriTemplate, Map uriVariables) {
52 | return this.handler.expand(apply(uriTemplate), uriVariables);
53 | }
54 |
55 | @Override
56 | public URI expand(String uriTemplate, Object... uriVariables) {
57 | return this.handler.expand(apply(uriTemplate), uriVariables);
58 | }
59 |
60 | private String apply(String uriTemplate) {
61 | if (StringUtils.startsWithIgnoreCase(uriTemplate, "/")) {
62 | return getRootUri() + uriTemplate;
63 | }
64 | return uriTemplate;
65 | }
66 |
67 | public String getRootUri() {
68 | return this.rootUri;
69 | }
70 |
71 | /**
72 | * Add a {@link RootUriTemplateHandler} instance to the given {@link RestTemplate}.
73 | * @param restTemplate the {@link RestTemplate} to add the handler to
74 | * @param rootUri the root URI
75 | * @return the added {@link RootUriTemplateHandler}.
76 | */
77 | public static RootUriTemplateHandler addTo(RestTemplate restTemplate, String rootUri) {
78 | Assert.notNull(restTemplate, "RestTemplate must not be null");
79 | var handler = new RootUriTemplateHandler(rootUri, restTemplate.getUriTemplateHandler());
80 | restTemplate.setUriTemplateHandler(handler);
81 | return handler;
82 | }
83 |
84 | }
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/RuntimeEnvironement.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.lang.System.getProperty;
4 |
5 | import java.io.BufferedReader;
6 | import java.io.IOException;
7 | import java.io.InputStreamReader;
8 | import java.net.InetAddress;
9 | import java.net.UnknownHostException;
10 | import java.util.function.BiConsumer;
11 | import java.util.function.UnaryOperator;
12 |
13 | import lombok.AccessLevel;
14 | import lombok.Getter;
15 | import lombok.RequiredArgsConstructor;
16 | import lombok.ToString;
17 | import lombok.With;
18 |
19 | /**
20 | *
21 | * @author u$f
22 | * @since 1.0
23 | *
24 | */
25 | @Getter
26 | @ToString
27 | @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
28 | public final class RuntimeEnvironement {
29 |
30 | private static String prefix = "$env-";
31 |
32 | @With
33 | private final String user;
34 | private final String os;
35 | private final String jre;
36 | private final String address;
37 | private final String branch;
38 |
39 | public void push(BiConsumer cons) {
40 | cons.accept(prefix+"user", user);
41 | cons.accept(prefix+"os", os);
42 | cons.accept(prefix+"jre", jre);
43 | cons.accept(prefix+"address", address);
44 | cons.accept(prefix+"branch", branch);
45 | }
46 |
47 | public static RuntimeEnvironement from(UnaryOperator fn) {
48 | return new RuntimeEnvironement(
49 | fn.apply(prefix+"user"),
50 | fn.apply(prefix+"os"),
51 | fn.apply(prefix+"jre"),
52 | fn.apply(prefix+"address"),
53 | fn.apply(prefix+"branch"));
54 | }
55 |
56 | public static RuntimeEnvironement build() {
57 | return new RuntimeEnvironement(
58 | getProperty("user.name"),
59 | getProperty("os.name"),
60 | getProperty("java.version"),
61 | getHostAddress(),
62 | getLocalBranch());
63 | }
64 |
65 | static String getHostAddress() {
66 | try {
67 | return InetAddress.getLocalHost().getHostAddress();
68 | } catch (UnknownHostException e) {
69 | return null;
70 | }
71 | }
72 |
73 | static String getLocalBranch() {
74 | try {
75 | Process process = Runtime.getRuntime().exec(new String[]{ "cmd", "/C", "git rev-parse --abbrev-ref HEAD" }); //unix shell ?
76 | try(InputStreamReader isr = new InputStreamReader(process.getInputStream());
77 | BufferedReader reader = new BufferedReader(isr)) {
78 | return reader.readLine();
79 | }
80 | } catch (IOException e) {
81 | return null;
82 | }
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/SequentialFuture.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.util.concurrent.Callable;
4 | import java.util.concurrent.ExecutionException;
5 | import java.util.concurrent.Future;
6 | import java.util.concurrent.TimeUnit;
7 | import java.util.concurrent.TimeoutException;
8 |
9 | import lombok.RequiredArgsConstructor;
10 |
11 | @RequiredArgsConstructor
12 | final class SequentialFuture implements Future {
13 |
14 | private final Callable function;
15 |
16 | @Override
17 | public T get() throws InterruptedException, ExecutionException {
18 | try {
19 | return function.call();
20 | } catch (Exception e) {
21 | throw new ExecutionException(e); //manage exceptions
22 | }
23 | }
24 |
25 | @Override
26 | public boolean cancel(boolean mayInterruptIfRunning) {
27 | return true; //!important
28 | }
29 |
30 | @Override
31 | public boolean isCancelled() {
32 | throw new UnsupportedOperationException("unsupported");
33 | }
34 |
35 | @Override
36 | public boolean isDone() {
37 | throw new UnsupportedOperationException("unsupported");
38 | }
39 |
40 | @Override
41 | public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
42 | throw new UnsupportedOperationException("unsupported");
43 | }
44 | }
45 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ServerAuth.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.util.HashMap;
4 |
5 | import lombok.NoArgsConstructor;
6 |
7 | /**
8 | *
9 | * @author u$f
10 | * @since 1.0
11 | *
12 | */
13 | @SuppressWarnings("serial")
14 | @NoArgsConstructor
15 | public final class ServerAuth extends HashMap {
16 |
17 | /**
18 | *
19 | * @see org.usf.assertapi.core.ClientAuthenticator.ServerAuthMethod
20 | */
21 | public String getAuthMethod() {
22 | return get("type");
23 | }
24 |
25 | public String getToken() {
26 | return get("token");
27 | }
28 |
29 | public String getUsername() {
30 | return get("username");
31 | }
32 |
33 | public String getPassword() {
34 | return get("password");
35 | }
36 |
37 | public String getAccessTokenUrl() {
38 | return get("access-token-url");
39 | }
40 |
41 | @Override
42 | public String toString() {
43 | return "type=" + getAuthMethod();
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/ServerConfig.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.lang.String.format;
4 |
5 | import lombok.Getter;
6 | import lombok.NoArgsConstructor;
7 | import lombok.Setter;
8 |
9 | /**
10 | *
11 | * @author u$f
12 | * @since 1.0
13 | *
14 | */
15 | @Getter
16 | @Setter
17 | @NoArgsConstructor
18 | public final class ServerConfig { //TD make it immutable
19 |
20 | private String host;
21 | private int port;
22 | private ServerAuth auth;
23 |
24 | public ServerConfig(String host, int port, ServerAuth auth) {
25 | this.host = host;
26 | this.port = port;
27 | this.auth = auth;
28 | }
29 |
30 | public String buildRootUrl() {
31 | return format("http%s://%s%s/",
32 | port == 443 ? "s" : "", host,
33 | port == 80 || port == 443 ? "" : ":" + port);
34 | }
35 |
36 | public static ServerConfig localServer(int port) {
37 | return localServer(port, null);
38 | }
39 |
40 | public static ServerConfig localServer(int port, ServerAuth auth) {
41 | return new ServerConfig("localhost", port, auth);
42 | }
43 |
44 | @Override
45 | public String toString() {
46 | var s = buildRootUrl();
47 | if(auth != null) {
48 | s+= " {" + auth + "}";
49 | }
50 | return s;
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/StaticResponse.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.util.Objects.requireNonNullElse;
4 |
5 | import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
6 |
7 | import lombok.Getter;
8 |
9 | /**
10 | *
11 | * @author u$f
12 | * @since 1.0
13 | *
14 | */
15 | @Getter
16 | @JsonIgnoreProperties({"uri", "method"}) //unused fields check that
17 | public final class StaticResponse extends HttpRequest {
18 |
19 | private int status = DEFAULT_STATUS;
20 |
21 | public StaticResponse setStatus(Integer status) {
22 | this.status = requireNonNullElse(status, DEFAULT_STATUS);
23 | return this;
24 | }
25 |
26 | @Override
27 | public StaticResponse setUri(String uri) {
28 | throw unsupportedOperation("setUri");
29 | }
30 |
31 | @Override
32 | public String getUri() {
33 | throw unsupportedOperation("getUri");
34 | }
35 |
36 | @Override
37 | public StaticResponse setMethod(String method) {
38 | throw unsupportedOperation("setMethod");
39 | }
40 |
41 | @Override
42 | public String getMethod() {
43 | throw unsupportedOperation("getMethod");
44 | }
45 |
46 | private UnsupportedOperationException unsupportedOperation(String method) {
47 | return new UnsupportedOperationException(getClass().getCanonicalName() + "::" + method);
48 | }
49 | }
50 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/StringBytesDeserializer.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.io.IOException;
4 |
5 | import com.fasterxml.jackson.core.JsonParser;
6 | import com.fasterxml.jackson.databind.DeserializationContext;
7 | import com.fasterxml.jackson.databind.JsonDeserializer;
8 |
9 | public final class StringBytesDeserializer extends JsonDeserializer {
10 |
11 | @Override
12 | public byte[] deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
13 | return ctxt.readTree(p).toString().getBytes();
14 | }
15 |
16 | }
17 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/StringBytesSerializer.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import java.io.IOException;
4 |
5 | import com.fasterxml.jackson.core.JsonGenerator;
6 | import com.fasterxml.jackson.databind.JsonSerializer;
7 | import com.fasterxml.jackson.databind.SerializerProvider;
8 |
9 | public final class StringBytesSerializer extends JsonSerializer {
10 |
11 | @Override
12 | public void serialize(byte[] value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
13 | gen.writeRawValue(new String(value));
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/TemporalShift.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.lang.Long.parseLong;
4 | import static java.time.format.DateTimeFormatter.ofPattern;
5 | import static java.time.temporal.ChronoUnit.DAYS;
6 | import static java.time.temporal.ChronoUnit.HOURS;
7 | import static java.time.temporal.ChronoUnit.MILLIS;
8 | import static java.time.temporal.ChronoUnit.MINUTES;
9 | import static java.time.temporal.ChronoUnit.MONTHS;
10 | import static java.time.temporal.ChronoUnit.NANOS;
11 | import static java.time.temporal.ChronoUnit.SECONDS;
12 | import static java.time.temporal.ChronoUnit.YEARS;
13 | import static java.util.Objects.nonNull;
14 | import static java.util.regex.Pattern.compile;
15 | import static org.usf.assertapi.core.PolymorphicType.jsonTypeName;
16 | import static org.usf.assertapi.core.Utils.requireAnyOneNonEmpty;
17 | import static org.usf.assertapi.core.Utils.requireNonEmpty;
18 | import static org.usf.assertapi.core.Utils.requireStringValue;
19 |
20 | import java.time.Instant;
21 | import java.time.LocalDate;
22 | import java.time.LocalDateTime;
23 | import java.time.LocalTime;
24 | import java.time.OffsetDateTime;
25 | import java.time.ZonedDateTime;
26 | import java.time.format.DateTimeFormatter;
27 | import java.time.temporal.Temporal;
28 | import java.time.temporal.TemporalAccessor;
29 | import java.time.temporal.TemporalUnit;
30 | import java.util.regex.Pattern;
31 |
32 | import com.fasterxml.jackson.annotation.JsonTypeName;
33 |
34 | @JsonTypeName("TEMPORAL_SHIFT")
35 | public final class TemporalShift implements DataTransformer {
36 |
37 | private final Pattern pattern = compile("(\\d+)(min|ms|ns|y|m|d|h|s)"); //do not change order
38 | private final DateTimeFormatter formatter;
39 | private final String plus;
40 | private final String minus;
41 |
42 | public TemporalShift(String pattern, String plus, String minus) {
43 | this.formatter = ofPattern(requireNonEmpty(pattern, jsonTypeName(this.getClass()), "pattern"));
44 | requireAnyOneNonEmpty(jsonTypeName(this.getClass()), "plus|minus", Utils::isEmpty, plus, minus);
45 | this.plus = plus;
46 | this.minus = minus;
47 | }
48 |
49 | @Override
50 | public Object transform(Object value) {
51 | Temporal temporal = value instanceof Temporal
52 | ? (Temporal) value
53 | : from(requireStringValue(value));
54 | if(nonNull(plus)) {
55 | temporal = adjust(temporal, plus, true);
56 | }
57 | if(nonNull(minus)) {
58 | temporal = adjust(temporal, minus, false);
59 | }
60 | return formatter.format(temporal); //origin format
61 | }
62 |
63 | Temporal adjust(Temporal t, String s, boolean add) {
64 | var m = pattern.matcher(s);
65 | while(m.find()) {
66 | var v = parseLong(m.group(1));
67 | var u = parseUnit(m.group(2));
68 | t = add
69 | ? t.plus(v, u)
70 | : t.minus(v, u);
71 | }
72 | return t;
73 | }
74 |
75 | Temporal from(String value) {
76 | TemporalAccessor ta = formatter.parseBest(value,
77 | Instant::from,
78 | ZonedDateTime::from,
79 | OffsetDateTime::from,
80 | LocalDateTime::from,
81 | LocalDate::from,
82 | LocalTime::from);
83 | if(ta instanceof Temporal) {
84 | return (Temporal) ta;
85 | }
86 | throw new UnsupportedOperationException("Unsupported pattern " + value);
87 | }
88 |
89 | static TemporalUnit parseUnit(String unit) {
90 | switch (unit) {
91 | case "y": return YEARS;
92 | case "m": return MONTHS;
93 | case "d": return DAYS;
94 | case "h": return HOURS;
95 | case "min": return MINUTES;
96 | case "s": return SECONDS;
97 | case "ms": return MILLIS;
98 | case "ns": return NANOS;
99 | default: throw new UnsupportedOperationException("Unsupported unit " + unit);
100 | }
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/Utils.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static java.util.Objects.isNull;
4 | import static java.util.Objects.requireNonNull;
5 | import static java.util.Optional.ofNullable;
6 | import static org.springframework.http.converter.json.Jackson2ObjectMapperBuilder.json;
7 |
8 | import java.util.Collection;
9 | import java.util.Map;
10 | import java.util.function.BiFunction;
11 | import java.util.function.Predicate;
12 | import java.util.stream.Stream;
13 |
14 | import com.fasterxml.jackson.databind.ObjectMapper;
15 | import com.fasterxml.jackson.databind.module.SimpleModule;
16 | import com.fasterxml.jackson.module.paramnames.ParameterNamesModule;
17 |
18 | import lombok.AccessLevel;
19 | import lombok.NoArgsConstructor;
20 | import lombok.NonNull;
21 | import net.minidev.json.JSONArray;
22 |
23 | @NoArgsConstructor(access = AccessLevel.PRIVATE)
24 | public final class Utils {
25 |
26 | public static int sizeOf(byte[] arr) {//arr is nullable
27 | return ofNullable(arr).map(a-> a.length).orElse(0);
28 | }
29 |
30 | public static boolean isEmpty(String str) {
31 | return isNull(str) || str.isEmpty();
32 | }
33 |
34 | public static boolean isEmpty(int[] arr) {
35 | return isNull(arr) || arr.length == 0;
36 | }
37 |
38 | public static boolean isEmpty(T[] arr) {
39 | return isNull(arr) || arr.length == 0;
40 | }
41 |
42 | public static boolean isEmpty(Collection c) {
43 | return isNull(c) || c.isEmpty();
44 | }
45 |
46 | public static boolean isEmpty(Map map) {
47 | return isNull(map) || map.isEmpty();
48 | }
49 |
50 | public static String requireNonEmpty(String str, String parent, String fieldName) {
51 | return requireNonEmpty(str, Utils::isEmpty, parent, fieldName);
52 | }
53 |
54 | public static int[] requireNonEmpty(int[] arr, String parent, String fieldName) {
55 | return requireNonEmpty(arr, Utils::isEmpty, parent, fieldName);
56 | }
57 |
58 | public static T[] requireNonEmpty(T[] arr, String parent, String fieldName) {
59 | return requireNonEmpty(arr, Utils::isEmpty, parent, fieldName);
60 | }
61 |
62 | public static Map requireNonEmpty(Map map, String parent, String fieldName) {
63 | return requireNonEmpty(map, Utils::isEmpty, parent, fieldName);
64 | }
65 |
66 | private static T requireNonEmpty(T o, Predicate emptyFn, String parent, String fieldName) {
67 | if(emptyFn.test(o)) {
68 | throw new EmptyValueException(parent, fieldName);
69 | }
70 | return o;
71 | }
72 |
73 | @SafeVarargs
74 | public static void requireAnyOneNonEmpty(String parent, String fieldName, Predicate emptyFn, @NonNull T... args) {
75 | if(Stream.of(args).allMatch(emptyFn)) {
76 | throw new EmptyValueException(parent, fieldName);
77 | }
78 | }
79 |
80 | @SuppressWarnings("serial")
81 | public static final class EmptyValueException extends RuntimeException {
82 |
83 | public EmptyValueException(String parent, String fieldName) {
84 | super(parent + " : require [" + fieldName + "] field");
85 | }
86 | }
87 |
88 | @SuppressWarnings("serial")
89 | public static final class TooManyValueException extends RuntimeException {
90 |
91 | public TooManyValueException(String parent, String fieldName) {
92 | super(parent + " : [" + fieldName + "] should take only one value");
93 | }
94 | }
95 |
96 | public static SimpleModule defaultModule() {
97 | return new SimpleModule("assertapi").registerSubtypes(
98 | //register DataTransformer implementations
99 | DataMapper.class
100 | , TemporalShift.class
101 | //register TypeComparatorConfig implementations
102 | , JsonDataComparator.class
103 | , CsvDataComparator.class
104 | //register ModelTransformer implementations
105 | , JsonPathFilter.class
106 | , JsonPathMover.class
107 | , JsonDataMapper.class
108 | , JsonKeyMapper.class);
109 | }
110 |
111 | public static ObjectMapper defaultMapper() {
112 | return json().build().registerModules(new ParameterNamesModule(), defaultModule());
113 | }
114 |
115 | public static boolean isJsonObject(Object o) {
116 | return o instanceof Map;
117 | }
118 |
119 | public static boolean isJsonArray(Object o) {
120 | return o instanceof JSONArray;
121 | }
122 |
123 | public static String requireStringValue(Object o) {
124 | if(o instanceof String) {
125 | return o.toString();
126 | }
127 | throw new IllegalArgumentException("String value expected but was : " + o);
128 | }
129 |
130 | @SafeVarargs
131 | static T flow(T v, BiFunction fn , F... arr) { //Stream::reduce
132 | for(var f : requireNonNull(arr)) {
133 | v = fn.apply(f, v);
134 | }
135 | return v;
136 | }
137 | }
138 |
--------------------------------------------------------------------------------
/src/main/java/org/usf/assertapi/core/exception/TransformerException.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core.exception;
2 |
3 | import org.usf.assertapi.core.ApiAssertionRuntimeException;
4 |
5 | @Deprecated(forRemoval = true)
6 | @SuppressWarnings("serial")
7 | public final class TransformerException extends ApiAssertionRuntimeException {
8 |
9 | public TransformerException(String message, Throwable cause) {
10 | super(message, cause);
11 | }
12 |
13 | public TransformerException(String message) {
14 | super(message);
15 | }
16 | }
17 |
--------------------------------------------------------------------------------
/src/test/java/org/usf/assertapi/core/AbstractModelTransformerTest.java:
--------------------------------------------------------------------------------
1 | package org.usf.assertapi.core;
2 |
3 | import static org.junit.jupiter.api.Assertions.assertArrayEquals;
4 | import static org.junit.jupiter.api.Assertions.assertEquals;
5 | import static org.junit.jupiter.api.Assertions.assertFalse;
6 | import static org.junit.jupiter.api.Assertions.assertTrue;
7 | import static org.usf.assertapi.core.ReleaseTarget.LATEST;
8 | import static org.usf.assertapi.core.ReleaseTarget.STABLE;
9 |
10 | import org.junit.jupiter.api.Test;
11 |
12 | import com.fasterxml.jackson.annotation.JsonTypeName;
13 |
14 | class AbstractModelTransformerTest {
15 |
16 | @Test
17 | void testAbstractModelTransformer() {
18 | assertArrayEquals(new ReleaseTarget[] {STABLE}, newModelTransformer().getApplyOn()); //STABLE by default
19 | assertArrayEquals(new ReleaseTarget[] {LATEST}, newModelTransformer(LATEST).getApplyOn());
20 | assertArrayEquals(new ReleaseTarget[] {STABLE, LATEST}, newModelTransformer(STABLE, LATEST).getApplyOn());
21 | }
22 |
23 | @Test
24 | void testMatchTarget() {
25 | var mt = newModelTransformer();
26 | assertTrue(mt.matchTarget(STABLE));
27 | assertFalse(mt.matchTarget(LATEST));
28 | mt = newModelTransformer(STABLE, LATEST);
29 | assertTrue(mt.matchTarget(STABLE));
30 | assertTrue(mt.matchTarget(LATEST));
31 | }
32 |
33 | @Test
34 | void testToString() {
35 | assertEquals("null(STABLE)", newModelTransformer().toString()); //no annotation
36 | @JsonTypeName("dummy")
37 | class DummyClass extends AbstractModelTransformer