MINIFICPP-2675 Move Elasticsearch tests to modular docker tests

docker/RunBehaveTests.sh

@@ -201,4 +201,5 @@ exec \
     "${docker_dir}/../extensions/llamacpp/tests/features" \
     "${docker_dir}/../extensions/opc/tests/features" \
     "${docker_dir}/../extensions/kafka/tests/features" \
-    "${docker_dir}/../extensions/couchbase/tests/features"
+    "${docker_dir}/../extensions/couchbase/tests/features" \
+    "${docker_dir}/../extensions/elasticsearch/tests/features"

docker/test/integration/cluster/ContainerStore.py

@@ -26,8 +26,6 @@
 from .containers.PostgreSQLServerContainer import PostgreSQLServerContainer
 from .containers.MqttBrokerContainer import MqttBrokerContainer
 from .containers.SplunkContainer import SplunkContainer
-from .containers.ElasticsearchContainer import ElasticsearchContainer
-from .containers.OpensearchContainer import OpensearchContainer
 from .containers.SyslogUdpClientContainer import SyslogUdpClientContainer
 from .containers.SyslogTcpClientContainer import SyslogTcpClientContainer
 from .containers.MinifiAsPodInKubernetesCluster import MinifiAsPodInKubernetesCluster
@@ -179,22 +177,6 @@ def acquire_container(self, context, container_name: str, engine='minifi-cpp', c
                                                               network=self.network,
                                                               image_store=self.image_store,
                                                               command=command))
-        elif engine == 'elasticsearch':
-            return self.containers.setdefault(container_name,
-                                              ElasticsearchContainer(feature_context=feature_context,
-                                                                     name=container_name,
-                                                                     vols=self.vols,
-                                                                     network=self.network,
-                                                                     image_store=self.image_store,
-                                                                     command=command))
-        elif engine == 'opensearch':
-            return self.containers.setdefault(container_name,
-                                              OpensearchContainer(feature_context=feature_context,
-                                                                  name=container_name,
-                                                                  vols=self.vols,
-                                                                  network=self.network,
-                                                                  image_store=self.image_store,
-                                                                  command=command))
         elif engine == "syslog-udp-client":
             return self.containers.setdefault(container_name,
                                               SyslogUdpClientContainer(

docker/test/integration/cluster/DockerTestCluster.py

@@ -28,7 +28,6 @@
 from .MinifiControllerExecutor import MinifiControllerExecutor
 from .checkers.AwsChecker import AwsChecker
 from .checkers.AzureChecker import AzureChecker
-from .checkers.ElasticSearchChecker import ElasticSearchChecker
 from .checkers.GcsChecker import GcsChecker
 from .checkers.PostgresChecker import PostgresChecker
 from .checkers.PrometheusChecker import PrometheusChecker
@@ -47,7 +46,6 @@ def __init__(self, context, feature_id):
         self.container_store = ContainerStore(self.container_communicator.create_docker_network(feature_id), context.image_store, context.kubernetes_proxy, feature_id=feature_id)
         self.aws_checker = AwsChecker(self.container_communicator)
         self.azure_checker = AzureChecker(self.container_communicator)
-        self.elastic_search_checker = ElasticSearchChecker(self.container_communicator)
         self.gcs_checker = GcsChecker(self.container_communicator)
         self.postgres_checker = PostgresChecker(self.container_communicator)
         self.splunk_checker = SplunkChecker(self.container_communicator)
@@ -262,26 +260,6 @@ def is_gcs_bucket_empty(self, container_name):
         container_name = self.container_store.get_container_name_with_postfix(container_name)
         return self.gcs_checker.is_gcs_bucket_empty(container_name)
 
-    def is_elasticsearch_empty(self, container_name):
-        container_name = self.container_store.get_container_name_with_postfix(container_name)
-        return self.elastic_search_checker.is_elasticsearch_empty(container_name)
-
-    def create_doc_elasticsearch(self, container_name, index_name, doc_id):
-        container_name = self.container_store.get_container_name_with_postfix(container_name)
-        return self.elastic_search_checker.create_doc_elasticsearch(container_name, index_name, doc_id)
-
-    def check_elastic_field_value(self, container_name, index_name, doc_id, field_name, field_value):
-        container_name = self.container_store.get_container_name_with_postfix(container_name)
-        return self.elastic_search_checker.check_elastic_field_value(container_name, index_name, doc_id, field_name, field_value)
-
-    def elastic_generate_apikey(self, elastic_container_name):
-        elastic_container_name = self.container_store.get_container_name_with_postfix(elastic_container_name)
-        return self.elastic_search_checker.elastic_generate_apikey(elastic_container_name)
-
-    def add_elastic_user_to_opensearch(self, container_name):
-        container_name = self.container_store.get_container_name_with_postfix(container_name)
-        return self.elastic_search_checker.add_elastic_user_to_opensearch(container_name)
-
     def check_query_results(self, postgresql_container_name, query, number_of_rows, timeout_seconds):
         postgresql_container_name = self.container_store.get_container_name_with_postfix(postgresql_container_name)
         return self.postgres_checker.check_query_results(postgresql_container_name, query, number_of_rows, timeout_seconds)

docker/test/integration/features/MiNiFi_integration_test_driver.py

@@ -70,16 +70,6 @@ def start_splunk(self, context):
         assert self.cluster.wait_for_container_startup_to_finish('splunk') or self.cluster.log_app_output()
         assert self.cluster.enable_splunk_hec_indexer('splunk', 'splunk_hec_token') or self.cluster.log_app_output()
 
-    def start_elasticsearch(self, context):
-        self.cluster.acquire_container(context=context, name='elasticsearch', engine='elasticsearch')
-        self.cluster.deploy_container('elasticsearch')
-        assert self.cluster.wait_for_container_startup_to_finish('elasticsearch') or self.cluster.log_app_output()
-
-    def start_opensearch(self, context):
-        self.cluster.acquire_container(context=context, name='opensearch', engine='opensearch')
-        self.cluster.deploy_container('opensearch')
-        assert self.cluster.wait_for_container_startup_to_finish('opensearch') or self.cluster.log_app_output()
-
     def start_minifi_c2_server(self, context):
         self.cluster.acquire_container(context=context, name="minifi-c2-server", engine="minifi-c2-server")
         self.cluster.deploy_container('minifi-c2-server')
@@ -325,21 +315,6 @@ def check_google_cloud_storage(self, gcs_container_name, content):
     def check_empty_gcs_bucket(self, gcs_container_name):
         assert self.cluster.is_gcs_bucket_empty(gcs_container_name) or self.cluster.log_app_output()
 
-    def check_empty_elastic(self, elastic_container_name):
-        assert self.cluster.is_elasticsearch_empty(elastic_container_name) or self.cluster.log_app_output()
-
-    def elastic_generate_apikey(self, elastic_container_name):
-        return self.cluster.elastic_generate_apikey(elastic_container_name) or self.cluster.log_app_output()
-
-    def create_doc_elasticsearch(self, elastic_container_name, index_name, doc_id):
-        assert self.cluster.create_doc_elasticsearch(elastic_container_name, index_name, doc_id) or self.cluster.log_app_output()
-
-    def check_elastic_field_value(self, elastic_container_name, index_name, doc_id, field_name, field_value):
-        assert self.cluster.check_elastic_field_value(elastic_container_name, index_name, doc_id, field_name, field_value) or self.cluster.log_app_output()
-
-    def add_elastic_user_to_opensearch(self, container_name):
-        assert self.cluster.add_elastic_user_to_opensearch(container_name) or self.cluster.log_app_output()
-
     def check_minifi_log_contents(self, line, timeout_seconds=60, count=1):
         self.check_container_log_contents("minifi-cpp", line, timeout_seconds, count)