def test_add_remove_many_container(self):
client = fake_juju_client()
client.bootstrap()
client.juju('add-machine', ())
with patch.object(client._backend, 'juju',
wraps=client._backend.juju) as juju_mock:
status = client.get_status()
set_hardware(status.status['machines']['0'], root_disk=16384)
perform(AddRemoveManyContainerAction, client, status)
self.assertEqual([
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'add-machine', ('lxd:0')),
backend_call(client, 'remove-machine', ('0/lxd/0', )),
backend_call(client, 'remove-machine', ('0/lxd/1', )),
backend_call(client, 'remove-machine', ('0/lxd/2', )),
backend_call(client, 'remove-machine', ('0/lxd/3', )),
backend_call(client, 'remove-machine', ('0/lxd/4', )),
backend_call(client, 'remove-machine', ('0/lxd/5', )),
backend_call(client, 'remove-machine', ('0/lxd/6', )),
], juju_mock.mock_calls)
def test_generate_step_no_valid(self):
cur_client = fake_juju_client()
cur_client.bootstrap()
actions = FixedOrderActions([('one', self.InvalidAction)])
with self.assertRaisesRegex(NoValidActionsError,
'No valid actions for model.'):
actions.generate_step(cur_client)
def test_generate_step(self):
cur_client = fake_juju_client()
cur_client.bootstrap()
foo_bar = FooBarAction(cur_client)
actions = FixedOrderActions([('one', foo_bar)])
self.assertEqual(actions.generate_step(cur_client), ('one', foo_bar, {
'foo': 'bar'
}))
def client_and_plan():
cur_client = fake_juju_client()
cur_client.bootstrap()
with patch('hammer_time.hammer_time.client_for_existing',
return_value=cur_client,
autospec=True) as cfe_mock:
with temp_dir() as plan_dir:
plan_file = os.path.join(plan_dir, 'asdf.yaml')
yield (cur_client, cfe_mock, plan_file)
def test_generate_parameters_lxd(self):
client = fake_juju_client(
env=JujuData('steve', config={'type': 'lxd'}))
client.bootstrap()
client.juju('add-machine', ())
with self.assertRaisesRegex(InvalidActionError,
'Not supported on LXD provider.'):
AddRemoveManyContainerAction.generate_parameters(
client, client.get_status())
def run_cxt(self, wait_for=False):
client = fake_juju_client()
client.bootstrap()
step = Step(self, client, wait_for=wait_for)
actions = Actions({'step': step})
plan = [{'step': {'bar': 'baz'}}]
with patch('hammer_time.hammer_time.default_actions',
autospec=True,
return_value=actions):
yield client, plan, step
def test_perform_action(self):
client = fake_juju_client()
client.bootstrap()
client.deploy('app1')
parameters = RemoveUnitAction.generate_parameters(
client, client.get_status())
condition = RemoveUnitAction.perform(client, **parameters)
status = client.get_status()
self.assertEqual(set(), {u for u, d in status.iter_units()})
expected = client.make_remove_machine_condition('0')
self.assertEqual(condition, expected)
def test_generate_parameters(self):
client = fake_juju_client()
client.bootstrap()
parameters = KillMongoDAction.generate_parameters(
client, client.get_status())
self.assertEqual(parameters, {'machine_id': '0'})
controller_client = client.get_controller_client()
controller_client.juju('add-machine', ())
controller_client.remove_machine('0')
parameters = KillMongoDAction.generate_parameters(
client, client.get_status())
self.assertEqual(parameters, {'machine_id': '1'})
def test_generate_parameters(self):
client = fake_juju_client()
client.bootstrap()
with self.assertRaises(InvalidActionError):
parameters = MachineAction.generate_parameters(
client, client.get_status())
client.juju('add-machine', ('-n', '2'))
client.remove_machine('0')
parameters = MachineAction.generate_parameters(client,
client.get_status())
self.assertEqual(parameters, {'machine_id': '1'})
def test_choose_machine(self):
chosen = {}
client = fake_juju_client()
client.bootstrap()
client.juju('add-machine', ('-n', '2'))
status = client.get_status()
for x in range(50):
machine_id, data = choose_machine(status)
chosen[machine_id] = data
if set(chosen) == {'0', '1'}:
break
else:
raise AssertionError('Did not choose each machine.')
def test_perform(self):
client = fake_juju_client()
client.bootstrap()
client.juju('add-machine', ())
with patch.object(client._backend, 'juju',
wraps=client._backend.juju) as juju_mock:
with patch.object(RunAvailable,
'iter_blocking_state',
return_value=iter([])):
perform(KillJujuDAction, client)
self.assertEqual([
backend_call(client, 'ssh', ('0', ) + KillJujuDAction.kill_script),
], juju_mock.mock_calls)
def test_generate_parameters_container_max_10(self):
client = fake_juju_client(
env=JujuData('steve', config={
'type': 'not-lxd',
'region': 'asdf'
}))
client.bootstrap()
client.juju('add-machine', ())
status = client.get_status()
set_hardware(status.status['machines']['0'], root_disk=2048)
with self.assertRaisesRegex(InvalidActionError,
'No space for containers.'):
AddRemoveManyContainerAction.generate_parameters(client, status)
def test_perform_action(self):
client = fake_juju_client()
client.bootstrap()
client.deploy('app1')
parameters = AddUnitAction.generate_parameters(client,
client.get_status())
AddUnitAction.perform(client, **parameters)
status = client.get_status()
self.assertEqual(
{'app1/0', 'app1/1'},
{u
for u, d in status.iter_units()},
)
def test_add_remove_many_machine(self):
client = fake_juju_client()
client.bootstrap()
with patch.object(client._backend, 'juju',
wraps=client._backend.juju) as juju_mock:
AddRemoveManyMachineAction.perform(client)
self.assertEqual([
backend_call(client, 'add-machine', ('-n', '5')),
backend_call(client, 'remove-machine', ('0', )),
backend_call(client, 'remove-machine', ('1', )),
backend_call(client, 'remove-machine', ('2', )),
backend_call(client, 'remove-machine', ('3', )),
backend_call(client, 'remove-machine', ('4', )),
], juju_mock.mock_calls)
def test_iter_blocking_state(self):
client = fake_juju_client()
ra = RunAvailable(client, '0')
with patch.object(client._backend, 'juju',
return_value=1) as juju_mock:
self.assertEqual([('0', 'cannot-run')],
list(ra.iter_blocking_state(None)))
juju_mock.return_value = 0
self.assertEqual([], list(ra.iter_blocking_state(None)))
self.assertEqual([
backend_call(client,
'run',
('--machine', '0', 'exit 0', '--timeout', '20s'),
check=False)
] * 2, juju_mock.mock_calls)
def test_generate_parameters_container_max_10(self):
client = fake_juju_client(
env=JujuData('steve', config={
'type': 'not-lxd',
'region': 'asdf'
}))
client.bootstrap()
client.juju('add-machine', ())
status = client.get_status()
set_hardware(status.status['machines']['0'], root_disk=32768)
params = AddRemoveManyContainerAction.generate_parameters(
client, status)
self.assertEqual({
'machine_id': '0',
'container_count': 10,
}, params)
def test_generate_parameters(self):
client = fake_juju_client()
client.bootstrap()
with self.assertRaisesRegex(InvalidActionError,
'No units to choose from.'):
RemoveUnitAction.generate_parameters(client, client.get_status())
client.deploy('app1')
client.deploy('app2')
parameter_variations = set()
for count in range(50):
parameter_variations.add(
tuple(
RemoveUnitAction.generate_parameters(
client, client.get_status()).items()))
if parameter_variations == {
(('unit', 'app1/0'), ),
(('unit', 'app2/0'), ),
}:
break
else:
raise AssertionError(
'One of the expected units was never selected.')
def test_perform(self):
client = fake_juju_client()
client.bootstrap()
client.juju('add-machine', ())
up_status = Status(
{
'machines': {
'0': {
'juju-status': {
'current': 'started'
},
'series': 'angsty',
}
}
}, '')
down_status = Status(
{
'machines': {
'0': {
'juju-status': {
'current': 'down'
},
'series': 'angsty',
}
}
}, '')
with patch.object(client._backend, 'juju',
wraps=client._backend.juju) as juju_mock:
with patch.object(client,
'get_status',
side_effect=[up_status, up_status, down_status]):
perform(InterruptNetworkAction, client)
self.assertEqual([
backend_call(
client, 'run',
('--machine', '0', InterruptNetworkAction.get_command())),
], juju_mock.mock_calls)
def test_perform(self):
client = fake_juju_client()
client.bootstrap()
client.juju('add-machine', ())
parameters = RebootMachineAction.generate_parameters(
client, client.get_status())
with patch.object(client._backend, 'juju',
wraps=client._backend.juju) as juju_mock:
with patch.object(client._backend,
'get_juju_output',
autospec=True,
side_effect=['earlier', 'now']) as jo_mock:
RebootMachineAction.perform(client, **parameters)
self.assertEqual([
backend_call(client,
'run', ('--machine', '0', 'sudo', 'reboot'),
check=False),
], juju_mock.mock_calls)
expected_call = call('run', ('--machine', '0', 'uptime -s'),
client.used_feature_flags,
client.env.juju_home,
client._cmd_model(True, False),
user_name='admin')
self.assertEqual([expected_call, expected_call], jo_mock.mock_calls)
def test_no_machines(self):
client = fake_juju_client()
client.bootstrap()
status = client.get_status()
with self.assertRaises(InvalidActionError):
choose_machine(status)
