From 3d5bbc854a5b8b0f1dfec0fdfb1ed52f6bb150d6 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Thu, 15 Jul 2021 15:05:34 +0300 Subject: [PATCH 01/11] [issue207] feat(api, contract): ksqldb controller, client, service, statement strategies --- .../provectus/kafka/ui/client/KsqlClient.java | 30 +++++++++++++ .../kafka/ui/config/ClustersProperties.java | 1 + .../kafka/ui/controller/KsqlController.java | 26 +++++++++++ .../kafka/ui/exception/ErrorCode.java | 3 +- .../ui/exception/KsqlDbNotFoundException.java | 13 ++++++ .../kafka/ui/model/KafkaCluster.java | 1 + .../kafka/ui/service/KsqlService.java | 44 +++++++++++++++++++ .../ksqlStatement/KsqlStatementStrategy.java | 33 ++++++++++++++ .../ksqlStatement/ListStreamsStrategy.java | 29 ++++++++++++ .../ksqlStatement/ListTopicsStrategy.java | 26 +++++++++++ .../main/resources/swagger/kafka-ui-api.yaml | 35 +++++++++++++++ 11 files changed, 240 insertions(+), 1 deletion(-) create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/KsqlDbNotFoundException.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java new file mode 100644 index 0000000000..96fe7e9e85 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -0,0 +1,30 @@ +package com.provectus.kafka.ui.client; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; +import lombok.RequiredArgsConstructor; +import lombok.extern.log4j.Log4j2; +import org.springframework.http.MediaType; +import org.springframework.stereotype.Service; +import org.springframework.web.reactive.function.BodyInserters; +import org.springframework.web.reactive.function.client.WebClient; +import reactor.core.publisher.Mono; + +@Service +@RequiredArgsConstructor +@Log4j2 +public final class KsqlClient { + private final WebClient webClient; + private ObjectMapper objectMapper; + + public Mono execute(KsqlStatementStrategy ksqlStatement) { + return webClient.post() + .uri(ksqlStatement.getUri()) + .accept(new MediaType("application","vnd.ksql.v1+json")) + .body(BodyInserters.fromValue(ksqlStatement.getKsqlCommand())) + .retrieve() + .bodyToMono(String.class) + .map(ksqlStatement::serializeResponse) + .doOnError(log::error); + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/config/ClustersProperties.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/config/ClustersProperties.java index 2eee932958..2a1883287b 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/config/ClustersProperties.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/config/ClustersProperties.java @@ -20,6 +20,7 @@ public class ClustersProperties { String bootstrapServers; String zookeeper; String schemaRegistry; + String ksqldbServer; String schemaNameTemplate = "%s-value"; String protobufFile; String protobufMessageName; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java new file mode 100644 index 0000000000..8017aaaa24 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java @@ -0,0 +1,26 @@ +package com.provectus.kafka.ui.controller; + +import com.provectus.kafka.ui.api.KsqlApi; +import com.provectus.kafka.ui.model.KsqlCommand; + +import com.provectus.kafka.ui.service.KsqlService; +import lombok.RequiredArgsConstructor; +import lombok.extern.log4j.Log4j2; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.server.ServerWebExchange; +import reactor.core.publisher.Mono; + +@RestController +@RequiredArgsConstructor +@Log4j2 +public class KsqlController implements KsqlApi { + private final KsqlService ksqlService; + + @Override + public Mono> executeKsqlCommand(String clusterName, + Mono ksqlCommand, + ServerWebExchange exchange) { + return Mono.just(ResponseEntity.ok(ksqlService.getListStreams(clusterName, ksqlCommand))); + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/ErrorCode.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/ErrorCode.java index 4517507764..f50597d710 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/ErrorCode.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/ErrorCode.java @@ -17,7 +17,8 @@ public enum ErrorCode { CLUSTER_NOT_FOUND(4007, HttpStatus.NOT_FOUND), TOPIC_NOT_FOUND(4008, HttpStatus.NOT_FOUND), SCHEMA_NOT_FOUND(4009, HttpStatus.NOT_FOUND), - CONNECT_NOT_FOUND(4010, HttpStatus.NOT_FOUND); + CONNECT_NOT_FOUND(4010, HttpStatus.NOT_FOUND), + KSQLDB_NOT_FOUND(4011, HttpStatus.NOT_FOUND); static { // codes uniqueness check diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/KsqlDbNotFoundException.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/KsqlDbNotFoundException.java new file mode 100644 index 0000000000..c896ab0b98 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/exception/KsqlDbNotFoundException.java @@ -0,0 +1,13 @@ +package com.provectus.kafka.ui.exception; + +public class KsqlDbNotFoundException extends CustomBaseException { + + public KsqlDbNotFoundException() { + super("KSQL DB not found"); + } + + @Override + public ErrorCode getErrorCode() { + return ErrorCode.KSQLDB_NOT_FOUND; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/KafkaCluster.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/KafkaCluster.java index 3c9e914a66..b396a63bcb 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/KafkaCluster.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/KafkaCluster.java @@ -14,6 +14,7 @@ public class KafkaCluster { private final Integer jmxPort; private final String bootstrapServers; private final String zookeeper; + private final String ksqldbServer; private final String schemaRegistry; private final List kafkaConnect; private final String schemaNameTemplate; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java new file mode 100644 index 0000000000..dda8a78fad --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -0,0 +1,44 @@ +package com.provectus.kafka.ui.service; + +import com.provectus.kafka.ui.client.KsqlClient; +import com.provectus.kafka.ui.exception.ClusterNotFoundException; +import com.provectus.kafka.ui.exception.KsqlDbNotFoundException; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KafkaCluster; +import com.provectus.kafka.ui.model.KsqlCommand; +import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +import java.util.List; + +@Service +@RequiredArgsConstructor +public class KsqlService { + private final KsqlClient ksqlClient; + private final ClustersStorage clustersStorage; + private final List commandParamsStrategies; + + public Mono getListStreams(String name, Mono ksqlCommand) { + return Mono.justOrEmpty(clustersStorage.getClusterByName(name)) + .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) + .map(KafkaCluster::getKsqldbServer) + .switchIfEmpty(Mono.error(KsqlDbNotFoundException::new)) + .flatMap(host -> getStatementStrategyForKsqlCommand(ksqlCommand) + .map(statement -> statement.host(host)) + ) + .flatMap(statement -> ksqlClient.execute(statement)); + } + + private Mono getStatementStrategyForKsqlCommand(Mono ksqlCommand) { + return ksqlCommand + .map(command -> commandParamsStrategies.stream() + .filter(s -> s.test(command.getKsql())) + .map(s -> s.ksqlCommand(command)) + .findFirst()) + .flatMap(Mono::justOrEmpty) +// TODO: how to handle not parsed statements? + .switchIfEmpty(Mono.error(new UnprocessableEntityException("Invalid sql"))); + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java new file mode 100644 index 0000000000..880f981223 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java @@ -0,0 +1,33 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.provectus.kafka.ui.model.KsqlCommand; + +public abstract class KsqlStatementStrategy { + protected String host = null; + protected KsqlCommand ksqlCommand = null; + + public String getUri() { + if (this.host != null) { return this.host + this.getRequestPath(); } + return null; + } + + public KsqlStatementStrategy host(String host) { + this.host = host; + return this; + } + + public KsqlCommand getKsqlCommand() { + return ksqlCommand; + } + + public KsqlStatementStrategy ksqlCommand(KsqlCommand ksqlCommand) { + this.ksqlCommand = ksqlCommand; + return this; + } + + public abstract Object serializeResponse(String response); + + public abstract boolean test(String sql); + + protected abstract String getRequestPath(); +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java new file mode 100644 index 0000000000..b549fb12b1 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java @@ -0,0 +1,29 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.google.gson.JsonArray; +import com.google.gson.JsonParser; +import lombok.SneakyThrows; +import org.springframework.stereotype.Component; + + +@Component +public class ListStreamsStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + + @SneakyThrows + @Override + public Object serializeResponse(String response) { + JsonArray jsonArray = JsonParser.parseString(response).getAsJsonArray(); + return jsonArray.get(0).getAsJsonObject().get("streams").getAsJsonArray().toString(); + } + + @Override + public boolean test(String sql) { + return sql.trim().toLowerCase().matches("list streams;"); + } + + @Override + protected String getRequestPath() { + return requestPath; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java new file mode 100644 index 0000000000..74f0978fdb --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java @@ -0,0 +1,26 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.google.gson.JsonArray; +import com.google.gson.JsonParser; +import org.springframework.stereotype.Component; + +@Component +public class ListTopicsStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + + @Override + public Object serializeResponse(String response) { + JsonArray jsonArray = JsonParser.parseString(response).getAsJsonArray(); + return jsonArray.get(0).getAsJsonObject().get("topics").getAsJsonArray().toString(); + } + + @Override + public boolean test(String sql) { + return sql.trim().toLowerCase().matches("list topics;"); + } + + @Override + protected String getRequestPath() { + return requestPath; + } +} diff --git a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml index e04566b7ed..41ae457b05 100644 --- a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml +++ b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml @@ -1056,6 +1056,31 @@ paths: 200: description: OK + /api/clusters/{clusterName}/ksql: + post: + tags: + - Ksql + summary: executeKsqlCommand + operationId: executeKsqlCommand + parameters: + - name: clusterName + in: path + required: true + schema: + type: string + requestBody: + content: + application/json: + schema: + $ref: '#/components/schemas/KsqlCommand' + responses: + 200: + description: OK + content: + application/json: + schema: + type: object + /api/clusters/{clusterName}/connects/{connectName}/plugins: get: tags: @@ -1821,6 +1846,16 @@ components: items: $ref: '#/components/schemas/ConnectorPluginConfig' + KsqlCommand: + type: object + properties: + ksql: + type: string + streamsProperties: + type: string + required: + - ksql + FullConnectorInfo: type: object properties: From bd9f8280e8c9ae6028a5de3baa3636de95acb535 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Thu, 15 Jul 2021 15:18:33 +0300 Subject: [PATCH 02/11] [#207] fix(api): clean up --- .../main/java/com/provectus/kafka/ui/client/KsqlClient.java | 1 - .../com/provectus/kafka/ui/controller/KsqlController.java | 2 +- .../java/com/provectus/kafka/ui/service/KsqlService.java | 6 +++--- .../ui/strategy/ksqlStatement/ListStreamsStrategy.java | 2 +- .../kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java | 2 +- 5 files changed, 6 insertions(+), 7 deletions(-) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index 96fe7e9e85..746b50ca03 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -15,7 +15,6 @@ import reactor.core.publisher.Mono; @Log4j2 public final class KsqlClient { private final WebClient webClient; - private ObjectMapper objectMapper; public Mono execute(KsqlStatementStrategy ksqlStatement) { return webClient.post() diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java index 8017aaaa24..187a6e6563 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java @@ -21,6 +21,6 @@ public class KsqlController implements KsqlApi { public Mono> executeKsqlCommand(String clusterName, Mono ksqlCommand, ServerWebExchange exchange) { - return Mono.just(ResponseEntity.ok(ksqlService.getListStreams(clusterName, ksqlCommand))); + return Mono.just(ResponseEntity.ok(ksqlService.executeKsqlCommand(clusterName, ksqlCommand))); } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index dda8a78fad..cb0a8eae9e 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -20,8 +20,8 @@ public class KsqlService { private final ClustersStorage clustersStorage; private final List commandParamsStrategies; - public Mono getListStreams(String name, Mono ksqlCommand) { - return Mono.justOrEmpty(clustersStorage.getClusterByName(name)) + public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { + return Mono.justOrEmpty(clustersStorage.getClusterByName(clusterName)) .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) .map(KafkaCluster::getKsqldbServer) .switchIfEmpty(Mono.error(KsqlDbNotFoundException::new)) @@ -38,7 +38,7 @@ public class KsqlService { .map(s -> s.ksqlCommand(command)) .findFirst()) .flatMap(Mono::justOrEmpty) -// TODO: how to handle not parsed statements? + // TODO: handle not parsed statements? .switchIfEmpty(Mono.error(new UnprocessableEntityException("Invalid sql"))); } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java index b549fb12b1..966a7336ff 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java @@ -19,7 +19,7 @@ public class ListStreamsStrategy extends KsqlStatementStrategy { @Override public boolean test(String sql) { - return sql.trim().toLowerCase().matches("list streams;"); + return sql.trim().toLowerCase().matches("(list|show) streams;"); } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java index 74f0978fdb..c2e8933946 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java @@ -16,7 +16,7 @@ public class ListTopicsStrategy extends KsqlStatementStrategy { @Override public boolean test(String sql) { - return sql.trim().toLowerCase().matches("list topics;"); + return sql.trim().toLowerCase().matches("(list|show) topics;"); } @Override From 3686e75c8f3ed16edb400027736a77cf715f82ee Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Mon, 19 Jul 2021 17:21:23 +0300 Subject: [PATCH 03/11] [#207] feat(api, contract): return ksql command result as table --- .../provectus/kafka/ui/client/KsqlClient.java | 14 ++++- .../kafka/ui/controller/KsqlController.java | 9 +-- .../com/provectus/kafka/ui/model/Feature.java | 1 + .../kafka/ui/service/KsqlService.java | 3 +- .../ksqlStatement/KsqlStatementStrategy.java | 61 ++++++++++++++++++- .../ksqlStatement/ListStreamsStrategy.java | 29 --------- .../ksqlStatement/ListTopicsStrategy.java | 26 -------- .../ksqlStatement/ShowPropertiesStrategy.java | 27 ++++++++ .../ksqlStatement/ShowQueriesStrategy.java | 27 ++++++++ .../ksqlStatement/ShowStreamsStrategy.java | 27 ++++++++ .../ksqlStatement/ShowTablesStrategy.java | 26 ++++++++ .../ksqlStatement/ShowTopicsStrategy.java | 26 ++++++++ .../main/resources/swagger/kafka-ui-api.yaml | 18 +++++- 13 files changed, 228 insertions(+), 66 deletions(-) delete mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java delete mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index 746b50ca03..be38685d03 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -1,8 +1,11 @@ package com.provectus.kafka.ui.client; +import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.model.KsqlResponseTable; import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; import lombok.RequiredArgsConstructor; +import lombok.SneakyThrows; import lombok.extern.log4j.Log4j2; import org.springframework.http.MediaType; import org.springframework.stereotype.Service; @@ -15,15 +18,22 @@ import reactor.core.publisher.Mono; @Log4j2 public final class KsqlClient { private final WebClient webClient; + private final ObjectMapper mapper; - public Mono execute(KsqlStatementStrategy ksqlStatement) { + public Mono execute(KsqlStatementStrategy ksqlStatement) { return webClient.post() .uri(ksqlStatement.getUri()) .accept(new MediaType("application","vnd.ksql.v1+json")) .body(BodyInserters.fromValue(ksqlStatement.getKsqlCommand())) .retrieve() - .bodyToMono(String.class) + .bodyToMono(byte[].class) + .map(this::toJson) .map(ksqlStatement::serializeResponse) .doOnError(log::error); } + + @SneakyThrows + private JsonNode toJson(byte[] content) { + return this.mapper.readTree(content); + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java index 187a6e6563..fb780b4bc0 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java @@ -3,6 +3,7 @@ package com.provectus.kafka.ui.controller; import com.provectus.kafka.ui.api.KsqlApi; import com.provectus.kafka.ui.model.KsqlCommand; +import com.provectus.kafka.ui.model.KsqlResponseTable; import com.provectus.kafka.ui.service.KsqlService; import lombok.RequiredArgsConstructor; import lombok.extern.log4j.Log4j2; @@ -18,9 +19,9 @@ public class KsqlController implements KsqlApi { private final KsqlService ksqlService; @Override - public Mono> executeKsqlCommand(String clusterName, - Mono ksqlCommand, - ServerWebExchange exchange) { - return Mono.just(ResponseEntity.ok(ksqlService.executeKsqlCommand(clusterName, ksqlCommand))); + public Mono> executeKsqlCommand(String clusterName, + Mono ksqlCommand, + ServerWebExchange exchange) { + return ksqlService.executeKsqlCommand(clusterName, ksqlCommand).map(ResponseEntity::ok); } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java index 94a9fddf02..d624e298ad 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java @@ -12,6 +12,7 @@ public enum Feature { .isPresent() ), SCHEMA_REGISTRY(cluster -> cluster.getSchemaRegistry() != null); + // TODO: add feature for FE app private final Predicate isEnabled; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index cb0a8eae9e..1280bb8e9a 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -6,6 +6,7 @@ import com.provectus.kafka.ui.exception.KsqlDbNotFoundException; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KafkaCluster; import com.provectus.kafka.ui.model.KsqlCommand; +import com.provectus.kafka.ui.model.KsqlResponseTable; import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; @@ -20,7 +21,7 @@ public class KsqlService { private final ClustersStorage clustersStorage; private final List commandParamsStrategies; - public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { + public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { return Mono.justOrEmpty(clustersStorage.getClusterByName(clusterName)) .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) .map(KafkaCluster::getKsqldbServer) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java index 880f981223..7aba214511 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java @@ -1,16 +1,28 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; +import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommand; +import com.provectus.kafka.ui.model.KsqlResponseTable; + +import java.util.*; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; public abstract class KsqlStatementStrategy { protected String host = null; protected KsqlCommand ksqlCommand = null; public String getUri() { - if (this.host != null) { return this.host + this.getRequestPath(); } + if (this.host != null) { + return this.host + this.getRequestPath(); + } return null; } + public boolean test(String sql) { + return sql.trim().toLowerCase().matches(getTestRegExp()); + } + public KsqlStatementStrategy host(String host) { this.host = host; return this; @@ -25,9 +37,52 @@ public abstract class KsqlStatementStrategy { return this; } - public abstract Object serializeResponse(String response); + protected KsqlResponseTable getKsqlTable(JsonNode node) { + KsqlResponseTable table = new KsqlResponseTable(); + table.headers(new ArrayList<>()).rows(new ArrayList<>()); + if (node.size() > 0) { + List keys = getTableHeaders(node.get(0)); + List> rows = getTableRows(node, keys); + table.headers(keys).rows(rows); + } + return table; + } - public abstract boolean test(String sql); + protected KsqlResponseTable serializeTableResponse(JsonNode response, String path) { + if (response.isArray() && response.size() > 0) { + JsonNode first = response.get(0); + JsonNode items = first.path(path); + return this.getKsqlTable(items); + } + throw new InternalError("Invalid data format"); + } + + private List> getTableRows(JsonNode node, List keys) { + if (node.isArray() && node.size() > 0) { + return StreamSupport.stream(node.spliterator(), false) + .map(row -> keys.stream() + .map(header -> row.get(header).asText()) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()); + } + // TODO: handle + throw new InternalError("Invalid data format"); + } + + private List getTableHeaders(JsonNode node) { + if (node.isObject()) { + return StreamSupport.stream( + Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false + ).collect(Collectors.toList()); + } + // TODO: handle + throw new InternalError("Invalid data format"); + } + + public abstract KsqlResponseTable serializeResponse(JsonNode response); protected abstract String getRequestPath(); + + protected abstract String getTestRegExp(); } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java deleted file mode 100644 index 966a7336ff..0000000000 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStreamsStrategy.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; - -import com.google.gson.JsonArray; -import com.google.gson.JsonParser; -import lombok.SneakyThrows; -import org.springframework.stereotype.Component; - - -@Component -public class ListStreamsStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - - @SneakyThrows - @Override - public Object serializeResponse(String response) { - JsonArray jsonArray = JsonParser.parseString(response).getAsJsonArray(); - return jsonArray.get(0).getAsJsonObject().get("streams").getAsJsonArray().toString(); - } - - @Override - public boolean test(String sql) { - return sql.trim().toLowerCase().matches("(list|show) streams;"); - } - - @Override - protected String getRequestPath() { - return requestPath; - } -} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java deleted file mode 100644 index c2e8933946..0000000000 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListTopicsStrategy.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; - -import com.google.gson.JsonArray; -import com.google.gson.JsonParser; -import org.springframework.stereotype.Component; - -@Component -public class ListTopicsStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - - @Override - public Object serializeResponse(String response) { - JsonArray jsonArray = JsonParser.parseString(response).getAsJsonArray(); - return jsonArray.get(0).getAsJsonObject().get("topics").getAsJsonArray().toString(); - } - - @Override - public boolean test(String sql) { - return sql.trim().toLowerCase().matches("(list|show) topics;"); - } - - @Override - protected String getRequestPath() { - return requestPath; - } -} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java new file mode 100644 index 0000000000..a0b1245142 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java @@ -0,0 +1,27 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlResponseTable; +import org.springframework.stereotype.Component; + + +@Component +public class ShowPropertiesStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private final String responseValueKey = "properties"; + + @Override + public KsqlResponseTable serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + protected String getTestRegExp() { + return "show properties;"; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java new file mode 100644 index 0000000000..6dc2bd2c68 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java @@ -0,0 +1,27 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlResponseTable; +import org.springframework.stereotype.Component; + + +@Component +public class ShowQueriesStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private final String responseValueKey = "query"; + + @Override + public KsqlResponseTable serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + protected String getTestRegExp() { + return "show queries;"; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java new file mode 100644 index 0000000000..cfcfdaa3ba --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java @@ -0,0 +1,27 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlResponseTable; +import org.springframework.stereotype.Component; + + +@Component +public class ShowStreamsStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private final String responseValueKey = "streams"; + + @Override + public KsqlResponseTable serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + protected String getTestRegExp() { + return "(list|show) streams;"; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java new file mode 100644 index 0000000000..03b35adc9a --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java @@ -0,0 +1,26 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlResponseTable; +import org.springframework.stereotype.Component; + +@Component +public class ShowTablesStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private final String responseValueKey = "tables"; + + @Override + public KsqlResponseTable serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + protected String getTestRegExp() { + return "(list|show) tables;"; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java new file mode 100644 index 0000000000..7eae256666 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java @@ -0,0 +1,26 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlResponseTable; +import org.springframework.stereotype.Component; + +@Component +public class ShowTopicsStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private final String responseValueKey = "topics"; + + @Override + public KsqlResponseTable serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + protected String getTestRegExp() { + return "(list|show) topics;"; + } +} diff --git a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml index 41ae457b05..e753168c39 100644 --- a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml +++ b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml @@ -1079,7 +1079,7 @@ paths: content: application/json: schema: - type: object + $ref: '#/components/schemas/KsqlResponseTable' /api/clusters/{clusterName}/connects/{connectName}/plugins: get: @@ -1856,6 +1856,22 @@ components: required: - ksql + KsqlResponseTable: + type: object + properties: + headers: + type: array + items: + type: string + rows: + type: array + items: + type: array + items: + type: string + required: + - ksql + FullConnectorInfo: type: object properties: From fb68d19802fccf57688d222acc2dae933c7f9459 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Tue, 20 Jul 2021 15:39:34 +0300 Subject: [PATCH 04/11] [#207] feat(api, contract): added strategies for statements, return message or data with datble as response --- .../provectus/kafka/ui/client/KsqlClient.java | 4 +- .../kafka/ui/controller/KsqlController.java | 8 +- .../kafka/ui/service/KsqlService.java | 8 +- .../ksqlStatement/CreateStrategy.java | 27 +++++ ...iesStrategy.java => DescribeStrategy.java} | 11 +- ...StreamsStrategy.java => DropStrategy.java} | 12 +- ...picsStrategy.java => ExplainStrategy.java} | 10 +- .../ksqlStatement/KsqlStatementStrategy.java | 114 ++++++++++++++---- .../strategy/ksqlStatement/ListStrategy.java | 50 ++++++++ .../ksqlStatement/SelectStrategy.java | 27 +++++ .../strategy/ksqlStatement/ShowStrategy.java | 51 ++++++++ .../ksqlStatement/ShowTablesStrategy.java | 26 ---- ...esStrategy.java => TerminateStrategy.java} | 13 +- .../main/resources/swagger/kafka-ui-api.yaml | 19 ++- 14 files changed, 295 insertions(+), 85 deletions(-) create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/{ShowQueriesStrategy.java => DescribeStrategy.java} (58%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/{ShowStreamsStrategy.java => DropStrategy.java} (51%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/{ShowTopicsStrategy.java => ExplainStrategy.java} (61%) create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java create mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java delete mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/{ShowPropertiesStrategy.java => TerminateStrategy.java} (52%) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index be38685d03..c4714b61b7 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -2,7 +2,7 @@ package com.provectus.kafka.ui.client; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; import lombok.RequiredArgsConstructor; import lombok.SneakyThrows; @@ -20,7 +20,7 @@ public final class KsqlClient { private final WebClient webClient; private final ObjectMapper mapper; - public Mono execute(KsqlStatementStrategy ksqlStatement) { + public Mono execute(KsqlStatementStrategy ksqlStatement) { return webClient.post() .uri(ksqlStatement.getUri()) .accept(new MediaType("application","vnd.ksql.v1+json")) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java index fb780b4bc0..ef174a1de7 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java @@ -3,7 +3,7 @@ package com.provectus.kafka.ui.controller; import com.provectus.kafka.ui.api.KsqlApi; import com.provectus.kafka.ui.model.KsqlCommand; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.service.KsqlService; import lombok.RequiredArgsConstructor; import lombok.extern.log4j.Log4j2; @@ -19,9 +19,9 @@ public class KsqlController implements KsqlApi { private final KsqlService ksqlService; @Override - public Mono> executeKsqlCommand(String clusterName, - Mono ksqlCommand, - ServerWebExchange exchange) { + public Mono> executeKsqlCommand(String clusterName, + Mono ksqlCommand, + ServerWebExchange exchange) { return ksqlService.executeKsqlCommand(clusterName, ksqlCommand).map(ResponseEntity::ok); } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index 1280bb8e9a..5b896f578b 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -6,7 +6,7 @@ import com.provectus.kafka.ui.exception.KsqlDbNotFoundException; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KafkaCluster; import com.provectus.kafka.ui.model.KsqlCommand; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; @@ -19,9 +19,9 @@ import java.util.List; public class KsqlService { private final KsqlClient ksqlClient; private final ClustersStorage clustersStorage; - private final List commandParamsStrategies; + private final List ksqlStatementStrategies; - public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { + public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { return Mono.justOrEmpty(clustersStorage.getClusterByName(clusterName)) .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) .map(KafkaCluster::getKsqldbServer) @@ -34,7 +34,7 @@ public class KsqlService { private Mono getStatementStrategyForKsqlCommand(Mono ksqlCommand) { return ksqlCommand - .map(command -> commandParamsStrategies.stream() + .map(command -> ksqlStatementStrategies.stream() .filter(s -> s.test(command.getKsql())) .map(s -> s.ksqlCommand(command)) .findFirst()) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java new file mode 100644 index 0000000000..55793322e1 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java @@ -0,0 +1,27 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import org.springframework.stereotype.Component; + + +@Component +public class CreateStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private final String responseValueKey = "commandStatus"; + + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeMessageResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + protected String getTestRegExp() { + return "create (table|stream)(.*)(with|as select(.*)from)(.*);"; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java similarity index 58% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java index 6dc2bd2c68..a6b02636a3 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowQueriesStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java @@ -1,17 +1,18 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; import com.fasterxml.jackson.databind.JsonNode; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; @Component -public class ShowQueriesStrategy extends KsqlStatementStrategy { +public class DescribeStrategy extends KsqlStatementStrategy { private final String requestPath = "/ksql"; - private final String responseValueKey = "query"; + private final String responseValueKey = "sourceDescription"; @Override - public KsqlResponseTable serializeResponse(JsonNode response) { + public KsqlCommandResponse serializeResponse(JsonNode response) { + System.out.println(response); return serializeTableResponse(response, responseValueKey); } @@ -22,6 +23,6 @@ public class ShowQueriesStrategy extends KsqlStatementStrategy { @Override protected String getTestRegExp() { - return "show queries;"; + return "describe (.*);"; } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java similarity index 51% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java index cfcfdaa3ba..f9f30f3ffe 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStreamsStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java @@ -1,18 +1,18 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; import com.fasterxml.jackson.databind.JsonNode; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; @Component -public class ShowStreamsStrategy extends KsqlStatementStrategy { +public class DropStrategy extends KsqlStatementStrategy { private final String requestPath = "/ksql"; - private final String responseValueKey = "streams"; + private final String responseValueKey = "commandStatus"; @Override - public KsqlResponseTable serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeMessageResponse(response, responseValueKey); } @Override @@ -22,6 +22,6 @@ public class ShowStreamsStrategy extends KsqlStatementStrategy { @Override protected String getTestRegExp() { - return "(list|show) streams;"; + return "drop (table|stream) (.*);"; } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java similarity index 61% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java index 7eae256666..a106b46f64 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTopicsStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java @@ -1,16 +1,16 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; import com.fasterxml.jackson.databind.JsonNode; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; @Component -public class ShowTopicsStrategy extends KsqlStatementStrategy { +public class ExplainStrategy extends KsqlStatementStrategy { private final String requestPath = "/ksql"; - private final String responseValueKey = "topics"; + private final String responseValueKey = "queryDescription"; @Override - public KsqlResponseTable serializeResponse(JsonNode response) { + public KsqlCommandResponse serializeResponse(JsonNode response) { return serializeTableResponse(response, responseValueKey); } @@ -21,6 +21,6 @@ public class ShowTopicsStrategy extends KsqlStatementStrategy { @Override protected String getTestRegExp() { - return "(list|show) topics;"; + return "explain (.*);"; } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java index 7aba214511..6ee2cb0d44 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java @@ -2,10 +2,13 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommand; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.model.Table; import java.util.*; import java.util.stream.Collectors; +import java.util.stream.IntStream; +import java.util.stream.Stream; import java.util.stream.StreamSupport; public abstract class KsqlStatementStrategy { @@ -37,40 +40,102 @@ public abstract class KsqlStatementStrategy { return this; } - protected KsqlResponseTable getKsqlTable(JsonNode node) { - KsqlResponseTable table = new KsqlResponseTable(); + protected KsqlCommandResponse serializeTableResponse(JsonNode response, String path) { + if (response.isArray() && response.size() > 0) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + JsonNode first = response.get(0); + JsonNode items = first.path(path); + Table table = items.isArray() ? getTableFromArray(items) : getTableFromObject(items); + return commandResponse.data(table); + } + throw new InternalError("Invalid data format"); + } + + protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String path) { + if (response.isArray() && response.size() > 0) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + JsonNode first = response.get(0); + JsonNode item = first.path(path); + return commandResponse.message(getMessageFromObject(item)); + } + // TODO: handle + throw new InternalError("Invalid data format"); + } + + protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + Table table = (new Table()) + .headers(getQueryResponseHeader(response)) + .rows(getQueryResponseRows(response)); + return commandResponse.data(table); + } + + private List getQueryResponseHeader(JsonNode response) { + JsonNode headerRow = response.get(0); + if (headerRow.isObject() && headerRow.size() > 0) { + String schema = headerRow.get("header").get("schema").asText(); + return Arrays.stream(schema.split(",")).map(s -> s.trim()).collect(Collectors.toList()); + } + return new ArrayList<>(); + } + + private List> getQueryResponseRows(JsonNode node) { + return getStreamForJsonArray(node) + .filter(row -> row.has("row") && row.get("row").has("columns")) + .map(row -> row.get("row").get("columns")) + .map(cellNode -> getStreamForJsonArray(cellNode) + .map(cell -> cell.asText()) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()); + } + + private Table getTableFromArray(JsonNode node) { + Table table = new Table(); table.headers(new ArrayList<>()).rows(new ArrayList<>()); if (node.size() > 0) { - List keys = getTableHeaders(node.get(0)); + List keys = getJsonObjectKeys(node.get(0)); List> rows = getTableRows(node, keys); table.headers(keys).rows(rows); } return table; } - protected KsqlResponseTable serializeTableResponse(JsonNode response, String path) { - if (response.isArray() && response.size() > 0) { - JsonNode first = response.get(0); - JsonNode items = first.path(path); - return this.getKsqlTable(items); + private Table getTableFromObject(JsonNode node) { + List keys = getJsonObjectKeys(node); + List values = getJsonObjectValues(node); + List> rows = IntStream + .range(0, keys.size()) + .mapToObj(i -> List.of(keys.get(i), values.get(i))) + .collect(Collectors.toList()); + return (new Table()).headers(List.of("key", "value")).rows(rows); + } + + private String getMessageFromObject(JsonNode node) { + if (node.isObject() && node.has("message")) { + return node.get("message").asText(); } - throw new InternalError("Invalid data format"); + throw new InternalError("can't get message from empty object or array"); } private List> getTableRows(JsonNode node, List keys) { - if (node.isArray() && node.size() > 0) { - return StreamSupport.stream(node.spliterator(), false) - .map(row -> keys.stream() - .map(header -> row.get(header).asText()) - .collect(Collectors.toList()) - ) - .collect(Collectors.toList()); - } - // TODO: handle - throw new InternalError("Invalid data format"); + return getStreamForJsonArray(node) + .map(row -> keys.stream() + .map(header -> row.get(header).asText()) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()); } - private List getTableHeaders(JsonNode node) { + private Stream getStreamForJsonArray(JsonNode node) { + if (node.isArray() && node.size() > 0) { + return StreamSupport.stream(node.spliterator(), false); + } + // TODO: handle + throw new InternalError("not JsonArray or empty"); + } + + private List getJsonObjectKeys(JsonNode node) { if (node.isObject()) { return StreamSupport.stream( Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false @@ -80,7 +145,12 @@ public abstract class KsqlStatementStrategy { throw new InternalError("Invalid data format"); } - public abstract KsqlResponseTable serializeResponse(JsonNode response); + private List getJsonObjectValues(JsonNode node) { + return getJsonObjectKeys(node).stream().map(key -> node.get(key).asText()) + .collect(Collectors.toList()); + } + + public abstract KsqlCommandResponse serializeResponse(JsonNode response); protected abstract String getRequestPath(); diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java new file mode 100644 index 0000000000..4ec19536b4 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java @@ -0,0 +1,50 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import org.springframework.stereotype.Component; + +import java.util.List; +import java.util.Optional; + +@Component +public class ListStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private String responseValueKey = ""; + private final List statements = List.of("functions", "topics", "streams", "tables"); + + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + public boolean test(String sql) { + Optional statement = statements.stream() + .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) + .findFirst(); + if (statement.isPresent()) { + setResponseValueKey(statement.get()); + return true; + } + return false; + } + + @Override + protected String getTestRegExp() { + return ""; + } + + private String getTestRegExp(String key) { + return "list " + key + ";"; + } + + private void setResponseValueKey(String path) { + responseValueKey = path; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java new file mode 100644 index 0000000000..309578a826 --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java @@ -0,0 +1,27 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import org.springframework.stereotype.Component; + +@Component +public class SelectStrategy extends KsqlStatementStrategy { + private final String requestPath = "/query"; + + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + System.out.println(response); + return serializeQueryResponse(response); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + + @Override + protected String getTestRegExp() { + return "select (.*) from (.*);"; + } +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java new file mode 100644 index 0000000000..fede08189f --- /dev/null +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java @@ -0,0 +1,51 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import org.springframework.stereotype.Component; + +import java.util.List; +import java.util.Optional; + +@Component +public class ShowStrategy extends KsqlStatementStrategy { + private final String requestPath = "/ksql"; + private String responseValueKey = ""; + private final List statements = List.of("functions", "topics", "streams", "tables", "queries", "properties"); + + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } + + @Override + protected String getRequestPath() { + return requestPath; + } + + @Override + public boolean test(String sql) { + Optional statement = statements.stream() + .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) + .findFirst(); + if (statement.isPresent()) { + setResponseValueKey(statement.get()); + return true; + } + return false; + } + + @Override + protected String getTestRegExp() { + return ""; + } + + private String getTestRegExp(String key) { + return "show " + key + ";"; + } + + private void setResponseValueKey(String path) { + responseValueKey = path; + } + +} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java deleted file mode 100644 index 03b35adc9a..0000000000 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowTablesStrategy.java +++ /dev/null @@ -1,26 +0,0 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; - -import com.fasterxml.jackson.databind.JsonNode; -import com.provectus.kafka.ui.model.KsqlResponseTable; -import org.springframework.stereotype.Component; - -@Component -public class ShowTablesStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "tables"; - - @Override - public KsqlResponseTable serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return requestPath; - } - - @Override - protected String getTestRegExp() { - return "(list|show) tables;"; - } -} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java similarity index 52% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java index a0b1245142..34094cf869 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowPropertiesStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java @@ -1,18 +1,17 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; import com.fasterxml.jackson.databind.JsonNode; -import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; - @Component -public class ShowPropertiesStrategy extends KsqlStatementStrategy { +public class TerminateStrategy extends KsqlStatementStrategy { private final String requestPath = "/ksql"; - private final String responseValueKey = "properties"; + private final String responseValueKey = "commandStatus"; @Override - public KsqlResponseTable serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeMessageResponse(response, responseValueKey); } @Override @@ -22,6 +21,6 @@ public class ShowPropertiesStrategy extends KsqlStatementStrategy { @Override protected String getTestRegExp() { - return "show properties;"; + return "terminate (.*);"; } } diff --git a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml index e753168c39..31e7ccf4fc 100644 --- a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml +++ b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml @@ -1079,7 +1079,7 @@ paths: content: application/json: schema: - $ref: '#/components/schemas/KsqlResponseTable' + $ref: '#/components/schemas/KsqlCommandResponse' /api/clusters/{clusterName}/connects/{connectName}/plugins: get: @@ -1852,11 +1852,21 @@ components: ksql: type: string streamsProperties: - type: string + type: object + additionalProperties: + type: string required: - ksql - KsqlResponseTable: + KsqlCommandResponse: + type: object + properties: + data: + $ref: '#/components/schemas/Table' + message: + type: string + + Table: type: object properties: headers: @@ -1870,7 +1880,8 @@ components: items: type: string required: - - ksql + - headers + - rows FullConnectorInfo: type: object From 61289dde617a2627492fa6b964f81784dc9a1275 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Tue, 20 Jul 2021 17:03:10 +0300 Subject: [PATCH 05/11] [#207] feat(api): add ksql_db feature, expection handler to ksql client --- .../provectus/kafka/ui/client/KsqlClient.java | 45 ++++++++++++------- .../com/provectus/kafka/ui/model/Feature.java | 2 +- .../kafka/ui/service/KsqlService.java | 3 +- .../ksqlStatement/KsqlStatementStrategy.java | 18 ++++---- .../strategy/ksqlStatement/ListStrategy.java | 2 +- 5 files changed, 39 insertions(+), 31 deletions(-) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index c4714b61b7..b4df865c1a 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -2,14 +2,17 @@ package com.provectus.kafka.ui.client; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; import lombok.RequiredArgsConstructor; import lombok.SneakyThrows; import lombok.extern.log4j.Log4j2; +import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.stereotype.Service; import org.springframework.web.reactive.function.BodyInserters; +import org.springframework.web.reactive.function.client.ClientResponse; import org.springframework.web.reactive.function.client.WebClient; import reactor.core.publisher.Mono; @@ -17,23 +20,31 @@ import reactor.core.publisher.Mono; @RequiredArgsConstructor @Log4j2 public final class KsqlClient { - private final WebClient webClient; - private final ObjectMapper mapper; + private final WebClient webClient; + private final ObjectMapper mapper; - public Mono execute(KsqlStatementStrategy ksqlStatement) { - return webClient.post() - .uri(ksqlStatement.getUri()) - .accept(new MediaType("application","vnd.ksql.v1+json")) - .body(BodyInserters.fromValue(ksqlStatement.getKsqlCommand())) - .retrieve() - .bodyToMono(byte[].class) - .map(this::toJson) - .map(ksqlStatement::serializeResponse) - .doOnError(log::error); - } + public Mono execute(KsqlStatementStrategy ksqlStatement) { + return webClient.post() + .uri(ksqlStatement.getUri()) + .accept(new MediaType("application", "vnd.ksql.v1+json")) + .body(BodyInserters.fromValue(ksqlStatement.getKsqlCommand())) + .retrieve() + .onStatus(HttpStatus::isError, this::getErrorMessage) + .bodyToMono(byte[].class) + .map(this::toJson) + .map(ksqlStatement::serializeResponse); + } - @SneakyThrows - private JsonNode toJson(byte[] content) { - return this.mapper.readTree(content); - } + private Mono getErrorMessage(ClientResponse response) { + return response + .bodyToMono(byte[].class) + .map(this::toJson) + .map(jsonNode -> jsonNode.get("message").asText()) + .flatMap(error -> Mono.error(new UnprocessableEntityException(error))); + } + + @SneakyThrows + private JsonNode toJson(byte[] content) { + return this.mapper.readTree(content); + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java index d624e298ad..8b6e70264a 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/model/Feature.java @@ -11,8 +11,8 @@ public enum Feature { .filter(Predicate.not(List::isEmpty)) .isPresent() ), + KSQL_DB(cluster -> cluster.getKsqldbServer() != null), SCHEMA_REGISTRY(cluster -> cluster.getSchemaRegistry() != null); - // TODO: add feature for FE app private final Predicate isEnabled; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index 5b896f578b..e9306be22c 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -29,7 +29,7 @@ public class KsqlService { .flatMap(host -> getStatementStrategyForKsqlCommand(ksqlCommand) .map(statement -> statement.host(host)) ) - .flatMap(statement -> ksqlClient.execute(statement)); + .flatMap(ksqlClient::execute); } private Mono getStatementStrategyForKsqlCommand(Mono ksqlCommand) { @@ -39,7 +39,6 @@ public class KsqlService { .map(s -> s.ksqlCommand(command)) .findFirst()) .flatMap(Mono::justOrEmpty) - // TODO: handle not parsed statements? .switchIfEmpty(Mono.error(new UnprocessableEntityException("Invalid sql"))); } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java index 6ee2cb0d44..f936fa9e7b 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java @@ -1,6 +1,7 @@ package com.provectus.kafka.ui.strategy.ksqlStatement; import com.fasterxml.jackson.databind.JsonNode; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.model.Table; @@ -48,7 +49,7 @@ public abstract class KsqlStatementStrategy { Table table = items.isArray() ? getTableFromArray(items) : getTableFromObject(items); return commandResponse.data(table); } - throw new InternalError("Invalid data format"); + throw new UnprocessableEntityException("KSQL DB response mapping error"); } protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String path) { @@ -58,8 +59,7 @@ public abstract class KsqlStatementStrategy { JsonNode item = first.path(path); return commandResponse.message(getMessageFromObject(item)); } - // TODO: handle - throw new InternalError("Invalid data format"); + throw new UnprocessableEntityException("KSQL DB response mapping error"); } protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { @@ -74,7 +74,7 @@ public abstract class KsqlStatementStrategy { JsonNode headerRow = response.get(0); if (headerRow.isObject() && headerRow.size() > 0) { String schema = headerRow.get("header").get("schema").asText(); - return Arrays.stream(schema.split(",")).map(s -> s.trim()).collect(Collectors.toList()); + return Arrays.stream(schema.split(",")).map(String::trim).collect(Collectors.toList()); } return new ArrayList<>(); } @@ -84,7 +84,7 @@ public abstract class KsqlStatementStrategy { .filter(row -> row.has("row") && row.get("row").has("columns")) .map(row -> row.get("row").get("columns")) .map(cellNode -> getStreamForJsonArray(cellNode) - .map(cell -> cell.asText()) + .map(JsonNode::asText) .collect(Collectors.toList()) ) .collect(Collectors.toList()); @@ -115,7 +115,7 @@ public abstract class KsqlStatementStrategy { if (node.isObject() && node.has("message")) { return node.get("message").asText(); } - throw new InternalError("can't get message from empty object or array"); + throw new UnprocessableEntityException("KSQL DB response mapping error"); } private List> getTableRows(JsonNode node, List keys) { @@ -131,8 +131,7 @@ public abstract class KsqlStatementStrategy { if (node.isArray() && node.size() > 0) { return StreamSupport.stream(node.spliterator(), false); } - // TODO: handle - throw new InternalError("not JsonArray or empty"); + throw new UnprocessableEntityException("KSQL DB response mapping error"); } private List getJsonObjectKeys(JsonNode node) { @@ -141,8 +140,7 @@ public abstract class KsqlStatementStrategy { Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false ).collect(Collectors.toList()); } - // TODO: handle - throw new InternalError("Invalid data format"); + throw new UnprocessableEntityException("KSQL DB response mapping error"); } private List getJsonObjectValues(JsonNode node) { diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java index 4ec19536b4..e7bde0544c 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java @@ -10,8 +10,8 @@ import java.util.Optional; @Component public class ListStrategy extends KsqlStatementStrategy { private final String requestPath = "/ksql"; - private String responseValueKey = ""; private final List statements = List.of("functions", "topics", "streams", "tables"); + private String responseValueKey = ""; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { From d59b4e69f97be6791833443121b01cac85130da5 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Fri, 23 Jul 2021 10:07:54 +0300 Subject: [PATCH 06/11] [#207] tests(api): added unit tests for KsqlService, KsqlCommandStrategies --- .../provectus/kafka/ui/client/KsqlClient.java | 2 +- .../kafka/ui/service/KsqlService.java | 5 +- .../ksqlStatement/DescribeStrategy.java | 1 - .../ksqlStatement/KsqlStatementStrategy.java | 15 +- .../ksqlStatement/SelectStrategy.java | 2 - .../kafka/ui/service/KsqlServiceTest.java | 117 +++++++++++++++ .../ksqlStatement/CreateStrategyTest.java | 82 +++++++++++ .../ksqlStatement/DescribeStrategyTest.java | 74 ++++++++++ .../ksqlStatement/DropStrategyTest.java | 73 ++++++++++ .../ksqlStatement/ExplainStrategyTest.java | 72 ++++++++++ .../ksqlStatement/ListStrategyTest.java | 110 ++++++++++++++ .../ksqlStatement/SelectStrategyTest.java | 78 ++++++++++ .../ksqlStatement/ShowStrategyTest.java | 136 ++++++++++++++++++ .../ksqlStatement/TerminateStrategyTest.java | 70 +++++++++ .../main/resources/swagger/kafka-ui-api.yaml | 1 + 15 files changed, 827 insertions(+), 11 deletions(-) create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java create mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index b4df865c1a..29d19a89f2 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -19,7 +19,7 @@ import reactor.core.publisher.Mono; @Service @RequiredArgsConstructor @Log4j2 -public final class KsqlClient { +public class KsqlClient { private final WebClient webClient; private final ObjectMapper mapper; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index e9306be22c..c9eb9b9298 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -25,7 +25,10 @@ public class KsqlService { return Mono.justOrEmpty(clustersStorage.getClusterByName(clusterName)) .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) .map(KafkaCluster::getKsqldbServer) - .switchIfEmpty(Mono.error(KsqlDbNotFoundException::new)) + .onErrorResume(e -> { + Throwable throwable = e instanceof ClusterNotFoundException ? e : new KsqlDbNotFoundException(); + return Mono.error(throwable); + }) .flatMap(host -> getStatementStrategyForKsqlCommand(ksqlCommand) .map(statement -> statement.host(host)) ) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java index a6b02636a3..84299e8fcf 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java @@ -12,7 +12,6 @@ public class DescribeStrategy extends KsqlStatementStrategy { @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - System.out.println(response); return serializeTableResponse(response, responseValueKey); } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java index f936fa9e7b..2315971cf9 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java @@ -63,16 +63,19 @@ public abstract class KsqlStatementStrategy { } protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); - Table table = (new Table()) - .headers(getQueryResponseHeader(response)) - .rows(getQueryResponseRows(response)); - return commandResponse.data(table); + if (response.isArray() && response.size() > 0) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + Table table = (new Table()) + .headers(getQueryResponseHeader(response)) + .rows(getQueryResponseRows(response)); + return commandResponse.data(table); + } + throw new UnprocessableEntityException("KSQL DB response mapping error"); } private List getQueryResponseHeader(JsonNode response) { JsonNode headerRow = response.get(0); - if (headerRow.isObject() && headerRow.size() > 0) { + if (headerRow.isObject() && headerRow.has("header")) { String schema = headerRow.get("header").get("schema").asText(); return Arrays.stream(schema.split(",")).map(String::trim).collect(Collectors.toList()); } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java index 309578a826..3882bff434 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java @@ -10,7 +10,6 @@ public class SelectStrategy extends KsqlStatementStrategy { @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - System.out.println(response); return serializeQueryResponse(response); } @@ -19,7 +18,6 @@ public class SelectStrategy extends KsqlStatementStrategy { return requestPath; } - @Override protected String getTestRegExp() { return "select (.*) from (.*);"; diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java new file mode 100644 index 0000000000..303963367a --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java @@ -0,0 +1,117 @@ +package com.provectus.kafka.ui.service; + +import com.provectus.kafka.ui.client.KsqlClient; +import com.provectus.kafka.ui.exception.ClusterNotFoundException; +import com.provectus.kafka.ui.exception.KsqlDbNotFoundException; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KafkaCluster; +import com.provectus.kafka.ui.model.KsqlCommand; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksqlStatement.ShowStrategy; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.junit.jupiter.MockitoExtension; +import reactor.core.publisher.Mono; +import reactor.test.StepVerifier; + +import java.util.List; +import java.util.Optional; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +@ExtendWith(MockitoExtension.class) +class KsqlServiceTest { + private KsqlService ksqlService; + private KsqlStatementStrategy ksqlStatementStrategy; + + @Mock + private ClustersStorage clustersStorage; + @Mock + private KsqlClient ksqlClient; + + + @BeforeEach + public void setUp() { + this.ksqlStatementStrategy = new ShowStrategy(); + this.ksqlService = new KsqlService( + this.ksqlClient, + this.clustersStorage, + List.of(ksqlStatementStrategy) + ); + } + + @Test + public void shouldThrowClusterNotFoundExceptionOnExecuteKsqlCommand() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(null)); + + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyError(ClusterNotFoundException.class); + } + + @Test + public void shouldThrowKsqlDbNotFoundExceptionOnExecuteKsqlCommand() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn(null); + + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyError(KsqlDbNotFoundException.class); + } + + @Test + public void shouldThrowUnprocessableEntityExceptionOnExecuteKsqlCommand() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("CREATE STREAM users WITH (KAFKA_TOPIC='users');"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn("localhost:8088"); + + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyError(UnprocessableEntityException.class); + + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyErrorMessage("Invalid sql"); + } + + @Test + public void shouldSetHostToStrategy() { + String clusterName = "test"; + String host = "localhost:8088"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + + when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn(host); + when(ksqlClient.execute(any())).thenReturn(Mono.just(new KsqlCommandResponse())); + + ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo(host + "/ksql"); + } + + @Test + public void shouldCallClientAndReturnResponse() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + KsqlCommandResponse response = new KsqlCommandResponse().message("success"); + + when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn("host"); + when(ksqlClient.execute(any())).thenReturn(Mono.just(response)); + + KsqlCommandResponse receivedResponse = ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); + verify(ksqlClient, times(1)).execute(ksqlStatementStrategy); + assertThat(receivedResponse).isEqualTo(response); + + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java new file mode 100644 index 0000000000..938b5ae284 --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java @@ -0,0 +1,82 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class CreateStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new CreateStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream WITH (KAFKA_TOPIC='topic');")); + assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream" + + " AS SELECT users.id AS userid FROM users EMIT CHANGES;" + )); + assertTrue(ksqlStatementStrategy.test( + "CREATE TABLE table (id VARCHAR) WITH (KAFKA_TOPIC='table');" + )); + assertTrue(ksqlStatementStrategy.test( + "CREATE TABLE pageviews_regions WITH (KEY_FORMAT='JSON')" + + " AS SELECT gender, COUNT(*) AS numbers" + + " FROM pageviews EMIT CHANGES;" + )); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("show tables;")); + assertFalse(ksqlStatementStrategy.test("CREATE TABLE test;")); + assertFalse(ksqlStatementStrategy.test("CREATE STREAM test;")); + } + + @Test + public void shouldSerializeResponse() { + String message = "updated successful"; + JsonNode node = getResponseWithMessage(message); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + assertThat(serializedResponse.getMessage()).isEqualTo(message); + + } + + @Test + public void shouldSerializeWithException() { + JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithMessage(String message) { + JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); + JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java new file mode 100644 index 0000000000..a36fce35e2 --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java @@ -0,0 +1,74 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.model.Table; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class DescribeStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new DescribeStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("DESCRIBE users;")); + assertTrue(ksqlStatementStrategy.test("DESCRIBE EXTENDED users;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("list streams;")); + assertFalse(ksqlStatementStrategy.test("show tables;")); + } + + @Test + public void shouldSerializeResponse() { + JsonNode node = getResponseWithObjectNode(); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); + } + + @Test + public void shouldSerializeWithException() { + JsonNode sourceDescriptionNode = mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithObjectNode() { + JsonNode nodeWithMessage = mapper.createObjectNode().put("name", "kafka"); + JsonNode nodeWithResponse = mapper.createObjectNode().set("sourceDescription", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java new file mode 100644 index 0000000000..c1fb4e549f --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java @@ -0,0 +1,73 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class DropStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new DropStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("drop table table1;")); + assertTrue(ksqlStatementStrategy.test("drop stream stream2;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("show tables;")); + assertFalse(ksqlStatementStrategy.test("create table test;")); + assertFalse(ksqlStatementStrategy.test("create stream test;")); + } + + @Test + public void shouldSerializeResponse() { + String message = "updated successful"; + JsonNode node = getResponseWithMessage(message); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + assertThat(serializedResponse.getMessage()).isEqualTo(message); + + } + + @Test + public void shouldSerializeWithException() { + JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithMessage(String message) { + JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); + JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java new file mode 100644 index 0000000000..eb889576b6 --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java @@ -0,0 +1,72 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.model.Table; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class ExplainStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new ExplainStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("explain users_query_id;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show queries;")); + } + + @Test + public void shouldSerializeResponse() { + JsonNode node = getResponseWithObjectNode(); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); + } + + @Test + public void shouldSerializeWithException() { + JsonNode sourceDescriptionNode = mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithObjectNode() { + JsonNode nodeWithMessage = mapper.createObjectNode().put("name", "kafka"); + JsonNode nodeWithResponse = mapper.createObjectNode().set("queryDescription", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java new file mode 100644 index 0000000000..280151a92c --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java @@ -0,0 +1,110 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.model.Table; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class ListStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new ListStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("LIST STREAMS;")); + assertTrue(ksqlStatementStrategy.test("LIST TABLES;")); + assertTrue(ksqlStatementStrategy.test("LIST TOPICS;")); + assertTrue(ksqlStatementStrategy.test("LIST FUNCTIONS;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("SHOW STREAMS;")); + assertFalse(ksqlStatementStrategy.test("SHOW TABLES;")); + assertFalse(ksqlStatementStrategy.test("SHOW TOPICS;")); + assertFalse(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); + } + + @Test + public void shouldSerializeStreamsResponse() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("list streams;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeTablesResponse() { + JsonNode node = getResponseWithData("tables"); + ksqlStatementStrategy.test("list tables;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeTopicsResponse() { + JsonNode node = getResponseWithData("topics"); + ksqlStatementStrategy.test("list topics;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeFunctionsResponse() { + JsonNode node = getResponseWithData("functions"); + ksqlStatementStrategy.test("list functions;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeWithException() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("list tables;"); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithData(String key) { + JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); + JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); + JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java new file mode 100644 index 0000000000..7d62fa468f --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java @@ -0,0 +1,78 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.model.Table; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class SelectStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new SelectStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/query"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("select * from users;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("select *;")); + } + + @Test + public void shouldSerializeResponse() { + JsonNode node = getResponseWithData(); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header1", "header2")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value1", "value2"))); + } + + @Test + public void shouldSerializeWithException() { + JsonNode node = mapper.createObjectNode(); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithData() { + JsonNode headerNode = mapper.createObjectNode().set( + "header", mapper.createObjectNode().put("schema", "header1, header2") + ); + JsonNode row = mapper.createObjectNode().set( + "row", mapper.createObjectNode().set( + "columns", mapper.createArrayNode().add("value1").add("value2") + ) + ); + return mapper.createArrayNode().add(headerNode).add(row); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java new file mode 100644 index 0000000000..bf090752b2 --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java @@ -0,0 +1,136 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommand; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import com.provectus.kafka.ui.model.KsqlResponseTable; +import com.provectus.kafka.ui.model.Table; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class ShowStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new ShowStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("SHOW STREAMS;")); + assertTrue(ksqlStatementStrategy.test("SHOW TABLES;")); + assertTrue(ksqlStatementStrategy.test("SHOW TOPICS;")); + assertTrue(ksqlStatementStrategy.test("SHOW QUERIES;")); + assertTrue(ksqlStatementStrategy.test("SHOW PROPERTIES;")); + assertTrue(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("LIST STREAMS;")); + assertFalse(ksqlStatementStrategy.test("LIST TABLES;")); + assertFalse(ksqlStatementStrategy.test("LIST TOPICS;")); + assertFalse(ksqlStatementStrategy.test("LIST QUERIES;")); + assertFalse(ksqlStatementStrategy.test("LIST PROPERTIES;")); + assertFalse(ksqlStatementStrategy.test("LIST FUNCTIONS;")); + } + + @Test + public void shouldSerializeStreamsResponse() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("show streams;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeTablesResponse() { + JsonNode node = getResponseWithData("tables"); + ksqlStatementStrategy.test("show tables;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeTopicsResponse() { + JsonNode node = getResponseWithData("topics"); + ksqlStatementStrategy.test("show topics;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializePropertiesResponse() { + JsonNode node = getResponseWithData("properties"); + ksqlStatementStrategy.test("show properties;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeFunctionsResponse() { + JsonNode node = getResponseWithData("functions"); + ksqlStatementStrategy.test("show functions;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeQueriesResponse() { + JsonNode node = getResponseWithData("queries"); + ksqlStatementStrategy.test("show queries;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } + + @Test + public void shouldSerializeWithException() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("show tables;"); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithData(String key) { + JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); + JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); + JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } +} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java new file mode 100644 index 0000000000..8b1dffcfbb --- /dev/null +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java @@ -0,0 +1,70 @@ +package com.provectus.kafka.ui.strategy.ksqlStatement; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.provectus.kafka.ui.exception.UnprocessableEntityException; +import com.provectus.kafka.ui.model.KsqlCommandResponse; +import lombok.SneakyThrows; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.junit.jupiter.MockitoExtension; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.*; + +@ExtendWith(MockitoExtension.class) +class TerminateStrategyTest { + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); + + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new TerminateStrategy(); + } + + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } + + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("terminate query_id;")); + } + + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("create table test;")); + } + + @Test + public void shouldSerializeResponse() { + String message = "query terminated."; + JsonNode node = getResponseWithMessage(message); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + assertThat(serializedResponse.getMessage()).isEqualTo(message); + + } + + @Test + public void shouldSerializeWithException() { + JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); + + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } + + @SneakyThrows + private JsonNode getResponseWithMessage(String message) { + JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); + JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + } +} diff --git a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml index 31e7ccf4fc..3ca5097a86 100644 --- a/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml +++ b/kafka-ui-contract/src/main/resources/swagger/kafka-ui-api.yaml @@ -1206,6 +1206,7 @@ components: enum: - SCHEMA_REGISTRY - KAFKA_CONNECT + - KSQL_DB required: - id - name From 0434c48a2d740192aae38eab5b7c15654f8fabad Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Fri, 23 Jul 2021 12:49:11 +0300 Subject: [PATCH 07/11] [#207] fix(api): lint --- .../provectus/kafka/ui/client/KsqlClient.java | 48 ++-- .../kafka/ui/service/KsqlService.java | 39 +-- .../ksqlStatement/CreateStrategy.java | 28 +- .../ksqlStatement/DescribeStrategy.java | 28 +- .../strategy/ksqlStatement/DropStrategy.java | 28 +- .../ksqlStatement/ExplainStrategy.java | 28 +- .../ksqlStatement/KsqlStatementStrategy.java | 242 +++++++++--------- .../strategy/ksqlStatement/ListStrategy.java | 62 ++--- .../ksqlStatement/SelectStrategy.java | 26 +- .../strategy/ksqlStatement/ShowStrategy.java | 63 ++--- .../ksqlStatement/TerminateStrategy.java | 28 +- .../kafka/ui/service/KsqlServiceTest.java | 150 +++++------ .../ksqlStatement/CreateStrategyTest.java | 113 ++++---- .../ksqlStatement/DescribeStrategyTest.java | 91 +++---- .../ksqlStatement/DropStrategyTest.java | 92 +++---- .../ksqlStatement/ExplainStrategyTest.java | 87 +++---- .../ksqlStatement/ListStrategyTest.java | 156 +++++------ .../ksqlStatement/SelectStrategyTest.java | 98 +++---- .../ksqlStatement/ShowStrategyTest.java | 200 +++++++-------- .../ksqlStatement/TerminateStrategyTest.java | 86 +++---- 20 files changed, 853 insertions(+), 840 deletions(-) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index 29d19a89f2..aca317eb94 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -20,31 +20,31 @@ import reactor.core.publisher.Mono; @RequiredArgsConstructor @Log4j2 public class KsqlClient { - private final WebClient webClient; - private final ObjectMapper mapper; + private final WebClient webClient; + private final ObjectMapper mapper; - public Mono execute(KsqlStatementStrategy ksqlStatement) { - return webClient.post() - .uri(ksqlStatement.getUri()) - .accept(new MediaType("application", "vnd.ksql.v1+json")) - .body(BodyInserters.fromValue(ksqlStatement.getKsqlCommand())) - .retrieve() - .onStatus(HttpStatus::isError, this::getErrorMessage) - .bodyToMono(byte[].class) - .map(this::toJson) - .map(ksqlStatement::serializeResponse); - } + public Mono execute(KsqlStatementStrategy ksqlStatement) { + return webClient.post() + .uri(ksqlStatement.getUri()) + .accept(new MediaType("application", "vnd.ksql.v1+json")) + .body(BodyInserters.fromValue(ksqlStatement.getKsqlCommand())) + .retrieve() + .onStatus(HttpStatus::isError, this::getErrorMessage) + .bodyToMono(byte[].class) + .map(this::toJson) + .map(ksqlStatement::serializeResponse); + } - private Mono getErrorMessage(ClientResponse response) { - return response - .bodyToMono(byte[].class) - .map(this::toJson) - .map(jsonNode -> jsonNode.get("message").asText()) - .flatMap(error -> Mono.error(new UnprocessableEntityException(error))); - } + private Mono getErrorMessage(ClientResponse response) { + return response + .bodyToMono(byte[].class) + .map(this::toJson) + .map(jsonNode -> jsonNode.get("message").asText()) + .flatMap(error -> Mono.error(new UnprocessableEntityException(error))); + } - @SneakyThrows - private JsonNode toJson(byte[] content) { - return this.mapper.readTree(content); - } + @SneakyThrows + private JsonNode toJson(byte[] content) { + return this.mapper.readTree(content); + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index c9eb9b9298..93eab520c0 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -21,27 +21,30 @@ public class KsqlService { private final ClustersStorage clustersStorage; private final List ksqlStatementStrategies; - public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { + public Mono executeKsqlCommand(String clusterName, + Mono ksqlCommand) { return Mono.justOrEmpty(clustersStorage.getClusterByName(clusterName)) - .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) - .map(KafkaCluster::getKsqldbServer) - .onErrorResume(e -> { - Throwable throwable = e instanceof ClusterNotFoundException ? e : new KsqlDbNotFoundException(); - return Mono.error(throwable); - }) - .flatMap(host -> getStatementStrategyForKsqlCommand(ksqlCommand) - .map(statement -> statement.host(host)) - ) - .flatMap(ksqlClient::execute); + .switchIfEmpty(Mono.error(ClusterNotFoundException::new)) + .map(KafkaCluster::getKsqldbServer) + .onErrorResume(e -> { + Throwable throwable = + e instanceof ClusterNotFoundException ? e : new KsqlDbNotFoundException(); + return Mono.error(throwable); + }) + .flatMap(host -> getStatementStrategyForKsqlCommand(ksqlCommand) + .map(statement -> statement.host(host)) + ) + .flatMap(ksqlClient::execute); } - private Mono getStatementStrategyForKsqlCommand(Mono ksqlCommand) { + private Mono getStatementStrategyForKsqlCommand( + Mono ksqlCommand) { return ksqlCommand - .map(command -> ksqlStatementStrategies.stream() - .filter(s -> s.test(command.getKsql())) - .map(s -> s.ksqlCommand(command)) - .findFirst()) - .flatMap(Mono::justOrEmpty) - .switchIfEmpty(Mono.error(new UnprocessableEntityException("Invalid sql"))); + .map(command -> ksqlStatementStrategies.stream() + .filter(s -> s.test(command.getKsql())) + .map(s -> s.ksqlCommand(command)) + .findFirst()) + .flatMap(Mono::justOrEmpty) + .switchIfEmpty(Mono.error(new UnprocessableEntityException("Invalid sql"))); } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java index 55793322e1..9349fe92df 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java @@ -7,21 +7,21 @@ import org.springframework.stereotype.Component; @Component public class CreateStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "commandStatus"; + private final String requestPath = "/ksql"; + private final String responseValueKey = "commandStatus"; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeMessageResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeMessageResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - protected String getTestRegExp() { - return "create (table|stream)(.*)(with|as select(.*)from)(.*);"; - } + @Override + protected String getTestRegExp() { + return "create (table|stream)(.*)(with|as select(.*)from)(.*);"; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java index 84299e8fcf..d03a33f4ce 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java @@ -7,21 +7,21 @@ import org.springframework.stereotype.Component; @Component public class DescribeStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "sourceDescription"; + private final String requestPath = "/ksql"; + private final String responseValueKey = "sourceDescription"; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - protected String getTestRegExp() { - return "describe (.*);"; - } + @Override + protected String getTestRegExp() { + return "describe (.*);"; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java index f9f30f3ffe..e9821fa873 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java @@ -7,21 +7,21 @@ import org.springframework.stereotype.Component; @Component public class DropStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "commandStatus"; + private final String requestPath = "/ksql"; + private final String responseValueKey = "commandStatus"; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeMessageResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeMessageResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - protected String getTestRegExp() { - return "drop (table|stream) (.*);"; - } + @Override + protected String getTestRegExp() { + return "drop (table|stream) (.*);"; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java index a106b46f64..d58ea6f3be 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java @@ -6,21 +6,21 @@ import org.springframework.stereotype.Component; @Component public class ExplainStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "queryDescription"; + private final String requestPath = "/ksql"; + private final String responseValueKey = "queryDescription"; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - protected String getTestRegExp() { - return "explain (.*);"; - } + @Override + protected String getTestRegExp() { + return "explain (.*);"; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java index 2315971cf9..e9ca6c5788 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java @@ -13,147 +13,147 @@ import java.util.stream.Stream; import java.util.stream.StreamSupport; public abstract class KsqlStatementStrategy { - protected String host = null; - protected KsqlCommand ksqlCommand = null; + protected String host = null; + protected KsqlCommand ksqlCommand = null; - public String getUri() { - if (this.host != null) { - return this.host + this.getRequestPath(); - } - return null; + public String getUri() { + if (this.host != null) { + return this.host + this.getRequestPath(); } + return null; + } - public boolean test(String sql) { - return sql.trim().toLowerCase().matches(getTestRegExp()); + public boolean test(String sql) { + return sql.trim().toLowerCase().matches(getTestRegExp()); + } + + public KsqlStatementStrategy host(String host) { + this.host = host; + return this; + } + + public KsqlCommand getKsqlCommand() { + return ksqlCommand; + } + + public KsqlStatementStrategy ksqlCommand(KsqlCommand ksqlCommand) { + this.ksqlCommand = ksqlCommand; + return this; + } + + protected KsqlCommandResponse serializeTableResponse(JsonNode response, String path) { + if (response.isArray() && response.size() > 0) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + JsonNode first = response.get(0); + JsonNode items = first.path(path); + Table table = items.isArray() ? getTableFromArray(items) : getTableFromObject(items); + return commandResponse.data(table); } + throw new UnprocessableEntityException("KSQL DB response mapping error"); + } - public KsqlStatementStrategy host(String host) { - this.host = host; - return this; + protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String path) { + if (response.isArray() && response.size() > 0) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + JsonNode first = response.get(0); + JsonNode item = first.path(path); + return commandResponse.message(getMessageFromObject(item)); } + throw new UnprocessableEntityException("KSQL DB response mapping error"); + } - public KsqlCommand getKsqlCommand() { - return ksqlCommand; + protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { + if (response.isArray() && response.size() > 0) { + KsqlCommandResponse commandResponse = new KsqlCommandResponse(); + Table table = (new Table()) + .headers(getQueryResponseHeader(response)) + .rows(getQueryResponseRows(response)); + return commandResponse.data(table); } + throw new UnprocessableEntityException("KSQL DB response mapping error"); + } - public KsqlStatementStrategy ksqlCommand(KsqlCommand ksqlCommand) { - this.ksqlCommand = ksqlCommand; - return this; + private List getQueryResponseHeader(JsonNode response) { + JsonNode headerRow = response.get(0); + if (headerRow.isObject() && headerRow.has("header")) { + String schema = headerRow.get("header").get("schema").asText(); + return Arrays.stream(schema.split(",")).map(String::trim).collect(Collectors.toList()); } + return new ArrayList<>(); + } - protected KsqlCommandResponse serializeTableResponse(JsonNode response, String path) { - if (response.isArray() && response.size() > 0) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); - JsonNode first = response.get(0); - JsonNode items = first.path(path); - Table table = items.isArray() ? getTableFromArray(items) : getTableFromObject(items); - return commandResponse.data(table); - } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + private List> getQueryResponseRows(JsonNode node) { + return getStreamForJsonArray(node) + .filter(row -> row.has("row") && row.get("row").has("columns")) + .map(row -> row.get("row").get("columns")) + .map(cellNode -> getStreamForJsonArray(cellNode) + .map(JsonNode::asText) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()); + } + + private Table getTableFromArray(JsonNode node) { + Table table = new Table(); + table.headers(new ArrayList<>()).rows(new ArrayList<>()); + if (node.size() > 0) { + List keys = getJsonObjectKeys(node.get(0)); + List> rows = getTableRows(node, keys); + table.headers(keys).rows(rows); } + return table; + } - protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String path) { - if (response.isArray() && response.size() > 0) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); - JsonNode first = response.get(0); - JsonNode item = first.path(path); - return commandResponse.message(getMessageFromObject(item)); - } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + private Table getTableFromObject(JsonNode node) { + List keys = getJsonObjectKeys(node); + List values = getJsonObjectValues(node); + List> rows = IntStream + .range(0, keys.size()) + .mapToObj(i -> List.of(keys.get(i), values.get(i))) + .collect(Collectors.toList()); + return (new Table()).headers(List.of("key", "value")).rows(rows); + } + + private String getMessageFromObject(JsonNode node) { + if (node.isObject() && node.has("message")) { + return node.get("message").asText(); } + throw new UnprocessableEntityException("KSQL DB response mapping error"); + } - protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { - if (response.isArray() && response.size() > 0) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); - Table table = (new Table()) - .headers(getQueryResponseHeader(response)) - .rows(getQueryResponseRows(response)); - return commandResponse.data(table); - } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + private List> getTableRows(JsonNode node, List keys) { + return getStreamForJsonArray(node) + .map(row -> keys.stream() + .map(header -> row.get(header).asText()) + .collect(Collectors.toList()) + ) + .collect(Collectors.toList()); + } + + private Stream getStreamForJsonArray(JsonNode node) { + if (node.isArray() && node.size() > 0) { + return StreamSupport.stream(node.spliterator(), false); } + throw new UnprocessableEntityException("KSQL DB response mapping error"); + } - private List getQueryResponseHeader(JsonNode response) { - JsonNode headerRow = response.get(0); - if (headerRow.isObject() && headerRow.has("header")) { - String schema = headerRow.get("header").get("schema").asText(); - return Arrays.stream(schema.split(",")).map(String::trim).collect(Collectors.toList()); - } - return new ArrayList<>(); + private List getJsonObjectKeys(JsonNode node) { + if (node.isObject()) { + return StreamSupport.stream( + Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false + ).collect(Collectors.toList()); } + throw new UnprocessableEntityException("KSQL DB response mapping error"); + } - private List> getQueryResponseRows(JsonNode node) { - return getStreamForJsonArray(node) - .filter(row -> row.has("row") && row.get("row").has("columns")) - .map(row -> row.get("row").get("columns")) - .map(cellNode -> getStreamForJsonArray(cellNode) - .map(JsonNode::asText) - .collect(Collectors.toList()) - ) - .collect(Collectors.toList()); - } + private List getJsonObjectValues(JsonNode node) { + return getJsonObjectKeys(node).stream().map(key -> node.get(key).asText()) + .collect(Collectors.toList()); + } - private Table getTableFromArray(JsonNode node) { - Table table = new Table(); - table.headers(new ArrayList<>()).rows(new ArrayList<>()); - if (node.size() > 0) { - List keys = getJsonObjectKeys(node.get(0)); - List> rows = getTableRows(node, keys); - table.headers(keys).rows(rows); - } - return table; - } + public abstract KsqlCommandResponse serializeResponse(JsonNode response); - private Table getTableFromObject(JsonNode node) { - List keys = getJsonObjectKeys(node); - List values = getJsonObjectValues(node); - List> rows = IntStream - .range(0, keys.size()) - .mapToObj(i -> List.of(keys.get(i), values.get(i))) - .collect(Collectors.toList()); - return (new Table()).headers(List.of("key", "value")).rows(rows); - } + protected abstract String getRequestPath(); - private String getMessageFromObject(JsonNode node) { - if (node.isObject() && node.has("message")) { - return node.get("message").asText(); - } - throw new UnprocessableEntityException("KSQL DB response mapping error"); - } - - private List> getTableRows(JsonNode node, List keys) { - return getStreamForJsonArray(node) - .map(row -> keys.stream() - .map(header -> row.get(header).asText()) - .collect(Collectors.toList()) - ) - .collect(Collectors.toList()); - } - - private Stream getStreamForJsonArray(JsonNode node) { - if (node.isArray() && node.size() > 0) { - return StreamSupport.stream(node.spliterator(), false); - } - throw new UnprocessableEntityException("KSQL DB response mapping error"); - } - - private List getJsonObjectKeys(JsonNode node) { - if (node.isObject()) { - return StreamSupport.stream( - Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false - ).collect(Collectors.toList()); - } - throw new UnprocessableEntityException("KSQL DB response mapping error"); - } - - private List getJsonObjectValues(JsonNode node) { - return getJsonObjectKeys(node).stream().map(key -> node.get(key).asText()) - .collect(Collectors.toList()); - } - - public abstract KsqlCommandResponse serializeResponse(JsonNode response); - - protected abstract String getRequestPath(); - - protected abstract String getTestRegExp(); + protected abstract String getTestRegExp(); } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java index e7bde0544c..c89d92bcae 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java @@ -9,42 +9,42 @@ import java.util.Optional; @Component public class ListStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final List statements = List.of("functions", "topics", "streams", "tables"); - private String responseValueKey = ""; + private final String requestPath = "/ksql"; + private final List statements = List.of("functions", "topics", "streams", "tables"); + private String responseValueKey = ""; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - public boolean test(String sql) { - Optional statement = statements.stream() - .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) - .findFirst(); - if (statement.isPresent()) { - setResponseValueKey(statement.get()); - return true; - } - return false; + @Override + public boolean test(String sql) { + Optional statement = statements.stream() + .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) + .findFirst(); + if (statement.isPresent()) { + setResponseValueKey(statement.get()); + return true; } + return false; + } - @Override - protected String getTestRegExp() { - return ""; - } + @Override + protected String getTestRegExp() { + return ""; + } - private String getTestRegExp(String key) { - return "list " + key + ";"; - } + private String getTestRegExp(String key) { + return "list " + key + ";"; + } - private void setResponseValueKey(String path) { - responseValueKey = path; - } + private void setResponseValueKey(String path) { + responseValueKey = path; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java index 3882bff434..c90cdc847b 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java @@ -6,20 +6,20 @@ import org.springframework.stereotype.Component; @Component public class SelectStrategy extends KsqlStatementStrategy { - private final String requestPath = "/query"; + private final String requestPath = "/query"; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeQueryResponse(response); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeQueryResponse(response); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - protected String getTestRegExp() { - return "select (.*) from (.*);"; - } + @Override + protected String getTestRegExp() { + return "select (.*) from (.*);"; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java index fede08189f..7ee683a857 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java @@ -9,43 +9,44 @@ import java.util.Optional; @Component public class ShowStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private String responseValueKey = ""; - private final List statements = List.of("functions", "topics", "streams", "tables", "queries", "properties"); + private final String requestPath = "/ksql"; + private String responseValueKey = ""; + private final List statements = + List.of("functions", "topics", "streams", "tables", "queries", "properties"); - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeTableResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - public boolean test(String sql) { - Optional statement = statements.stream() - .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) - .findFirst(); - if (statement.isPresent()) { - setResponseValueKey(statement.get()); - return true; - } - return false; + @Override + public boolean test(String sql) { + Optional statement = statements.stream() + .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) + .findFirst(); + if (statement.isPresent()) { + setResponseValueKey(statement.get()); + return true; } + return false; + } - @Override - protected String getTestRegExp() { - return ""; - } + @Override + protected String getTestRegExp() { + return ""; + } - private String getTestRegExp(String key) { - return "show " + key + ";"; - } + private String getTestRegExp(String key) { + return "show " + key + ";"; + } - private void setResponseValueKey(String path) { - responseValueKey = path; - } + private void setResponseValueKey(String path) { + responseValueKey = path; + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java index 34094cf869..b342e2fd38 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java @@ -6,21 +6,21 @@ import org.springframework.stereotype.Component; @Component public class TerminateStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "commandStatus"; + private final String requestPath = "/ksql"; + private final String responseValueKey = "commandStatus"; - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeMessageResponse(response, responseValueKey); - } + @Override + public KsqlCommandResponse serializeResponse(JsonNode response) { + return serializeMessageResponse(response, responseValueKey); + } - @Override - protected String getRequestPath() { - return requestPath; - } + @Override + protected String getRequestPath() { + return requestPath; + } - @Override - protected String getTestRegExp() { - return "terminate (.*);"; - } + @Override + protected String getTestRegExp() { + return "terminate (.*);"; + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java index 303963367a..81c07d95a0 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java @@ -27,91 +27,97 @@ import static org.mockito.Mockito.*; @ExtendWith(MockitoExtension.class) class KsqlServiceTest { - private KsqlService ksqlService; - private KsqlStatementStrategy ksqlStatementStrategy; + private KsqlService ksqlService; + private KsqlStatementStrategy ksqlStatementStrategy; - @Mock - private ClustersStorage clustersStorage; - @Mock - private KsqlClient ksqlClient; + @Mock + private ClustersStorage clustersStorage; + @Mock + private KsqlClient ksqlClient; - @BeforeEach - public void setUp() { - this.ksqlStatementStrategy = new ShowStrategy(); - this.ksqlService = new KsqlService( - this.ksqlClient, - this.clustersStorage, - List.of(ksqlStatementStrategy) - ); - } + @BeforeEach + public void setUp() { + this.ksqlStatementStrategy = new ShowStrategy(); + this.ksqlService = new KsqlService( + this.ksqlClient, + this.clustersStorage, + List.of(ksqlStatementStrategy) + ); + } - @Test - public void shouldThrowClusterNotFoundExceptionOnExecuteKsqlCommand() { - String clusterName = "test"; - KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); - when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(null)); + @Test + public void shouldThrowClusterNotFoundExceptionOnExecuteKsqlCommand() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(null)); - StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) - .verifyError(ClusterNotFoundException.class); - } + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyError(ClusterNotFoundException.class); + } - @Test - public void shouldThrowKsqlDbNotFoundExceptionOnExecuteKsqlCommand() { - String clusterName = "test"; - KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); - KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); - when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); - when(kafkaCluster.getKsqldbServer()).thenReturn(null); + @Test + public void shouldThrowKsqlDbNotFoundExceptionOnExecuteKsqlCommand() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + when(clustersStorage.getClusterByName(clusterName)) + .thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn(null); - StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) - .verifyError(KsqlDbNotFoundException.class); - } + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyError(KsqlDbNotFoundException.class); + } - @Test - public void shouldThrowUnprocessableEntityExceptionOnExecuteKsqlCommand() { - String clusterName = "test"; - KsqlCommand command = (new KsqlCommand()).ksql("CREATE STREAM users WITH (KAFKA_TOPIC='users');"); - KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); - when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); - when(kafkaCluster.getKsqldbServer()).thenReturn("localhost:8088"); + @Test + public void shouldThrowUnprocessableEntityExceptionOnExecuteKsqlCommand() { + String clusterName = "test"; + KsqlCommand command = + (new KsqlCommand()).ksql("CREATE STREAM users WITH (KAFKA_TOPIC='users');"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + when(clustersStorage.getClusterByName(clusterName)) + .thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn("localhost:8088"); - StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) - .verifyError(UnprocessableEntityException.class); + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyError(UnprocessableEntityException.class); - StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) - .verifyErrorMessage("Invalid sql"); - } + StepVerifier.create(ksqlService.executeKsqlCommand(clusterName, Mono.just(command))) + .verifyErrorMessage("Invalid sql"); + } - @Test - public void shouldSetHostToStrategy() { - String clusterName = "test"; - String host = "localhost:8088"; - KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); - KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + @Test + public void shouldSetHostToStrategy() { + String clusterName = "test"; + String host = "localhost:8088"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); - when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); - when(kafkaCluster.getKsqldbServer()).thenReturn(host); - when(ksqlClient.execute(any())).thenReturn(Mono.just(new KsqlCommandResponse())); + when(clustersStorage.getClusterByName(clusterName)) + .thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn(host); + when(ksqlClient.execute(any())).thenReturn(Mono.just(new KsqlCommandResponse())); + ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo(host + "/ksql"); + } + + @Test + public void shouldCallClientAndReturnResponse() { + String clusterName = "test"; + KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); + KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); + KsqlCommandResponse response = new KsqlCommandResponse().message("success"); + + when(clustersStorage.getClusterByName(clusterName)) + .thenReturn(Optional.ofNullable(kafkaCluster)); + when(kafkaCluster.getKsqldbServer()).thenReturn("host"); + when(ksqlClient.execute(any())).thenReturn(Mono.just(response)); + + KsqlCommandResponse receivedResponse = ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo(host + "/ksql"); - } + verify(ksqlClient, times(1)).execute(ksqlStatementStrategy); + assertThat(receivedResponse).isEqualTo(response); - @Test - public void shouldCallClientAndReturnResponse() { - String clusterName = "test"; - KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); - KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); - KsqlCommandResponse response = new KsqlCommandResponse().message("success"); - - when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(kafkaCluster)); - when(kafkaCluster.getKsqldbServer()).thenReturn("host"); - when(ksqlClient.execute(any())).thenReturn(Mono.just(response)); - - KsqlCommandResponse receivedResponse = ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); - verify(ksqlClient, times(1)).execute(ksqlStatementStrategy); - assertThat(receivedResponse).isEqualTo(response); - - } + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java index 938b5ae284..41b67bc0a6 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java @@ -9,74 +9,75 @@ import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; + import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class CreateStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new CreateStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new CreateStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream WITH (KAFKA_TOPIC='topic');")); - assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream" + - " AS SELECT users.id AS userid FROM users EMIT CHANGES;" - )); - assertTrue(ksqlStatementStrategy.test( - "CREATE TABLE table (id VARCHAR) WITH (KAFKA_TOPIC='table');" - )); - assertTrue(ksqlStatementStrategy.test( - "CREATE TABLE pageviews_regions WITH (KEY_FORMAT='JSON')" + - " AS SELECT gender, COUNT(*) AS numbers" + - " FROM pageviews EMIT CHANGES;" - )); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream WITH (KAFKA_TOPIC='topic');")); + assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream" + + " AS SELECT users.id AS userid FROM users EMIT CHANGES;" + )); + assertTrue(ksqlStatementStrategy.test( + "CREATE TABLE table (id VARCHAR) WITH (KAFKA_TOPIC='table');" + )); + assertTrue(ksqlStatementStrategy.test( + "CREATE TABLE pageviews_regions WITH (KEY_FORMAT='JSON')" + + " AS SELECT gender, COUNT(*) AS numbers" + + " FROM pageviews EMIT CHANGES;" + )); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("show tables;")); - assertFalse(ksqlStatementStrategy.test("CREATE TABLE test;")); - assertFalse(ksqlStatementStrategy.test("CREATE STREAM test;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("show tables;")); + assertFalse(ksqlStatementStrategy.test("CREATE TABLE test;")); + assertFalse(ksqlStatementStrategy.test("CREATE STREAM test;")); + } - @Test - public void shouldSerializeResponse() { - String message = "updated successful"; - JsonNode node = getResponseWithMessage(message); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - assertThat(serializedResponse.getMessage()).isEqualTo(message); + @Test + public void shouldSerializeResponse() { + String message = "updated successful"; + JsonNode node = getResponseWithMessage(message); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + assertThat(serializedResponse.getMessage()).isEqualTo(message); - } + } - @Test - public void shouldSerializeWithException() { - JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); - JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithMessage(String message) { - JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); - JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); - return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); - } + @SneakyThrows + private JsonNode getResponseWithMessage(String message) { + JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); + JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java index a36fce35e2..4a57999a06 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java @@ -18,57 +18,58 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class DescribeStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new DescribeStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new DescribeStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("DESCRIBE users;")); - assertTrue(ksqlStatementStrategy.test("DESCRIBE EXTENDED users;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("DESCRIBE users;")); + assertTrue(ksqlStatementStrategy.test("DESCRIBE EXTENDED users;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("list streams;")); - assertFalse(ksqlStatementStrategy.test("show tables;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("list streams;")); + assertFalse(ksqlStatementStrategy.test("show tables;")); + } - @Test - public void shouldSerializeResponse() { - JsonNode node = getResponseWithObjectNode(); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); - } + @Test + public void shouldSerializeResponse() { + JsonNode node = getResponseWithObjectNode(); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); + } - @Test - public void shouldSerializeWithException() { - JsonNode sourceDescriptionNode = mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); - JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode sourceDescriptionNode = + mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithObjectNode() { - JsonNode nodeWithMessage = mapper.createObjectNode().put("name", "kafka"); - JsonNode nodeWithResponse = mapper.createObjectNode().set("sourceDescription", nodeWithMessage); - return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); - } + @SneakyThrows + private JsonNode getResponseWithObjectNode() { + JsonNode nodeWithMessage = mapper.createObjectNode().put("name", "kafka"); + JsonNode nodeWithResponse = mapper.createObjectNode().set("sourceDescription", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java index c1fb4e549f..70742d4500 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java @@ -15,59 +15,59 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class DropStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new DropStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new DropStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("drop table table1;")); - assertTrue(ksqlStatementStrategy.test("drop stream stream2;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("drop table table1;")); + assertTrue(ksqlStatementStrategy.test("drop stream stream2;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("show tables;")); - assertFalse(ksqlStatementStrategy.test("create table test;")); - assertFalse(ksqlStatementStrategy.test("create stream test;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("show tables;")); + assertFalse(ksqlStatementStrategy.test("create table test;")); + assertFalse(ksqlStatementStrategy.test("create stream test;")); + } - @Test - public void shouldSerializeResponse() { - String message = "updated successful"; - JsonNode node = getResponseWithMessage(message); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - assertThat(serializedResponse.getMessage()).isEqualTo(message); + @Test + public void shouldSerializeResponse() { + String message = "updated successful"; + JsonNode node = getResponseWithMessage(message); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + assertThat(serializedResponse.getMessage()).isEqualTo(message); - } + } - @Test - public void shouldSerializeWithException() { - JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); - JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithMessage(String message) { - JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); - JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); - return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); - } + @SneakyThrows + private JsonNode getResponseWithMessage(String message) { + JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); + JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java index eb889576b6..bf4131331e 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java @@ -18,55 +18,56 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class ExplainStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new ExplainStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new ExplainStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("explain users_query_id;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("explain users_query_id;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show queries;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show queries;")); + } - @Test - public void shouldSerializeResponse() { - JsonNode node = getResponseWithObjectNode(); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); - } + @Test + public void shouldSerializeResponse() { + JsonNode node = getResponseWithObjectNode(); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); + } - @Test - public void shouldSerializeWithException() { - JsonNode sourceDescriptionNode = mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); - JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode sourceDescriptionNode = + mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithObjectNode() { - JsonNode nodeWithMessage = mapper.createObjectNode().put("name", "kafka"); - JsonNode nodeWithResponse = mapper.createObjectNode().set("queryDescription", nodeWithMessage); - return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); - } + @SneakyThrows + private JsonNode getResponseWithObjectNode() { + JsonNode nodeWithMessage = mapper.createObjectNode().put("name", "kafka"); + JsonNode nodeWithResponse = mapper.createObjectNode().set("queryDescription", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java index 280151a92c..7a6997b448 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java @@ -18,93 +18,93 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class ListStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new ListStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new ListStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("LIST STREAMS;")); - assertTrue(ksqlStatementStrategy.test("LIST TABLES;")); - assertTrue(ksqlStatementStrategy.test("LIST TOPICS;")); - assertTrue(ksqlStatementStrategy.test("LIST FUNCTIONS;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("LIST STREAMS;")); + assertTrue(ksqlStatementStrategy.test("LIST TABLES;")); + assertTrue(ksqlStatementStrategy.test("LIST TOPICS;")); + assertTrue(ksqlStatementStrategy.test("LIST FUNCTIONS;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("SHOW STREAMS;")); - assertFalse(ksqlStatementStrategy.test("SHOW TABLES;")); - assertFalse(ksqlStatementStrategy.test("SHOW TOPICS;")); - assertFalse(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("SHOW STREAMS;")); + assertFalse(ksqlStatementStrategy.test("SHOW TABLES;")); + assertFalse(ksqlStatementStrategy.test("SHOW TOPICS;")); + assertFalse(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); + } - @Test - public void shouldSerializeStreamsResponse() { - JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("list streams;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeStreamsResponse() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("list streams;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeTablesResponse() { - JsonNode node = getResponseWithData("tables"); - ksqlStatementStrategy.test("list tables;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeTablesResponse() { + JsonNode node = getResponseWithData("tables"); + ksqlStatementStrategy.test("list tables;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeTopicsResponse() { - JsonNode node = getResponseWithData("topics"); - ksqlStatementStrategy.test("list topics;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeTopicsResponse() { + JsonNode node = getResponseWithData("topics"); + ksqlStatementStrategy.test("list topics;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeFunctionsResponse() { - JsonNode node = getResponseWithData("functions"); - ksqlStatementStrategy.test("list functions;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeFunctionsResponse() { + JsonNode node = getResponseWithData("functions"); + ksqlStatementStrategy.test("list functions;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeWithException() { - JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("list tables;"); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("list tables;"); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithData(String key) { - JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); - JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); - JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); - return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); - } + @SneakyThrows + private JsonNode getResponseWithData(String key) { + JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); + JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); + JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java index 7d62fa468f..fa88acb981 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java @@ -18,61 +18,61 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class SelectStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new SelectStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new SelectStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/query"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/query"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("select * from users;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("select * from users;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("select *;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("select *;")); + } - @Test - public void shouldSerializeResponse() { - JsonNode node = getResponseWithData(); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header1", "header2")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value1", "value2"))); - } + @Test + public void shouldSerializeResponse() { + JsonNode node = getResponseWithData(); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header1", "header2")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value1", "value2"))); + } - @Test - public void shouldSerializeWithException() { - JsonNode node = mapper.createObjectNode(); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode node = mapper.createObjectNode(); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithData() { - JsonNode headerNode = mapper.createObjectNode().set( - "header", mapper.createObjectNode().put("schema", "header1, header2") - ); - JsonNode row = mapper.createObjectNode().set( - "row", mapper.createObjectNode().set( - "columns", mapper.createArrayNode().add("value1").add("value2") - ) - ); - return mapper.createArrayNode().add(headerNode).add(row); - } + @SneakyThrows + private JsonNode getResponseWithData() { + JsonNode headerNode = mapper.createObjectNode().set( + "header", mapper.createObjectNode().put("schema", "header1, header2") + ); + JsonNode row = mapper.createObjectNode().set( + "row", mapper.createObjectNode().set( + "columns", mapper.createArrayNode().add("value1").add("value2") + ) + ); + return mapper.createArrayNode().add(headerNode).add(row); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java index bf090752b2..9610336e43 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java @@ -20,117 +20,117 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class ShowStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new ShowStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new ShowStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("SHOW STREAMS;")); - assertTrue(ksqlStatementStrategy.test("SHOW TABLES;")); - assertTrue(ksqlStatementStrategy.test("SHOW TOPICS;")); - assertTrue(ksqlStatementStrategy.test("SHOW QUERIES;")); - assertTrue(ksqlStatementStrategy.test("SHOW PROPERTIES;")); - assertTrue(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("SHOW STREAMS;")); + assertTrue(ksqlStatementStrategy.test("SHOW TABLES;")); + assertTrue(ksqlStatementStrategy.test("SHOW TOPICS;")); + assertTrue(ksqlStatementStrategy.test("SHOW QUERIES;")); + assertTrue(ksqlStatementStrategy.test("SHOW PROPERTIES;")); + assertTrue(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("LIST STREAMS;")); - assertFalse(ksqlStatementStrategy.test("LIST TABLES;")); - assertFalse(ksqlStatementStrategy.test("LIST TOPICS;")); - assertFalse(ksqlStatementStrategy.test("LIST QUERIES;")); - assertFalse(ksqlStatementStrategy.test("LIST PROPERTIES;")); - assertFalse(ksqlStatementStrategy.test("LIST FUNCTIONS;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("LIST STREAMS;")); + assertFalse(ksqlStatementStrategy.test("LIST TABLES;")); + assertFalse(ksqlStatementStrategy.test("LIST TOPICS;")); + assertFalse(ksqlStatementStrategy.test("LIST QUERIES;")); + assertFalse(ksqlStatementStrategy.test("LIST PROPERTIES;")); + assertFalse(ksqlStatementStrategy.test("LIST FUNCTIONS;")); + } - @Test - public void shouldSerializeStreamsResponse() { - JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("show streams;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeStreamsResponse() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("show streams;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeTablesResponse() { - JsonNode node = getResponseWithData("tables"); - ksqlStatementStrategy.test("show tables;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeTablesResponse() { + JsonNode node = getResponseWithData("tables"); + ksqlStatementStrategy.test("show tables;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeTopicsResponse() { - JsonNode node = getResponseWithData("topics"); - ksqlStatementStrategy.test("show topics;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeTopicsResponse() { + JsonNode node = getResponseWithData("topics"); + ksqlStatementStrategy.test("show topics;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializePropertiesResponse() { - JsonNode node = getResponseWithData("properties"); - ksqlStatementStrategy.test("show properties;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializePropertiesResponse() { + JsonNode node = getResponseWithData("properties"); + ksqlStatementStrategy.test("show properties;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeFunctionsResponse() { - JsonNode node = getResponseWithData("functions"); - ksqlStatementStrategy.test("show functions;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeFunctionsResponse() { + JsonNode node = getResponseWithData("functions"); + ksqlStatementStrategy.test("show functions;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeQueriesResponse() { - JsonNode node = getResponseWithData("queries"); - ksqlStatementStrategy.test("show queries;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } + @Test + public void shouldSerializeQueriesResponse() { + JsonNode node = getResponseWithData("queries"); + ksqlStatementStrategy.test("show queries;"); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + Table table = serializedResponse.getData(); + assertThat(table.getHeaders()).isEqualTo(List.of("header")); + assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); + } - @Test - public void shouldSerializeWithException() { - JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("show tables;"); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode node = getResponseWithData("streams"); + ksqlStatementStrategy.test("show tables;"); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithData(String key) { - JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); - JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); - JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); - return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); - } + @SneakyThrows + private JsonNode getResponseWithData(String key) { + JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); + JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); + JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); + return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); + } } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java index 8b1dffcfbb..d58a911f2d 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java @@ -15,56 +15,56 @@ import static org.junit.jupiter.api.Assertions.*; @ExtendWith(MockitoExtension.class) class TerminateStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private KsqlStatementStrategy ksqlStatementStrategy; + private ObjectMapper mapper = new ObjectMapper(); - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new TerminateStrategy(); - } + @BeforeEach + public void setUp() { + ksqlStatementStrategy = new TerminateStrategy(); + } - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } + @Test + public void shouldReturnUri() { + ksqlStatementStrategy.host("ksqldb-server:8088"); + assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + } - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("terminate query_id;")); - } + @Test + public void shouldReturnTrueInTest() { + assertTrue(ksqlStatementStrategy.test("terminate query_id;")); + } - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("create table test;")); - } + @Test + public void shouldReturnFalseInTest() { + assertFalse(ksqlStatementStrategy.test("show streams;")); + assertFalse(ksqlStatementStrategy.test("create table test;")); + } - @Test - public void shouldSerializeResponse() { - String message = "query terminated."; - JsonNode node = getResponseWithMessage(message); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - assertThat(serializedResponse.getMessage()).isEqualTo(message); + @Test + public void shouldSerializeResponse() { + String message = "query terminated."; + JsonNode node = getResponseWithMessage(message); + KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + assertThat(serializedResponse.getMessage()).isEqualTo(message); - } + } - @Test - public void shouldSerializeWithException() { - JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); - JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); + @Test + public void shouldSerializeWithException() { + JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); + JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + Exception exception = assertThrows( + UnprocessableEntityException.class, + () -> ksqlStatementStrategy.serializeResponse(node) + ); - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } + assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); + } - @SneakyThrows - private JsonNode getResponseWithMessage(String message) { - JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); - JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); - return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); - } + @SneakyThrows + private JsonNode getResponseWithMessage(String message) { + JsonNode nodeWithMessage = mapper.createObjectNode().put("message", message); + JsonNode commandStatusNode = mapper.createObjectNode().set("commandStatus", nodeWithMessage); + return mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); + } } From c784fc87c47cb8565e7e7985853438bfadddb38f Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Fri, 23 Jul 2021 13:04:01 +0300 Subject: [PATCH 08/11] [#207] fix(api): lint import --- .../provectus/kafka/ui/client/KsqlClient.java | 2 +- .../kafka/ui/controller/KsqlController.java | 1 - .../kafka/ui/service/KsqlService.java | 5 ++--- .../statement}/CreateStrategy.java | 2 +- .../statement}/DescribeStrategy.java | 2 +- .../statement}/DropStrategy.java | 2 +- .../statement}/ExplainStrategy.java | 2 +- .../statement}/KsqlStatementStrategy.java | 9 ++++++--- .../statement}/ListStrategy.java | 5 ++--- .../statement}/SelectStrategy.java | 2 +- .../statement}/ShowStrategy.java | 7 +++---- .../statement}/TerminateStrategy.java | 2 +- .../kafka/ui/service/KsqlServiceTest.java | 19 ++++++++++--------- .../statement}/CreateStrategyTest.java | 12 +++++++----- .../statement}/DescribeStrategyTest.java | 15 ++++++++------- .../statement}/DropStrategyTest.java | 12 +++++++----- .../statement}/ExplainStrategyTest.java | 15 ++++++++------- .../statement}/ListStrategyTest.java | 15 ++++++++------- .../statement}/SelectStrategyTest.java | 15 ++++++++------- .../statement}/ShowStrategyTest.java | 17 ++++++++--------- .../statement}/TerminateStrategyTest.java | 12 +++++++----- 21 files changed, 91 insertions(+), 82 deletions(-) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/CreateStrategy.java (92%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/DescribeStrategy.java (92%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/DropStrategy.java (92%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/ExplainStrategy.java (92%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/KsqlStatementStrategy.java (96%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/ListStrategy.java (95%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/SelectStrategy.java (91%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/ShowStrategy.java (95%) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/TerminateStrategy.java (92%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/CreateStrategyTest.java (91%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/DescribeStrategyTest.java (89%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/DropStrategyTest.java (89%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/ExplainStrategyTest.java (89%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/ListStrategyTest.java (93%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/SelectStrategyTest.java (89%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/ShowStrategyTest.java (94%) rename kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/{ksqlStatement => ksql/statement}/TerminateStrategyTest.java (88%) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index aca317eb94..e0e3af37d8 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -4,7 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.KsqlStatementStrategy; import lombok.RequiredArgsConstructor; import lombok.SneakyThrows; import lombok.extern.log4j.Log4j2; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java index ef174a1de7..0a02de3b9a 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/controller/KsqlController.java @@ -2,7 +2,6 @@ package com.provectus.kafka.ui.controller; import com.provectus.kafka.ui.api.KsqlApi; import com.provectus.kafka.ui.model.KsqlCommand; - import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.service.KsqlService; import lombok.RequiredArgsConstructor; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index 93eab520c0..39c0e7f3d6 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -7,13 +7,12 @@ import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KafkaCluster; import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.KsqlStatementStrategy; +import java.util.List; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; import reactor.core.publisher.Mono; -import java.util.List; - @Service @RequiredArgsConstructor public class KsqlService { diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java similarity index 92% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java index 9349fe92df..9ce7d5db6d 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java @@ -1,4 +1,4 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java similarity index 92% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java index d03a33f4ce..b36bb06f44 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java @@ -1,4 +1,4 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java similarity index 92% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java index e9821fa873..c1d11347a8 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java @@ -1,4 +1,4 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java similarity index 92% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java index d58ea6f3be..54524398dd 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java @@ -1,4 +1,4 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/KsqlStatementStrategy.java similarity index 96% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/KsqlStatementStrategy.java index e9ca6c5788..c32d104425 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/KsqlStatementStrategy.java @@ -1,12 +1,15 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.model.Table; - -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Spliterator; +import java.util.Spliterators; import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java similarity index 95% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java index c89d92bcae..c443f181bd 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java @@ -1,11 +1,10 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import org.springframework.stereotype.Component; - import java.util.List; import java.util.Optional; +import org.springframework.stereotype.Component; @Component public class ListStrategy extends KsqlStatementStrategy { diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java similarity index 91% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java index c90cdc847b..0ce1462f33 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java @@ -1,4 +1,4 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java similarity index 95% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java index 7ee683a857..cfffaa3e98 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java @@ -1,18 +1,17 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import org.springframework.stereotype.Component; - import java.util.List; import java.util.Optional; +import org.springframework.stereotype.Component; @Component public class ShowStrategy extends KsqlStatementStrategy { private final String requestPath = "/ksql"; - private String responseValueKey = ""; private final List statements = List.of("functions", "topics", "streams", "tables", "queries", "properties"); + private String responseValueKey = ""; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java similarity index 92% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java index b342e2fd38..90e285e006 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java @@ -1,4 +1,4 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java index 81c07d95a0..270a819e70 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java @@ -1,5 +1,11 @@ package com.provectus.kafka.ui.service; +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import com.provectus.kafka.ui.client.KsqlClient; import com.provectus.kafka.ui.exception.ClusterNotFoundException; import com.provectus.kafka.ui.exception.KsqlDbNotFoundException; @@ -7,8 +13,10 @@ import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KafkaCluster; import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.strategy.ksqlStatement.KsqlStatementStrategy; -import com.provectus.kafka.ui.strategy.ksqlStatement.ShowStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.ShowStrategy; +import java.util.List; +import java.util.Optional; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; @@ -18,13 +26,6 @@ import org.mockito.junit.jupiter.MockitoExtension; import reactor.core.publisher.Mono; import reactor.test.StepVerifier; -import java.util.List; -import java.util.Optional; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.*; - @ExtendWith(MockitoExtension.class) class KsqlServiceTest { private KsqlService ksqlService; diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java similarity index 91% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java index 41b67bc0a6..b2d2ee07e2 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/CreateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java @@ -1,4 +1,9 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; @@ -10,13 +15,10 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class CreateStrategyTest { + private final ObjectMapper mapper = new ObjectMapper(); private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java similarity index 89% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java index 4a57999a06..14bd3bbe15 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DescribeStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java @@ -1,25 +1,26 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.model.Table; +import java.util.List; import lombok.SneakyThrows; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class DescribeStrategyTest { + private final ObjectMapper mapper = new ObjectMapper(); private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java similarity index 89% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java index 70742d4500..097b247be7 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/DropStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java @@ -1,4 +1,9 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; @@ -10,13 +15,10 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class DropStrategyTest { + private final ObjectMapper mapper = new ObjectMapper(); private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java similarity index 89% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java index bf4131331e..e3bcfd58fc 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ExplainStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java @@ -1,25 +1,26 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.model.Table; +import java.util.List; import lombok.SneakyThrows; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class ExplainStrategyTest { + private final ObjectMapper mapper = new ObjectMapper(); private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java similarity index 93% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java index 7a6997b448..b8381b0d23 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ListStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java @@ -1,25 +1,26 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.model.Table; +import java.util.List; import lombok.SneakyThrows; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class ListStrategyTest { + private final ObjectMapper mapper = new ObjectMapper(); private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java similarity index 89% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java index fa88acb981..bc748ac8d9 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/SelectStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java @@ -1,25 +1,26 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; import com.provectus.kafka.ui.model.Table; +import java.util.List; import lombok.SneakyThrows; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class SelectStrategyTest { private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private final ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java similarity index 94% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java index 9610336e43..69cb4cdfad 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/ShowStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java @@ -1,27 +1,26 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; -import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.model.KsqlResponseTable; import com.provectus.kafka.ui.model.Table; +import java.util.List; import lombok.SneakyThrows; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class ShowStrategyTest { private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); + private final ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java similarity index 88% rename from kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java rename to kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java index d58a911f2d..18e918b56b 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksqlStatement/TerminateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java @@ -1,4 +1,9 @@ -package com.provectus.kafka.ui.strategy.ksqlStatement; +package com.provectus.kafka.ui.strategy.ksql.statement; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; @@ -10,13 +15,10 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.junit.jupiter.MockitoExtension; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.*; - @ExtendWith(MockitoExtension.class) class TerminateStrategyTest { + private final ObjectMapper mapper = new ObjectMapper(); private KsqlStatementStrategy ksqlStatementStrategy; - private ObjectMapper mapper = new ObjectMapper(); @BeforeEach public void setUp() { From 82ce5384889230d2e2dccef41411a5d357205792 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Fri, 23 Jul 2021 13:15:34 +0300 Subject: [PATCH 09/11] [#207] fix(api): lint --- .../ui/strategy/ksql/statement/CreateStrategyTest.java | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java index b2d2ee07e2..86e63b1515 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java @@ -34,16 +34,16 @@ class CreateStrategyTest { @Test public void shouldReturnTrueInTest() { assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream WITH (KAFKA_TOPIC='topic');")); - assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream" + - " AS SELECT users.id AS userid FROM users EMIT CHANGES;" + assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream" + + " AS SELECT users.id AS userid FROM users EMIT CHANGES;" )); assertTrue(ksqlStatementStrategy.test( "CREATE TABLE table (id VARCHAR) WITH (KAFKA_TOPIC='table');" )); assertTrue(ksqlStatementStrategy.test( - "CREATE TABLE pageviews_regions WITH (KEY_FORMAT='JSON')" + - " AS SELECT gender, COUNT(*) AS numbers" + - " FROM pageviews EMIT CHANGES;" + "CREATE TABLE pageviews_regions WITH (KEY_FORMAT='JSON')" + + " AS SELECT gender, COUNT(*) AS numbers" + + " FROM pageviews EMIT CHANGES;" )); } From 232a17b80df0b069c18f9be07e0b0a46558b66a2 Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Fri, 23 Jul 2021 16:32:45 +0300 Subject: [PATCH 10/11] [#207]: fix(api): clean up --- README.md | 1 + .../provectus/kafka/ui/client/KsqlClient.java | 4 +- .../kafka/ui/service/KsqlService.java | 6 +- ...atementStrategy.java => BaseStrategy.java} | 23 ++-- .../ksql/statement/CreateStrategy.java | 8 +- .../ksql/statement/DescribeStrategy.java | 8 +- .../strategy/ksql/statement/DropStrategy.java | 8 +- .../ksql/statement/ExplainStrategy.java | 7 +- .../strategy/ksql/statement/ListStrategy.java | 49 -------- .../ksql/statement/SelectStrategy.java | 5 +- .../strategy/ksql/statement/ShowStrategy.java | 33 ++++-- .../ksql/statement/TerminateStrategy.java | 7 +- .../src/main/resources/application-local.yml | 3 +- .../kafka/ui/service/KsqlServiceTest.java | 22 ++-- .../ksql/statement/CreateStrategyTest.java | 40 +++---- .../ksql/statement/DescribeStrategyTest.java | 32 ++--- .../ksql/statement/DropStrategyTest.java | 36 +++--- .../ksql/statement/ExplainStrategyTest.java | 28 ++--- .../ksql/statement/ListStrategyTest.java | 111 ------------------ .../ksql/statement/SelectStrategyTest.java | 30 ++--- .../ksql/statement/ShowStrategyTest.java | 82 ++++++------- .../ksql/statement/TerminateStrategyTest.java | 30 ++--- 22 files changed, 210 insertions(+), 363 deletions(-) rename kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/{KsqlStatementStrategy.java => BaseStrategy.java} (85%) delete mode 100644 kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java delete mode 100644 kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java diff --git a/README.md b/README.md index c443569afa..99c0c8221e 100644 --- a/README.md +++ b/README.md @@ -156,6 +156,7 @@ For example, if you want to use an environment variable to set the `name` parame |`KAFKA_CLUSTERS_0_NAME` | Cluster name |`KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS` |Address where to connect |`KAFKA_CLUSTERS_0_ZOOKEEPER` | Zookeper service address +|`KAFKA_CLUSTERS_0_KSQLDBSERVER` | KSQL DB server address |`KAFKA_CLUSTERS_0_PROPERTIES_SECURITY_PROTOCOL` |Security protocol to connect to the brokers. For SSL connection use "SSL", for plaintext connection don't set this environment variable |`KAFKA_CLUSTERS_0_SCHEMAREGISTRY` |SchemaRegistry's address |`KAFKA_CLUSTERS_0_SCHEMANAMETEMPLATE` |How keys are saved to schemaRegistry diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java index e0e3af37d8..58ece1b7a7 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/client/KsqlClient.java @@ -4,7 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.strategy.ksql.statement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.BaseStrategy; import lombok.RequiredArgsConstructor; import lombok.SneakyThrows; import lombok.extern.log4j.Log4j2; @@ -23,7 +23,7 @@ public class KsqlClient { private final WebClient webClient; private final ObjectMapper mapper; - public Mono execute(KsqlStatementStrategy ksqlStatement) { + public Mono execute(BaseStrategy ksqlStatement) { return webClient.post() .uri(ksqlStatement.getUri()) .accept(new MediaType("application", "vnd.ksql.v1+json")) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java index 39c0e7f3d6..18824b36ce 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/service/KsqlService.java @@ -7,7 +7,7 @@ import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KafkaCluster; import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.strategy.ksql.statement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.BaseStrategy; import java.util.List; import lombok.RequiredArgsConstructor; import org.springframework.stereotype.Service; @@ -18,7 +18,7 @@ import reactor.core.publisher.Mono; public class KsqlService { private final KsqlClient ksqlClient; private final ClustersStorage clustersStorage; - private final List ksqlStatementStrategies; + private final List ksqlStatementStrategies; public Mono executeKsqlCommand(String clusterName, Mono ksqlCommand) { @@ -36,7 +36,7 @@ public class KsqlService { .flatMap(ksqlClient::execute); } - private Mono getStatementStrategyForKsqlCommand( + private Mono getStatementStrategyForKsqlCommand( Mono ksqlCommand) { return ksqlCommand .map(command -> ksqlStatementStrategies.stream() diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/KsqlStatementStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java similarity index 85% rename from kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/KsqlStatementStrategy.java rename to kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java index c32d104425..e79b2c50c7 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/KsqlStatementStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java @@ -15,7 +15,10 @@ import java.util.stream.IntStream; import java.util.stream.Stream; import java.util.stream.StreamSupport; -public abstract class KsqlStatementStrategy { +public abstract class BaseStrategy { + protected static final String ksqlRequestPath = "/ksql"; + protected static final String queryRequestPath = "/query"; + private static final String mappingExceptionMessage = "KSQL DB response mapping error"; protected String host = null; protected KsqlCommand ksqlCommand = null; @@ -23,14 +26,14 @@ public abstract class KsqlStatementStrategy { if (this.host != null) { return this.host + this.getRequestPath(); } - return null; + throw new UnprocessableEntityException("Strategy doesn't have host"); } public boolean test(String sql) { return sql.trim().toLowerCase().matches(getTestRegExp()); } - public KsqlStatementStrategy host(String host) { + public BaseStrategy host(String host) { this.host = host; return this; } @@ -39,7 +42,7 @@ public abstract class KsqlStatementStrategy { return ksqlCommand; } - public KsqlStatementStrategy ksqlCommand(KsqlCommand ksqlCommand) { + public BaseStrategy ksqlCommand(KsqlCommand ksqlCommand) { this.ksqlCommand = ksqlCommand; return this; } @@ -52,7 +55,7 @@ public abstract class KsqlStatementStrategy { Table table = items.isArray() ? getTableFromArray(items) : getTableFromObject(items); return commandResponse.data(table); } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + throw new UnprocessableEntityException(mappingExceptionMessage); } protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String path) { @@ -62,7 +65,7 @@ public abstract class KsqlStatementStrategy { JsonNode item = first.path(path); return commandResponse.message(getMessageFromObject(item)); } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + throw new UnprocessableEntityException(mappingExceptionMessage); } protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { @@ -73,7 +76,7 @@ public abstract class KsqlStatementStrategy { .rows(getQueryResponseRows(response)); return commandResponse.data(table); } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + throw new UnprocessableEntityException(mappingExceptionMessage); } private List getQueryResponseHeader(JsonNode response) { @@ -121,7 +124,7 @@ public abstract class KsqlStatementStrategy { if (node.isObject() && node.has("message")) { return node.get("message").asText(); } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + throw new UnprocessableEntityException(mappingExceptionMessage); } private List> getTableRows(JsonNode node, List keys) { @@ -137,7 +140,7 @@ public abstract class KsqlStatementStrategy { if (node.isArray() && node.size() > 0) { return StreamSupport.stream(node.spliterator(), false); } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + throw new UnprocessableEntityException(mappingExceptionMessage); } private List getJsonObjectKeys(JsonNode node) { @@ -146,7 +149,7 @@ public abstract class KsqlStatementStrategy { Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false ).collect(Collectors.toList()); } - throw new UnprocessableEntityException("KSQL DB response mapping error"); + throw new UnprocessableEntityException(mappingExceptionMessage); } private List getJsonObjectValues(JsonNode node) { diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java index 9ce7d5db6d..3858811761 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java @@ -4,11 +4,9 @@ import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; - @Component -public class CreateStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "commandStatus"; +public class CreateStrategy extends BaseStrategy { + private static final String responseValueKey = "commandStatus"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { @@ -17,7 +15,7 @@ public class CreateStrategy extends KsqlStatementStrategy { @Override protected String getRequestPath() { - return requestPath; + return BaseStrategy.ksqlRequestPath; } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java index b36bb06f44..a5c333f57a 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java @@ -4,11 +4,9 @@ import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; - @Component -public class DescribeStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "sourceDescription"; +public class DescribeStrategy extends BaseStrategy { + private static final String responseValueKey = "sourceDescription"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { @@ -17,7 +15,7 @@ public class DescribeStrategy extends KsqlStatementStrategy { @Override protected String getRequestPath() { - return requestPath; + return BaseStrategy.ksqlRequestPath; } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java index c1d11347a8..aaf3474d6e 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java @@ -4,11 +4,9 @@ import com.fasterxml.jackson.databind.JsonNode; import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; - @Component -public class DropStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "commandStatus"; +public class DropStrategy extends BaseStrategy { + private static final String responseValueKey = "commandStatus"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { @@ -17,7 +15,7 @@ public class DropStrategy extends KsqlStatementStrategy { @Override protected String getRequestPath() { - return requestPath; + return BaseStrategy.ksqlRequestPath; } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java index 54524398dd..21624d589a 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java @@ -5,9 +5,8 @@ import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; @Component -public class ExplainStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "queryDescription"; +public class ExplainStrategy extends BaseStrategy { + private static final String responseValueKey = "queryDescription"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { @@ -16,7 +15,7 @@ public class ExplainStrategy extends KsqlStatementStrategy { @Override protected String getRequestPath() { - return requestPath; + return BaseStrategy.ksqlRequestPath; } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java deleted file mode 100644 index c443f181bd..0000000000 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategy.java +++ /dev/null @@ -1,49 +0,0 @@ -package com.provectus.kafka.ui.strategy.ksql.statement; - -import com.fasterxml.jackson.databind.JsonNode; -import com.provectus.kafka.ui.model.KsqlCommandResponse; -import java.util.List; -import java.util.Optional; -import org.springframework.stereotype.Component; - -@Component -public class ListStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final List statements = List.of("functions", "topics", "streams", "tables"); - private String responseValueKey = ""; - - @Override - public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return requestPath; - } - - @Override - public boolean test(String sql) { - Optional statement = statements.stream() - .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) - .findFirst(); - if (statement.isPresent()) { - setResponseValueKey(statement.get()); - return true; - } - return false; - } - - @Override - protected String getTestRegExp() { - return ""; - } - - private String getTestRegExp(String key) { - return "list " + key + ";"; - } - - private void setResponseValueKey(String path) { - responseValueKey = path; - } -} diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java index 0ce1462f33..7496f6650d 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java @@ -5,8 +5,7 @@ import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; @Component -public class SelectStrategy extends KsqlStatementStrategy { - private final String requestPath = "/query"; +public class SelectStrategy extends BaseStrategy { @Override public KsqlCommandResponse serializeResponse(JsonNode response) { @@ -15,7 +14,7 @@ public class SelectStrategy extends KsqlStatementStrategy { @Override protected String getRequestPath() { - return requestPath; + return BaseStrategy.queryRequestPath; } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java index cfffaa3e98..ad37ad1413 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java @@ -7,10 +7,11 @@ import java.util.Optional; import org.springframework.stereotype.Component; @Component -public class ShowStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final List statements = +public class ShowStrategy extends BaseStrategy { + private final List showStatements = List.of("functions", "topics", "streams", "tables", "queries", "properties"); + private final List listStatements = + List.of("functions", "topics", "streams", "tables"); private String responseValueKey = ""; @Override @@ -18,15 +19,10 @@ public class ShowStrategy extends KsqlStatementStrategy { return serializeTableResponse(response, responseValueKey); } - @Override - protected String getRequestPath() { - return requestPath; - } - @Override public boolean test(String sql) { - Optional statement = statements.stream() - .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s))) + Optional statement = showStatements.stream() + .filter(s -> testSql(sql, getShowRegExp(s)) || testSql(sql, getListRegExp(s))) .findFirst(); if (statement.isPresent()) { setResponseValueKey(statement.get()); @@ -35,17 +31,32 @@ public class ShowStrategy extends KsqlStatementStrategy { return false; } + @Override + protected String getRequestPath() { + return BaseStrategy.ksqlRequestPath; + } + @Override protected String getTestRegExp() { return ""; } - private String getTestRegExp(String key) { + protected String getShowRegExp(String key) { return "show " + key + ";"; } + protected String getListRegExp(String key) { + if (listStatements.contains(key)) { + return "list " + key + ";"; + } + return ""; + } + private void setResponseValueKey(String path) { responseValueKey = path; } + private boolean testSql(String sql, String pattern) { + return sql.trim().toLowerCase().matches(pattern); + } } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java index 90e285e006..2653bbb5da 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java @@ -5,9 +5,8 @@ import com.provectus.kafka.ui.model.KsqlCommandResponse; import org.springframework.stereotype.Component; @Component -public class TerminateStrategy extends KsqlStatementStrategy { - private final String requestPath = "/ksql"; - private final String responseValueKey = "commandStatus"; +public class TerminateStrategy extends BaseStrategy { + private static final String responseValueKey = "commandStatus"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { @@ -16,7 +15,7 @@ public class TerminateStrategy extends KsqlStatementStrategy { @Override protected String getRequestPath() { - return requestPath; + return BaseStrategy.ksqlRequestPath; } @Override diff --git a/kafka-ui-api/src/main/resources/application-local.yml b/kafka-ui-api/src/main/resources/application-local.yml index 5822849109..eaa6c15d4b 100644 --- a/kafka-ui-api/src/main/resources/application-local.yml +++ b/kafka-ui-api/src/main/resources/application-local.yml @@ -5,6 +5,7 @@ kafka: bootstrapServers: localhost:9092 zookeeper: localhost:2181 schemaRegistry: http://localhost:8081 + ksqldbServer: http://localhost:8088 kafkaConnect: - name: first address: http://localhost:8083 @@ -26,4 +27,4 @@ spring: jmx: enabled: true auth: - enabled: false \ No newline at end of file + enabled: false diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java index 270a819e70..aef12d8ec8 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/service/KsqlServiceTest.java @@ -13,7 +13,7 @@ import com.provectus.kafka.ui.exception.UnprocessableEntityException; import com.provectus.kafka.ui.model.KafkaCluster; import com.provectus.kafka.ui.model.KsqlCommand; import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.strategy.ksql.statement.KsqlStatementStrategy; +import com.provectus.kafka.ui.strategy.ksql.statement.BaseStrategy; import com.provectus.kafka.ui.strategy.ksql.statement.ShowStrategy; import java.util.List; import java.util.Optional; @@ -29,7 +29,7 @@ import reactor.test.StepVerifier; @ExtendWith(MockitoExtension.class) class KsqlServiceTest { private KsqlService ksqlService; - private KsqlStatementStrategy ksqlStatementStrategy; + private BaseStrategy baseStrategy; @Mock private ClustersStorage clustersStorage; @@ -39,16 +39,16 @@ class KsqlServiceTest { @BeforeEach public void setUp() { - this.ksqlStatementStrategy = new ShowStrategy(); + this.baseStrategy = new ShowStrategy(); this.ksqlService = new KsqlService( this.ksqlClient, this.clustersStorage, - List.of(ksqlStatementStrategy) + List.of(baseStrategy) ); } @Test - public void shouldThrowClusterNotFoundExceptionOnExecuteKsqlCommand() { + void shouldThrowClusterNotFoundExceptionOnExecuteKsqlCommand() { String clusterName = "test"; KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); when(clustersStorage.getClusterByName(clusterName)).thenReturn(Optional.ofNullable(null)); @@ -58,7 +58,7 @@ class KsqlServiceTest { } @Test - public void shouldThrowKsqlDbNotFoundExceptionOnExecuteKsqlCommand() { + void shouldThrowKsqlDbNotFoundExceptionOnExecuteKsqlCommand() { String clusterName = "test"; KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); @@ -71,7 +71,7 @@ class KsqlServiceTest { } @Test - public void shouldThrowUnprocessableEntityExceptionOnExecuteKsqlCommand() { + void shouldThrowUnprocessableEntityExceptionOnExecuteKsqlCommand() { String clusterName = "test"; KsqlCommand command = (new KsqlCommand()).ksql("CREATE STREAM users WITH (KAFKA_TOPIC='users');"); @@ -88,7 +88,7 @@ class KsqlServiceTest { } @Test - public void shouldSetHostToStrategy() { + void shouldSetHostToStrategy() { String clusterName = "test"; String host = "localhost:8088"; KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); @@ -100,11 +100,11 @@ class KsqlServiceTest { when(ksqlClient.execute(any())).thenReturn(Mono.just(new KsqlCommandResponse())); ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo(host + "/ksql"); + assertThat(baseStrategy.getUri()).isEqualTo(host + "/ksql"); } @Test - public void shouldCallClientAndReturnResponse() { + void shouldCallClientAndReturnResponse() { String clusterName = "test"; KsqlCommand command = (new KsqlCommand()).ksql("show streams;"); KafkaCluster kafkaCluster = Mockito.mock(KafkaCluster.class); @@ -117,7 +117,7 @@ class KsqlServiceTest { KsqlCommandResponse receivedResponse = ksqlService.executeKsqlCommand(clusterName, Mono.just(command)).block(); - verify(ksqlClient, times(1)).execute(ksqlStatementStrategy); + verify(ksqlClient, times(1)).execute(baseStrategy); assertThat(receivedResponse).isEqualTo(response); } diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java index 86e63b1515..58e838531b 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategyTest.java @@ -18,29 +18,29 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class CreateStrategyTest { private final ObjectMapper mapper = new ObjectMapper(); - private KsqlStatementStrategy ksqlStatementStrategy; + private CreateStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new CreateStrategy(); + void setUp() { + strategy = new CreateStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream WITH (KAFKA_TOPIC='topic');")); - assertTrue(ksqlStatementStrategy.test("CREATE STREAM stream" + void shouldReturnTrueInTest() { + assertTrue(strategy.test("CREATE STREAM stream WITH (KAFKA_TOPIC='topic');")); + assertTrue(strategy.test("CREATE STREAM stream" + " AS SELECT users.id AS userid FROM users EMIT CHANGES;" )); - assertTrue(ksqlStatementStrategy.test( + assertTrue(strategy.test( "CREATE TABLE table (id VARCHAR) WITH (KAFKA_TOPIC='table');" )); - assertTrue(ksqlStatementStrategy.test( + assertTrue(strategy.test( "CREATE TABLE pageviews_regions WITH (KEY_FORMAT='JSON')" + " AS SELECT gender, COUNT(*) AS numbers" + " FROM pageviews EMIT CHANGES;" @@ -48,29 +48,29 @@ class CreateStrategyTest { } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("show tables;")); - assertFalse(ksqlStatementStrategy.test("CREATE TABLE test;")); - assertFalse(ksqlStatementStrategy.test("CREATE STREAM test;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("show streams;")); + assertFalse(strategy.test("show tables;")); + assertFalse(strategy.test("CREATE TABLE test;")); + assertFalse(strategy.test("CREATE STREAM test;")); } @Test - public void shouldSerializeResponse() { + void shouldSerializeResponse() { String message = "updated successful"; JsonNode node = getResponseWithMessage(message); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); assertThat(serializedResponse.getMessage()).isEqualTo(message); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java index 14bd3bbe15..9591959533 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategyTest.java @@ -20,48 +20,48 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class DescribeStrategyTest { private final ObjectMapper mapper = new ObjectMapper(); - private KsqlStatementStrategy ksqlStatementStrategy; + private DescribeStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new DescribeStrategy(); + void setUp() { + strategy = new DescribeStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("DESCRIBE users;")); - assertTrue(ksqlStatementStrategy.test("DESCRIBE EXTENDED users;")); + void shouldReturnTrueInTest() { + assertTrue(strategy.test("DESCRIBE users;")); + assertTrue(strategy.test("DESCRIBE EXTENDED users;")); } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("list streams;")); - assertFalse(ksqlStatementStrategy.test("show tables;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("list streams;")); + assertFalse(strategy.test("show tables;")); } @Test - public void shouldSerializeResponse() { + void shouldSerializeResponse() { JsonNode node = getResponseWithObjectNode(); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode sourceDescriptionNode = mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java index 097b247be7..2c95dbe87e 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategyTest.java @@ -18,49 +18,49 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class DropStrategyTest { private final ObjectMapper mapper = new ObjectMapper(); - private KsqlStatementStrategy ksqlStatementStrategy; + private DropStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new DropStrategy(); + void setUp() { + strategy = new DropStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("drop table table1;")); - assertTrue(ksqlStatementStrategy.test("drop stream stream2;")); + void shouldReturnTrueInTest() { + assertTrue(strategy.test("drop table table1;")); + assertTrue(strategy.test("drop stream stream2;")); } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("show tables;")); - assertFalse(ksqlStatementStrategy.test("create table test;")); - assertFalse(ksqlStatementStrategy.test("create stream test;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("show streams;")); + assertFalse(strategy.test("show tables;")); + assertFalse(strategy.test("create table test;")); + assertFalse(strategy.test("create stream test;")); } @Test - public void shouldSerializeResponse() { + void shouldSerializeResponse() { String message = "updated successful"; JsonNode node = getResponseWithMessage(message); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); assertThat(serializedResponse.getMessage()).isEqualTo(message); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java index e3bcfd58fc..6ad4d15563 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategyTest.java @@ -20,46 +20,46 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class ExplainStrategyTest { private final ObjectMapper mapper = new ObjectMapper(); - private KsqlStatementStrategy ksqlStatementStrategy; + private ExplainStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new ExplainStrategy(); + void setUp() { + strategy = new ExplainStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("explain users_query_id;")); + void shouldReturnTrueInTest() { + assertTrue(strategy.test("explain users_query_id;")); } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show queries;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("show queries;")); } @Test - public void shouldSerializeResponse() { + void shouldSerializeResponse() { JsonNode node = getResponseWithObjectNode(); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("key", "value")); assertThat(table.getRows()).isEqualTo(List.of(List.of("name", "kafka"))); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode sourceDescriptionNode = mapper.createObjectNode().put("sourceDescription", "nodeWithMessage"); JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(sourceDescriptionNode)); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java deleted file mode 100644 index b8381b0d23..0000000000 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ListStrategyTest.java +++ /dev/null @@ -1,111 +0,0 @@ -package com.provectus.kafka.ui.strategy.ksql.statement; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertThrows; -import static org.junit.jupiter.api.Assertions.assertTrue; - -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; -import com.provectus.kafka.ui.exception.UnprocessableEntityException; -import com.provectus.kafka.ui.model.KsqlCommandResponse; -import com.provectus.kafka.ui.model.Table; -import java.util.List; -import lombok.SneakyThrows; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.junit.jupiter.MockitoExtension; - -@ExtendWith(MockitoExtension.class) -class ListStrategyTest { - private final ObjectMapper mapper = new ObjectMapper(); - private KsqlStatementStrategy ksqlStatementStrategy; - - @BeforeEach - public void setUp() { - ksqlStatementStrategy = new ListStrategy(); - } - - @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); - } - - @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("LIST STREAMS;")); - assertTrue(ksqlStatementStrategy.test("LIST TABLES;")); - assertTrue(ksqlStatementStrategy.test("LIST TOPICS;")); - assertTrue(ksqlStatementStrategy.test("LIST FUNCTIONS;")); - } - - @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("SHOW STREAMS;")); - assertFalse(ksqlStatementStrategy.test("SHOW TABLES;")); - assertFalse(ksqlStatementStrategy.test("SHOW TOPICS;")); - assertFalse(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); - } - - @Test - public void shouldSerializeStreamsResponse() { - JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("list streams;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } - - @Test - public void shouldSerializeTablesResponse() { - JsonNode node = getResponseWithData("tables"); - ksqlStatementStrategy.test("list tables;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } - - @Test - public void shouldSerializeTopicsResponse() { - JsonNode node = getResponseWithData("topics"); - ksqlStatementStrategy.test("list topics;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } - - @Test - public void shouldSerializeFunctionsResponse() { - JsonNode node = getResponseWithData("functions"); - ksqlStatementStrategy.test("list functions;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); - Table table = serializedResponse.getData(); - assertThat(table.getHeaders()).isEqualTo(List.of("header")); - assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); - } - - @Test - public void shouldSerializeWithException() { - JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("list tables;"); - Exception exception = assertThrows( - UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) - ); - - assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); - } - - @SneakyThrows - private JsonNode getResponseWithData(String key) { - JsonNode nodeWithDataItem = mapper.createObjectNode().put("header", "value"); - JsonNode nodeWithData = mapper.createArrayNode().add(nodeWithDataItem); - JsonNode nodeWithResponse = mapper.createObjectNode().set(key, nodeWithData); - return mapper.createArrayNode().add(mapper.valueToTree(nodeWithResponse)); - } -} diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java index bc748ac8d9..7509c12301 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategyTest.java @@ -19,46 +19,46 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class SelectStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; private final ObjectMapper mapper = new ObjectMapper(); + private SelectStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new SelectStrategy(); + void setUp() { + strategy = new SelectStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/query"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/query"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("select * from users;")); + void shouldReturnTrueInTest() { + assertTrue(strategy.test("select * from users;")); } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("select *;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("show streams;")); + assertFalse(strategy.test("select *;")); } @Test - public void shouldSerializeResponse() { + void shouldSerializeResponse() { JsonNode node = getResponseWithData(); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header1", "header2")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value1", "value2"))); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode node = mapper.createObjectNode(); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java index 69cb4cdfad..056e5f153b 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategyTest.java @@ -19,107 +19,107 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class ShowStrategyTest { - private KsqlStatementStrategy ksqlStatementStrategy; private final ObjectMapper mapper = new ObjectMapper(); + private ShowStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new ShowStrategy(); + void setUp() { + strategy = new ShowStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("SHOW STREAMS;")); - assertTrue(ksqlStatementStrategy.test("SHOW TABLES;")); - assertTrue(ksqlStatementStrategy.test("SHOW TOPICS;")); - assertTrue(ksqlStatementStrategy.test("SHOW QUERIES;")); - assertTrue(ksqlStatementStrategy.test("SHOW PROPERTIES;")); - assertTrue(ksqlStatementStrategy.test("SHOW FUNCTIONS;")); + void shouldReturnTrueInTest() { + assertTrue(strategy.test("SHOW STREAMS;")); + assertTrue(strategy.test("SHOW TABLES;")); + assertTrue(strategy.test("SHOW TOPICS;")); + assertTrue(strategy.test("SHOW QUERIES;")); + assertTrue(strategy.test("SHOW PROPERTIES;")); + assertTrue(strategy.test("SHOW FUNCTIONS;")); + assertTrue(strategy.test("LIST STREAMS;")); + assertTrue(strategy.test("LIST TABLES;")); + assertTrue(strategy.test("LIST TOPICS;")); + assertTrue(strategy.test("LIST FUNCTIONS;")); } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("LIST STREAMS;")); - assertFalse(ksqlStatementStrategy.test("LIST TABLES;")); - assertFalse(ksqlStatementStrategy.test("LIST TOPICS;")); - assertFalse(ksqlStatementStrategy.test("LIST QUERIES;")); - assertFalse(ksqlStatementStrategy.test("LIST PROPERTIES;")); - assertFalse(ksqlStatementStrategy.test("LIST FUNCTIONS;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("LIST QUERIES;")); + assertFalse(strategy.test("LIST PROPERTIES;")); } @Test - public void shouldSerializeStreamsResponse() { + void shouldSerializeStreamsResponse() { JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("show streams;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + strategy.test("show streams;"); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); } @Test - public void shouldSerializeTablesResponse() { + void shouldSerializeTablesResponse() { JsonNode node = getResponseWithData("tables"); - ksqlStatementStrategy.test("show tables;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + strategy.test("show tables;"); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); } @Test - public void shouldSerializeTopicsResponse() { + void shouldSerializeTopicsResponse() { JsonNode node = getResponseWithData("topics"); - ksqlStatementStrategy.test("show topics;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + strategy.test("show topics;"); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); } @Test - public void shouldSerializePropertiesResponse() { + void shouldSerializePropertiesResponse() { JsonNode node = getResponseWithData("properties"); - ksqlStatementStrategy.test("show properties;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + strategy.test("show properties;"); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); } @Test - public void shouldSerializeFunctionsResponse() { + void shouldSerializeFunctionsResponse() { JsonNode node = getResponseWithData("functions"); - ksqlStatementStrategy.test("show functions;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + strategy.test("show functions;"); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); } @Test - public void shouldSerializeQueriesResponse() { + void shouldSerializeQueriesResponse() { JsonNode node = getResponseWithData("queries"); - ksqlStatementStrategy.test("show queries;"); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + strategy.test("show queries;"); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); Table table = serializedResponse.getData(); assertThat(table.getHeaders()).isEqualTo(List.of("header")); assertThat(table.getRows()).isEqualTo(List.of(List.of("value"))); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode node = getResponseWithData("streams"); - ksqlStatementStrategy.test("show tables;"); + strategy.test("show tables;"); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); diff --git a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java index 18e918b56b..c84ca2d5da 100644 --- a/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java +++ b/kafka-ui-api/src/test/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategyTest.java @@ -18,46 +18,46 @@ import org.mockito.junit.jupiter.MockitoExtension; @ExtendWith(MockitoExtension.class) class TerminateStrategyTest { private final ObjectMapper mapper = new ObjectMapper(); - private KsqlStatementStrategy ksqlStatementStrategy; + private TerminateStrategy strategy; @BeforeEach - public void setUp() { - ksqlStatementStrategy = new TerminateStrategy(); + void setUp() { + strategy = new TerminateStrategy(); } @Test - public void shouldReturnUri() { - ksqlStatementStrategy.host("ksqldb-server:8088"); - assertThat(ksqlStatementStrategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); + void shouldReturnUri() { + strategy.host("ksqldb-server:8088"); + assertThat(strategy.getUri()).isEqualTo("ksqldb-server:8088/ksql"); } @Test - public void shouldReturnTrueInTest() { - assertTrue(ksqlStatementStrategy.test("terminate query_id;")); + void shouldReturnTrueInTest() { + assertTrue(strategy.test("terminate query_id;")); } @Test - public void shouldReturnFalseInTest() { - assertFalse(ksqlStatementStrategy.test("show streams;")); - assertFalse(ksqlStatementStrategy.test("create table test;")); + void shouldReturnFalseInTest() { + assertFalse(strategy.test("show streams;")); + assertFalse(strategy.test("create table test;")); } @Test - public void shouldSerializeResponse() { + void shouldSerializeResponse() { String message = "query terminated."; JsonNode node = getResponseWithMessage(message); - KsqlCommandResponse serializedResponse = ksqlStatementStrategy.serializeResponse(node); + KsqlCommandResponse serializedResponse = strategy.serializeResponse(node); assertThat(serializedResponse.getMessage()).isEqualTo(message); } @Test - public void shouldSerializeWithException() { + void shouldSerializeWithException() { JsonNode commandStatusNode = mapper.createObjectNode().put("commandStatus", "nodeWithMessage"); JsonNode node = mapper.createArrayNode().add(mapper.valueToTree(commandStatusNode)); Exception exception = assertThrows( UnprocessableEntityException.class, - () -> ksqlStatementStrategy.serializeResponse(node) + () -> strategy.serializeResponse(node) ); assertThat(exception.getMessage()).isEqualTo("KSQL DB response mapping error"); From 64e2caf55cd593cbe40ceea4ccb6fb0788557dad Mon Sep 17 00:00:00 2001 From: Ilnur Farukhshin Date: Mon, 26 Jul 2021 13:52:38 +0300 Subject: [PATCH 11/11] [#207]: PR feedback --- .../strategy/ksql/statement/BaseStrategy.java | 57 ++++++++++--------- .../ksql/statement/CreateStrategy.java | 9 +-- .../ksql/statement/DescribeStrategy.java | 9 +-- .../strategy/ksql/statement/DropStrategy.java | 9 +-- .../ksql/statement/ExplainStrategy.java | 9 +-- .../ksql/statement/SelectStrategy.java | 2 +- .../strategy/ksql/statement/ShowStrategy.java | 13 ++--- .../ksql/statement/TerminateStrategy.java | 9 +-- 8 files changed, 44 insertions(+), 73 deletions(-) diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java index e79b2c50c7..4e6a9ae4f2 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/BaseStrategy.java @@ -16,9 +16,9 @@ import java.util.stream.Stream; import java.util.stream.StreamSupport; public abstract class BaseStrategy { - protected static final String ksqlRequestPath = "/ksql"; - protected static final String queryRequestPath = "/query"; - private static final String mappingExceptionMessage = "KSQL DB response mapping error"; + protected static final String KSQL_REQUEST_PATH = "/ksql"; + protected static final String QUERY_REQUEST_PATH = "/query"; + private static final String MAPPING_EXCEPTION_ERROR = "KSQL DB response mapping error"; protected String host = null; protected KsqlCommand ksqlCommand = null; @@ -47,36 +47,39 @@ public abstract class BaseStrategy { return this; } - protected KsqlCommandResponse serializeTableResponse(JsonNode response, String path) { - if (response.isArray() && response.size() > 0) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); - JsonNode first = response.get(0); - JsonNode items = first.path(path); - Table table = items.isArray() ? getTableFromArray(items) : getTableFromObject(items); - return commandResponse.data(table); - } - throw new UnprocessableEntityException(mappingExceptionMessage); + protected String getRequestPath() { + return BaseStrategy.KSQL_REQUEST_PATH; } - protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String path) { - if (response.isArray() && response.size() > 0) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); - JsonNode first = response.get(0); - JsonNode item = first.path(path); - return commandResponse.message(getMessageFromObject(item)); - } - throw new UnprocessableEntityException(mappingExceptionMessage); + protected KsqlCommandResponse serializeTableResponse(JsonNode response, String key) { + JsonNode item = getResponseFirstItemValue(response, key); + Table table = item.isArray() ? getTableFromArray(item) : getTableFromObject(item); + return (new KsqlCommandResponse()).data(table); + } + + protected KsqlCommandResponse serializeMessageResponse(JsonNode response, String key) { + JsonNode item = getResponseFirstItemValue(response, key); + return (new KsqlCommandResponse()).message(getMessageFromObject(item)); } protected KsqlCommandResponse serializeQueryResponse(JsonNode response) { if (response.isArray() && response.size() > 0) { - KsqlCommandResponse commandResponse = new KsqlCommandResponse(); Table table = (new Table()) .headers(getQueryResponseHeader(response)) .rows(getQueryResponseRows(response)); - return commandResponse.data(table); + return (new KsqlCommandResponse()).data(table); } - throw new UnprocessableEntityException(mappingExceptionMessage); + throw new UnprocessableEntityException(MAPPING_EXCEPTION_ERROR); + } + + private JsonNode getResponseFirstItemValue(JsonNode response, String key) { + if (response.isArray() && response.size() > 0) { + JsonNode first = response.get(0); + if (first.has(key)) { + return first.path(key); + } + } + throw new UnprocessableEntityException(MAPPING_EXCEPTION_ERROR); } private List getQueryResponseHeader(JsonNode response) { @@ -124,7 +127,7 @@ public abstract class BaseStrategy { if (node.isObject() && node.has("message")) { return node.get("message").asText(); } - throw new UnprocessableEntityException(mappingExceptionMessage); + throw new UnprocessableEntityException(MAPPING_EXCEPTION_ERROR); } private List> getTableRows(JsonNode node, List keys) { @@ -140,7 +143,7 @@ public abstract class BaseStrategy { if (node.isArray() && node.size() > 0) { return StreamSupport.stream(node.spliterator(), false); } - throw new UnprocessableEntityException(mappingExceptionMessage); + throw new UnprocessableEntityException(MAPPING_EXCEPTION_ERROR); } private List getJsonObjectKeys(JsonNode node) { @@ -149,7 +152,7 @@ public abstract class BaseStrategy { Spliterators.spliteratorUnknownSize(node.fieldNames(), Spliterator.ORDERED), false ).collect(Collectors.toList()); } - throw new UnprocessableEntityException(mappingExceptionMessage); + throw new UnprocessableEntityException(MAPPING_EXCEPTION_ERROR); } private List getJsonObjectValues(JsonNode node) { @@ -159,7 +162,5 @@ public abstract class BaseStrategy { public abstract KsqlCommandResponse serializeResponse(JsonNode response); - protected abstract String getRequestPath(); - protected abstract String getTestRegExp(); } diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java index 3858811761..bfdbce6773 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/CreateStrategy.java @@ -6,16 +6,11 @@ import org.springframework.stereotype.Component; @Component public class CreateStrategy extends BaseStrategy { - private static final String responseValueKey = "commandStatus"; + private static final String RESPONSE_VALUE_KEY = "commandStatus"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeMessageResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return BaseStrategy.ksqlRequestPath; + return serializeMessageResponse(response, RESPONSE_VALUE_KEY); } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java index a5c333f57a..611cae99c8 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DescribeStrategy.java @@ -6,16 +6,11 @@ import org.springframework.stereotype.Component; @Component public class DescribeStrategy extends BaseStrategy { - private static final String responseValueKey = "sourceDescription"; + private static final String RESPONSE_VALUE_KEY = "sourceDescription"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return BaseStrategy.ksqlRequestPath; + return serializeTableResponse(response, RESPONSE_VALUE_KEY); } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java index aaf3474d6e..253c3906c6 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/DropStrategy.java @@ -6,16 +6,11 @@ import org.springframework.stereotype.Component; @Component public class DropStrategy extends BaseStrategy { - private static final String responseValueKey = "commandStatus"; + private static final String RESPONSE_VALUE_KEY = "commandStatus"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeMessageResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return BaseStrategy.ksqlRequestPath; + return serializeMessageResponse(response, RESPONSE_VALUE_KEY); } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java index 21624d589a..c80b255eae 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ExplainStrategy.java @@ -6,16 +6,11 @@ import org.springframework.stereotype.Component; @Component public class ExplainStrategy extends BaseStrategy { - private static final String responseValueKey = "queryDescription"; + private static final String RESPONSE_VALUE_KEY = "queryDescription"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeTableResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return BaseStrategy.ksqlRequestPath; + return serializeTableResponse(response, RESPONSE_VALUE_KEY); } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java index 7496f6650d..0c7a6a6d87 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/SelectStrategy.java @@ -14,7 +14,7 @@ public class SelectStrategy extends BaseStrategy { @Override protected String getRequestPath() { - return BaseStrategy.queryRequestPath; + return BaseStrategy.QUERY_REQUEST_PATH; } @Override diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java index ad37ad1413..1b80c6648b 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/ShowStrategy.java @@ -8,9 +8,9 @@ import org.springframework.stereotype.Component; @Component public class ShowStrategy extends BaseStrategy { - private final List showStatements = + private static final List SHOW_STATEMENTS = List.of("functions", "topics", "streams", "tables", "queries", "properties"); - private final List listStatements = + private static final List LIST_STATEMENTS = List.of("functions", "topics", "streams", "tables"); private String responseValueKey = ""; @@ -21,7 +21,7 @@ public class ShowStrategy extends BaseStrategy { @Override public boolean test(String sql) { - Optional statement = showStatements.stream() + Optional statement = SHOW_STATEMENTS.stream() .filter(s -> testSql(sql, getShowRegExp(s)) || testSql(sql, getListRegExp(s))) .findFirst(); if (statement.isPresent()) { @@ -31,11 +31,6 @@ public class ShowStrategy extends BaseStrategy { return false; } - @Override - protected String getRequestPath() { - return BaseStrategy.ksqlRequestPath; - } - @Override protected String getTestRegExp() { return ""; @@ -46,7 +41,7 @@ public class ShowStrategy extends BaseStrategy { } protected String getListRegExp(String key) { - if (listStatements.contains(key)) { + if (LIST_STATEMENTS.contains(key)) { return "list " + key + ";"; } return ""; diff --git a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java index 2653bbb5da..a7b531d0bb 100644 --- a/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java +++ b/kafka-ui-api/src/main/java/com/provectus/kafka/ui/strategy/ksql/statement/TerminateStrategy.java @@ -6,16 +6,11 @@ import org.springframework.stereotype.Component; @Component public class TerminateStrategy extends BaseStrategy { - private static final String responseValueKey = "commandStatus"; + private static final String RESPONSE_VALUE_KEY = "commandStatus"; @Override public KsqlCommandResponse serializeResponse(JsonNode response) { - return serializeMessageResponse(response, responseValueKey); - } - - @Override - protected String getRequestPath() { - return BaseStrategy.ksqlRequestPath; + return serializeMessageResponse(response, RESPONSE_VALUE_KEY); } @Override