You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@ignite.apache.org by GitBox <gi...@apache.org> on 2021/02/19 07:11:16 UTC
[GitHub] [ignite] Sega76 commented on a change in pull request #8686: IGNITE-14023 Password based authentication support in ducktape tests
Sega76 commented on a change in pull request #8686:
URL: https://github.com/apache/ignite/pull/8686#discussion_r578752775
##########
File path: modules/ducktests/tests/ignitetest/services/utils/control_utility.py
##########
@@ -34,27 +36,11 @@ class ControlUtility:
BASE_COMMAND = "control.sh"
# pylint: disable=R0913
- def __init__(self, cluster,
- key_store_jks: str = None, key_store_password: str = DEFAULT_PASSWORD,
- trust_store_jks: str = DEFAULT_TRUSTSTORE, trust_store_password: str = DEFAULT_PASSWORD):
+ def __init__(self, cluster, **kwargs):
self._cluster = cluster
Review comment:
we can immediately receive SslContextFactory and CredsProvider
it's easier to use them
```
def __init__(self, cluster, ssl_context: SslContextFactory = None, creds: CredsProvider = None):
self._cluster = cluster
self.logger = cluster.context.logger
self.ssl_context = get_ssl_context_with_globals(cluster.context.globals, "admin", ssl_context)
self.creds = get_creds_provider_with_globals(cluster.context.globals, "admin", creds)
```
##########
File path: modules/ducktests/tests/ignitetest/services/utils/control_utility.py
##########
@@ -313,6 +305,41 @@ def __parse_output(raw_output):
def __alives(self):
return [node for node in self._cluster.nodes if self._cluster.alive(node)]
+ def _parse_ssl_params(self, user, globals_dict, **kwargs):
Review comment:
can be simplified like this
```
def get_creds_provider_with_globals(globals: dict, user: str, creds_dflt: CredsProvider) -> CredsProvider:
"""
:param globals Globals
:param user User
:param creds_dflt Default CredsProvider
:return CredsProvider
"""
if globals.get('use_auth'):
if user in globals and 'creds' in globals[user]:
creds_provider = CredsProvider(**globals[user]['creds'])
else:
creds_provider = creds_dflt if creds_dflt else CredsProvider()
else:
creds_provider = creds_dflt
return creds_provider
def get_ssl_context_with_globals(globals: dict, user: str, ssl_ctx_dflt: SslContextFactory) -> SslContextFactory:
"""
:param globals Globals
:param user User
:param ssl_ctx_dflt Default SslContextFactory
:return SslContextFactory
"""
root_dir = globals.get("install_root", "/opt")
if globals.get('use_ssl'):
if user in globals and 'ssl' in globals[user]:
ssl_context_factory = SslContextFactory(root_dir, **globals[user]['ssl'])
else:
ssl_context_factory = ssl_ctx_dflt if ssl_ctx_dflt else SslContextFactory(root_dir, DEFAULT_ADMIN_KEYSTORE)
else:
ssl_context_factory = ssl_ctx_dflt
return ssl_context_factory
```
##########
File path: modules/ducktests/tests/ignitetest/services/utils/auth/creds_provider.py
##########
@@ -0,0 +1,31 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+"""
+This module contains classes and utilities for Authentication Provider.
+"""
+
+DEFAULT_AUTH_PASSWORD = "ignite"
+DEFAULT_AUTH_LOGIN = "ignite"
+
+
+class CredsProvider:
+ """
+ Credentials provider.
+ """
+
+ def __init__(self, login=None, password=None):
Review comment:
we may use default value in __init__
##########
File path: modules/ducktests/tests/ignitetest/tests/auth_test.py
##########
@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module contains password based authentication tests
+"""
+
+from ignitetest.services.ignite import IgniteService
+from ignitetest.services.utils.control_utility import ControlUtility, ControlUtilityError
+from ignitetest.services.utils.ignite_configuration import IgniteConfiguration, DataStorageConfiguration
+from ignitetest.services.utils.ignite_configuration.data_storage import DataRegionConfiguration
+from ignitetest.utils import ignite_versions, cluster, ignore_if
+from ignitetest.utils.ignite_test import IgniteTest
+from ignitetest.utils.version import DEV_BRANCH, LATEST, IgniteVersion
+
+
+# pylint: disable=W0223
+class AuthenticationTests(IgniteTest):
+ """
+ Tests Ignite Authentication
+ """
+ NUM_NODES = 3
+
+ @cluster(num_nodes=NUM_NODES)
+ @ignite_versions(str(DEV_BRANCH), str(LATEST))
+ def test_activate_good_user(self, ignite_version):
+ """
+ Test activate cluster.
+ Authentication enabled
+ Positive case
+ """
+
+ config = IgniteConfiguration(
+ cluster_state="INACTIVE",
+ auth=True,
+ version=IgniteVersion(ignite_version),
+ data_storage=DataStorageConfiguration(
+ default=DataRegionConfiguration(name='persistent', persistent=True),
+ )
+ )
+
+ servers = IgniteService(self.test_context, config=config, num_nodes=self.NUM_NODES, startup_timeout_sec=60)
+
+ servers.start()
+
+ control_utility = ControlUtility(cluster=servers, login="ignite", password="ignite")
+ control_utility.activate()
+
+ @cluster(num_nodes=NUM_NODES)
+ @ignore_if(lambda version, globals_dict: globals_dict.get("use_auth", False)) # Globals overrides test params
+ @ignite_versions(str(DEV_BRANCH), str(LATEST))
+ def test_activate_bad_user(self, ignite_version):
+ """
+ Test activate cluster.
+ Authentication enabled
+ Negative case
+ """
+
+ config = IgniteConfiguration(
+ cluster_state="INACTIVE",
+ auth=True,
+ version=IgniteVersion(ignite_version),
+ data_storage=DataStorageConfiguration(
+ default=DataRegionConfiguration(name='persistent', persistent=True),
+ )
+ )
+
+ servers = IgniteService(self.test_context, config=config, num_nodes=self.NUM_NODES, startup_timeout_sec=60)
+
+ servers.start()
+
+ control_utility = ControlUtility(cluster=servers, login="bad_person", password="wrong_password")
Review comment:
if you use the suggested above
```
control_utility = ControlUtility(cluster=servers,
creds=CredsProvider(login="bad_person", password="wrong_password"))
##########
File path: modules/ducktests/tests/ignitetest/tests/auth_test.py
##########
@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module contains password based authentication tests
+"""
+
+from ignitetest.services.ignite import IgniteService
+from ignitetest.services.utils.control_utility import ControlUtility, ControlUtilityError
+from ignitetest.services.utils.ignite_configuration import IgniteConfiguration, DataStorageConfiguration
+from ignitetest.services.utils.ignite_configuration.data_storage import DataRegionConfiguration
+from ignitetest.utils import ignite_versions, cluster, ignore_if
+from ignitetest.utils.ignite_test import IgniteTest
+from ignitetest.utils.version import DEV_BRANCH, LATEST, IgniteVersion
+
+
+# pylint: disable=W0223
+class AuthenticationTests(IgniteTest):
+ """
+ Tests Ignite Authentication
+ """
+ NUM_NODES = 3
+
+ @cluster(num_nodes=NUM_NODES)
+ @ignite_versions(str(DEV_BRANCH), str(LATEST))
+ def test_activate_good_user(self, ignite_version):
+ """
+ Test activate cluster.
+ Authentication enabled
+ Positive case
+ """
+
+ config = IgniteConfiguration(
+ cluster_state="INACTIVE",
+ auth=True,
+ version=IgniteVersion(ignite_version),
+ data_storage=DataStorageConfiguration(
+ default=DataRegionConfiguration(name='persistent', persistent=True),
+ )
+ )
+
+ servers = IgniteService(self.test_context, config=config, num_nodes=self.NUM_NODES, startup_timeout_sec=60)
+
+ servers.start()
+
+ control_utility = ControlUtility(cluster=servers, login="ignite", password="ignite")
Review comment:
if you use the suggested above
```
control_utility = ControlUtility(cluster=servers, creds=CredsProvider())
```
##########
File path: modules/ducktests/tests/ignitetest/tests/auth_test.py
##########
@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module contains password based authentication tests
+"""
+
+from ignitetest.services.ignite import IgniteService
+from ignitetest.services.utils.control_utility import ControlUtility, ControlUtilityError
+from ignitetest.services.utils.ignite_configuration import IgniteConfiguration, DataStorageConfiguration
+from ignitetest.services.utils.ignite_configuration.data_storage import DataRegionConfiguration
+from ignitetest.utils import ignite_versions, cluster, ignore_if
+from ignitetest.utils.ignite_test import IgniteTest
+from ignitetest.utils.version import DEV_BRANCH, LATEST, IgniteVersion
+
+
+# pylint: disable=W0223
+class AuthenticationTests(IgniteTest):
+ """
+ Tests Ignite Authentication
+ """
+ NUM_NODES = 3
+
+ @cluster(num_nodes=NUM_NODES)
+ @ignite_versions(str(DEV_BRANCH), str(LATEST))
+ def test_activate_good_user(self, ignite_version):
+ """
+ Test activate cluster.
+ Authentication enabled
+ Positive case
+ """
+
+ config = IgniteConfiguration(
+ cluster_state="INACTIVE",
+ auth=True,
+ version=IgniteVersion(ignite_version),
+ data_storage=DataStorageConfiguration(
+ default=DataRegionConfiguration(name='persistent', persistent=True),
+ )
+ )
+
+ servers = IgniteService(self.test_context, config=config, num_nodes=self.NUM_NODES, startup_timeout_sec=60)
+
+ servers.start()
+
+ control_utility = ControlUtility(cluster=servers, login="ignite", password="ignite")
+ control_utility.activate()
+
+ @cluster(num_nodes=NUM_NODES)
+ @ignore_if(lambda version, globals_dict: globals_dict.get("use_auth", False)) # Globals overrides test params
+ @ignite_versions(str(DEV_BRANCH), str(LATEST))
+ def test_activate_bad_user(self, ignite_version):
+ """
+ Test activate cluster.
+ Authentication enabled
+ Negative case
+ """
+
+ config = IgniteConfiguration(
+ cluster_state="INACTIVE",
+ auth=True,
+ version=IgniteVersion(ignite_version),
+ data_storage=DataStorageConfiguration(
+ default=DataRegionConfiguration(name='persistent', persistent=True),
+ )
+ )
+
+ servers = IgniteService(self.test_context, config=config, num_nodes=self.NUM_NODES, startup_timeout_sec=60)
+
Review comment:
startup_timeout_sec=60 is default value
##########
File path: modules/ducktests/tests/ignitetest/tests/auth_test.py
##########
@@ -0,0 +1,90 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+This module contains password based authentication tests
+"""
+
+from ignitetest.services.ignite import IgniteService
+from ignitetest.services.utils.control_utility import ControlUtility, ControlUtilityError
+from ignitetest.services.utils.ignite_configuration import IgniteConfiguration, DataStorageConfiguration
+from ignitetest.services.utils.ignite_configuration.data_storage import DataRegionConfiguration
+from ignitetest.utils import ignite_versions, cluster, ignore_if
+from ignitetest.utils.ignite_test import IgniteTest
+from ignitetest.utils.version import DEV_BRANCH, LATEST, IgniteVersion
+
+
+# pylint: disable=W0223
+class AuthenticationTests(IgniteTest):
+ """
+ Tests Ignite Authentication
+ """
+ NUM_NODES = 3
+
+ @cluster(num_nodes=NUM_NODES)
+ @ignite_versions(str(DEV_BRANCH), str(LATEST))
+ def test_activate_good_user(self, ignite_version):
+ """
+ Test activate cluster.
+ Authentication enabled
+ Positive case
+ """
+
+ config = IgniteConfiguration(
+ cluster_state="INACTIVE",
+ auth=True,
+ version=IgniteVersion(ignite_version),
+ data_storage=DataStorageConfiguration(
+ default=DataRegionConfiguration(name='persistent', persistent=True),
Review comment:
the name parameter has a default value
##########
File path: modules/ducktests/tests/checks/utils/check_controls_util_parameters.py
##########
@@ -0,0 +1,250 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Checks Control Utility params pasrsing
+"""
+
+import pytest
+from ignitetest.services.utils.auth.creds_provider import CredsProvider, DEFAULT_AUTH_LOGIN, DEFAULT_AUTH_PASSWORD
+from ignitetest.services.utils.ssl.ssl_factory import SslContextFactory, DEFAULT_PASSWORD, DEFAULT_TRUSTSTORE, \
+ DEFAULT_ADMIN_KEYSTORE
+from ignitetest.services.utils.control_utility import ControlUtility
+
+
+class Cluster:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.context = Context(globals_dict)
+ self.certificate_dir = '/opt/certs/'
+
+
+class Context:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.logger = ''
+ self.globals = globals_dict
+
+
+def compare_ssl(class1, class2):
+ """
+ Compare two SslContextFactory objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, SslContextFactory) and isinstance(class2, SslContextFactory):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+def compare_creds(class1, class2):
+ """
+ Compare two CredsProvider objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, CredsProvider) and isinstance(class2, CredsProvider):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+class TestParams:
+ """
+ Globals and Kwargs for tests
+ """
+
+ test_ssl_jks = {'key_store_jks': 'admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_jks': 'truststore.jks', 'trust_store_password': 'qwe123'}
+ test_ssl_path = {'key_store_path': '/opt/certs/admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_path': '/opt/certs/truststore.jks',
+ 'trust_store_password': 'qwe123'}
+ test_ssl_only_key = {'key_store_jks': 'admin1.jks'}
+
+ test_creds = {'login': 'admin1', 'password': 'qwe123'}
+ test_creds_only_login = {'login': 'admin1'}
+
+ expected_ssl = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password='qwe123',
+ trust_store_path='/opt/certs/truststore.jks',
+ trust_store_password='qwe123')
+ expected_ssl_default = SslContextFactory(key_store_path='/opt/certs/'+DEFAULT_ADMIN_KEYSTORE,
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+ expected_ssl_only_key = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+
+ expected_creds = CredsProvider(login='admin1',
+ password='qwe123')
+ expected_creds_default = CredsProvider(login=DEFAULT_AUTH_LOGIN,
+ password=DEFAULT_AUTH_PASSWORD)
+ expected_creds_only_login = CredsProvider(login='admin1',
+ password=DEFAULT_AUTH_PASSWORD)
+
+
+class CheckCaseGlobalsSetKwargsNotSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_path}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_only_key}}, {}, TestParams.expected_ssl_only_key),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, {}, None), ])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsNotSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({}, TestParams.test_ssl_jks, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_path, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_only_key, TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, TestParams.test_ssl_only_key,
+ TestParams.expected_ssl),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, TestParams.test_ssl_only_key,
+ TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsSetKwargsNotSetCreds:
+ """
+ Check that control_utulity.py correctly parse credentials from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_auth': True,
+ 'admin': {'creds': TestParams.test_creds}}, {}, TestParams.expected_creds),
+ ({'use_auth': True,
+ 'admin': {'creds': TestParams.test_creds_only_login}}, {},
+ TestParams.expected_creds_only_login),
+ ({'use_auth': True}, {},
+ TestParams.expected_creds_default)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse credentials from globals
+ """
+ print(expected.__dict__)
Review comment:
for debugging?
##########
File path: modules/ducktests/tests/checks/utils/check_controls_util_parameters.py
##########
@@ -0,0 +1,250 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Checks Control Utility params pasrsing
+"""
+
+import pytest
+from ignitetest.services.utils.auth.creds_provider import CredsProvider, DEFAULT_AUTH_LOGIN, DEFAULT_AUTH_PASSWORD
+from ignitetest.services.utils.ssl.ssl_factory import SslContextFactory, DEFAULT_PASSWORD, DEFAULT_TRUSTSTORE, \
+ DEFAULT_ADMIN_KEYSTORE
+from ignitetest.services.utils.control_utility import ControlUtility
+
+
+class Cluster:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.context = Context(globals_dict)
+ self.certificate_dir = '/opt/certs/'
+
+
+class Context:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.logger = ''
+ self.globals = globals_dict
+
+
+def compare_ssl(class1, class2):
+ """
+ Compare two SslContextFactory objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, SslContextFactory) and isinstance(class2, SslContextFactory):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+def compare_creds(class1, class2):
+ """
+ Compare two CredsProvider objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, CredsProvider) and isinstance(class2, CredsProvider):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+class TestParams:
+ """
+ Globals and Kwargs for tests
+ """
+
+ test_ssl_jks = {'key_store_jks': 'admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_jks': 'truststore.jks', 'trust_store_password': 'qwe123'}
+ test_ssl_path = {'key_store_path': '/opt/certs/admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_path': '/opt/certs/truststore.jks',
+ 'trust_store_password': 'qwe123'}
+ test_ssl_only_key = {'key_store_jks': 'admin1.jks'}
+
+ test_creds = {'login': 'admin1', 'password': 'qwe123'}
+ test_creds_only_login = {'login': 'admin1'}
+
+ expected_ssl = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password='qwe123',
+ trust_store_path='/opt/certs/truststore.jks',
+ trust_store_password='qwe123')
+ expected_ssl_default = SslContextFactory(key_store_path='/opt/certs/'+DEFAULT_ADMIN_KEYSTORE,
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+ expected_ssl_only_key = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+
+ expected_creds = CredsProvider(login='admin1',
+ password='qwe123')
+ expected_creds_default = CredsProvider(login=DEFAULT_AUTH_LOGIN,
+ password=DEFAULT_AUTH_PASSWORD)
+ expected_creds_only_login = CredsProvider(login='admin1',
+ password=DEFAULT_AUTH_PASSWORD)
+
+
+class CheckCaseGlobalsSetKwargsNotSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
Review comment:
test_kwargs not used on this test
##########
File path: modules/ducktests/tests/checks/utils/check_controls_util_parameters.py
##########
@@ -0,0 +1,250 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Checks Control Utility params pasrsing
+"""
+
+import pytest
+from ignitetest.services.utils.auth.creds_provider import CredsProvider, DEFAULT_AUTH_LOGIN, DEFAULT_AUTH_PASSWORD
+from ignitetest.services.utils.ssl.ssl_factory import SslContextFactory, DEFAULT_PASSWORD, DEFAULT_TRUSTSTORE, \
+ DEFAULT_ADMIN_KEYSTORE
+from ignitetest.services.utils.control_utility import ControlUtility
+
+
+class Cluster:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.context = Context(globals_dict)
+ self.certificate_dir = '/opt/certs/'
+
+
+class Context:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.logger = ''
+ self.globals = globals_dict
+
+
+def compare_ssl(class1, class2):
+ """
+ Compare two SslContextFactory objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, SslContextFactory) and isinstance(class2, SslContextFactory):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+def compare_creds(class1, class2):
+ """
+ Compare two CredsProvider objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, CredsProvider) and isinstance(class2, CredsProvider):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+class TestParams:
+ """
+ Globals and Kwargs for tests
+ """
+
+ test_ssl_jks = {'key_store_jks': 'admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_jks': 'truststore.jks', 'trust_store_password': 'qwe123'}
+ test_ssl_path = {'key_store_path': '/opt/certs/admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_path': '/opt/certs/truststore.jks',
+ 'trust_store_password': 'qwe123'}
+ test_ssl_only_key = {'key_store_jks': 'admin1.jks'}
+
+ test_creds = {'login': 'admin1', 'password': 'qwe123'}
+ test_creds_only_login = {'login': 'admin1'}
+
+ expected_ssl = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password='qwe123',
+ trust_store_path='/opt/certs/truststore.jks',
+ trust_store_password='qwe123')
+ expected_ssl_default = SslContextFactory(key_store_path='/opt/certs/'+DEFAULT_ADMIN_KEYSTORE,
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+ expected_ssl_only_key = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+
+ expected_creds = CredsProvider(login='admin1',
+ password='qwe123')
+ expected_creds_default = CredsProvider(login=DEFAULT_AUTH_LOGIN,
+ password=DEFAULT_AUTH_PASSWORD)
+ expected_creds_only_login = CredsProvider(login='admin1',
+ password=DEFAULT_AUTH_PASSWORD)
+
+
+class CheckCaseGlobalsSetKwargsNotSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_path}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_only_key}}, {}, TestParams.expected_ssl_only_key),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, {}, None), ])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsNotSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({}, TestParams.test_ssl_jks, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_path, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_only_key, TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, TestParams.test_ssl_only_key,
+ TestParams.expected_ssl),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, TestParams.test_ssl_only_key,
+ TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsSetKwargsNotSetCreds:
+ """
+ Check that control_utulity.py correctly parse credentials from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_auth': True,
+ 'admin': {'creds': TestParams.test_creds}}, {}, TestParams.expected_creds),
Review comment:
test_kwargs not used on this test
##########
File path: modules/ducktests/tests/checks/utils/check_controls_util_parameters.py
##########
@@ -0,0 +1,250 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Checks Control Utility params pasrsing
+"""
+
+import pytest
+from ignitetest.services.utils.auth.creds_provider import CredsProvider, DEFAULT_AUTH_LOGIN, DEFAULT_AUTH_PASSWORD
+from ignitetest.services.utils.ssl.ssl_factory import SslContextFactory, DEFAULT_PASSWORD, DEFAULT_TRUSTSTORE, \
+ DEFAULT_ADMIN_KEYSTORE
+from ignitetest.services.utils.control_utility import ControlUtility
+
+
+class Cluster:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.context = Context(globals_dict)
+ self.certificate_dir = '/opt/certs/'
+
+
+class Context:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.logger = ''
+ self.globals = globals_dict
+
+
+def compare_ssl(class1, class2):
+ """
+ Compare two SslContextFactory objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, SslContextFactory) and isinstance(class2, SslContextFactory):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+def compare_creds(class1, class2):
+ """
+ Compare two CredsProvider objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, CredsProvider) and isinstance(class2, CredsProvider):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+class TestParams:
+ """
+ Globals and Kwargs for tests
+ """
+
+ test_ssl_jks = {'key_store_jks': 'admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_jks': 'truststore.jks', 'trust_store_password': 'qwe123'}
+ test_ssl_path = {'key_store_path': '/opt/certs/admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_path': '/opt/certs/truststore.jks',
+ 'trust_store_password': 'qwe123'}
+ test_ssl_only_key = {'key_store_jks': 'admin1.jks'}
+
+ test_creds = {'login': 'admin1', 'password': 'qwe123'}
+ test_creds_only_login = {'login': 'admin1'}
+
+ expected_ssl = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password='qwe123',
+ trust_store_path='/opt/certs/truststore.jks',
+ trust_store_password='qwe123')
+ expected_ssl_default = SslContextFactory(key_store_path='/opt/certs/'+DEFAULT_ADMIN_KEYSTORE,
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+ expected_ssl_only_key = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+
+ expected_creds = CredsProvider(login='admin1',
+ password='qwe123')
+ expected_creds_default = CredsProvider(login=DEFAULT_AUTH_LOGIN,
+ password=DEFAULT_AUTH_PASSWORD)
+ expected_creds_only_login = CredsProvider(login='admin1',
+ password=DEFAULT_AUTH_PASSWORD)
+
+
+class CheckCaseGlobalsSetKwargsNotSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_path}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_only_key}}, {}, TestParams.expected_ssl_only_key),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, {}, None), ])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsNotSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({}, TestParams.test_ssl_jks, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_path, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_only_key, TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, TestParams.test_ssl_only_key,
+ TestParams.expected_ssl),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, TestParams.test_ssl_only_key,
+ TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsSetKwargsNotSetCreds:
+ """
+ Check that control_utulity.py correctly parse credentials from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_auth': True,
+ 'admin': {'creds': TestParams.test_creds}}, {}, TestParams.expected_creds),
+ ({'use_auth': True,
+ 'admin': {'creds': TestParams.test_creds_only_login}}, {},
+ TestParams.expected_creds_only_login),
+ ({'use_auth': True}, {},
+ TestParams.expected_creds_default)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse credentials from globals
+ """
+ print(expected.__dict__)
+ print(ControlUtility(Cluster(test_globals), **test_kwargs).creds_prover.__dict__)
+
+ assert compare_creds(ControlUtility(Cluster(test_globals), **test_kwargs).creds_prover, expected)
+
+
+class CheckCaseGlobalsNotSetKwargsSetCreds:
+ """
+ Check that control_utulity.py correctly parse credentials from kwargs
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({}, TestParams.test_creds, TestParams.expected_creds),
+ ({}, TestParams.test_creds_only_login, TestParams.expected_creds_only_login)])
+ def check_parse(test_globals, test_kwargs, expected):
Review comment:
test_globals does not change in the test
##########
File path: modules/ducktests/tests/checks/utils/check_controls_util_parameters.py
##########
@@ -0,0 +1,250 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Checks Control Utility params pasrsing
+"""
+
+import pytest
+from ignitetest.services.utils.auth.creds_provider import CredsProvider, DEFAULT_AUTH_LOGIN, DEFAULT_AUTH_PASSWORD
+from ignitetest.services.utils.ssl.ssl_factory import SslContextFactory, DEFAULT_PASSWORD, DEFAULT_TRUSTSTORE, \
+ DEFAULT_ADMIN_KEYSTORE
+from ignitetest.services.utils.control_utility import ControlUtility
+
+
+class Cluster:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.context = Context(globals_dict)
+ self.certificate_dir = '/opt/certs/'
+
+
+class Context:
+ """
+ Need this to initialise ControlUtility
+ """
+
+ def __init__(self, globals_dict):
+ self.logger = ''
+ self.globals = globals_dict
+
+
+def compare_ssl(class1, class2):
+ """
+ Compare two SslContextFactory objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, SslContextFactory) and isinstance(class2, SslContextFactory):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+def compare_creds(class1, class2):
+ """
+ Compare two CredsProvider objects
+ """
+
+ if class1 is None and class2 is None:
+ return True
+ if isinstance(class1, CredsProvider) and isinstance(class2, CredsProvider):
+ return class1.__dict__ == class2.__dict__
+ return False
+
+
+class TestParams:
+ """
+ Globals and Kwargs for tests
+ """
+
+ test_ssl_jks = {'key_store_jks': 'admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_jks': 'truststore.jks', 'trust_store_password': 'qwe123'}
+ test_ssl_path = {'key_store_path': '/opt/certs/admin1.jks', 'key_store_password': 'qwe123',
+ 'trust_store_path': '/opt/certs/truststore.jks',
+ 'trust_store_password': 'qwe123'}
+ test_ssl_only_key = {'key_store_jks': 'admin1.jks'}
+
+ test_creds = {'login': 'admin1', 'password': 'qwe123'}
+ test_creds_only_login = {'login': 'admin1'}
+
+ expected_ssl = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password='qwe123',
+ trust_store_path='/opt/certs/truststore.jks',
+ trust_store_password='qwe123')
+ expected_ssl_default = SslContextFactory(key_store_path='/opt/certs/'+DEFAULT_ADMIN_KEYSTORE,
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+ expected_ssl_only_key = SslContextFactory(key_store_path='/opt/certs/admin1.jks',
+ key_store_password=DEFAULT_PASSWORD,
+ trust_store_path='/opt/certs/'+DEFAULT_TRUSTSTORE,
+ trust_store_password=DEFAULT_PASSWORD)
+
+ expected_creds = CredsProvider(login='admin1',
+ password='qwe123')
+ expected_creds_default = CredsProvider(login=DEFAULT_AUTH_LOGIN,
+ password=DEFAULT_AUTH_PASSWORD)
+ expected_creds_only_login = CredsProvider(login='admin1',
+ password=DEFAULT_AUTH_PASSWORD)
+
+
+class CheckCaseGlobalsSetKwargsNotSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_jks}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_path}}, {}, TestParams.expected_ssl),
+ ({'use_ssl': True,
+ 'admin': {'ssl': TestParams.test_ssl_only_key}}, {}, TestParams.expected_ssl_only_key),
+ ({'admin': {'ssl': TestParams.test_ssl_jks}}, {}, None), ])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from globals
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
+
+
+class CheckCaseGlobalsNotSetKwargsSetSsl:
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ @staticmethod
+ @pytest.mark.parametrize('test_globals, test_kwargs, expected',
+ [({}, TestParams.test_ssl_jks, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_path, TestParams.expected_ssl),
+ ({}, TestParams.test_ssl_only_key, TestParams.expected_ssl_only_key)])
+ def check_parse(test_globals, test_kwargs, expected):
+ """
+ Check that control_utulity.py correctly parse SSL params from kwargs
+ """
+
+ assert compare_ssl(ControlUtility(Cluster(test_globals), **test_kwargs).ssl_context, expected)
Review comment:
test_globals does not change in the test
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
users@infra.apache.org