def test_config_changed(self):
self.hooks.cmd = mock_cmd()
self.hooks.hook_config_changed()
# Check calls of cmd done by rsync
assert_equal(len(py_subprocess.cmd.call_args_list), 2)
assert_equal(py_subprocess.cmd.call_args_list[0][0],
([u'rsync', u'-a', u'-r', u'../../charms/oscied-orchestra/ssh/', os.path.expanduser(u'~/.ssh/')],))
assert_equal(py_subprocess.cmd.call_args_list[0][1]['fail'], True)
assert_equal(py_subprocess.cmd.call_args_list[1][0],
([u'rsync', u'-a', u'-r', u'juju', os.path.expanduser(u'~/.juju/')],))
assert_equal(py_subprocess.cmd.call_args_list[1][1]['fail'], True)
# Check calls of cmd done by OrchestraHooks
assert_equal(self.hooks.cmd.call_args_list, [
call(u'service mongodb start', fail=False),
call(u'service rabbitmq-server start', fail=False),
call(u'a2dissite default'),
call(u'a2ensite oscied-orchestra-0'),
call(u'mongo f.js'),
call(u'mongo orchestra f.js'),
call(u'mongo celery g.js'),
call(u'rabbitmqctl delete_user guest', fail=False),
call(u'rabbitmqctl delete_vhost /', fail=False),
call(u'rabbitmqctl add_user node "Alice_in_wonderland"', fail=False),
call(u'rabbitmqctl add_vhost celery', fail=False),
call(u'rabbitmqctl set_permissions -p celery node ".*" ".*" ".*"', fail=False)])
def assert_len(client, mapper, expected):
client.do_request = mock_cmd()
try:
len(mapper)
except:
pass
assert_equal(client.do_request.call_args_list, expected)
def test_storage_remount_storage_config(self):
self.hooks, system_hosts = self.create_hooks(CharmHooks_Storage_tmp, CONFIG_STORAGE)
self.hooks.cmd = mock_cmd()
py_unittest.MOCK_SIDE_EFFECT_RETURNS = [False, False, True, True]
self.hooks.storage_remount()
assert_equal(self.hooks.cmd.call_args_list,
[call([u'mount', u'-t', u'glusterfs', u'home.ch:/medias_volume_0', u'/mnt/storage'])])
assert_equal(system_hosts, open(self.hooks.local_config.hosts_file, u'r', u'utf-8').readlines())
def test_volume_set_allowed_ips_raise(self):
self.hooks.config.allowed_ips = u"192.168.1.*,10.10.*"
self.hooks.local_config.allowed_ips = [u"129.194.185.47"]
self.hooks.volume_do = mock_cmd(
u"\nVolume Name: medias_volume_14\nType: Distribute\nStatus: Started\nNumber of Bricks: 1\n"
"Transport-type: tcp\nBricks:\nBrick1: ip-10-36-122-169.ec2.internal:/mnt/bricks/exp14\n"
"Options Reconfigured:\nauth.allow: 192.168.1.*\n"
)
self.hooks.volume_set_allowed_ips()
def test_storage_remount_do_not_re_re_mount(self):
self.hooks, system_hosts = self.create_hooks(CharmHooks_Storage_tmp, CONFIG_DEFAULT)
self.hooks.cmd = mock_cmd()
py_unittest.MOCK_SIDE_EFFECT_RETURNS = [False, False, True, True]
self.hooks.storage_remount(address=u'home.ch', fstype=u'glusterfs', mountpoint=u'my_vol_0')
py_unittest.MOCK_SIDE_EFFECT_RETURNS = [Exception(u'oups')]
self.hooks.storage_remount(address=u'home.ch', fstype=u'glusterfs', mountpoint=u'my_vol_0')
self.hooks.storage_remount(address=u'home.ch', fstype=u'glusterfs', mountpoint=u'my_vol_0')
assert_equal(self.hooks.cmd.call_args_list,
[call([u'mount', u'-t', u'glusterfs', u'home.ch:/my_vol_0', u'/mnt/storage'])])
assert_equal(system_hosts, open(self.hooks.local_config.hosts_file, u'r', u'utf-8').readlines())
def test_cmd(self):
cmd_log = mock_cmd()
cmd([u'echo', u'it seem to work'], log=cmd_log)
assert_equal(cmd(u'cat missing_file', fail=False, log=cmd_log)[u'returncode'], 1)
validate_list(cmd_log.call_args_list, [
r"call\(u*\"Execute \[u*'echo', u*'it seem to work'\]\"\)",
r"call\(u*'Execute cat missing_file'\)"])
assert(cmd(u'my.funny.missing.script.sh', fail=False)[u'stderr'] != u'')
result = cmd(u'cat {0}'.format(__file__))
# There are at least 30 lines in this source file !
assert(len(result[u'stdout'].splitlines()) > 30)
def test_ensure_num_units(self):
import pytoolbox.subprocess
old_cmd = pytoolbox.subprocess.cmd
cmd = pytoolbox.subprocess.cmd = mock_cmd()
try: # Ensure that juju_do uses mock'ed cmd()
del sys.modules['pytoolbox.juju']
except:
pass
import pytoolbox.juju
from pytoolbox.juju import PENDING, STARTED, ERROR
TEST_UNITS_SQL_5 = {
0: {'agent-state': STARTED},
1: {'agent-state': PENDING},
2: {'agent-state': ERROR},
3: {},
4: {'agent-state': ERROR}
}
environment = pytoolbox.juju.Environment('maas', release='raring', auto=True)
environment.get_units = Mock(return_value=None)
environment.get_unit = Mock(return_value=None)
environment.__dict__.update(DEFAULT)
self.dict_equal(
environment.ensure_num_units('mysql', 'my_mysql', num_units=2), {'deploy_units': None})
self.dict_equal(
environment.ensure_num_units('lamp', None, num_units=4), {'deploy_units': None})
with self.raises(ValueError):
environment.ensure_num_units(None, 'salut')
environment.get_units = Mock(return_value=TEST_UNITS_SQL_2)
self.dict_equal(
environment.ensure_num_units('mysql', 'my_mysql', num_units=5), {'add_units': None})
environment.get_units = Mock(return_value=TEST_UNITS_LAMP_4)
self.dict_equal(
environment.ensure_num_units(None, 'lamp', num_units=5), {'add_units': None})
environment.get_units = Mock(return_value=TEST_UNITS_SQL_5)
environment.get_unit = Mock(return_value={})
environment.ensure_num_units('mysql', 'my_mysql', num_units=1, units_number_to_keep=[1])
environment.get_units = Mock(return_value=TEST_UNITS_LAMP_5)
print(environment.ensure_num_units('mysql', 'my_mysql', num_units=None))
[call_args[1].pop('env') for call_args in cmd.call_args_list]
eq = self.equal
a = cmd.call_args_list
self.equal(len(a), 9)
kwargs = {'fail': False, 'log': None}
eq(a[0], call(DEPLOY + [N, 2] + CFG + [R, '.', 'local:raring/mysql', 'my_mysql'], **kwargs))
eq(a[1], call(DEPLOY + [N, 4] + CFG + [R, '.', 'local:raring/lamp', 'lamp'], **kwargs))
eq(a[2], call(ADD_UNIT + [N, 3] + ['my_mysql'], **kwargs))
eq(a[3], call(ADD_UNIT + [N, 1] + ['lamp'], **kwargs))
eq(a[4], call(DESTROY_UNIT + ['my_mysql/2'], **kwargs))
eq(a[5], call(DESTROY_UNIT + ['my_mysql/3'], **kwargs))
eq(a[6], call(DESTROY_UNIT + ['my_mysql/4'], **kwargs))
eq(a[7], call(DESTROY_UNIT + ['my_mysql/0'], **kwargs))
eq(a[8], call(DESTROY_SERVICE + ['my_mysql'], **kwargs))
pytoolbox.subprocess.cmd = old_cmd
def test_ensure_num_units(self):
import pytoolbox.subprocess
old_cmd = pytoolbox.subprocess.cmd
cmd = pytoolbox.subprocess.cmd = mock_cmd()
try: # Ensure that juju_do uses mock'ed cmd()
del sys.modules['pytoolbox.juju']
except:
pass
import pytoolbox.juju
from pytoolbox.juju import PENDING, STARTED, ERROR
TEST_UNITS_SQL_5 = {
0: {'agent-state': STARTED}, 1: {'agent-state': PENDING}, 2: {'agent-state': ERROR}, 3: {},
4: {'agent-state': ERROR}
}
environment = pytoolbox.juju.Environment('maas', release='raring', auto=True)
environment.get_units = Mock(return_value=None)
environment.get_unit = Mock(return_value=None)
environment.__dict__.update(DEFAULT)
self.assertDictEqual(environment.ensure_num_units('mysql', 'my_mysql', num_units=2), {'deploy_units': None})
self.assertDictEqual(environment.ensure_num_units('lamp', None, num_units=4), {'deploy_units': None})
with self.assertRaises(ValueError):
environment.ensure_num_units(None, 'salut')
environment.get_units = Mock(return_value=TEST_UNITS_SQL_2)
self.assertDictEqual(environment.ensure_num_units('mysql', 'my_mysql', num_units=5), {'add_units': None})
environment.get_units = Mock(return_value=TEST_UNITS_LAMP_4)
self.assertDictEqual(environment.ensure_num_units(None, 'lamp', num_units=5), {'add_units': None})
environment.get_units = Mock(return_value=TEST_UNITS_SQL_5)
environment.get_unit = Mock(return_value={})
environment.ensure_num_units('mysql', 'my_mysql', num_units=1, units_number_to_keep=[1])
environment.get_units = Mock(return_value=TEST_UNITS_LAMP_5)
print(environment.ensure_num_units('mysql', 'my_mysql', num_units=None))
[call_args[1].pop('env') for call_args in cmd.call_args_list]
eq = self.assertEqual
a = cmd.call_args_list
self.assertEqual(len(a), 9)
eq(a[0], call(DEPLOY + [N, 2] + CFG + [R, '.', 'local:raring/mysql', 'my_mysql'], fail=False, log=None))
eq(a[1], call(DEPLOY + [N, 4] + CFG + [R, '.', 'local:raring/lamp', 'lamp'], fail=False, log=None))
eq(a[2], call(ADD_UNIT + [N, 3] + ['my_mysql'], fail=False, log=None))
eq(a[3], call(ADD_UNIT + [N, 1] + ['lamp'], fail=False, log=None))
eq(a[4], call(DESTROY_UNIT + ['my_mysql/2'], fail=False, log=None))
eq(a[5], call(DESTROY_UNIT + ['my_mysql/3'], fail=False, log=None))
eq(a[6], call(DESTROY_UNIT + ['my_mysql/4'], fail=False, log=None))
eq(a[7], call(DESTROY_UNIT + ['my_mysql/0'], fail=False, log=None))
eq(a[8], call(DESTROY_SERVICE + ['my_mysql'], fail=False, log=None))
pytoolbox.subprocess.cmd = old_cmd
def test_volume_infos(self):
self.hooks.volume_do = mock_cmd(
u"\nVolume Name: medias_volume_14\nType: Distribute\nStatus: Started\nNumber of Bricks: 1\n"
"Transport-type: tcp\nBricks:\nBrick1: ip-10-36-122-169.ec2.internal:/mnt/bricks/exp14\n"
"Options Reconfigured:\nauth.allow: 192.168.0.104\n"
)
infos = self.hooks.volume_infos()
assert_equal(
infos,
{
u"name": u"medias_volume_14",
u"type": u"Distribute",
u"status": u"Started",
u"transport": u"tcp",
u"bricks": [u"ip-10-36-122-169.ec2.internal:/mnt/bricks/exp14"],
u"auth_allow": u"192.168.0.104",
},
)
self.hooks.volume_do.assert_called_with(u"info", volume=None, fail=False)
def test_ensure_num_units(self):
import pytoolbox.subprocess
old_cmd = pytoolbox.subprocess.cmd
cmd = pytoolbox.subprocess.cmd = mock_cmd()
try: # Ensure that juju_do uses mock'ed cmd()
del sys.modules['pytoolbox.juju']
except:
pass
import pytoolbox.juju
from pytoolbox.juju import PENDING, STARTED, ERROR
TEST_UNITS_SQL_5 = {0: {'agent-state': STARTED}, 1: {'agent-state': PENDING}, 2: {'agent-state': ERROR},
3: {}, 4: {'agent-state': ERROR}}
pytoolbox.juju.get_units = Mock(return_value=None)
pytoolbox.juju.get_unit = Mock(return_value=None)
environment = pytoolbox.juju.Environment(u'maas', release=u'raring', auto=True)
environment.__dict__.update(DEFAULT)
print(environment.ensure_num_units(u'mysql', u'my_mysql', num_units=2))
print(environment.ensure_num_units(u'lamp', None, num_units=4))
assert_raises(ValueError, environment.ensure_num_units, None, u'salut')
pytoolbox.juju.get_units = Mock(return_value=TEST_UNITS_SQL_2)
print(environment.ensure_num_units(u'mysql', u'my_mysql', num_units=5))
pytoolbox.juju.get_units = Mock(return_value=TEST_UNITS_LAMP_4)
print(environment.ensure_num_units(None, u'lamp', num_units=5))
pytoolbox.juju.get_units = Mock(return_value=TEST_UNITS_SQL_5)
print(environment.ensure_num_units(u'mysql', u'my_mysql', num_units=1, units_number_to_keep=[1]))
pytoolbox.juju.get_units = Mock(return_value=TEST_UNITS_LAMP_5)
print(environment.ensure_num_units(u'mysql', u'my_mysql', num_units=None))
[call_args[1].pop(u'env') for call_args in cmd.call_args_list]
a_eq = assert_equal
a = cmd.call_args_list
#assert_equal(len(a), 8)
a_eq(a[0], call(DEPLOY + [N, 2] + CFG + [R, u'.', u'local:raring/mysql', u'my_mysql'], fail=False, log=None))
a_eq(a[1], call(DEPLOY + [N, 4] + CFG + [R, u'.', u'local:raring/lamp', u'lamp'], fail=False, log=None))
a_eq(a[2], call(ADD_UNIT + [N, 3] + [u'my_mysql'], fail=False, log=None))
a_eq(a[3], call(ADD_UNIT + [N, 1] + [u'lamp'], fail=False, log=None))
a_eq(a[4], call(DESTROY_UNIT + [u'my_mysql/2'], fail=False, log=None))
a_eq(a[5], call(DESTROY_UNIT + [u'my_mysql/3'], fail=False, log=None))
a_eq(a[6], call(DESTROY_UNIT + [u'my_mysql/4'], fail=False, log=None))
a_eq(a[7], call(DESTROY_UNIT + [u'my_mysql/0'], fail=False, log=None))
a_eq(a[8], call(DESTROY_SERVICE + [u'my_mysql'], fail=False, log=None))
pytoolbox.subprocess.cmd = old_cmd
def test_volume_set_allowed_ips_ok(self):
self.hooks.config.allowed_ips = u"192.168.1.*,10.10.*"
self.hooks.local_config.allowed_ips = [u"129.194.185.47"]
self.hooks.volume_do = mock_cmd(
u"\nVolume Name: medias_volume_14\nType: Distribute\nStatus: Started\nNumber of Bricks: 1\n"
"Transport-type: tcp\nBricks:\nBrick1: ip-10-36-122-169.ec2.internal:/mnt/bricks/exp14\n"
"Options Reconfigured:\nauth.allow: 10.10.*,129.194.185.47,192.168.1.*\n"
)
self.hooks.volume_set_allowed_ips()
assert_equal(
self.hooks.volume_do.call_args_list,
[
call(
u"set",
fail=False,
volume=u"medias_volume_14",
options=u'auth.allow "10.10.*,129.194.185.47,192.168.1.*"',
),
call(u"info", fail=False, volume=u"medias_volume_14"),
call(u"info", fail=False, volume=u"medias_volume_14"),
],
)
assert_equal(self.hooks.allowed_ips_string, u"10.10.*,129.194.185.47,192.168.1.*")
def test_screen(self):
try:
# Launch some screens
assert_equal(len(screen_launch(u'my_1st_screen', u'top', fail=False)[u'stderr']), 0)
assert_equal(len(screen_launch(u'my_2nd_screen', u'top', fail=False)[u'stderr']), 0)
assert_equal(len(screen_launch(u'my_2nd_screen', u'top', fail=False)[u'stderr']), 0)
# List the launched screen sessions
screens = screen_list(name=u'my_1st_screen')
assert(len(screens) >= 1 and screens[0].endswith(u'my_1st_screen'))
screens = screen_list(name=u'my_2nd_screen')
assert(len(screens) >= 1 and screens[0].endswith(u'my_2nd_screen'))
finally:
# Cleanup
kill_log = mock_cmd()
screen_kill(name=u'my_1st_screen', log=kill_log)
screen_kill(name=u'my_2nd_screen', log=kill_log)
#raise NotImplementedError(kill_log.call_args_list)
validate_list(kill_log.call_args_list, [
r"call\(u*\"Execute \[u*'screen', u*'-ls', u*'my_1st_screen'\]\"\)",
r"call\(u*\"Execute \[u*'screen', u*'-S', u*'\d+\.my_1st_screen', u*'-X', u*'quit'\]\"\)",
r"call\(u*\"Execute \[u*'screen', u*'-ls', u*'my_2nd_screen'\]\"\)",
r"call\(u*\"Execute \[u*'screen', u*'-S', u*'\d+\.my_2nd_screen', u*'-X', u*'quit'\]\"\)",
r"call\(u*\"Execute \[u*'screen', u*'-S', u*'\d+\.my_2nd_screen', u*'-X', u*'quit'\]\"\)"])
def __init__(self, api_url, environment='maas'):
self.api_url = api_url
self.environment = environment
self.do_request = mock_cmd()
def test_storage_remount_no_storage_at_all(self):
self.hooks, system_hosts = self.create_hooks(CharmHooks_Storage, CONFIG_DEFAULT)
self.hooks.cmd = mock_cmd()
self.hooks.storage_remount()
assert_equal(self.hooks.cmd.call_args_list, [])
assert_equal(system_hosts, open(self.hooks.local_config.hosts_file, u'r', u'utf-8').readlines())
class OrchestraHooks_tmp(OrchestraHooks):
def __init__(self, m, c, l, o):
super(OrchestraHooks_tmp, self).__init__(m, c, l, o)
@property
def rabbit_users(self):
return [u'node']
@property
def rabbit_vhosts(self):
return [u'celery']
import pytoolbox.subprocess as py_subprocess
py_subprocess.cmd = mock_cmd()
class TestOrchestraHooks(object):
def setUp(self):
OrchestraLocalConfig().write(u'test.pkl')
self.hooks = OrchestraHooks_tmp(None, CONFIG, u'test.pkl', OS_ENV)
shutil.copy(self.hooks.local_config.hosts_file, 'hosts')
shutil.copy(u'mongodb.conf', u'mongodb_test.conf')
self.hooks.local_config.hosts_file = u'hosts' # Avoid writing to system hosts file !
self.hooks.local_config.celery_config_file = u'celeryconfig.py'
self.hooks.local_config.celery_template_file = os.path.join(
u'../../charms/oscied-orchestra', self.hooks.local_config.celery_template_file)
self.hooks.local_config.site_path = u'.'
self.hooks.local_config.site_template_file = os.path.join(
u'../../charms/oscied-orchestra', self.hooks.local_config.site_template_file)
