def test_gen_defaults_uses_only_ready(self):
"""gen_defaults should only use ready machines"""
mock_maas_state = MagicMock()
mock_maas_state.machines.return_value = []
c = Config()
c.setopt('storage_backend', 'none')
pc = PlacementController(config=c, maas_state=mock_maas_state)
# reset the mock to avoid looking at calls from
# PlacementController.__init__().
mock_maas_state.reset_mock()
pc.gen_defaults()
# we simply check the first call because we know that
# follow-on calls are from calls to get_assignments and do
# not affect machines used for defaults
self.assertEqual(mock_maas_state.machines.mock_calls[0],
call(MaasMachineStatus.READY))
def test_gen_defaults_uses_only_ready(self):
"""gen_defaults should only use ready machines"""
mock_maas_state = MagicMock()
mock_maas_state.machines.return_value = []
c = Config()
c.setopt('storage_backend', 'none')
pc = PlacementController(config=c, maas_state=mock_maas_state)
# reset the mock to avoid looking at calls from
# PlacementController.__init__().
mock_maas_state.reset_mock()
pc.gen_defaults()
# we simply check the first call because we know that
# follow-on calls are from calls to get_assignments and do
# not affect machines used for defaults
self.assertEqual(mock_maas_state.machines.mock_calls[0],
call(MaasMachineStatus.READY))
class WaitForDeployedServicesReadyCoreTestCase(unittest.TestCase):
""" Tests core.wait_for_deployed_services_ready to make sure waiting
for services to start are handled properly.
"""
def setUp(self):
self.conf = Config({})
self.mock_ui = MagicMock(name='ui')
self.mock_log = MagicMock(name='log')
self.mock_loop = MagicMock(name='loop')
self.conf.setopt('headless', False)
self.dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=self.mock_loop)
self.dc.initialize = MagicMock()
self.dc.juju_state = JujuState(juju=MagicMock())
self.dc.juju_state.all_agents_started = MagicMock()
def test_validate_services_ready(self):
""" Verifies wait_for_deployed_services_ready
time.sleep should not be called here as all services
are in a started state.
"""
self.dc.juju_state.all_agents_started.return_value = True
with patch('cloudinstall.core.time.sleep') as mock_sleep:
self.dc.wait_for_deployed_services_ready()
self.assertEqual(len(mock_sleep.mock_calls), 0)
def test_validate_services_some_ready(self):
""" Verifies wait_for_deployed_services_ready against some of the
services in started state
Here we test if time.sleep was called twice due to some services
being in an installing and allocating state.
"""
self.dc.juju_state.all_agents_started.side_effect = [
False, False, True, True]
with patch('cloudinstall.core.time.sleep') as mock_sleep:
self.dc.wait_for_deployed_services_ready()
print(mock_sleep.mock_calls)
self.assertEqual(len(mock_sleep.mock_calls), 2)
def test_gen_single_backends(self):
"gen_single has no storage backend by default"
def find_charm(cn, defs):
allcharms = []
for mname, ad in defs.items():
for atype, charmclasses in ad.items():
allcharms += charmclasses
return cn in allcharms
c = Config()
pc = PlacementController(config=c)
# default storage_backend is 'none'
c.setopt('storage_backend', 'none')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'swift')
defaults = pc.gen_single()
self.assertTrue(find_charm(CharmSwiftProxy, defaults))
self.assertTrue(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'ceph')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertTrue(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
def test_gen_single_backends(self):
"gen_single has no storage backend by default"
def find_charm(cn, defs):
allcharms = []
for mname, ad in defs.items():
for atype, charmclasses in ad.items():
allcharms += charmclasses
return cn in allcharms
c = Config()
pc = PlacementController(config=c)
# default storage_backend is 'none'
c.setopt('storage_backend', 'none')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'swift')
defaults = pc.gen_single()
self.assertTrue(find_charm(CharmSwiftProxy, defaults))
self.assertTrue(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'ceph')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertTrue(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
class ControllerStateTestCase(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name, save_backups=False)
self.bad_states_int = [5, 6, 7]
self.good_states_int = [0, 1, 2]
def test_set_controller_state(self):
""" Validate config controller state """
for i in self.bad_states_int:
self.conf.setopt('current_state', i)
with self.assertRaises(ValueError):
s = self.conf.getopt('current_state')
ControllerState(s)
for i in self.good_states_int:
self.conf.setopt('current_state', i)
s = self.conf.getopt('current_state')
self.assertEqual(ControllerState(s), i)
class MultiInstallNewMaasTestCase(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name)
self.conf.setopt('openstack_password', 'ampersand&')
def make_installer(self, loop=None, dc=None):
if dc is None:
dc = MagicMock(name="display_controller")
if loop is None:
loop = MagicMock(name="loop")
self.installer = MultiInstallNewMaas(
loop, dc, self.conf)
def _create_superuser(self, raises):
expected = ("maas-region-admin createadmin --username root "
"--password 'ampersand&' "
"--email [email protected]")
self.make_installer()
with patch('cloudinstall.multi_install.utils') as mock_utils:
if raises:
mock_utils.get_command_output.return_value = {'status': -1}
self.assertRaises(MaasInstallError,
self.installer.create_superuser)
else:
mock_utils.get_command_output.return_value = {'status': 0}
self.installer.create_superuser()
mock_utils.get_command_output.assert_called_with(expected)
def test_create_superuser_raises(self):
self._create_superuser(True)
def test_create_superuser_ok(self):
self._create_superuser(False)
class InstallStateTestCase(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name)
self.bad_states_int = [5, 6, 7]
self.good_states_int = [0, 1]
def test_install_state(self):
""" Validate config install state """
for i in self.bad_states_int:
self.conf.setopt('current_state', i)
with self.assertRaises(ValueError):
s = self.conf.getopt('current_state')
InstallState(s)
for i in self.good_states_int:
self.conf.setopt('current_state', i)
s = self.conf.getopt('current_state')
self.assertEqual(InstallState(s), i)
class ControllerStateTestCase(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name, save_backups=False)
self.bad_states_int = [5, 6, 7]
self.good_states_int = [0, 1, 2]
def test_set_controller_state(self):
""" Validate config controller state """
for i in self.bad_states_int:
self.conf.setopt('current_state', i)
with self.assertRaises(ValueError):
s = self.conf.getopt('current_state')
ControllerState(s)
for i in self.good_states_int:
self.conf.setopt('current_state', i)
s = self.conf.getopt('current_state')
self.assertEqual(ControllerState(s), i)
class InstallStateTestCase(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name)
self.bad_states_int = [5, 6, 7]
self.good_states_int = [0, 1]
def test_install_state(self):
""" Validate config install state """
for i in self.bad_states_int:
self.conf.setopt('current_state', i)
with self.assertRaises(ValueError):
s = self.conf.getopt('current_state')
InstallState(s)
for i in self.good_states_int:
self.conf.setopt('current_state', i)
s = self.conf.getopt('current_state')
self.assertEqual(InstallState(s), i)
class MultiInstallNewMaasTestCase(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name)
self.conf.setopt('openstack_password', 'ampersand&')
def make_installer(self, loop=None, dc=None):
if dc is None:
dc = MagicMock(name="display_controller")
if loop is None:
loop = MagicMock(name="loop")
self.installer = MultiInstallNewMaas(loop, dc, self.conf)
def _create_superuser(self, raises):
expected = ("maas-region-admin createadmin --username root "
"--password 'ampersand&' "
"--email [email protected]")
self.make_installer()
with patch('cloudinstall.multi_install.utils') as mock_utils:
if raises:
mock_utils.get_command_output.return_value = {'status': -1}
self.assertRaises(MaasInstallError,
self.installer.create_superuser)
else:
mock_utils.get_command_output.return_value = {'status': 0}
self.installer.create_superuser()
mock_utils.get_command_output.assert_called_with(expected)
def test_create_superuser_raises(self):
self._create_superuser(True)
def test_create_superuser_ok(self):
self._create_superuser(False)
class TestRenderCharmConfig(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.config = Config({}, tempf.name)
type(self.config).cfg_path = PropertyMock(return_value='fake_cfg_path')
self.config.setopt('openstack_password', 'fake_pw')
self.ltp = patch('cloudinstall.utils.load_template')
self.mock_load_template = self.ltp.start()
self.mock_load_template.side_effect = source_tree_template_loader
def tearDown(self):
self.ltp.stop()
def _do_test_osrel(self, optsvalue, expected, mockspew):
"check that opts.openstack_release is rendered correctly"
self.config.setopt('openstack_release', optsvalue)
render_charm_config(self.config)
(fake_path, generated_yaml), kwargs = mockspew.call_args
d = yaml.load(generated_yaml)
print(d)
for oscharmname in ['nova-cloud-controller', 'glance',
'openstack-dashboard', 'keystone', 'swift-proxy']:
if expected is None:
self.assertTrue(oscharmname not in d or
'openstack-origin' not in d[oscharmname])
else:
self.assertEqual(d[oscharmname]['openstack-origin'], expected)
def test_render_openstack_release_given(self, mockspew):
self._do_test_osrel('klaxon', 'cloud:trusty-klaxon', mockspew)
def _do_test_multiplier(self, is_single, mockspew, expected=None):
if is_single:
self.config.setopt('install_type', 'Single')
else:
self.config.setopt('install_type', 'Multi')
self.config.setopt('openstack_release', 'klaxon')
render_charm_config(self.config)
(fake_path, generated_yaml), kwargs = mockspew.call_args
d = yaml.load(generated_yaml)
wmul = d['nova-cloud-controller'].get('worker-multiplier', None)
self.assertEqual(wmul, expected)
wmul = d['glance'].get('worker-multiplier', None)
self.assertEqual(wmul, expected)
wmul = d['keystone'].get('worker-multiplier', None)
self.assertEqual(wmul, expected)
def test_render_worker_multiplier_multi(self, mockspew):
self._do_test_multiplier(False, mockspew)
def test_render_worker_multiplier_single(self, mockspew):
self._do_test_multiplier(True, mockspew, expected=1)
def test_charmconfig_custom_merge(self, mockspew):
""" Verify rightmost custom charm config dictionary
does not overwrite untouched items in rendered
charmconfig
"""
charm_custom = {'swift-proxy': {'replicas': 15},
'mysql': {'dataset-size': '2048M'}}
charm_conf = yaml.load(slurp(os.path.join(DATA_DIR, 'charmconf.yaml')))
merged_dicts = merge_dicts(charm_conf, charm_custom)
self.assertEqual(merged_dicts['mysql']['max-connections'], 25000)
self.assertEqual(merged_dicts['swift-proxy']['zone-assignment'],
'auto')
class TestRenderCharmConfig(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode="w+", encoding="utf-8") as tempf:
# Override config file to save to
self.config = Config({}, tempf.name)
type(self.config).cfg_path = PropertyMock(return_value="fake_cfg_path")
self.config.setopt("openstack_password", "fake_pw")
self.ltp = patch("cloudinstall.utils.load_template")
self.mock_load_template = self.ltp.start()
self.mock_load_template.side_effect = source_tree_template_loader
def tearDown(self):
self.ltp.stop()
def _do_test_osrel(self, series, optsvalue, expected, mockspew):
"check that opts.openstack_release is rendered correctly"
self.config.setopt("openstack_release", optsvalue)
self.config.setopt("ubuntu_series", series)
render_charm_config(self.config)
(fake_path, generated_yaml), kwargs = mockspew.call_args
d = yaml.load(generated_yaml)
print(d)
for oscharmname in ["nova-cloud-controller", "glance", "openstack-dashboard", "keystone", "swift-proxy"]:
if expected is None:
self.assertTrue(oscharmname not in d or "openstack-origin" not in d[oscharmname])
else:
self.assertEqual(d[oscharmname]["openstack-origin"], expected)
def test_render_openstack_release_given(self, mockspew):
self._do_test_osrel("trusty", "klaxon", "cloud:trusty-klaxon", mockspew)
def _do_test_multiplier(self, is_single, mockspew, expected=None):
if is_single:
self.config.setopt("install_type", "Single")
else:
self.config.setopt("install_type", "Multi")
self.config.setopt("openstack_release", "klaxon")
render_charm_config(self.config)
(fake_path, generated_yaml), kwargs = mockspew.call_args
d = yaml.load(generated_yaml)
wmul = d["nova-cloud-controller"].get("worker-multiplier", None)
self.assertEqual(wmul, expected)
wmul = d["glance"].get("worker-multiplier", None)
self.assertEqual(wmul, expected)
wmul = d["keystone"].get("worker-multiplier", None)
self.assertEqual(wmul, expected)
def test_render_worker_multiplier_multi(self, mockspew):
self._do_test_multiplier(False, mockspew)
def test_render_worker_multiplier_single(self, mockspew):
self._do_test_multiplier(True, mockspew, expected=1)
def test_charmconfig_custom_merge(self, mockspew):
""" Verify rightmost custom charm config dictionary
does not overwrite untouched items in rendered
charmconfig
"""
charm_custom = {"swift-proxy": {"replicas": 15}, "mysql": {"dataset-size": "2048M"}}
charm_conf = yaml.load(slurp(os.path.join(DATA_DIR, "charmconf.yaml")))
merged_dicts = merge_dicts(charm_conf, charm_custom)
self.assertEqual(merged_dicts["mysql"]["max-connections"], 25000)
self.assertEqual(merged_dicts["swift-proxy"]["zone-assignment"], "auto")
class LandscapeInstallFinalTestCase(unittest.TestCase):
def setUp(self):
self.mock_multi_installer = MagicMock()
self.mock_display_controller = MagicMock()
self.loop = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name)
def make_installer_with_config(self, landscape_creds=None,
maas_creds=None):
if landscape_creds is None:
landscape_creds = dict(admin_name="fakeadminname",
admin_email="*****@*****.**",
system_email="*****@*****.**",
maas_server='fake.host',
maas_apikey='fake:keyz:yo')
self.conf.setopt('maascreds', dict(api_host='fake.host',
api_key='fake:keyz:yo'))
self.conf.setopt('landscapecreds', landscape_creds)
pm_binpath = PropertyMock(return_value='mockbinpath')
type(self.conf).bin_path = pm_binpath
pm_cfgpath = PropertyMock(return_value='mockcfgpath')
type(self.conf).cfg_path = pm_cfgpath
lif = LandscapeInstallFinal(self.mock_multi_installer,
self.mock_display_controller,
self.conf,
self.loop)
self.installer = lif
def test_run_configure_not_sudo_user(self, mock_utils):
"""Do not sudo -u $SUDO_USER when running landscape-configure, it will
be 'root'.
"""
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {'status': '',
'output': ''}
self.installer.run_configure_script()
mock_utils.get_command_output.assert_called_with(ANY, timeout=None)
def test_run_configure_quotes_config_values(self, mock_utils):
cd = dict(admin_name="fake admin name with spaces",
admin_email="[email protected]",
system_email="[email protected]")
self.make_installer_with_config(landscape_creds=cd)
mock_utils.get_command_output.return_value = {'status': '',
'output': ''}
self.installer.run_configure_script()
expectedcmdstr = ("mockbinpath/configure-landscape "
"--admin-email '{}' "
"--admin-name '{}' "
"--system-email '{}' "
"--maas-host fake.host".format(cd['admin_email'],
cd['admin_name'],
cd['system_email']))
mock_utils.get_command_output.assert_called_with(expectedcmdstr,
timeout=None)
def test_run_configure_raises_on_error(self, mock_utils):
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {'status': 1,
'output': 'failure'}
self.assertRaises(Exception, self.installer.run_configure_script)
def test_run_deployer_raises_on_error(self, mock_utils):
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {'status': 1,
'output': 'failure'}
self.assertRaises(Exception, self.installer.run_deployer)
def test_run_deployer_has_no_timeout(self, mock_utils):
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {'status': '',
'output': 'failure'}
self.installer.run_deployer()
mock_utils.get_command_output.assert_called_with(ANY, timeout=None,
user_sudo=ANY)
class ServicesListTestCase(unittest.TestCase):
def setUp(self):
self.mock_maas_state = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
self.conf = Config({}, tempf.name)
self.conf.setopt('storage_backend', 'none')
self.pc = PlacementController(self.mock_maas_state,
self.conf)
self.mock_machine = make_fake_machine('machine1', {'cpu_count': 3})
self.mock_machine2 = make_fake_machine('machine2')
self.mock_machine3 = make_fake_machine('machine3')
self.mock_machines = [self.mock_machine]
self.mock_maas_state.machines.return_value = self.mock_machines
self.actions = []
self.sub_actions = []
def test_widgets_config(self, mock_servicewidgetclass):
for show_constraints in [False, True]:
sl = ServicesList(self.pc, self.actions, self.sub_actions,
show_constraints=show_constraints)
mock_servicewidgetclass.assert_any_call(
CharmNovaCompute,
self.pc,
self.actions,
show_constraints,
show_placements=sl.show_placements)
mock_servicewidgetclass.reset_mock()
def test_no_machine_no_constraints(self, mock_servicewidgetclass):
with patch.object(self.pc, 'charm_classes') as mock_classesfunc:
fc = MagicMock(name='fakeclass1')
fc.required_num_units.return_value = 1
fc.constraints = {'cpu_count': 1000}
mock_classesfunc.return_value = [fc]
sl = ServicesList(self.pc, self.actions, self.sub_actions)
self.assertEqual(len(sl.service_widgets), 1)
def test_machine_checks_constraints(self, mock_servicewidgetclass):
mock_machine = make_fake_machine('fm', {'cpu_count': 0,
'storage': 0,
'memory': 0})
sl = ServicesList(self.pc, self.actions, self.sub_actions,
machine=mock_machine)
self.assertEqual(len(sl.service_widgets), 0)
def test_do_not_show_assigned(self, mock_servicewidgetclass):
mock_machine = make_fake_machine('fm', {'cpu_count': 0,
'storage': 0,
'memory': 0})
self.pc.assign(mock_machine, CharmNovaCompute,
AssignmentType.LXC)
sl = ServicesList(self.pc, self.actions, self.sub_actions,
machine=mock_machine)
classes = [sw.charm_class for sw in sl.service_widgets]
self.assertTrue(CharmNovaCompute not in classes)
def test_show_type(self, mock_servicewidgetclass):
"""Test combinations of show_type values.
This tests three values of show_type with three return values
for is_required(): all required, no required, and 1/3
required. It's all lumped in one test to consolidate setup.
"""
mock_sw1 = MagicMock(name='sw1')
mock_sw1.charm_class.charm_name = 'cc1'
mock_sw2 = MagicMock(name='sw2')
mock_sw2.charm_class.charm_name = 'cc2'
mock_sw3 = MagicMock(name='sw3')
mock_sw3.charm_class.charm_name = 'cc3'
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
with patch.object(self.pc, 'get_charm_state') as mock_get_state:
with patch.object(self.pc, 'charm_classes') as mock_classesfunc:
mock_classesfunc.return_value = [MagicMock(name='fake-class-1',
charm_name='cc1'),
MagicMock(name='fake-class-2',
charm_name='cc2'),
MagicMock(name='fake-class-3',
charm_name='cc3')]
# First, test when all charms are required
mock_get_state.return_value = (CharmState.REQUIRED, [], [])
# rsl shows required charms
rsl = ServicesList(self.pc, self.actions,
self.sub_actions, machine=None,
show_type='required')
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show all 3
self.assertEqual(len(rsl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
# usl shows ONLY un-required charms
usl = ServicesList(self.pc, self.actions,
self.sub_actions, machine=None,
show_type='non-required')
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show 0
self.assertEqual(len(usl.service_widgets), 0)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
# asl has default show_type='all', showing all charms
asl = ServicesList(self.pc, self.actions, self.sub_actions)
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show all 3
self.assertEqual(len(asl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
# next, test where no charms are required
mock_get_state.return_value = (CharmState.OPTIONAL, [], [])
rsl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show 0 charms
self.assertEqual(len(rsl.service_widgets), 0)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
usl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show all 3
self.assertEqual(len(usl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
asl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should still show all 3
self.assertEqual(len(asl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
# next test two un-required and one required charm:
mock_get_state.side_effect = [(CharmState.OPTIONAL, [], []),
(CharmState.REQUIRED, [], []),
(CharmState.OPTIONAL, [], [])]
rsl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show 1:
self.assertEqual(len(rsl.service_widgets), 1)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
mock_get_state.side_effect = [(CharmState.OPTIONAL, [], []),
(CharmState.REQUIRED, [], []),
(CharmState.OPTIONAL, [], [])]
usl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show two
self.assertEqual(len(usl.service_widgets), 2)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2,
mock_sw3]
mock_get_state.side_effect = [(CharmState.OPTIONAL, [], []),
(CharmState.REQUIRED, [], []),
(CharmState.OPTIONAL, [], [])]
asl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should still show all three
self.assertEqual(len(asl.service_widgets), 3)
class ServiceWidgetTestCase(unittest.TestCase):
def setUp(self):
self.mock_maas_state = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
self.conf = Config({}, tempf.name)
self.conf.setopt('storage_backend', 'none')
self.pc = PlacementController(self.mock_maas_state,
self.conf)
self.mock_machine = make_fake_machine('machine1')
self.mock_machine_2 = make_fake_machine('machine2')
self.mock_machines = [self.mock_machine, self.mock_machine_2]
self.mock_maas_state.machines.return_value = self.mock_machines
def test_required_label_shown(self):
"""Widget showing a required charm should have a label showing how
many units are required"""
w = ServiceWidget(CharmKeystone, self.pc)
self.assertTrue(search_in_widget("0 of 1 placed", w))
def test_required_label_not_shown(self):
"""Widget showing a non-required charm should NOT have a label showing
how many units are required.
"""
w = ServiceWidget(CharmJujuGui, self.pc)
self.assertFalse(search_in_widget(".* of .* placed", w))
def test_show_placements(self):
"""Widget with show_placements set should show placements"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_placements=True)
self.assertTrue(search_in_widget("LXC.*machine1-hostname", w))
def test_dont_show_placements(self):
"""Widget with show_placements set to FALSE should NOT show
placements"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_placements=False)
self.assertFalse(search_in_widget("LXC.*machine1-hostname", w))
def test_show_constraints(self):
"""Widget with show_constraints set should show constraints"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_constraints=True)
conpat = ("constraints.*" +
".*".join(CharmNovaCompute.constraints.keys()))
self.assertTrue(search_in_widget(conpat, w))
def test_dont_show_constraints(self):
"""Widget with show_constraints set to FALSE should NOT show
constraints"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_constraints=False)
self.assertFalse(search_in_widget("constraints", w))
def test_show_actions(self):
"""Actions should be shown as buttons"""
fake_action_func = MagicMock()
actions = [("fake-action", fake_action_func)]
w = ServiceWidget(CharmNovaCompute, self.pc, actions=actions)
self.assertTrue(search_in_widget("fake-action", w))
def test_actions_use_pred(self):
"""Action predicates control whether a button appears (disabled)"""
# NOTE: this test assumes that disabled buttons are just the
# button label with parentheses.
fake_action_func = MagicMock()
fake_pred = MagicMock()
fake_pred.return_value = False
actions = [(fake_pred, "fake-action", fake_action_func)]
w = ServiceWidget(CharmNovaCompute, self.pc, actions=actions)
self.assertTrue(search_in_widget("\(.*fake-action.*\)", w))
fake_pred.assert_called_with(CharmNovaCompute)
fake_pred.return_value = True
fake_pred.reset_mock()
w.update()
self.assertTrue(search_in_widget("<.*fake-action.*>", w))
fake_pred.assert_called_with(CharmNovaCompute)
class PlacementControllerTestCase(unittest.TestCase):
def setUp(self):
self.mock_maas_state = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
self.conf = Config({}, tempf.name)
self.conf.setopt('storage_backend', 'none')
self.pc = PlacementController(self.mock_maas_state, self.conf)
self.mock_machine = MagicMock(name='machine1')
pmid = PropertyMock(return_value='fake-instance-id-1')
type(self.mock_machine).instance_id = pmid
self.mock_machine_2 = MagicMock(name='machine2')
pmid2 = PropertyMock(return_value='fake-instance-id-2')
type(self.mock_machine_2).instance_id = pmid2
self.mock_machines = [self.mock_machine, self.mock_machine_2]
self.mock_maas_state.machines.return_value = self.mock_machines
def test_get_assignments_atype(self):
self.assertEqual(0, len(self.pc.get_assignments(CharmNovaCompute)))
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
md = self.pc.get_assignments(CharmNovaCompute)
self.assertEqual(1, len(md))
self.assertEqual(2, len(md[AssignmentType.LXC]))
def _do_test_simple_assign_type(self, assignment_type):
self.pc.assign(self.mock_machine, CharmNovaCompute, assignment_type)
print("assignments is {}".format(self.pc.assignments))
machines = self.pc.get_assignments(CharmNovaCompute)
print('machines for charm is {}'.format(machines))
self.assertEqual(machines, {assignment_type: [self.mock_machine]})
ma = self.pc.assignments_for_machine(self.mock_machine)
self.assertEqual(ma[assignment_type], [CharmNovaCompute])
def test_simple_assign_bare(self):
self._do_test_simple_assign_type(AssignmentType.BareMetal)
def test_simple_assign_lxc(self):
self._do_test_simple_assign_type(AssignmentType.LXC)
def test_simple_assign_kvm(self):
self._do_test_simple_assign_type(AssignmentType.KVM)
def test_assign_nonmulti(self):
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.LXC)
self.assertEqual(self.pc.get_assignments(CharmKeystone),
{AssignmentType.LXC: [self.mock_machine]})
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.KVM)
self.assertEqual(self.pc.get_assignments(CharmKeystone),
{AssignmentType.KVM: [self.mock_machine]})
am = self.pc.assignments_for_machine(self.mock_machine)
self.assertEqual(am[AssignmentType.KVM], [CharmKeystone])
self.assertEqual(am[AssignmentType.LXC], [])
def test_assign_multi(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.assertEqual(self.pc.get_assignments(CharmNovaCompute),
{AssignmentType.LXC: [self.mock_machine]})
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.assertEqual(
self.pc.get_assignments(CharmNovaCompute), {
AssignmentType.LXC: [self.mock_machine],
AssignmentType.KVM: [self.mock_machine]
})
ma = self.pc.assignments_for_machine(self.mock_machine)
self.assertEqual(ma[AssignmentType.LXC], [CharmNovaCompute])
self.assertEqual(ma[AssignmentType.KVM], [CharmNovaCompute])
def test_remove_assignment_multi(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmNovaCompute,
AssignmentType.LXC)
mfc = self.pc.get_assignments(CharmNovaCompute)
mfc_lxc = set(mfc[AssignmentType.LXC])
self.assertEqual(mfc_lxc, set(self.mock_machines))
self.pc.clear_assignments(self.mock_machine)
self.assertEqual(self.pc.get_assignments(CharmNovaCompute),
{AssignmentType.LXC: [self.mock_machine_2]})
def test_gen_defaults(self):
satisfies_importstring = 'cloudinstall.placement.controller.satisfies'
with patch(satisfies_importstring) as mock_satisfies:
mock_satisfies.return_value = (True, )
defs = self.pc.gen_defaults(
charm_classes=[CharmNovaCompute, CharmKeystone],
maas_machines=[self.mock_machine, self.mock_machine_2])
m1_as = defs[self.mock_machine.instance_id]
m2_as = defs[self.mock_machine_2.instance_id]
self.assertEqual(m1_as[AssignmentType.BareMetal],
[CharmNovaCompute])
self.assertEqual(m1_as[AssignmentType.LXC], [])
self.assertEqual(m1_as[AssignmentType.KVM], [])
self.assertEqual(m2_as[AssignmentType.BareMetal], [])
self.assertEqual(m2_as[AssignmentType.LXC], [CharmKeystone])
self.assertEqual(m2_as[AssignmentType.KVM], [])
def test_remove_one_assignment_sametype(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
self.assertEqual(lxcs, [CharmNovaCompute])
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
self.assertEqual(lxcs, [])
def test_remove_one_assignment_othertype(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
kvms = md[AssignmentType.KVM]
self.assertEqual(1, len(lxcs) + len(kvms))
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
kvms = md[AssignmentType.KVM]
self.assertEqual(0, len(lxcs) + len(kvms))
def test_clear_all(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmNovaCompute,
AssignmentType.KVM)
self.pc.clear_all_assignments()
# check that it's empty:
self.assertEqual(self.pc.assignments, {})
# and that it's still a defaultdict(lambda: defaultdict(list))
mid = self.mock_machine.machine_id
lxcs = self.pc.assignments[mid][AssignmentType.LXC]
self.assertEqual(lxcs, [])
def test_unassigned_starts_full(self):
self.assertEqual(len(self.pc.unassigned_undeployed_services()),
len(self.pc.charm_classes()))
def test_assigned_charm_classes_starts_empty(self):
self.assertEqual(0, len(self.pc.assigned_charm_classes()))
def test_reset_unassigned_undeployed_none(self):
"""Assign all charms, ensure that unassigned is empty"""
for cc in self.pc.charm_classes():
self.pc.assign(self.mock_machine, cc, AssignmentType.LXC)
self.pc.reset_assigned_deployed()
self.assertEqual(0, len(self.pc.unassigned_undeployed_services()))
def test_reset_unassigned_undeployed_two(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmKeystone, AssignmentType.KVM)
self.pc.reset_assigned_deployed()
self.assertEqual(
len(self.pc.charm_classes()) - 2,
len(self.pc.unassigned_undeployed_services()))
def test_reset_excepting_compute(self):
for cc in self.pc.charm_classes():
if cc.charm_name == 'nova-compute':
continue
self.pc.assign(self.mock_machine, cc, AssignmentType.LXC)
self.pc.reset_assigned_deployed()
self.assertEqual(len(self.pc.unassigned_undeployed_services()), 1)
def test_unassigned_undeployed(self):
all_charms = set(self.pc.charm_classes())
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.KVM)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.pc.mark_deployed(self.mock_machine, CharmKeystone,
AssignmentType.KVM)
self.assertTrue(
CharmKeystone not in self.pc.unassigned_undeployed_services())
self.assertTrue(
CharmNovaCompute not in self.pc.unassigned_undeployed_services())
self.assertTrue(self.pc.is_deployed(CharmKeystone))
self.assertTrue(self.pc.is_assigned(CharmNovaCompute))
self.assertTrue(
len(all_charms) - 2, len(self.pc.unassigned_undeployed_services()))
n_k_as = self.pc.assignment_machine_count_for_charm(CharmKeystone)
self.assertEqual(n_k_as, 0)
n_k_dl = self.pc.deployment_machine_count_for_charm(CharmKeystone)
self.assertEqual(n_k_dl, 1)
n_nc_as = self.pc.assignment_machine_count_for_charm(CharmNovaCompute)
self.assertEqual(n_nc_as, 1)
n_nc_dl = self.pc.deployment_machine_count_for_charm(CharmNovaCompute)
self.assertEqual(n_nc_dl, 0)
def test_deployed_charms_starts_empty(self):
"Initially there are no deployed charms"
self.assertEqual(0, len(self.pc.deployed_charm_classes()))
def test_mark_deployed_unsets_assignment(self):
"Setting a placement to deployed removes it from assignment dict"
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.KVM)
self.assertEqual([CharmKeystone], self.pc.assigned_charm_classes())
self.pc.mark_deployed(self.mock_machine, CharmKeystone,
AssignmentType.KVM)
self.assertEqual([CharmKeystone], self.pc.deployed_charm_classes())
self.assertEqual([], self.pc.assigned_charm_classes())
def test_set_deployed_unsets_assignment_only_once(self):
"Setting a placement to deployed removes it from assignment dict"
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.pc.assign(self.mock_machine_2, CharmNovaCompute,
AssignmentType.KVM)
self.assertEqual([CharmNovaCompute], self.pc.assigned_charm_classes())
ad = self.pc.get_assignments(CharmNovaCompute)
dd = self.pc.get_deployments(CharmNovaCompute)
from pprint import pformat
print("Assignments is {}".format(pformat(ad)))
print("Deployments is {}".format(pformat(dd)))
self.assertEqual(set([self.mock_machine, self.mock_machine_2]),
set(ad[AssignmentType.KVM]))
self.assertEqual(len(dd.items()), 0)
self.pc.mark_deployed(self.mock_machine, CharmNovaCompute,
AssignmentType.KVM)
self.assertEqual([CharmNovaCompute], self.pc.deployed_charm_classes())
self.assertEqual([CharmNovaCompute], self.pc.assigned_charm_classes())
ad = self.pc.get_assignments(CharmNovaCompute)
dd = self.pc.get_deployments(CharmNovaCompute)
self.assertEqual([self.mock_machine_2], ad[AssignmentType.KVM])
self.assertEqual([self.mock_machine], dd[AssignmentType.KVM])
def test_get_charm_state(self):
"Test a sampling of required services and special handling for compute"
self.assertEqual(
self.pc.get_charm_state(CharmKeystone)[0], CharmState.REQUIRED)
self.assertEqual(
self.pc.get_charm_state(CharmNovaCompute)[0], CharmState.REQUIRED)
def test_one_compute_required(self):
"""after being assigned at least once, novacompute is no longer
considered 'required' (aka required)"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.assertNotEqual(
self.pc.get_charm_state(CharmNovaCompute)[0], CharmState.REQUIRED)
def test_swift_unrequired_then_required_default(self):
"Swift and swift-proxy are both optional until you add swift"
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwift, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_swift_unrequired_then_required_swift_backend(self):
"Swift and swift-proxy are not optional with swift as the backend."
self.conf.setopt('storage_backend', 'swift')
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwift, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_swift_proxy_unrequired_then_required_default(self):
"Swift and swift-proxy are both optional until you add swift-proxy"
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
# Only one swift-proxy is required, so now that we've added
# it, it is still not required:
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_swift_proxy_unrequired_then_required_swift_backend(self):
"Swift and swift-proxy are not optional with swift as the backend"
self.conf.setopt('storage_backend', 'swift')
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
# Only one swift-proxy is required, so now that we've added
# it, it is still not required:
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_storage_backends_in_is_required(self):
# default is 'none'
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCeph)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCephOSD)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.conf.setopt('storage_backend', 'swift')
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCeph)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCephOSD)[0])
self.assertEqual(CharmState.CONFLICTED,
self.pc.get_charm_state(CharmCephRadosGw)[0])
st = self.pc.get_charm_state(CharmSwift)
swift_state, swift_cons, swift_deps = st
self.assertEqual(CharmState.REQUIRED, swift_state)
st = self.pc.get_charm_state(CharmSwiftProxy)
swp_state, swp_cons, swp_deps = st
self.assertEqual(CharmState.REQUIRED, swp_state)
self.assertEqual([], swp_cons)
ceph_state, ceph_cons, ceph_deps = self.pc.get_charm_state(CharmCeph)
self.assertEqual(CharmState.OPTIONAL, ceph_state)
st = self.pc.get_charm_state(CharmCephRadosGw)
ceph_rg_state, ceph_rg_cons, ceph_rg_deps = st
self.assertEqual(CharmState.CONFLICTED, ceph_rg_state)
self.conf.setopt('storage_backend', 'ceph')
ceph_state, ceph_cons, ceph_deps = self.pc.get_charm_state(CharmCeph)
self.assertEqual(CharmState.REQUIRED, ceph_state)
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCephOSD)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_ceph_num_required(self):
"3 units of ceph should be required after having been assigned"
state, cons, deps = self.pc.get_charm_state(CharmCeph)
self.assertEqual(state, CharmState.OPTIONAL)
self.pc.assign(self.mock_machine, CharmCeph, AssignmentType.KVM)
self.assertEqual(
self.pc.get_charm_state(CharmCeph)[0], CharmState.REQUIRED)
self.pc.assign(self.mock_machine, CharmCeph, AssignmentType.KVM)
self.pc.assign(self.mock_machine, CharmCeph, AssignmentType.KVM)
self.assertEqual(
self.pc.get_charm_state(CharmCeph)[0], CharmState.OPTIONAL)
def test_persistence(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmKeystone, AssignmentType.KVM)
cons1 = PropertyMock(return_value={})
type(self.mock_machine).constraints = cons1
cons2 = PropertyMock(return_value={'cpu': 8})
type(self.mock_machine_2).constraints = cons2
with TemporaryFile(mode='w+', encoding='utf-8') as tempf:
self.pc.save(tempf)
tempf.seek(0)
print(tempf.read())
tempf.seek(0)
newpc = PlacementController(self.mock_maas_state, self.conf)
newpc.load(tempf)
self.assertEqual(self.pc.assignments, newpc.assignments)
self.assertEqual(self.pc.machines_pending(), newpc.machines_pending())
self.assertEqual(self.pc.assigned_charm_classes(),
newpc.assigned_charm_classes())
m2 = next((m for m in newpc.machines_pending()
if m.instance_id == 'fake-instance-id-2'))
self.assertEqual(m2.constraints, {'cpu': 8})
def test_load_machines_single(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
conf = Config({}, tempf.name)
fake_assignments = {
'fake_iid': {
'constraints': {},
'assignments': {
'KVM': ['nova-compute']
}
},
'fake_iid_2': {
'constraints': {
'cpu': 8
},
'assignments': {
'BareMetal': ['nova-compute']
}
}
}
singlepc = PlacementController(None, conf)
with TemporaryFile(mode='w+', encoding='utf-8') as tempf:
yaml.dump(fake_assignments, tempf)
tempf.seek(0)
singlepc.load(tempf)
self.assertEqual(
set([m.instance_id for m in singlepc.machines_pending()]),
set(['fake_iid', 'fake_iid_2']))
m2 = next((m for m in singlepc.machines_pending()
if m.instance_id == 'fake_iid_2'))
self.assertEqual(m2.constraints, {'cpu': 8})
def test_load_error_mismatch_charm_name(self):
"""Should safely ignore (and log) a charm name in a placement file
that can't be matched to a loaded charm class."""
singlepc = PlacementController(None, self.conf)
fake_assignments = {
'fake_iid': {
'constraints': {},
'assignments': {
'KVM': ['non-existent']
}
},
'fake_iid_2': {
'constraints': {
'cpu': 8
},
'assignments': {
'BareMetal': ['nova-compute']
}
}
}
with TemporaryFile(mode='w+', encoding='utf-8') as tempf:
yaml.dump(fake_assignments, tempf)
tempf.seek(0)
singlepc.load(tempf)
self.assertEqual(
set([m.instance_id for m in singlepc.machines_pending()]),
set(['fake_iid_2']))
m2 = next((m for m in singlepc.machines_pending()
if m.instance_id == 'fake_iid_2'))
self.assertEqual(m2.constraints, {'cpu': 8})
def test_is_assigned_to_is_deployed_to(self):
self.assertFalse(
self.pc.is_assigned_to(CharmSwiftProxy, self.mock_machine))
self.assertFalse(
self.pc.is_deployed_to(CharmSwiftProxy, self.mock_machine))
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.assertFalse(
self.pc.is_deployed_to(CharmSwiftProxy, self.mock_machine))
self.assertTrue(
self.pc.is_assigned_to(CharmSwiftProxy, self.mock_machine))
self.pc.mark_deployed(self.mock_machine, CharmSwiftProxy,
AssignmentType.LXC)
self.assertTrue(
self.pc.is_deployed_to(CharmSwiftProxy, self.mock_machine))
self.assertFalse(
self.pc.is_assigned_to(CharmSwiftProxy, self.mock_machine))
def test_double_clear_ok(self):
"""clearing assignments for a machine that isn't assigned (anymore) is
OK and should do nothing
"""
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.pc.clear_assignments(self.mock_machine)
self.pc.clear_assignments(self.mock_machine)
self.pc.clear_assignments(self.mock_machine_2)
def test_gen_defaults_raises_with_no_maas_state(self):
pc = PlacementController(None, self.conf)
self.assertRaises(PlacementError, pc.gen_defaults)
def test_gen_defaults_uses_only_ready(self):
"""gen_defaults should only use ready machines"""
mock_maas_state = MagicMock()
mock_maas_state.machines.return_value = []
c = Config()
c.setopt('storage_backend', 'none')
pc = PlacementController(config=c, maas_state=mock_maas_state)
# reset the mock to avoid looking at calls from
# PlacementController.__init__().
mock_maas_state.reset_mock()
pc.gen_defaults()
# we simply check the first call because we know that
# follow-on calls are from calls to get_assignments and do
# not affect machines used for defaults
self.assertEqual(mock_maas_state.machines.mock_calls[0],
call(MaasMachineStatus.READY))
def test_gen_single_backends(self):
"gen_single has no storage backend by default"
def find_charm(cn, defs):
allcharms = []
for mname, ad in defs.items():
for atype, charmclasses in ad.items():
allcharms += charmclasses
return cn in allcharms
c = Config()
pc = PlacementController(config=c)
# default storage_backend is 'none'
c.setopt('storage_backend', 'none')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'swift')
defaults = pc.gen_single()
self.assertTrue(find_charm(CharmSwiftProxy, defaults))
self.assertTrue(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'ceph')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertTrue(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
class LandscapeInstallFinalTestCase(unittest.TestCase):
def setUp(self):
self.mock_multi_installer = MagicMock()
self.mock_display_controller = MagicMock()
self.loop = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config({}, tempf.name)
def make_installer_with_config(self,
landscape_creds=None,
maas_creds=None):
if landscape_creds is None:
landscape_creds = dict(admin_name="fakeadminname",
admin_email="*****@*****.**",
system_email="*****@*****.**",
maas_server='fake.host',
maas_apikey='fake:keyz:yo')
self.conf.setopt('maascreds',
dict(api_host='fake.host', api_key='fake:keyz:yo'))
self.conf.setopt('landscapecreds', landscape_creds)
pm_binpath = PropertyMock(return_value='mockbinpath')
type(self.conf).bin_path = pm_binpath
pm_cfgpath = PropertyMock(return_value='mockcfgpath')
type(self.conf).cfg_path = pm_cfgpath
lif = LandscapeInstallFinal(self.mock_multi_installer,
self.mock_display_controller, self.conf,
self.loop)
self.installer = lif
def test_run_configure_not_sudo_user(self, mock_utils):
"""Do not sudo -u $SUDO_USER when running landscape-configure, it will
be 'root'.
"""
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {
'status': '',
'output': ''
}
self.installer.run_configure_script()
mock_utils.get_command_output.assert_called_with(ANY, timeout=None)
def test_run_configure_quotes_config_values(self, mock_utils):
cd = dict(admin_name="fake admin name with spaces",
admin_email="[email protected]",
system_email="[email protected]")
self.make_installer_with_config(landscape_creds=cd)
mock_utils.get_command_output.return_value = {
'status': '',
'output': ''
}
self.installer.run_configure_script()
expectedcmdstr = ("mockbinpath/configure-landscape "
"--admin-email '{}' "
"--admin-name '{}' "
"--system-email '{}' "
"--maas-host fake.host".format(
cd['admin_email'], cd['admin_name'],
cd['system_email']))
mock_utils.get_command_output.assert_called_with(expectedcmdstr,
timeout=None)
def test_run_configure_raises_on_error(self, mock_utils):
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {
'status': 1,
'output': 'failure'
}
self.assertRaises(Exception, self.installer.run_configure_script)
def test_run_deployer_raises_on_error(self, mock_utils):
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {
'status': 1,
'output': 'failure'
}
self.assertRaises(Exception, self.installer.run_deployer)
def test_run_deployer_has_no_timeout(self, mock_utils):
self.make_installer_with_config()
mock_utils.get_command_output.return_value = {
'status': '',
'output': 'failure'
}
self.installer.run_deployer()
mock_utils.get_command_output.assert_called_with(ANY,
timeout=None,
user_sudo=ANY)
class ServiceWidgetTestCase(unittest.TestCase):
def setUp(self):
self.mock_maas_state = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
self.conf = Config({}, tempf.name)
self.conf.setopt('storage_backend', 'none')
self.pc = PlacementController(self.mock_maas_state, self.conf)
self.mock_machine = make_fake_machine('machine1')
self.mock_machine_2 = make_fake_machine('machine2')
self.mock_machines = [self.mock_machine, self.mock_machine_2]
self.mock_maas_state.machines.return_value = self.mock_machines
def test_required_label_shown(self):
"""Widget showing a required charm should have a label showing how
many units are required"""
w = ServiceWidget(CharmKeystone, self.pc)
self.assertTrue(search_in_widget("0 of 1 placed", w))
def test_required_label_not_shown(self):
"""Widget showing a non-required charm should NOT have a label showing
how many units are required.
"""
w = ServiceWidget(CharmJujuGui, self.pc)
self.assertFalse(search_in_widget(".* of .* placed", w))
def test_show_placements(self):
"""Widget with show_placements set should show placements"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_placements=True)
self.assertTrue(search_in_widget("LXC.*machine1-hostname", w))
def test_dont_show_placements(self):
"""Widget with show_placements set to FALSE should NOT show
placements"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_placements=False)
self.assertFalse(search_in_widget("LXC.*machine1-hostname", w))
def test_show_constraints(self):
"""Widget with show_constraints set should show constraints"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_constraints=True)
conpat = ("constraints.*" +
".*".join(CharmNovaCompute.constraints.keys()))
self.assertTrue(search_in_widget(conpat, w))
def test_dont_show_constraints(self):
"""Widget with show_constraints set to FALSE should NOT show
constraints"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
w = ServiceWidget(CharmNovaCompute, self.pc, show_constraints=False)
self.assertFalse(search_in_widget("constraints", w))
def test_show_actions(self):
"""Actions should be shown as buttons"""
fake_action_func = MagicMock()
actions = [("fake-action", fake_action_func)]
w = ServiceWidget(CharmNovaCompute, self.pc, actions=actions)
self.assertTrue(search_in_widget("fake-action", w))
def test_actions_use_pred(self):
"""Action predicates control whether a button appears (disabled)"""
# NOTE: this test assumes that disabled buttons are just the
# button label with parentheses.
fake_action_func = MagicMock()
fake_pred = MagicMock()
fake_pred.return_value = False
actions = [(fake_pred, "fake-action", fake_action_func)]
w = ServiceWidget(CharmNovaCompute, self.pc, actions=actions)
self.assertTrue(search_in_widget("\(.*fake-action.*\)", w))
fake_pred.assert_called_with(CharmNovaCompute)
fake_pred.return_value = True
fake_pred.reset_mock()
w.update()
self.assertTrue(search_in_widget("<.*fake-action.*>", w))
fake_pred.assert_called_with(CharmNovaCompute)
class EventLoopCoreTestCase(unittest.TestCase):
def setUp(self):
self.conf = Config({})
self.mock_ui = MagicMock(name='ui')
self.mock_log = MagicMock(name='log')
self.mock_loop = MagicMock(name='loop')
def make_ev(self, headless=False):
self.conf.setopt('headless', headless)
return EventLoop(self.mock_ui, self.conf,
self.mock_log)
def test_validate_loop(self):
""" Validate eventloop runs """
self.conf.setopt('headless', False)
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=self.mock_loop)
dc.initialize = MagicMock()
dc.start()
self.mock_loop.run.assert_called_once_with()
def test_validate_redraw_screen_commit_placement(self):
""" Validate redraw_screen on commit_placement """
self.conf.setopt('headless', False)
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=self.mock_loop)
dc.initialize = MagicMock()
dc.commit_placement()
self.mock_loop.redraw_screen.assert_called_once_with()
def test_validate_redraw_screen_enqueue(self):
""" Validate redraw_screen on enqueue_deployed_charms """
self.conf.setopt('headless', False)
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=self.mock_loop)
dc.initialize = MagicMock()
dc.enqueue_deployed_charms()
self.mock_loop.redraw_screen.assert_called_once_with()
def test_validate_set_alarm_in(self):
""" Validate set_alarm_in called with eventloop """
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=self.mock_loop)
dc.initialize = MagicMock()
self.conf.node_install_wait_interval = 1
dc.update(self.conf.node_install_wait_interval, ANY)
self.mock_loop.set_alarm_in.assert_called_once_with(1, ANY)
def test_validate_exit(self):
""" Validate error code set with eventloop """
ev = self.make_ev()
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=ev)
dc.initialize = MagicMock()
with self.assertRaises(urwid.ExitMainLoop):
dc.loop.exit(1)
self.assertEqual(ev.error_code, 1)
def test_hotkey_exit(self):
ev = self.make_ev()
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=ev)
dc.initialize = MagicMock()
with self.assertRaises(urwid.ExitMainLoop):
dc.loop.header_hotkeys('q')
self.assertEqual(ev.error_code, 0)
def test_repr_ev(self):
""" Prints appropriate class string for eventloop """
ev = self.make_ev()
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=ev)
dc.initialize = MagicMock()
self.assertEqual(str(ev), '<eventloop urwid based on select()>')
def test_repr_no_ev(self):
""" Prints appropriate class string for no eventloop """
ev = self.make_ev(True)
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=ev)
dc.initialize = MagicMock()
self.assertEqual(str(ev), '<eventloop disabled>')
def test_validate_exit_no_ev(self):
""" Validate SystemExit with no eventloop """
ev = self.make_ev(True)
dc = Controller(
ui=self.mock_ui, config=self.conf,
loop=ev)
dc.initialize = MagicMock()
with self.assertRaises(SystemExit) as cm:
dc.loop.exit(1)
exc = cm.exception
self.assertEqual(ev.error_code, exc.code, "Found loop")
class EventLoopCoreTestCase(unittest.TestCase):
def setUp(self):
self.conf = Config({}, save_backups=False)
self.mock_ui = MagicMock(name='ui')
self.mock_log = MagicMock(name='log')
self.mock_loop = MagicMock(name='loop')
def make_ev(self, headless=False):
self.conf.setopt('headless', headless)
return EventLoop(self.mock_ui, self.conf, self.mock_log)
def test_validate_loop(self):
""" Validate eventloop runs """
self.conf.setopt('headless', False)
self.conf.setopt('openstack_release', 'kilo')
dc = Controller(ui=self.mock_ui, config=self.conf, loop=self.mock_loop)
dc.initialize = MagicMock()
dc.start()
self.mock_loop.run.assert_called_once_with()
def test_validate_redraw_screen_commit_placement(self):
""" Validate redraw_screen on commit_placement """
self.conf.setopt('headless', False)
dc = Controller(ui=self.mock_ui, config=self.conf, loop=self.mock_loop)
dc.initialize = MagicMock()
dc.commit_placement()
self.mock_loop.redraw_screen.assert_called_once_with()
def test_validate_redraw_screen_enqueue(self):
""" Validate redraw_screen on enqueue_deployed_charms """
self.conf.setopt('headless', False)
dc = Controller(ui=self.mock_ui, config=self.conf, loop=self.mock_loop)
dc.initialize = MagicMock()
dc.enqueue_deployed_charms()
self.mock_loop.redraw_screen.assert_called_once_with()
def test_validate_set_alarm_in(self):
""" Validate set_alarm_in called with eventloop """
dc = Controller(ui=self.mock_ui, config=self.conf, loop=self.mock_loop)
dc.initialize = MagicMock()
self.conf.node_install_wait_interval = 1
dc.update(self.conf.node_install_wait_interval, ANY)
self.mock_loop.set_alarm_in.assert_called_once_with(1, ANY)
def test_validate_exit(self):
""" Validate error code set with eventloop """
ev = self.make_ev()
dc = Controller(ui=self.mock_ui, config=self.conf, loop=ev)
dc.initialize = MagicMock()
with self.assertRaises(urwid.ExitMainLoop):
dc.loop.exit(1)
self.assertEqual(ev.error_code, 1)
def test_hotkey_exit(self):
ev = self.make_ev()
dc = Controller(ui=self.mock_ui, config=self.conf, loop=ev)
dc.initialize = MagicMock()
with self.assertRaises(urwid.ExitMainLoop):
dc.loop.header_hotkeys('q')
self.assertEqual(ev.error_code, 0)
def test_repr_ev(self):
""" Prints appropriate class string for eventloop """
ev = self.make_ev()
dc = Controller(ui=self.mock_ui, config=self.conf, loop=ev)
dc.initialize = MagicMock()
self.assertEqual(str(ev), '<eventloop urwid based on tornado()>')
def test_repr_no_ev(self):
""" Prints appropriate class string for no eventloop """
ev = self.make_ev(True)
dc = Controller(ui=self.mock_ui, config=self.conf, loop=ev)
dc.initialize = MagicMock()
self.assertEqual(str(ev), '<eventloop disabled>')
def test_validate_exit_no_ev(self):
""" Validate SystemExit with no eventloop """
ev = self.make_ev(True)
dc = Controller(ui=self.mock_ui, config=self.conf, loop=ev)
dc.initialize = MagicMock()
with self.assertRaises(SystemExit) as cm:
dc.loop.exit(1)
exc = cm.exception
self.assertEqual(ev.error_code, exc.code, "Found loop")
class PlacementControllerTestCase(unittest.TestCase):
def setUp(self):
self.mock_maas_state = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
self.conf = Config({}, tempf.name)
self.conf.setopt('storage_backend', 'none')
self.pc = PlacementController(self.mock_maas_state,
self.conf)
self.mock_machine = MagicMock(name='machine1')
pmid = PropertyMock(return_value='fake-instance-id-1')
type(self.mock_machine).instance_id = pmid
self.mock_machine_2 = MagicMock(name='machine2')
pmid2 = PropertyMock(return_value='fake-instance-id-2')
type(self.mock_machine_2).instance_id = pmid2
self.mock_machines = [self.mock_machine, self.mock_machine_2]
self.mock_maas_state.machines.return_value = self.mock_machines
def test_get_assignments_atype(self):
self.assertEqual(0,
len(self.pc.get_assignments(CharmNovaCompute)))
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
md = self.pc.get_assignments(CharmNovaCompute)
self.assertEqual(1, len(md))
self.assertEqual(2, len(md[AssignmentType.LXC]))
def _do_test_simple_assign_type(self, assignment_type):
self.pc.assign(self.mock_machine, CharmNovaCompute, assignment_type)
print("assignments is {}".format(self.pc.assignments))
machines = self.pc.get_assignments(CharmNovaCompute)
print('machines for charm is {}'.format(machines))
self.assertEqual(machines,
{assignment_type: [self.mock_machine]})
ma = self.pc.assignments_for_machine(self.mock_machine)
self.assertEqual(ma[assignment_type], [CharmNovaCompute])
def test_simple_assign_bare(self):
self._do_test_simple_assign_type(AssignmentType.BareMetal)
def test_simple_assign_lxc(self):
self._do_test_simple_assign_type(AssignmentType.LXC)
def test_simple_assign_kvm(self):
self._do_test_simple_assign_type(AssignmentType.KVM)
def test_assign_nonmulti(self):
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.LXC)
self.assertEqual(self.pc.get_assignments(CharmKeystone),
{AssignmentType.LXC: [self.mock_machine]})
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.KVM)
self.assertEqual(self.pc.get_assignments(CharmKeystone),
{AssignmentType.KVM: [self.mock_machine]})
am = self.pc.assignments_for_machine(self.mock_machine)
self.assertEqual(am[AssignmentType.KVM], [CharmKeystone])
self.assertEqual(am[AssignmentType.LXC], [])
def test_assign_multi(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.assertEqual(self.pc.get_assignments(CharmNovaCompute),
{AssignmentType.LXC: [self.mock_machine]})
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.assertEqual(self.pc.get_assignments(CharmNovaCompute),
{AssignmentType.LXC: [self.mock_machine],
AssignmentType.KVM: [self.mock_machine]})
ma = self.pc.assignments_for_machine(self.mock_machine)
self.assertEqual(ma[AssignmentType.LXC], [CharmNovaCompute])
self.assertEqual(ma[AssignmentType.KVM], [CharmNovaCompute])
def test_remove_assignment_multi(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmNovaCompute,
AssignmentType.LXC)
mfc = self.pc.get_assignments(CharmNovaCompute)
mfc_lxc = set(mfc[AssignmentType.LXC])
self.assertEqual(mfc_lxc, set(self.mock_machines))
self.pc.clear_assignments(self.mock_machine)
self.assertEqual(self.pc.get_assignments(CharmNovaCompute),
{AssignmentType.LXC: [self.mock_machine_2]})
def test_gen_defaults(self):
satisfies_importstring = 'cloudinstall.placement.controller.satisfies'
with patch(satisfies_importstring) as mock_satisfies:
mock_satisfies.return_value = (True, )
defs = self.pc.gen_defaults(charm_classes=[CharmNovaCompute,
CharmKeystone],
maas_machines=[self.mock_machine,
self.mock_machine_2])
m1_as = defs[self.mock_machine.instance_id]
m2_as = defs[self.mock_machine_2.instance_id]
self.assertEqual(m1_as[AssignmentType.BareMetal],
[CharmNovaCompute])
self.assertEqual(m1_as[AssignmentType.LXC], [])
self.assertEqual(m1_as[AssignmentType.KVM], [])
self.assertEqual(m2_as[AssignmentType.BareMetal], [])
self.assertEqual(m2_as[AssignmentType.LXC], [CharmKeystone])
self.assertEqual(m2_as[AssignmentType.KVM], [])
def test_remove_one_assignment_sametype(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
self.assertEqual(lxcs, [CharmNovaCompute])
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
self.assertEqual(lxcs, [])
def test_remove_one_assignment_othertype(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
kvms = md[AssignmentType.KVM]
self.assertEqual(1, len(lxcs) + len(kvms))
self.pc.remove_one_assignment(self.mock_machine, CharmNovaCompute)
md = self.pc.assignments[self.mock_machine.instance_id]
lxcs = md[AssignmentType.LXC]
kvms = md[AssignmentType.KVM]
self.assertEqual(0, len(lxcs) + len(kvms))
def test_clear_all(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2,
CharmNovaCompute, AssignmentType.KVM)
self.pc.clear_all_assignments()
# check that it's empty:
self.assertEqual(self.pc.assignments, {})
# and that it's still a defaultdict(lambda: defaultdict(list))
mid = self.mock_machine.machine_id
lxcs = self.pc.assignments[mid][AssignmentType.LXC]
self.assertEqual(lxcs, [])
def test_unassigned_starts_full(self):
self.assertEqual(len(self.pc.unassigned_undeployed_services()),
len(self.pc.charm_classes()))
def test_assigned_charm_classes_starts_empty(self):
self.assertEqual(0, len(self.pc.assigned_charm_classes()))
def test_reset_unassigned_undeployed_none(self):
"""Assign all charms, ensure that unassigned is empty"""
for cc in self.pc.charm_classes():
self.pc.assign(self.mock_machine, cc, AssignmentType.LXC)
self.pc.reset_assigned_deployed()
self.assertEqual(0, len(self.pc.unassigned_undeployed_services()))
def test_reset_unassigned_undeployed_two(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmKeystone, AssignmentType.KVM)
self.pc.reset_assigned_deployed()
self.assertEqual(len(self.pc.charm_classes()) - 2,
len(self.pc.unassigned_undeployed_services()))
def test_reset_excepting_compute(self):
for cc in self.pc.charm_classes():
if cc.charm_name == 'nova-compute':
continue
self.pc.assign(self.mock_machine, cc, AssignmentType.LXC)
self.pc.reset_assigned_deployed()
self.assertEqual(len(self.pc.unassigned_undeployed_services()), 1)
def test_unassigned_undeployed(self):
all_charms = set(self.pc.charm_classes())
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.KVM)
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.pc.mark_deployed(self.mock_machine, CharmKeystone,
AssignmentType.KVM)
self.assertTrue(CharmKeystone not in
self.pc.unassigned_undeployed_services())
self.assertTrue(CharmNovaCompute not in
self.pc.unassigned_undeployed_services())
self.assertTrue(self.pc.is_deployed(CharmKeystone))
self.assertTrue(self.pc.is_assigned(CharmNovaCompute))
self.assertTrue(len(all_charms) - 2,
len(self.pc.unassigned_undeployed_services()))
n_k_as = self.pc.assignment_machine_count_for_charm(CharmKeystone)
self.assertEqual(n_k_as, 0)
n_k_dl = self.pc.deployment_machine_count_for_charm(CharmKeystone)
self.assertEqual(n_k_dl, 1)
n_nc_as = self.pc.assignment_machine_count_for_charm(CharmNovaCompute)
self.assertEqual(n_nc_as, 1)
n_nc_dl = self.pc.deployment_machine_count_for_charm(CharmNovaCompute)
self.assertEqual(n_nc_dl, 0)
def test_deployed_charms_starts_empty(self):
"Initially there are no deployed charms"
self.assertEqual(0, len(self.pc.deployed_charm_classes()))
def test_mark_deployed_unsets_assignment(self):
"Setting a placement to deployed removes it from assignment dict"
self.pc.assign(self.mock_machine, CharmKeystone, AssignmentType.KVM)
self.assertEqual([CharmKeystone], self.pc.assigned_charm_classes())
self.pc.mark_deployed(self.mock_machine, CharmKeystone,
AssignmentType.KVM)
self.assertEqual([CharmKeystone], self.pc.deployed_charm_classes())
self.assertEqual([], self.pc.assigned_charm_classes())
def test_set_deployed_unsets_assignment_only_once(self):
"Setting a placement to deployed removes it from assignment dict"
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.KVM)
self.pc.assign(self.mock_machine_2, CharmNovaCompute,
AssignmentType.KVM)
self.assertEqual([CharmNovaCompute], self.pc.assigned_charm_classes())
ad = self.pc.get_assignments(CharmNovaCompute)
dd = self.pc.get_deployments(CharmNovaCompute)
from pprint import pformat
print("Assignments is {}".format(pformat(ad)))
print("Deployments is {}".format(pformat(dd)))
self.assertEqual(set([self.mock_machine, self.mock_machine_2]),
set(ad[AssignmentType.KVM]))
self.assertEqual(len(dd.items()), 0)
self.pc.mark_deployed(self.mock_machine, CharmNovaCompute,
AssignmentType.KVM)
self.assertEqual([CharmNovaCompute], self.pc.deployed_charm_classes())
self.assertEqual([CharmNovaCompute], self.pc.assigned_charm_classes())
ad = self.pc.get_assignments(CharmNovaCompute)
dd = self.pc.get_deployments(CharmNovaCompute)
self.assertEqual([self.mock_machine_2], ad[AssignmentType.KVM])
self.assertEqual([self.mock_machine], dd[AssignmentType.KVM])
def test_get_charm_state(self):
"Test a sampling of required services and special handling for compute"
self.assertEqual(self.pc.get_charm_state(CharmKeystone)[0],
CharmState.REQUIRED)
self.assertEqual(self.pc.get_charm_state(CharmNovaCompute)[0],
CharmState.REQUIRED)
def test_one_compute_required(self):
"""after being assigned at least once, novacompute is no longer
considered 'required' (aka required)"""
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.assertNotEqual(self.pc.get_charm_state(CharmNovaCompute)[0],
CharmState.REQUIRED)
def test_swift_unrequired_then_required_default(self):
"Swift and swift-proxy are both optional until you add swift"
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwift, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_swift_unrequired_then_required_swift_backend(self):
"Swift and swift-proxy are not optional with swift as the backend."
self.conf.setopt('storage_backend', 'swift')
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwift, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_swift_proxy_unrequired_then_required_default(self):
"Swift and swift-proxy are both optional until you add swift-proxy"
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
# Only one swift-proxy is required, so now that we've added
# it, it is still not required:
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_swift_proxy_unrequired_then_required_swift_backend(self):
"Swift and swift-proxy are not optional with swift as the backend"
self.conf.setopt('storage_backend', 'swift')
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.assertEqual(CharmState.REQUIRED,
self.pc.get_charm_state(CharmSwift)[0])
# Only one swift-proxy is required, so now that we've added
# it, it is still not required:
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_storage_backends_in_is_required(self):
# default is 'none'
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCeph)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCephOSD)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
self.conf.setopt('storage_backend', 'swift')
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCeph)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCephOSD)[0])
self.assertEqual(CharmState.CONFLICTED,
self.pc.get_charm_state(CharmCephRadosGw)[0])
st = self.pc.get_charm_state(CharmSwift)
swift_state, swift_cons, swift_deps = st
self.assertEqual(CharmState.REQUIRED, swift_state)
st = self.pc.get_charm_state(CharmSwiftProxy)
swp_state, swp_cons, swp_deps = st
self.assertEqual(CharmState.REQUIRED, swp_state)
self.assertEqual([], swp_cons)
ceph_state, ceph_cons, ceph_deps = self.pc.get_charm_state(CharmCeph)
self.assertEqual(CharmState.OPTIONAL, ceph_state)
st = self.pc.get_charm_state(CharmCephRadosGw)
ceph_rg_state, ceph_rg_cons, ceph_rg_deps = st
self.assertEqual(CharmState.CONFLICTED, ceph_rg_state)
self.conf.setopt('storage_backend', 'ceph')
ceph_state, ceph_cons, ceph_deps = self.pc.get_charm_state(CharmCeph)
self.assertEqual(CharmState.REQUIRED, ceph_state)
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmCephOSD)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwift)[0])
self.assertEqual(CharmState.OPTIONAL,
self.pc.get_charm_state(CharmSwiftProxy)[0])
def test_ceph_num_required(self):
"3 units of ceph should be required after having been assigned"
state, cons, deps = self.pc.get_charm_state(CharmCeph)
self.assertEqual(state, CharmState.OPTIONAL)
self.pc.assign(self.mock_machine, CharmCeph, AssignmentType.KVM)
self.assertEqual(self.pc.get_charm_state(CharmCeph)[0],
CharmState.REQUIRED)
self.pc.assign(self.mock_machine, CharmCeph, AssignmentType.KVM)
self.pc.assign(self.mock_machine, CharmCeph, AssignmentType.KVM)
self.assertEqual(self.pc.get_charm_state(CharmCeph)[0],
CharmState.OPTIONAL)
def test_persistence(self):
self.pc.assign(self.mock_machine, CharmNovaCompute, AssignmentType.LXC)
self.pc.assign(self.mock_machine_2, CharmKeystone, AssignmentType.KVM)
cons1 = PropertyMock(return_value={})
type(self.mock_machine).constraints = cons1
cons2 = PropertyMock(return_value={'cpu': 8})
type(self.mock_machine_2).constraints = cons2
with TemporaryFile(mode='w+', encoding='utf-8') as tempf:
self.pc.save(tempf)
tempf.seek(0)
print(tempf.read())
tempf.seek(0)
newpc = PlacementController(
self.mock_maas_state, self.conf)
newpc.load(tempf)
self.assertEqual(self.pc.assignments, newpc.assignments)
self.assertEqual(self.pc.machines_pending(), newpc.machines_pending())
self.assertEqual(self.pc.assigned_charm_classes(),
newpc.assigned_charm_classes())
m2 = next((m for m in newpc.machines_pending()
if m.instance_id == 'fake-instance-id-2'))
self.assertEqual(m2.constraints, {'cpu': 8})
def test_load_machines_single(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
conf = Config({}, tempf.name)
fake_assignments = {
'fake_iid': {'constraints': {},
'assignments': {'KVM':
['nova-compute']}},
'fake_iid_2': {'constraints': {'cpu': 8},
'assignments':
{'BareMetal': ['nova-compute']}}}
singlepc = PlacementController(
None, conf)
with TemporaryFile(mode='w+', encoding='utf-8') as tempf:
yaml.dump(fake_assignments, tempf)
tempf.seek(0)
singlepc.load(tempf)
self.assertEqual(set([m.instance_id for m in
singlepc.machines_pending()]),
set(['fake_iid', 'fake_iid_2']))
m2 = next((m for m in singlepc.machines_pending()
if m.instance_id == 'fake_iid_2'))
self.assertEqual(m2.constraints, {'cpu': 8})
def test_load_error_mismatch_charm_name(self):
"""Should safely ignore (and log) a charm name in a placement file
that can't be matched to a loaded charm class."""
singlepc = PlacementController(None, self.conf)
fake_assignments = {
'fake_iid': {
'constraints': {},
'assignments': {'KVM':
['non-existent']}},
'fake_iid_2': {
'constraints': {'cpu': 8},
'assignments':
{'BareMetal': ['nova-compute']}}}
with TemporaryFile(mode='w+', encoding='utf-8') as tempf:
yaml.dump(fake_assignments, tempf)
tempf.seek(0)
singlepc.load(tempf)
self.assertEqual(set([m.instance_id for m in
singlepc.machines_pending()]),
set(['fake_iid_2']))
m2 = next((m for m in singlepc.machines_pending()
if m.instance_id == 'fake_iid_2'))
self.assertEqual(m2.constraints, {'cpu': 8})
def test_is_assigned_to_is_deployed_to(self):
self.assertFalse(self.pc.is_assigned_to(CharmSwiftProxy,
self.mock_machine))
self.assertFalse(self.pc.is_deployed_to(CharmSwiftProxy,
self.mock_machine))
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.assertFalse(self.pc.is_deployed_to(CharmSwiftProxy,
self.mock_machine))
self.assertTrue(self.pc.is_assigned_to(CharmSwiftProxy,
self.mock_machine))
self.pc.mark_deployed(self.mock_machine, CharmSwiftProxy,
AssignmentType.LXC)
self.assertTrue(self.pc.is_deployed_to(CharmSwiftProxy,
self.mock_machine))
self.assertFalse(self.pc.is_assigned_to(CharmSwiftProxy,
self.mock_machine))
def test_double_clear_ok(self):
"""clearing assignments for a machine that isn't assigned (anymore) is
OK and should do nothing
"""
self.pc.assign(self.mock_machine, CharmSwiftProxy, AssignmentType.LXC)
self.pc.clear_assignments(self.mock_machine)
self.pc.clear_assignments(self.mock_machine)
self.pc.clear_assignments(self.mock_machine_2)
def test_gen_defaults_raises_with_no_maas_state(self):
pc = PlacementController(None, self.conf)
self.assertRaises(PlacementError, pc.gen_defaults)
def test_gen_defaults_uses_only_ready(self):
"""gen_defaults should only use ready machines"""
mock_maas_state = MagicMock()
mock_maas_state.machines.return_value = []
c = Config()
c.setopt('storage_backend', 'none')
pc = PlacementController(config=c, maas_state=mock_maas_state)
# reset the mock to avoid looking at calls from
# PlacementController.__init__().
mock_maas_state.reset_mock()
pc.gen_defaults()
# we simply check the first call because we know that
# follow-on calls are from calls to get_assignments and do
# not affect machines used for defaults
self.assertEqual(mock_maas_state.machines.mock_calls[0],
call(MaasMachineStatus.READY))
def test_gen_single_backends(self):
"gen_single has no storage backend by default"
def find_charm(cn, defs):
allcharms = []
for mname, ad in defs.items():
for atype, charmclasses in ad.items():
allcharms += charmclasses
return cn in allcharms
c = Config()
pc = PlacementController(config=c)
# default storage_backend is 'none'
c.setopt('storage_backend', 'none')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'swift')
defaults = pc.gen_single()
self.assertTrue(find_charm(CharmSwiftProxy, defaults))
self.assertTrue(find_charm(CharmSwift, defaults))
self.assertFalse(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
c.setopt('storage_backend', 'ceph')
defaults = pc.gen_single()
self.assertFalse(find_charm(CharmSwiftProxy, defaults))
self.assertFalse(find_charm(CharmSwift, defaults))
self.assertTrue(find_charm(CharmCeph, defaults))
self.assertFalse(find_charm(CharmCephOSD, defaults))
class TestGoodConfig(unittest.TestCase):
def setUp(self):
self._temp_conf = Config(GOOD_CONFIG)
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config(self._temp_conf._config, tempf.name)
def test_save_openstack_password(self):
""" Save openstack password to config """
self.conf.setopt('openstack_password', 'pass')
self.conf.save()
self.assertEqual('pass', self.conf.getopt('openstack_password'))
def test_save_maas_creds(self):
""" Save maas credentials """
self.conf.setopt('maascreds', dict(api_host='127.0.0.1',
api_key='1234567'))
self.conf.save()
self.assertEqual(
'127.0.0.1', self.conf.getopt('maascreds')['api_host'])
def test_save_landscape_creds(self):
""" Save landscape credentials """
self.conf.setopt('landscapecreds',
dict(admin_name='foo',
admin_email='*****@*****.**',
system_email='*****@*****.**',
maas_server='127.0.0.1',
maas_apikey='123457'))
self.conf.save()
self.assertEqual(
'*****@*****.**', self.conf.getopt('landscapecreds')['admin_email'])
def test_save_installer_type(self):
""" Save installer type """
self.conf.setopt("install_type", 'multi')
self.conf.save()
self.assertEqual('multi', self.conf.getopt('install_type'))
@unittest.skip
def test_cfg_path(self):
""" Validate current users config path """
self.assertEqual(
self.conf.cfg_path, path.join(USER_DIR, '.cloud-install'))
def test_bin_path(self):
""" Validate additional tools bin path """
self.assertEqual(self.conf.bin_path, '/usr/share/openstack/bin')
@unittest.skip
def test_juju_environments_path(self):
""" Validate juju environments path in user dir """
self.assertEqual(
self.conf.juju_environments_path,
path.join(
USER_DIR, '.cloud-install/juju/environments.yaml'))
def test_clear_empty_args(self):
""" Empty cli options are not populated
in generated config
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(parse_opts(['--config', cfg_file]))
self.assertEqual(True, 'http-proxy' not in cfg)
def test_config_file_persists(self):
""" CLI options override options in config file
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(
parse_opts(['--config', cfg_file,
'--headless']))
self.assertEqual(True, cfg['headless'])
def test_config_file_persists_new_cli_opts(self):
""" Generated config object appends new options
passed via cli
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(
parse_opts(['--config', cfg_file,
'--install-only',
'--killcloud-noprompt']))
self.assertEqual(True, cfg['install_only'])
self.assertEqual(True, cfg['killcloud_noprompt'])
def test_config_overrides_from_cli(self):
""" Config object item is not overridden
by unset cli option
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(
parse_opts(['--http-proxy',
'http://localhost:2222',
'--killcloud-noprompt',
'--config', cfg_file]))
self.assertEqual(cfg['https_proxy'], GOOD_CONFIG['https_proxy'])
def test_default_opts_not_override_config(self):
""" Verify that default cli opts that are False
do not override their config_option whose option
is True.
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg_opts_raw = parse_opts(['--config', cfg_file])
cfg_opts_raw = vars(cfg_opts_raw)
self.assertEqual(True, 'headless' not in cfg_opts_raw)
cfg = utils.populate_config(parse_opts(['--config', cfg_file]))
self.assertEqual(True, cfg['headless'])
def test_default_opts_no_config(self):
""" Verify that default cli opts are sanitized
and that no options set to False or None exist
in the config object
"""
cfg = utils.populate_config(parse_opts([]))
print(cfg)
self.assertEqual(True, 'headless' not in cfg)
class TestGoodConfig(unittest.TestCase):
def setUp(self):
self._temp_conf = Config(GOOD_CONFIG)
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.conf = Config(self._temp_conf._config, tempf.name)
def test_save_openstack_password(self):
""" Save openstack password to config """
self.conf.setopt('openstack_password', 'pass')
self.conf.save()
self.assertEqual('pass', self.conf.getopt('openstack_password'))
def test_save_maas_creds(self):
""" Save maas credentials """
self.conf.setopt('maascreds',
dict(api_host='127.0.0.1', api_key='1234567'))
self.conf.save()
self.assertEqual('127.0.0.1',
self.conf.getopt('maascreds')['api_host'])
def test_save_landscape_creds(self):
""" Save landscape credentials """
self.conf.setopt(
'landscapecreds',
dict(admin_name='foo',
admin_email='*****@*****.**',
system_email='*****@*****.**',
maas_server='127.0.0.1',
maas_apikey='123457'))
self.conf.save()
self.assertEqual('*****@*****.**',
self.conf.getopt('landscapecreds')['admin_email'])
def test_save_installer_type(self):
""" Save installer type """
self.conf.setopt("install_type", 'multi')
self.conf.save()
self.assertEqual('multi', self.conf.getopt('install_type'))
def test_cfg_path(self):
""" Validate current users config path """
self.assertEqual(self.conf.cfg_path,
path.join(USER_DIR, '.cloud-install'))
def test_bin_path(self):
""" Validate additional tools bin path """
self.assertEqual(self.conf.bin_path, '/usr/share/openstack/bin')
def test_juju_environments_path(self):
""" Validate juju environments path in user dir """
self.assertEqual(
self.conf.juju_environments_path,
path.join(USER_DIR, '.cloud-install/juju/environments.yaml'))
def test_clear_empty_args(self):
""" Empty cli options are not populated
in generated config
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(parse_opts(['--config', cfg_file]))
self.assertEqual(True, 'http-proxy' not in cfg)
def test_config_file_persists(self):
""" CLI options override options in config file
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(
parse_opts(['--config', cfg_file, '--headless']))
self.assertEqual(True, cfg['headless'])
def test_config_file_persists_new_cli_opts(self):
""" Generated config object appends new options
passed via cli
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(
parse_opts([
'--config', cfg_file, '--install-only', '--killcloud-noprompt'
]))
self.assertEqual(True, cfg['install_only'])
self.assertEqual(True, cfg['killcloud_noprompt'])
def test_config_overrides_from_cli(self):
""" Config object item is not overridden
by unset cli option
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg = utils.populate_config(
parse_opts([
'--http-proxy', 'http://localhost:2222',
'--killcloud-noprompt', '--config', cfg_file
]))
self.assertEqual(cfg['https_proxy'], GOOD_CONFIG['https_proxy'])
def test_default_opts_not_override_config(self):
""" Verify that default cli opts that are False
do not override their config_option whose option
is True.
"""
cfg_file = path.join(DATA_DIR, 'good_config.yaml')
cfg_opts_raw = parse_opts(['--config', cfg_file])
cfg_opts_raw = vars(cfg_opts_raw)
self.assertEqual(True, 'headless' not in cfg_opts_raw)
cfg = utils.populate_config(parse_opts(['--config', cfg_file]))
self.assertEqual(True, cfg['headless'])
def test_default_opts_no_config(self):
""" Verify that default cli opts are sanitized
and that no options set to False or None exist
in the config object
"""
cfg = utils.populate_config(parse_opts([]))
print(cfg)
self.assertEqual(True, 'headless' not in cfg)
class TestRenderCharmConfig(unittest.TestCase):
def setUp(self):
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
# Override config file to save to
self.config = Config({}, tempf.name)
type(self.config).cfg_path = PropertyMock(return_value='fake_cfg_path')
self.config.setopt('openstack_password', 'fake_pw')
self.ltp = patch('cloudinstall.utils.load_template')
self.mock_load_template = self.ltp.start()
self.mock_load_template.side_effect = source_tree_template_loader
def tearDown(self):
self.ltp.stop()
def _do_test_osrel(self, optsvalue, expected, mockspew):
"check that opts.openstack_release is rendered correctly"
self.config.setopt('openstack_release', optsvalue)
render_charm_config(self.config)
(fake_path, generated_yaml), kwargs = mockspew.call_args
d = yaml.load(generated_yaml)
print(d)
for oscharmname in [
'nova-cloud-controller', 'glance', 'openstack-dashboard',
'keystone', 'swift-proxy'
]:
if expected is None:
self.assertTrue(oscharmname not in d
or 'openstack-origin' not in d[oscharmname])
else:
self.assertEqual(d[oscharmname]['openstack-origin'], expected)
def test_render_openstack_release_given(self, mockspew):
self._do_test_osrel('klaxon', 'cloud:trusty-klaxon', mockspew)
def _do_test_multiplier(self, is_single, mockspew, expected=None):
if is_single:
self.config.setopt('install_type', 'Single')
else:
self.config.setopt('install_type', 'Multi')
self.config.setopt('openstack_release', 'klaxon')
render_charm_config(self.config)
(fake_path, generated_yaml), kwargs = mockspew.call_args
d = yaml.load(generated_yaml)
wmul = d['nova-cloud-controller'].get('worker-multiplier', None)
self.assertEqual(wmul, expected)
wmul = d['glance'].get('worker-multiplier', None)
self.assertEqual(wmul, expected)
wmul = d['keystone'].get('worker-multiplier', None)
self.assertEqual(wmul, expected)
def test_render_worker_multiplier_multi(self, mockspew):
self._do_test_multiplier(False, mockspew)
def test_render_worker_multiplier_single(self, mockspew):
self._do_test_multiplier(True, mockspew, expected=1)
def test_charmconfig_custom_merge(self, mockspew):
""" Verify rightmost custom charm config dictionary
does not overwrite untouched items in rendered
charmconfig
"""
charm_custom = {
'swift-proxy': {
'replicas': 15
},
'mysql': {
'dataset-size': '2048M'
}
}
charm_conf = yaml.load(slurp(os.path.join(DATA_DIR, 'charmconf.yaml')))
merged_dicts = merge_dicts(charm_conf, charm_custom)
self.assertEqual(merged_dicts['mysql']['max-connections'], 25000)
self.assertEqual(merged_dicts['swift-proxy']['zone-assignment'],
'auto')
class ServicesListTestCase(unittest.TestCase):
def setUp(self):
self.mock_maas_state = MagicMock()
with NamedTemporaryFile(mode='w+', encoding='utf-8') as tempf:
utils.spew(tempf.name, yaml.dump(dict()))
self.conf = Config({}, tempf.name)
self.conf.setopt('storage_backend', 'none')
self.pc = PlacementController(self.mock_maas_state, self.conf)
self.mock_machine = make_fake_machine('machine1', {'cpu_count': 3})
self.mock_machine2 = make_fake_machine('machine2')
self.mock_machine3 = make_fake_machine('machine3')
self.mock_machines = [self.mock_machine]
self.mock_maas_state.machines.return_value = self.mock_machines
self.actions = []
self.sub_actions = []
def test_widgets_config(self, mock_servicewidgetclass):
for show_constraints in [False, True]:
sl = ServicesList(self.pc,
self.actions,
self.sub_actions,
show_constraints=show_constraints)
mock_servicewidgetclass.assert_any_call(
CharmNovaCompute,
self.pc,
self.actions,
show_constraints,
show_placements=sl.show_placements)
mock_servicewidgetclass.reset_mock()
def test_no_machine_no_constraints(self, mock_servicewidgetclass):
with patch.object(self.pc, 'charm_classes') as mock_classesfunc:
fc = MagicMock(name='fakeclass1')
fc.required_num_units.return_value = 1
fc.constraints = {'cpu_count': 1000}
mock_classesfunc.return_value = [fc]
sl = ServicesList(self.pc, self.actions, self.sub_actions)
self.assertEqual(len(sl.service_widgets), 1)
def test_machine_checks_constraints(self, mock_servicewidgetclass):
mock_machine = make_fake_machine('fm', {
'cpu_count': 0,
'storage': 0,
'memory': 0
})
sl = ServicesList(self.pc,
self.actions,
self.sub_actions,
machine=mock_machine)
self.assertEqual(len(sl.service_widgets), 0)
def test_do_not_show_assigned(self, mock_servicewidgetclass):
mock_machine = make_fake_machine('fm', {
'cpu_count': 0,
'storage': 0,
'memory': 0
})
self.pc.assign(mock_machine, CharmNovaCompute, AssignmentType.LXC)
sl = ServicesList(self.pc,
self.actions,
self.sub_actions,
machine=mock_machine)
classes = [sw.charm_class for sw in sl.service_widgets]
self.assertTrue(CharmNovaCompute not in classes)
def test_show_type(self, mock_servicewidgetclass):
"""Test combinations of show_type values.
This tests three values of show_type with three return values
for is_required(): all required, no required, and 1/3
required. It's all lumped in one test to consolidate setup.
"""
mock_sw1 = MagicMock(name='sw1')
mock_sw1.charm_class.charm_name = 'cc1'
mock_sw2 = MagicMock(name='sw2')
mock_sw2.charm_class.charm_name = 'cc2'
mock_sw3 = MagicMock(name='sw3')
mock_sw3.charm_class.charm_name = 'cc3'
mock_servicewidgetclass.side_effect = [mock_sw1, mock_sw2, mock_sw3]
with patch.object(self.pc, 'get_charm_state') as mock_get_state:
with patch.object(self.pc, 'charm_classes') as mock_classesfunc:
mock_classesfunc.return_value = [
MagicMock(name='fake-class-1', charm_name='cc1'),
MagicMock(name='fake-class-2', charm_name='cc2'),
MagicMock(name='fake-class-3', charm_name='cc3')
]
# First, test when all charms are required
mock_get_state.return_value = (CharmState.REQUIRED, [], [])
# rsl shows required charms
rsl = ServicesList(self.pc,
self.actions,
self.sub_actions,
machine=None,
show_type='required')
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show all 3
self.assertEqual(len(rsl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
# usl shows ONLY un-required charms
usl = ServicesList(self.pc,
self.actions,
self.sub_actions,
machine=None,
show_type='non-required')
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show 0
self.assertEqual(len(usl.service_widgets), 0)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
# asl has default show_type='all', showing all charms
asl = ServicesList(self.pc, self.actions, self.sub_actions)
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show all 3
self.assertEqual(len(asl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
# next, test where no charms are required
mock_get_state.return_value = (CharmState.OPTIONAL, [], [])
rsl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show 0 charms
self.assertEqual(len(rsl.service_widgets), 0)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
usl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show all 3
self.assertEqual(len(usl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
asl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should still show all 3
self.assertEqual(len(asl.service_widgets), 3)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
# next test two un-required and one required charm:
mock_get_state.side_effect = [(CharmState.OPTIONAL, [], []),
(CharmState.REQUIRED, [], []),
(CharmState.OPTIONAL, [], [])]
rsl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show 1:
self.assertEqual(len(rsl.service_widgets), 1)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
mock_get_state.side_effect = [(CharmState.OPTIONAL, [], []),
(CharmState.REQUIRED, [], []),
(CharmState.OPTIONAL, [], [])]
usl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should show two
self.assertEqual(len(usl.service_widgets), 2)
mock_get_state.reset_mock()
mock_servicewidgetclass.reset_mock()
mock_servicewidgetclass.side_effect = [
mock_sw1, mock_sw2, mock_sw3
]
mock_get_state.side_effect = [(CharmState.OPTIONAL, [], []),
(CharmState.REQUIRED, [], []),
(CharmState.OPTIONAL, [], [])]
asl.update()
self.assertEqual(len(mock_get_state.mock_calls), 3)
# should still show all three
self.assertEqual(len(asl.service_widgets), 3)