--- /dev/null
+# Copyright 2019 Nokia
+#
+# Licensed 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.
+
+import abc
+import itertools
+from collections import namedtuple
+import pytest
+import six
+import mock
+from crl.remotesession.remotesession import RemoteSession
+from hostcli import HostCli
+from .cluster import (
+ MgmtTarget,
+ Cluster,
+ ClusterError)
+from .testutils.profiles import (
+ MasterProfile,
+ WorkerProfile,
+ StorageProfile,
+ ManagementProfile,
+ BaseProfile)
+from .testutils.ippool import IPPool
+from .testutils.host import (
+ MasterGenerator,
+ WorkerGenerator,
+ DpdkWorkerGenerator)
+from .metasingleton import MetaSingleton
+
+
+class ClusterMocks(namedtuple('ClusterMocks', ['remotesession',
+ 'hostcli',
+ 'envcreator',
+ 'usermanager'])):
+ pass
+
+
+@six.add_metaclass(abc.ABCMeta)
+class ClusterVerifierBase(object):
+
+ _mgmt_target = MgmtTarget(host='host',
+ user='user',
+ password='password')
+
+ _sudoshelldicts = [{'shellname': 'BashShell', 'cmd': 'sudo bash'}]
+
+ def __init__(self, cluster_mocks):
+ self._mocks = cluster_mocks
+ self._ippool = IPPool()
+ self._hosts = [h for h in self._hosts_gen()]
+ self._cluster = None
+ MetaSingleton.clear(Cluster)
+
+ @property
+ def cluster(self):
+ if self._cluster is None:
+ self._setup_cluster()
+ return self._cluster
+
+ def _setup_cluster(self):
+ self._cluster = self._create_cluster()
+
+ def verify_get_host(self):
+ for h in self._hosts:
+ actual_host = self.cluster.get_host(h.name)
+ assert actual_host.shelldicts == self._expected_shelldicts(h), (
+ 'expected: {}, got: {}'.format(
+ self._expected_shelldicts(h),
+ actual_host.shelldicts))
+ assert actual_host.network_domain == h.expected_network_domain, (
+ 'expected: {expected}, got: {actual}'.format(
+ expected=h.expected_network_domain,
+ actual=actual_host.network_domain))
+ assert actual_host.is_dpdk == h.expected_is_dpdk()
+
+ def verify_master_external_ip(self):
+ for master in self._masters:
+ actual_ip = self.cluster.get_host(master.name).external_ip
+ assert actual_ip == master.external_ip, (
+ 'Expected external_ip : {expected}, actual: {actual}'.format(
+ expected=master.external_ip,
+ actual=actual_ip))
+
+ @property
+ def _masters(self):
+ for h in self._hosts:
+ if MasterProfile in h.service_profiles:
+ yield h
+
+ def verify_get_hosts_with_profiles(self):
+ for profs, eh in self._expected_restricted_profs.items():
+ expected_hosts = sorted(eh)
+ hosts = self.cluster.get_hosts_with_profiles(*profs)
+ assert hosts == expected_hosts, (
+ 'Expected hosts: {e}, got: {g}'.format(e=expected_hosts, g=hosts))
+
+ def verify_hosts_containing(self):
+ for p in self._profs_combinations():
+ hosts = set(self.cluster.get_hosts_containing(*p))
+ expected_hosts = set(self._get_expected_hosts_containing(set(p)))
+ assert set(hosts) == expected_hosts, (
+ 'Expected hosts: {e}, got: {g}'.format(e=expected_hosts, g=hosts))
+
+ def verify_initialize_remotesession(self):
+ mock_remotesession = mock.create_autospec(RemoteSession).return_value
+ self.cluster.initialize_remotesession(mock_remotesession)
+ self._verify_initialize_mock_calls(mock_remotesession)
+
+ def _verify_initialize_mock_calls(self, mock_remotesession):
+ mock_remotesession.set_envcreator.assert_called_once_with(
+ self._mocks.envcreator.return_value)
+ self._verify_normal_and_sudo_mgmt(mock_remotesession)
+ self._verify_remotescript_default(mock_remotesession)
+ for h in self.cluster.get_hosts():
+ self._verify_normal_and_sudo_host(h, mock_remotesession)
+
+ def _verify_normal_and_sudo_mgmt(self, mock_remotesession):
+ mgmtshelldicts = self.cluster.get_mgmt_shelldicts()
+ self._should_be_in_set_runner(mock.call(mgmtshelldicts),
+ mock_remotesession=mock_remotesession)
+ sudodicts = mgmtshelldicts + self._sudoshelldicts
+ self._should_be_in_set_runner(mock.call(shelldicts=sudodicts,
+ name='sudo-default'),
+ mock_remotesession=mock_remotesession)
+
+ def _verify_remotescript_default(self, mock_remotesession):
+ self._should_be_in_set_target(mock.call(host=self._mgmt_target.host,
+ username=self._mgmt_target.user,
+ password=self._mgmt_target.password,
+ name='remotescript-default'),
+ mock_remotesession=mock_remotesession)
+
+ def _should_be_in_set_target(self, call, mock_remotesession):
+ set_target_calls = self._get_set_target_calls(mock_remotesession)
+ assert call in set_target_calls, (
+ '{call} is not in {set_target_calls}'.format(
+ call=call,
+ set_target_calls=set_target_calls))
+
+ @staticmethod
+ def _get_set_target_calls(mock_remotesession):
+ return mock_remotesession.set_target.mock_calls
+
+ def _verify_normal_and_sudo_host(self, host, mock_remotesession):
+ self._should_be_in_set_runner(mock.call(shelldicts=host.shelldicts,
+ name=host.name),
+ mock_remotesession=mock_remotesession)
+ sudodicts = host.shelldicts + self._sudoshelldicts
+ self._should_be_in_set_runner(mock.call(shelldicts=sudodicts,
+ name='sudo-{}'.format(host.name)),
+ mock_remotesession=mock_remotesession)
+
+ def verify_create_remotesession(self):
+ self._verify_initialize_mock_calls(self.cluster.create_remotesession())
+
+ def _should_be_in_set_runner(self, call, mock_remotesession):
+ set_runner_target_calls = self._get_set_runner_target_calls(mock_remotesession)
+ assert call in set_runner_target_calls, (
+ '{call} is not in {set_runner_target_calls}'.format(
+ call=call,
+ set_runner_target_calls=set_runner_target_calls))
+
+ def verify_initialize_hostcli(self):
+ mock_hostcli = mock.create_autospec(HostCli)
+ self.cluster.initialize_hostcli(mock_hostcli)
+ mock_hostcli.initialize.assert_called_once_with(
+ self._mocks.remotesession.return_value)
+
+ def verify_create_hostcli(self):
+ assert self.cluster.create_hostcli() == self._mocks.hostcli.return_value
+ assert self._mocks.hostcli.return_value.initialize.mock_calls == [
+ mock.call(self._mocks.remotesession.return_value) for _ in range(2)]
+
+ def verify_create_user_with_roles(self):
+ roles = ['role1', 'role2']
+ create_user = self._mocks.usermanager.return_value.create_user_with_roles
+ assert self.cluster.create_user_with_roles(*roles) == create_user.return_value
+ self._mocks.usermanager.assert_called_once_with(
+ hostcli_factory=self._cluster.create_hostcli)
+ create_user.assert_called_once_with(*roles)
+
+ def verify_delete_users(self):
+ self.cluster.delete_users()
+ self._mocks.usermanager.assert_called_once_with(
+ hostcli_factory=self._cluster.create_hostcli)
+ self._mocks.usermanager.return_value.delete_users.assert_called_once_with()
+
+ def verify_envcreator(self):
+ self._setup_cluster()
+ self._mocks.envcreator.assert_called_once_with(
+ remotesession_factory=self.cluster.create_remotesession,
+ usermanager=self._mocks.usermanager.return_value)
+
+ @staticmethod
+ def _get_set_runner_target_calls(mock_remotesession):
+ return mock_remotesession.set_runner_target.mock_calls
+
+ def verify_cluster_config_caching(self):
+ self._create_cluster()
+ cluster = Cluster()
+ self._setup_cluster_and_verify(cluster)
+
+ def verify_mgmt_shelldicts(self):
+ assert self.cluster.get_mgmt_shelldicts() == [self._mgmt_target.asdict()]
+
+ def verify_is_dpdk(self):
+ assert self.cluster.is_dpdk() == self._expected_is_dpdk
+
+ def verify_get_hosts_with_dpdk(self):
+ assert self.cluster.get_hosts_with_dpdk() == sorted(self._expected_hosts_with_dpdk())
+
+ def _expected_hosts_with_dpdk(self):
+ for h in self._hosts:
+ if h.expected_is_dpdk():
+ yield h.name
+
+ @property
+ def _expected_is_dpdk(self):
+ for h in self._hosts:
+ if h.expected_is_dpdk():
+ return True
+
+ return False
+
+ @abc.abstractmethod
+ def _hosts_gen(self):
+ """Return generator of :class:`.testutils.Host` instances."""
+
+ def _create_cluster(self):
+ c = Cluster()
+ c.clear_cache()
+ self._setup_cluster_and_verify(c)
+ return c
+
+ def _setup_cluster_and_verify(self, cluster):
+ self._mocks.hostcli.return_value.run.return_value = self._configprops
+ cluster.set_profiles(master=str(MasterProfile()), worker=str(WorkerProfile()))
+ cluster.initialize(**self._mgmt_target.asdict())
+ self._verify_after_initialize(cluster)
+
+ def _verify_after_initialize(self, cluster):
+ assert len(self._hosts) == len(cluster.get_hosts()), (
+ len(self._hosts), len(cluster.get_hosts()))
+
+ hostcli = self._mocks.hostcli.return_value
+ hostcli.initialize.assert_called_once_with(
+ self._mocks.remotesession.return_value)
+ hostcli.run.assert_called_once_with('config-manager list properties')
+
+ def _get_expected_hosts_containing(self, profs):
+ hosts = set()
+ for p, h in self._expected_profs.items():
+ if profs.issubset(p):
+ hosts = hosts.union(set(h))
+ return hosts
+
+ @property
+ def _expected_restricted_profs(self):
+ def profile_filter(prof):
+ return prof in [MasterProfile, WorkerProfile, StorageProfile]
+
+ return self._get_expected_profs_for_filter(profile_filter)
+
+ @property
+ def _expected_profs(self):
+ return self._get_expected_profs_for_filter(lambda prof: True)
+
+ def _get_expected_profs_for_filter(self, profile_filter):
+ p = {}
+ for host in self._hosts:
+ key = frozenset([str(s()) for s in host.service_profiles if profile_filter(s)])
+ if key not in p:
+ p[key] = []
+ p[key].append(host.name)
+ return p
+
+ @staticmethod
+ def _profs_combinations():
+ profs = [str(p()) for p in [MasterProfile,
+ WorkerProfile,
+ BaseProfile,
+ ManagementProfile]]
+ for r in range(1, len(profs) + 1):
+ for p in itertools.combinations(profs, r):
+ yield p
+
+ def _expected_shelldicts(self, host):
+ if MasterProfile in host.service_profiles:
+ return [{'host': host.external_ip,
+ 'user': self._mgmt_target.user,
+ 'password': self._mgmt_target.password}]
+ return [self._mgmt_target.asdict(),
+ {'host': host.internal_ip,
+ 'user': self._mgmt_target.user,
+ 'password': self._mgmt_target.password}]
+
+ @property
+ def _configprops(self):
+ return list(self._hosts_config_gen()) + [self._get_hosts_network_profiles()]
+
+ def _hosts_config_gen(self):
+ for h in self._hosts:
+ yield {'property': '{host}.networking'.format(host=h.name),
+ 'value': h.networking}
+
+ yield {'property': 'cloud.hosts',
+ 'value': {h.name: h.host_dict for h in self._hosts}}
+
+ def _get_hosts_network_profiles(self):
+ return {'property': 'cloud.network_profiles',
+ 'value': self._get_network_profile_details()}
+
+ def _get_network_profile_details(self):
+ d = {}
+ for h in self._hosts:
+ d.update(h.network_profile_details)
+ return d
+
+ @property
+ def _master_gen(self):
+ return MasterGenerator(self._ippool).gen
+
+ @property
+ def _worker_gen(self):
+ return WorkerGenerator(self._ippool).gen
+
+
+class Type1Verifier(ClusterVerifierBase):
+ # pylint: disable=not-callable
+ def _hosts_gen(self):
+ return itertools.chain(self._master_gen(3),
+ self._worker_gen(2))
+
+
+class Type2Verifier(ClusterVerifierBase):
+
+ def _hosts_gen(self):
+ return itertools.chain(self._master_gen(3),
+ self._dpdk_worker_gen(2))
+
+ @property
+ def _dpdk_worker_gen(self):
+ return DpdkWorkerGenerator(self._ippool).gen
+
+
+class CorruptedVerifier(Type1Verifier):
+
+ def _hosts_config_gen(self):
+ yield {'property': 'not-relevant',
+ 'value': 'not-relevant'}
+
+ def verify_corrupted_raises(self):
+ with pytest.raises(ClusterError) as exinfo:
+ self.cluster.get_host('somename')
+
+ assert 'Property not found' in str(exinfo.value)
Code Review / ta / cloudtaf.git / blobdiff