[#207] fix(api): lint

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<KsqlCommandResponse> 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<KsqlCommandResponse> 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<Throwable> 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<Throwable> 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);
+  }
 }

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<KsqlStatementStrategy> ksqlStatementStrategies;
 
-  public Mono<KsqlCommandResponse> executeKsqlCommand(String clusterName, Mono<KsqlCommand> ksqlCommand) {
+  public Mono<KsqlCommandResponse> executeKsqlCommand(String clusterName,
+                                                      Mono<KsqlCommand> 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<KsqlStatementStrategy> getStatementStrategyForKsqlCommand(Mono<KsqlCommand> ksqlCommand) {
+  private Mono<KsqlStatementStrategy> getStatementStrategyForKsqlCommand(
+      Mono<KsqlCommand> 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")));
   }
 }

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)(.*);";
+  }
 }

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 (.*);";
+  }
 }

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) (.*);";
+  }
 }

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 (.*);";
+  }
 }

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;
-
-    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 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");
-    }
-
-    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");
-    }
-
-    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<String> 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<List<String>> 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<String> keys = getJsonObjectKeys(node.get(0));
-            List<List<String>> rows = getTableRows(node, keys);
-            table.headers(keys).rows(rows);
-        }
-        return table;
-    }
-
-    private Table getTableFromObject(JsonNode node) {
-        List<String> keys = getJsonObjectKeys(node);
-        List<String> values = getJsonObjectValues(node);
-        List<List<String>> 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");
-    }
-
-    private List<List<String>> getTableRows(JsonNode node, List<String> keys) {
-        return getStreamForJsonArray(node)
-                .map(row -> keys.stream()
-                        .map(header -> row.get(header).asText())
-                        .collect(Collectors.toList())
-                )
-                .collect(Collectors.toList());
-    }
-
-    private Stream<JsonNode> 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<String> 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<String> 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 String host = null;
+  protected KsqlCommand ksqlCommand = 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 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");
+  }
+
+  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");
+  }
+
+  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<String> 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<List<String>> 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<String> keys = getJsonObjectKeys(node.get(0));
+      List<List<String>> rows = getTableRows(node, keys);
+      table.headers(keys).rows(rows);
+    }
+    return table;
+  }
+
+  private Table getTableFromObject(JsonNode node) {
+    List<String> keys = getJsonObjectKeys(node);
+    List<String> values = getJsonObjectValues(node);
+    List<List<String>> 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");
+  }
+
+  private List<List<String>> getTableRows(JsonNode node, List<String> keys) {
+    return getStreamForJsonArray(node)
+        .map(row -> keys.stream()
+            .map(header -> row.get(header).asText())
+            .collect(Collectors.toList())
+        )
+        .collect(Collectors.toList());
+  }
+
+  private Stream<JsonNode> 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<String> 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<String> 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();
 }

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<String> 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<String> statement = statements.stream()
-                .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s)))
-                .findFirst();
-        if (statement.isPresent()) {
-            setResponseValueKey(statement.get());
-            return true;
-        }
-        return false;
+  private final String requestPath = "/ksql";
+  private final List<String> 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<String> 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;
+  }
 }

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 (.*);";
+  }
 }

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<String> 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<String> statement = statements.stream()
-                .filter(s -> sql.trim().toLowerCase().matches(getTestRegExp(s)))
-                .findFirst();
-        if (statement.isPresent()) {
-            setResponseValueKey(statement.get());
-            return true;
-        }
-        return false;
+  private final String requestPath = "/ksql";
+  private String responseValueKey = "";
+  private final List<String> 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<String> 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;
+  }
 
 }

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 (.*);";
+  }
 }

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;
-
-    @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()));
-
+  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();
-        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);
+    verify(ksqlClient, times(1)).execute(ksqlStatementStrategy);
+    assertThat(receivedResponse).isEqualTo(response);
 
-    }
+  }
 }

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));
+  }
 }

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));
+  }
 }

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));
+  }
 }

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));
+  }
 }

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));
+  }
 }

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);
+  }
 }

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();
-
-    @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));
-    }
+  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));
+  }
 }

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));
+  }
 }