def test_disabled(self):
'''
Test to ensure an Apache conf is disabled.
'''
name = 'saltstack.com'
ret = {'name': name,
'result': None,
'changes': {},
'comment': ''}
mock = MagicMock(side_effect=[True, True, False])
mock_str = MagicMock(return_value={'Status': ['disabled']})
with patch.dict(apache_conf.__salt__,
{'apache.check_conf_enabled': mock,
'apache.a2disconf': mock_str}):
comt = ('Apache conf {0} is set to be disabled.'.format(name))
ret.update({'comment': comt, 'changes': {'new': None, 'old': name}})
with patch.dict(apache_conf.__opts__, {'test': True}):
self.assertDictEqual(apache_conf.disabled(name), ret)
comt = ('Failed to disable {0} Apache conf'.format(name))
ret.update({'comment': comt, 'result': False,
'changes': {}})
with patch.dict(apache_conf.__opts__, {'test': False}):
self.assertDictEqual(apache_conf.disabled(name), ret)
comt = ('{0} already disabled.'.format(name))
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(apache_conf.disabled(name), ret)
def test_flush(self):
'''
Test to flush current iptables state
'''
ret = {'name': 'salt',
'changes': {},
'result': None,
'comment': ''}
mock = MagicMock(return_value=[])
with patch.object(iptables, '_STATE_INTERNAL_KEYWORDS', mock):
with patch.dict(iptables.__opts__, {'test': True}):
ret.update({'comment': 'iptables rules in salt table filter'
' chain ipv4 family needs to be flushed'})
self.assertDictEqual(iptables.flush('salt'), ret)
with patch.dict(iptables.__opts__, {'test': False}):
mock = MagicMock(side_effect=[False, True])
with patch.dict(iptables.__salt__,
{'iptables.flush': mock}):
ret.update({'changes': {'locale': 'salt'},
'comment': 'Flush iptables rules in'
' table chain ipv4 family',
'result': True})
self.assertDictEqual(iptables.flush('salt',
table='', chain=''),
ret)
ret.update({'changes': {},
'comment': 'Failed to flush iptables rules',
'result': False})
self.assertDictEqual(iptables.flush('salt',
table='', chain=''),
ret)
def test_atq_list(self, salt_modules_at__cmd_mock):
'''
Tests the list all queued and running jobs.
'''
salt_modules_at__cmd_mock.return_value = '101\tThu Dec 11 \
19:48:47 2014 A B'
with patch.dict(at.__grains__, {'os_family': '', 'os': ''}):
self.assertDictEqual(at.atq(), {'jobs': [{'date': '2014-12-11',
'job': 101,
'queue': 'A',
'tag': '',
'time': '19:48:00',
'user': '******'}]})
salt_modules_at__cmd_mock.return_value = '101\t2014-12-11 \
19:48:47 A B'
with patch.dict(at.__grains__, {'os_family': 'RedHat', 'os': ''}):
self.assertDictEqual(at.atq(), {'jobs': [{'date': '2014-12-11',
'job': 101,
'queue': 'A',
'tag': '',
'time': '19:48:47',
'user': '******'}]})
salt_modules_at__cmd_mock.return_value = 'SALT: Dec 11, \
2014 19:48 A 101 B'
with patch.dict(at.__grains__, {'os_family': '', 'os': 'OpenBSD'}):
self.assertDictEqual(at.atq(), {'jobs': [{'date': '2014-12-11',
'job': '101',
'queue': 'B',
'tag': '',
'time': '19:48:00',
'user': '******'}]})
def test_absent(self):
'''
Test to remove a entry or entries from a chain
'''
name = 'salt'
entry = ['192.168.0.3', '192.168.1.3']
ret = {'name': name,
'result': False,
'comment': '',
'changes': {}}
mock = MagicMock(side_effect=[True, False, False])
with patch.dict(ipset.__salt__, {'ipset.check': mock}):
comt = ('ipset entry must be specified')
ret.update({'comment': comt})
self.assertDictEqual(ipset.absent(name), ret)
with patch.dict(ipset.__opts__, {'test': True}):
comt = ('ipset entry 192.168.0.3 needs to removed '
'from set salt for family ipv4\n')
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(ipset.absent(name, entry, set_name='salt'),
ret)
comt = ('ipset entry for 192.168.0.3 not present in set (salt) for '
'ipv4\nipset entry for 192.168.1.3 not present in set '
'(salt) for ipv4\n')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(ipset.absent(name, entry, set_name='salt'),
ret)
def test_omits(self):
with patch.dict(config.DEFAULTS, DEFAULTS):
with patch.dict(config.__pillar__, __pillar__):
with patch.dict(config.__opts__, __opts__):
opt_name = 'test.option.all'
opt = config.option(opt_name,
omit_opts=False,
omit_master=True,
omit_pillar=True)
self.assertEqual(opt, config.__opts__[opt_name])
opt = config.option(opt_name,
omit_opts=True,
omit_master=True,
omit_pillar=False)
self.assertEqual(opt, config.__pillar__[opt_name])
opt = config.option(opt_name,
omit_opts=True,
omit_master=False,
omit_pillar=True)
self.assertEqual(
opt, config.__pillar__['master'][opt_name])
def test_network(self):
'''
Test to ensure the DRAC network settings are consistent
'''
ip_ = '10.225.108.29'
netmask = '255.255.255.224'
gateway = '10.225.108.1'
ret = {'name': ip_,
'result': None,
'comment': '',
'changes': {}}
net_info = {'IPv4 settings': {'IP Address': ip_, 'Subnet Mask': netmask,
'Gateway': gateway}}
mock_info = MagicMock(return_value=net_info)
mock_bool = MagicMock(side_effect=[True, False])
with patch.dict(drac.__salt__, {'drac.network_info': mock_info,
'drac.set_network': mock_bool}):
with patch.dict(drac.__opts__, {'test': True}):
self.assertDictEqual(drac.network(ip_, netmask, gateway), ret)
with patch.dict(drac.__opts__, {'test': False}):
comt = ('Network is in the desired state')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(drac.network(ip_, netmask, gateway), ret)
comt = ('unable to configure network')
ret.update({'comment': comt, 'result': False})
self.assertDictEqual(drac.network(ip_, netmask, gateway), ret)
def test_joined(self):
'''
Test to ensure the current node joined
to a cluster with node user@host
'''
ret = {'name': 'salt',
'changes': {},
'result': True,
'comment': ''}
mock = MagicMock(side_effect=[['rahulha@salt'], [''], ['']])
with patch.dict(rabbitmq_cluster.__salt__,
{"rabbitmq.cluster_status": mock}):
ret.update({'comment': 'Already in cluster'})
self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt',
'rahulha'), ret)
with patch.dict(rabbitmq_cluster.__opts__, {"test": True}):
ret.update({'result': None,
'comment': 'Node is set to join '
'cluster rahulha@salt'})
self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt',
'rahulha'), ret)
with patch.dict(rabbitmq_cluster.__opts__, {"test": False}):
mock = MagicMock(return_value={'Error': 'ERR'})
with patch.dict(rabbitmq_cluster.__salt__,
{"rabbitmq.join_cluster": mock}):
ret.update({'result': False,
'comment': 'ERR'})
self.assertDictEqual(rabbitmq_cluster.joined('salt',
'salt',
'rahulha'),
ret)
def test_function(self):
'''
Test to execute a single module function on a remote
minion via salt or salt-ssh
'''
name = 'state'
tgt = 'larry'
comt = ('Function state will be executed'
' on target {0} as test=False'.format(tgt))
ret = {'name': name,
'changes': {},
'result': None,
'comment': comt}
with patch.dict(saltmod.__opts__, {'test': True}):
self.assertDictEqual(saltmod.function(name, tgt), ret)
ret.update({'result': True,
'changes': {'out': 'highstate', 'ret': {tgt: ''}},
'comment': 'Function ran successfully.'
' Function state ran on {0}.'.format(tgt)})
with patch.dict(saltmod.__opts__, {'test': False}):
mock_ret = {'larry': {'ret': '', 'retcode': 0, 'failed': False}}
mock_cmd = MagicMock(return_value=mock_ret)
with patch.dict(saltmod.__salt__, {'saltutil.cmd': mock_cmd}):
self.assertDictEqual(saltmod.function(name, tgt), ret)
def test_present(self):
'''
Test to ensure the user exists on the Dell DRAC
'''
name = 'damian'
password = '******'
permission = 'login,test_alerts,clear_logs'
ret = {'name': name,
'result': True,
'comment': '',
'changes': {}}
mock = MagicMock(return_value=[name])
with patch.dict(drac.__salt__, {'drac.list_users': mock}):
with patch.dict(drac.__opts__, {'test': True}):
comt = ('`{0}` already exists'.format(name))
ret.update({'comment': comt})
self.assertDictEqual(drac.present(name, password, permission),
ret)
with patch.dict(drac.__opts__, {'test': False}):
comt = ('`{0}` already exists'.format(name))
ret.update({'comment': comt})
self.assertDictEqual(drac.present(name, password, permission),
ret)
def test_chfullname(self):
'''
Change the user's Full Name
'''
mock = MagicMock(return_value=False)
with patch.object(pw_user, '_get_gecos', mock):
self.assertFalse(pw_user.chfullname('name', 'fullname'))
mock = MagicMock(return_value={'fullname': 'fullname'})
with patch.object(pw_user, '_get_gecos', mock):
self.assertTrue(pw_user.chfullname('name', 'fullname'))
mock = MagicMock(return_value={'fullname': 'fullname'})
with patch.object(pw_user, '_get_gecos', mock):
mock = MagicMock(return_value=None)
with patch.dict(pw_user.__salt__, {'cmd.run': mock}):
mock = MagicMock(return_value={'fullname': 'fullname2'})
with patch.object(pw_user, 'info', mock):
self.assertFalse(pw_user.chfullname('name', 'fullname1'))
mock = MagicMock(return_value={'fullname': 'fullname2'})
with patch.object(pw_user, '_get_gecos', mock):
mock = MagicMock(return_value=None)
with patch.dict(pw_user.__salt__, {'cmd.run': mock}):
mock = MagicMock(return_value={'fullname': 'fullname2'})
with patch.object(pw_user, 'info', mock):
self.assertFalse(pw_user.chfullname('name', 'fullname1'))
def test_chhomephone(self):
'''
Change the user's Home Phone
'''
mock = MagicMock(return_value=False)
with patch.object(pw_user, '_get_gecos', mock):
self.assertFalse(pw_user.chhomephone('name', 1))
mock = MagicMock(return_value={'homephone': '1'})
with patch.object(pw_user, '_get_gecos', mock):
self.assertTrue(pw_user.chhomephone('name', 1))
mock = MagicMock(return_value={'homephone': '2'})
with patch.object(pw_user, '_get_gecos', mock):
mock = MagicMock(return_value=None)
with patch.dict(pw_user.__salt__, {'cmd.run': mock}):
mock = MagicMock(return_value={'homephone': '3'})
with patch.object(pw_user, 'info', mock):
self.assertFalse(pw_user.chhomephone('name', 1))
mock = MagicMock(return_value={'homephone': '3'})
with patch.object(pw_user, '_get_gecos', mock):
mock = MagicMock(return_value=None)
with patch.dict(pw_user.__salt__, {'cmd.run': mock}):
mock = MagicMock(return_value={'homephone': '3'})
with patch.object(pw_user, 'info', mock):
self.assertFalse(pw_user.chhomephone('name', 1))
def test_check_mine_cache_is_refreshed_on_container_change_event(self, _):
'''
Every command that might modify docker containers state.
Should trig an update on ``mine.send``
'''
for command_name, args in (('create', ()),
('rm_', ()),
('kill', ()),
('pause', ()),
('signal_', ('KILL',)),
('start', ()),
('stop', ()),
('unpause', ()),
('_run', ('command',)),
('_script', ('command',)),
):
mine_send = Mock()
command = getattr(dockerng_mod, command_name)
docker_client = MagicMock()
docker_client.api_version = '1.12'
with patch.dict(dockerng_mod.__salt__,
{'mine.send': mine_send,
'container_resource.run': MagicMock(),
'cp.cache_file': MagicMock(return_value=False)}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': docker_client}):
command('container', *args)
mine_send.assert_called_with('dockerng.ps', verbose=True, all=True,
host=True)
def test_absent(self):
'''
Test to ensure that the named extension is absent.
'''
name = 'frank'
ret = {'name': name,
'changes': {},
'result': False,
'comment': ''}
mock_t = MagicMock(side_effect=[True, False])
mock = MagicMock(side_effect=[True, True, True, False])
with patch.dict(postgres_extension.__salt__,
{'postgres.is_installed_extension': mock,
'postgres.drop_extension': mock_t}):
with patch.dict(postgres_extension.__opts__, {'test': True}):
comt = ('Extension {0} is set to be removed'.format(name))
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(postgres_extension.absent(name), ret)
with patch.dict(postgres_extension.__opts__, {'test': False}):
comt = ('Extension {0} has been removed'.format(name))
ret.update({'comment': comt, 'result': True,
'changes': {name: 'Absent'}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = ('Extension {0} failed to be removed'.format(name))
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(postgres_extension.absent(name), ret)
comt = ('Extension {0} is not present, so it cannot be removed'
.format(name))
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(postgres_extension.absent(name), ret)
def test__chkconfig_is_enabled(self):
'''
test _chkconfig_is_enabled function
'''
name = 'atd'
chkconfig_out = textwrap.dedent('''\
{0} 0:off 1:off 2:off 3:on 4:on 5:on 6:off
'''.format(name))
xinetd_out = textwrap.dedent('''\
xinetd based services:
{0} on
'''.format(name))
with patch.object(rh_service, '_runlevel', MagicMock(return_value=3)):
mock_run = MagicMock(return_value={'retcode': 0,
'stdout': chkconfig_out})
with patch.dict(rh_service.__salt__, {'cmd.run_all': mock_run}):
self.assertTrue(rh_service._chkconfig_is_enabled(name))
self.assertFalse(rh_service._chkconfig_is_enabled(name, 2))
self.assertTrue(rh_service._chkconfig_is_enabled(name, 3))
mock_run = MagicMock(return_value={'retcode': 0,
'stdout': xinetd_out})
with patch.dict(rh_service.__salt__, {'cmd.run_all': mock_run}):
self.assertTrue(rh_service._chkconfig_is_enabled(name))
self.assertTrue(rh_service._chkconfig_is_enabled(name, 2))
self.assertTrue(rh_service._chkconfig_is_enabled(name, 3))
def test_create_with_labels_dictlist(self, *args):
'''
Create container with labels dictlist.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.19'
client.create_host_config.return_value = host_config
client.create_container.return_value = {}
with patch.dict(dockerng_mod.__dict__,
{'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.create(
'image',
name='ctn',
labels=[{'KEY1': 'VALUE1'}, {'KEY2': 'VALUE2'}],
validate_input=True,
)
client.create_container.assert_called_once_with(
labels={'KEY1': 'VALUE1', 'KEY2': 'VALUE2'},
host_config=host_config,
image='image',
name='ctn',
)
def test_issue_6030_deprecated_never_download(self):
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}):
virtualenv_mod.create(
'/tmp/foo', never_download=True
)
mock.assert_called_once_with(
'virtualenv --never-download /tmp/foo',
runas=None
)
with TestsLoggingHandler() as handler:
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
# Let's fake a higher virtualenv version
virtualenv_mock = MagicMock()
virtualenv_mock.__version__ = '1.10rc1'
with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}):
with patch.dict('sys.modules',
{'virtualenv': virtualenv_mock}):
virtualenv_mod.create(
'/tmp/foo', never_download=True
)
mock.assert_called_once_with('virtualenv /tmp/foo',
runas=None)
# Are we logging the deprecation information?
self.assertIn(
'INFO:The virtualenv \'--never-download\' option has been '
'deprecated in virtualenv(>=1.10), as such, the '
'\'never_download\' option to `virtualenv.create()` has '
'also been deprecated and it\'s not necessary anymore.',
handler.messages
)
def test_list_absent(self):
'''
Test to delete a value from a grain formed as a list
'''
ret = {'changes': {}, 'name': self.name, 'result': True,
'comment': 'Value edam is absent from grain cheese'}
ret1 = {'changes': {'deleted': self.value}, 'name': self.name,
'result': None,
'comment': 'Value edam in grain cheese is set to be deleted'}
ret2 = {'changes': {}, 'name': self.name, 'result': True,
'comment': 'Grain cheese does not exist'}
ret3 = {'changes': {}, 'name': self.name, 'result': False,
'comment': 'Grain cheese is not a valid list'}
with patch.dict(grains.__grains__, {self.name: ['eves']}):
self.assertDictEqual(grains.list_absent(self.name, self.value), ret)
with patch.dict(grains.__opts__, {'test': True}):
with patch.dict(grains.__grains__, {self.name: [self.value]}):
self.assertDictEqual(grains.list_absent(self.name, self.value),
ret1)
self.assertDictEqual(grains.list_absent(self.name, self.value), ret2)
with patch.dict(grains.__grains__, {self.name: 'eves'}):
self.assertDictEqual(grains.list_absent(self.name, self.value), ret3)
def test_absent(self):
'''
Test to verify that the specified python is not installed with pyenv.
'''
name = 'python-2.7.6'
ret = {'name': name,
'changes': {},
'result': None,
'comment': ''}
with patch.dict(pyenv.__opts__, {'test': True}):
comt = ('python 2.7.6 is set to be uninstalled')
ret.update({'comment': comt})
self.assertDictEqual(pyenv.absent(name), ret)
with patch.dict(pyenv.__opts__, {'test': False}):
mock_f = MagicMock(side_effect=[False, True])
mock_t = MagicMock(return_value=True)
mock_str = MagicMock(return_value='2.7.6')
mock_lst = MagicMock(return_value=['2.7.6'])
with patch.dict(pyenv.__salt__, {'pyenv.is_installed': mock_f,
'pyenv.uninstall_python': mock_t,
'pyenv.default': mock_str,
'pyenv.versions': mock_lst}):
comt = ('pyenv not installed, 2.7.6 not either')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(pyenv.absent(name), ret)
comt = ('Successfully removed python')
ret.update({'comment': comt, 'result': True, 'default': True,
'changes': {'2.7.6': 'Uninstalled'}})
self.assertDictEqual(pyenv.absent(name), ret)
def test_prompt_argument(self):
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}):
virtualenv_mod.create('/tmp/foo', prompt='PY Prompt')
mock.assert_called_once_with(
'virtualenv --prompt=\'PY Prompt\' /tmp/foo',
runas=None
)
# Now with some quotes on the mix
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}):
virtualenv_mod.create('/tmp/foo', prompt='\'PY\' Prompt')
mock.assert_called_once_with(
'virtualenv --prompt="\'PY\' Prompt" /tmp/foo',
runas=None
)
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}):
virtualenv_mod.create('/tmp/foo', prompt='"PY" Prompt')
mock.assert_called_once_with(
'virtualenv --prompt=\'"PY" Prompt\' /tmp/foo',
runas=None
)
def test_install_pyenv(self):
'''
Test to install pyenv if not installed.
'''
name = 'python-2.7.6'
ret = {'name': name,
'changes': {},
'result': None,
'comment': ''}
with patch.dict(pyenv.__opts__, {'test': True}):
comt = ('pyenv is set to be installed')
ret.update({'comment': comt})
self.assertDictEqual(pyenv.install_pyenv(name), ret)
with patch.dict(pyenv.__opts__, {'test': False}):
mock_t = MagicMock(return_value=True)
mock_str = MagicMock(return_value='2.7.6')
mock_lst = MagicMock(return_value=['2.7.6'])
with patch.dict(pyenv.__salt__, {'pyenv.install_python': mock_t,
'pyenv.default': mock_str,
'pyenv.versions': mock_lst}):
comt = ('Successfully installed python')
ret.update({'comment': comt, 'result': True, 'default': False,
'changes': {None: 'Installed'}})
self.assertDictEqual(pyenv.install_pyenv(name), ret)
def test_installed(self):
'''
Test to verify that the specified python is installed with pyenv.
'''
name = 'python-2.7.6'
ret = {'name': name,
'changes': {},
'result': None,
'comment': ''}
with patch.dict(pyenv.__opts__, {'test': True}):
comt = ('python 2.7.6 is set to be installed')
ret.update({'comment': comt})
self.assertDictEqual(pyenv.installed(name), ret)
with patch.dict(pyenv.__opts__, {'test': False}):
mock_f = MagicMock(side_effect=[False, False, True])
mock_fa = MagicMock(side_effect=[False, True])
mock_str = MagicMock(return_value='2.7.6')
mock_lst = MagicMock(return_value=['2.7.6'])
with patch.dict(pyenv.__salt__, {'pyenv.is_installed': mock_f,
'pyenv.install': mock_fa,
'pyenv.default': mock_str,
'pyenv.versions': mock_lst}):
comt = ('pyenv failed to install')
ret.update({'comment': comt, 'result': False})
self.assertDictEqual(pyenv.installed(name), ret)
comt = ('Requested python exists.')
ret.update({'comment': comt, 'result': True, 'default': True})
self.assertDictEqual(pyenv.installed(name), ret)
self.assertDictEqual(pyenv.installed(name), ret)
def test_unrar(self):
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.unrar(
'/tmp/rarfile.rar',
'/home/strongbad/',
excludes='file_1,file_2'
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'unrar x -idp /tmp/rarfile.rar '
'-x file_1 -x file_2 /home/strongbad/',
template=None
)
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.unrar(
'/tmp/rarfile.rar',
'/home/strongbad/',
excludes=['file_1', 'file_2']
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'unrar x -idp /tmp/rarfile.rar '
'-x file_1 -x file_2 /home/strongbad/',
template=None
)
def test_unzip(self):
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.unzip(
'/tmp/salt.{{grains.id}}.zip',
'/tmp/dest',
excludes='/tmp/tmpePe8yO,/tmp/tmpLeSw1A',
template='jinja'
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'unzip /tmp/salt.{{grains.id}}.zip -d /tmp/dest '
'-x /tmp/tmpePe8yO /tmp/tmpLeSw1A',
template='jinja'
)
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.unzip(
'/tmp/salt.{{grains.id}}.zip',
'/tmp/dest',
excludes=['/tmp/tmpePe8yO', '/tmp/tmpLeSw1A'],
template='jinja'
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'unzip /tmp/salt.{{grains.id}}.zip -d /tmp/dest '
'-x /tmp/tmpePe8yO /tmp/tmpLeSw1A',
template='jinja'
)
def test_usage(self):
'''
Test if it shows in which disk the chunks are allocated.
'''
mock = MagicMock(return_value={'retcode': 1,
'stderr': '',
'stdout': 'Salt'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'Salt': 'salt'})
with patch.object(btrfs, '_usage_specific', mock):
self.assertDictEqual(btrfs.usage('/dev/sda1'),
{'Salt': 'salt'})
mock = MagicMock(return_value={'retcode': 1,
'stderr': '',
'stdout': 'Unallocated:\n'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': True})
with patch.object(btrfs, '_usage_unallocated', mock):
self.assertDictEqual(btrfs.usage('/dev/sda1'),
{'unallocated': {'/dev/sda1': True}})
mock = MagicMock(return_value={'retcode': 1,
'stderr': '',
'stdout': 'Overall:\n'})
with patch.dict(btrfs.__salt__, {'cmd.run_all': mock}):
mock = MagicMock(return_value={'/dev/sda1': True})
with patch.object(btrfs, '_usage_overall', mock):
self.assertDictEqual(btrfs.usage('/dev/sda1'),
{'overall': {'/dev/sda1': True}})
def test_chain_present(self):
'''
Test to verify the chain is exist.
'''
ret = {'name': 'salt',
'changes': {},
'result': True,
'comment': ''}
mock = MagicMock(side_effect=[True, False, False])
with patch.dict(nftables.__salt__, {"nftables.check_chain": mock}):
ret.update({'comment': 'nftables salt chain is already'
' exist in filter table for ipv4'})
self.assertDictEqual(nftables.chain_present('salt'), ret)
mock = MagicMock(side_effect=[True, ''])
with patch.dict(nftables.__salt__, {"nftables.new_chain": mock}):
ret.update({'changes': {'locale': 'salt'},
'comment': 'nftables salt chain in filter'
' table create success for ipv4'})
self.assertDictEqual(nftables.chain_present('salt'), ret)
ret.update({'changes': {},
'comment': 'Failed to create salt chain'
' in filter table: for ipv4',
'result': False})
self.assertDictEqual(nftables.chain_present('salt'), ret)
def test_set_present(self):
'''
Test to verify the chain is exist.
'''
name = 'salt'
set_type = {'bitmap': '192.168.0.3'}
ret = {'name': name,
'result': True,
'comment': '',
'changes': {}}
mock = MagicMock(side_effect=[True, False, False, True, False, ''])
with patch.dict(ipset.__salt__, {'ipset.check_set': mock,
'ipset.new_set': mock}):
comt = ('ipset set {0} already exist for ipv4'.format(name))
ret.update({'comment': comt})
self.assertDictEqual(ipset.set_present(name, set_type), ret)
with patch.dict(ipset.__opts__, {'test': True}):
comt = ('ipset set {0} needs to added for ipv4'.format(name))
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(ipset.set_present(name, set_type), ret)
with patch.dict(ipset.__opts__, {'test': False}):
comt = ('ipset set {0} created successfully for ipv4'
.format(name))
ret.update({'comment': comt, 'result': True,
'changes': {'locale': 'salt'}})
self.assertDictEqual(ipset.set_present(name, set_type), ret)
comt = ('Failed to create salt set: for ipv4')
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(ipset.set_present(name, set_type), ret)
def test_set_absent(self):
'''
Test to verify the set is absent.
'''
name = 'salt'
ret = {'name': name,
'result': True,
'comment': '',
'changes': {}}
mock = MagicMock(side_effect=[False, True, True, ''])
with patch.dict(ipset.__salt__, {'ipset.check_set': mock,
'ipset.flush': mock}):
comt = ('ipset set salt is already absent for family ipv4')
ret.update({'comment': comt})
self.assertDictEqual(ipset.set_absent(name), ret)
with patch.dict(ipset.__opts__, {'test': True}):
comt = ('ipset set salt needs to be removed family ipv4')
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(ipset.set_absent(name), ret)
with patch.dict(ipset.__opts__, {'test': False}):
comt = ('Failed to flush salt set: for ipv4')
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(ipset.set_absent(name), ret)
def test_rar(self):
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.rar(
'/tmp/rarfile.rar',
'/tmp/sourcefile1,/tmp/sourcefile2'
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'rar a -idp /tmp/rarfile.rar '
'/tmp/sourcefile1 /tmp/sourcefile2',
template=None
)
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.rar(
'/tmp/rarfile.rar',
['/tmp/sourcefile1', '/tmp/sourcefile2']
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'rar a -idp /tmp/rarfile.rar '
'/tmp/sourcefile1 /tmp/sourcefile2',
template=None
)
def test_flush(self):
'''
Test to flush current ipset set.
'''
name = 'salt'
ret = {'name': name,
'result': False,
'comment': '',
'changes': {}}
mock = MagicMock(side_effect=[False, True, True, True])
mock_f = MagicMock(side_effect=[True, False])
with patch.dict(ipset.__salt__, {'ipset.check_set': mock,
'ipset.flush': mock_f}):
comt = ('ipset set {0} does not exist for ipv4'.format(name))
ret.update({'comment': comt})
self.assertDictEqual(ipset.flush(name), ret)
with patch.dict(ipset.__opts__, {'test': True}):
comt = ('ipset entries in set {0} family ipv4 needs to '
'be flushed'.format(name))
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(ipset.flush(name), ret)
with patch.dict(ipset.__opts__, {'test': False}):
comt = ('Flush ipset entries in set {0} family ipv4'
.format(name))
ret.update({'comment': comt, 'result': True,
'changes': {'locale': 'salt'}})
self.assertDictEqual(ipset.flush(name), ret)
comt = ('Failed to flush ipset entries')
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(ipset.flush(name), ret)
def test_tar(self):
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.tar(
'zcvf', 'foo.tar',
['/tmp/something-to-compress-1',
'/tmp/something-to-compress-2'],
cwd=None, template=None
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'tar -zcvf foo.tar /tmp/something-to-compress-1 '
'/tmp/something-to-compress-2',
cwd=None,
template=None
)
mock = MagicMock(return_value='salt')
with patch.dict(archive.__salt__, {'cmd.run': mock}):
ret = archive.tar(
'zcvf', 'foo.tar',
'/tmp/something-to-compress-1,/tmp/something-to-compress-2',
cwd=None, template=None
)
self.assertEqual(['salt'], ret)
mock.assert_called_once_with(
'tar -zcvf foo.tar /tmp/something-to-compress-1 '
'/tmp/something-to-compress-2',
cwd=None,
template=None
)
def _run_ubuntu_os_grains_tests(self, os_release_map):
path_isfile_mock = MagicMock(
side_effect=lambda x: x in ['/etc/os-release'])
empty_mock = MagicMock(return_value={})
osarch_mock = MagicMock(return_value="amd64")
os_release_mock = MagicMock(
return_value=os_release_map.get('os_release_file'))
orig_import = __import__
def _import_mock(name, *args):
if name == 'lsb_release':
raise ImportError('No module named lsb_release')
return orig_import(name, *args)
# Skip the first if statement
with patch.object(salt.utils, 'is_proxy',
MagicMock(return_value=False)):
# Skip the selinux/systemd stuff (not pertinent)
with patch.object(core, '_linux_bin_exists',
MagicMock(return_value=False)):
# Skip the init grain compilation (not pertinent)
with patch.object(os.path, 'exists', path_isfile_mock):
# Ensure that lsb_release fails to import
with patch('__builtin__.__import__',
side_effect=_import_mock):
# Skip all the /etc/*-release stuff (not pertinent)
with patch.object(os.path, 'isfile', path_isfile_mock):
with patch.object(core, '_parse_os_release',
os_release_mock):
# Mock platform.linux_distribution to give us the
# OS name that we want.
distro_mock = MagicMock(
return_value=('Ubuntu', '16.04', 'xenial'))
with patch("salt.utils.fopen",
mock_open()) as suse_release_file:
suse_release_file.return_value.__iter__.return_value = os_release_map.get(
'suse_release_file', '').splitlines()
with patch.object(platform,
'linux_distribution',
distro_mock):
with patch.object(
core, '_linux_gpu_data',
empty_mock):
with patch.object(
core, '_linux_cpudata',
empty_mock):
with patch.object(
core, '_virtual',
empty_mock):
# Mock the osarch
with patch.dict(
core.__salt__, {
'cmd.run':
osarch_mock
}):
os_grains = core.os_data(
)
self.assertEqual(os_grains.get('os'), 'Ubuntu')
self.assertEqual(os_grains.get('os_family'), 'Debian')
self.assertEqual(os_grains.get('osfullname'),
os_release_map['osfullname'])
self.assertEqual(os_grains.get('oscodename'),
os_release_map['oscodename'])
self.assertEqual(os_grains.get('osrelease'),
os_release_map['osrelease'])
self.assertListEqual(list(os_grains.get('osrelease_info')),
os_release_map['osrelease_info'])
self.assertEqual(os_grains.get('osmajorrelease'),
os_release_map['osmajorrelease'])
def test_check_loglevel_quiet(self):
'''
Tests the return of providing a loglevel of 'quiet'
'''
with patch.dict(LOG_LEVELS, self.mock_loglevels):
self.assertEqual(cmdmod._check_loglevel(level='quiet'), None)
def test_check_loglevel_bad_level_not_str(self):
'''
Tests the return of providing an invalid loglevel option that is not a string
'''
with patch.dict(LOG_LEVELS, self.mock_loglevels):
self.assertEqual(cmdmod._check_loglevel(level=1000), 'foo')
def test_running(self):
'''
Test to verify that the service is running
'''
ret = [{
'comment': '',
'changes': {},
'name': 'salt',
'result': True
}, {
'changes': {},
'comment': 'The service salt is already running',
'name': 'salt',
'result': True
}, {
'changes': 'saltstack',
'comment': 'The service salt is already running',
'name': 'salt',
'result': True
}, {
'changes': {},
'comment': 'Service salt is set to start',
'name': 'salt',
'result': None
}, {
'changes': 'saltstack',
'comment': 'Started Service salt',
'name': 'salt',
'result': True
}, {
'changes': {},
'comment': 'The service salt is already running',
'name': 'salt',
'result': True
}]
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
vmock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', vmock):
self.assertEqual(service.running("salt", enabled=1), 'salt')
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.running("salt"), ret[0])
with patch.object(service, '_available', tmock):
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(service.__salt__, {
'service.enabled': tmock,
'service.status': tmock
})):
self.assertDictEqual(service.running("salt"), ret[1])
# service was enabled and running, no changes
mock = MagicMock(return_value={'changes': 'saltstack'})
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.enabled':
MagicMock(side_effect=[False, True]),
'service.status':
tmock
}), patch.object(service, '_enable', mock)):
self.assertDictEqual(service.running("salt", True), ret[2])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.enabled':
MagicMock(side_effect=[True, False]),
'service.status':
tmock
}), patch.object(service, '_disable', mock)):
self.assertDictEqual(service.running("salt", False),
ret[2])
with patch.dict(service.__opts__, {'test': True}):
self.assertDictEqual(service.running("salt"), ret[5])
with contextlib.nested(
patch.dict(service.__salt__,
{'service.status': fmock}),
patch.dict(service.__opts__, {'test': True})):
self.assertDictEqual(service.running("salt"), ret[3])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.status':
MagicMock(side_effect=[False, True]),
'service.enabled':
MagicMock(side_effect=[False, True]),
'service.start':
MagicMock(return_value="stack")
}),
patch.object(
service, '_enable',
MagicMock(return_value={'changes': 'saltstack'}))):
self.assertDictEqual(service.running("salt", True), ret[4])
def test_dead(self):
'''
Test to ensure that the named service is dead
'''
ret = [{
'changes': {},
'comment': '',
'name': 'salt',
'result': True
}, {
'changes': 'saltstack',
'comment': 'The service salt is already dead',
'name': 'salt',
'result': True
}, {
'changes': {},
'comment': 'Service salt is set to be killed',
'name': 'salt',
'result': None
}, {
'changes': 'saltstack',
'comment': 'Service salt was killed',
'name': 'salt',
'result': True
}, {
'changes': {},
'comment': 'Service salt was killed',
'name': 'salt',
'result': True
}, {
'changes': 'saltstack',
'comment': 'The service salt is already dead',
'name': 'salt',
'result': True
}]
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.dead("salt", enabled=1), 'salt')
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.dead("salt"), ret[0])
with patch.object(service, '_available', tmock):
mock = MagicMock(return_value={'changes': 'saltstack'})
with contextlib.nested(
patch.dict(service.__opts__, {'test': True}),
patch.dict(
service.__salt__, {
'service.enabled': MagicMock(return_value=False),
'service.stop': MagicMock(return_value=True),
'service.status': MagicMock(return_value=False)
}), patch.object(service, '_enable', mock)):
self.assertDictEqual(service.dead("salt", True), ret[5])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.enabled': MagicMock(return_value=False),
'service.stop': MagicMock(return_value=True),
'service.status': MagicMock(return_value=False)
}), patch.object(service, '_enable', mock)):
self.assertDictEqual(service.dead("salt", True), ret[1])
with contextlib.nested(
patch.dict(service.__opts__, {'test': True}),
patch.dict(
service.__salt__, {
'service.enabled': MagicMock(return_value=True),
'service.status': MagicMock(return_value=True)
}),
):
self.assertDictEqual(service.dead("salt"), ret[2])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.enabled':
MagicMock(side_effect=[True, True, False]),
'service.status':
MagicMock(side_effect=[True, True, False]),
'service.stop':
MagicMock(return_value="stack")
}),
patch.object(
service, '_enable',
MagicMock(return_value={'changes': 'saltstack'}))):
self.assertDictEqual(service.dead("salt", True), ret[3])
# test an initd which a wrong status (True even if dead)
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.enabled':
MagicMock(side_effect=[False, False, False]),
'service.status':
MagicMock(side_effect=[True, True, True]),
'service.stop':
MagicMock(return_value="stack")
}),
patch.object(service, '_disable',
MagicMock(return_value={}))):
self.assertDictEqual(service.dead("salt", False), ret[4])
def test_set_proxy_macos(self):
'''
Test to make sure we can set the proxy settings on macOS
'''
proxy.__grains__['os'] = 'Darwin'
expected = {
'changes': {
'new': [{
'port': '3128',
'server': '192.168.0.1',
'service': 'http',
'user': '******'
}, {
'port': '3128',
'server': '192.168.0.1',
'service': 'https',
'user': '******'
}, {
'port': '3128',
'server': '192.168.0.1',
'service': 'ftp',
'user': '******'
}, {
'bypass_domains': ['salt.com', 'test.com']
}]
},
'comment':
'http proxy settings updated correctly\nhttps proxy settings updated correctly\nftp proxy '
'settings updated correctly\nProxy bypass domains updated correctly\n',
'name':
'192.168.0.1',
'result':
True
}
set_proxy_mock = MagicMock(return_value=True)
patches = {
'proxy.get_http_proxy': MagicMock(return_value={}),
'proxy.get_https_proxy': MagicMock(return_value={}),
'proxy.get_ftp_proxy': MagicMock(return_value={}),
'proxy.get_proxy_bypass': MagicMock(return_value=[]),
'proxy.set_http_proxy': set_proxy_mock,
'proxy.set_https_proxy': set_proxy_mock,
'proxy.set_ftp_proxy': set_proxy_mock,
'proxy.set_proxy_bypass': set_proxy_mock,
}
with patch.dict(proxy.__salt__, patches):
out = proxy.managed('192.168.0.1',
'3128',
user='******',
password='******',
bypass_domains=['salt.com', 'test.com'])
calls = [
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call(['salt.com', 'test.com'], 'Ethernet')
]
set_proxy_mock.assert_has_calls(calls)
self.assertEqual(out, expected)
def test_sls(self):
'''
Test to execute a set list of state files from an environment
'''
arg = "core,edit.vim dev"
ret = [
'Pillar failed to render with the following messages:', 'E', '1'
]
mock = MagicMock(return_value=True)
with patch.object(state, 'running', mock):
with patch.dict(state.__context__, {"retcode": 1}):
self.assertEqual(state.sls("core,edit.vim dev"), True)
mock = MagicMock(side_effect=[True, True, True, True, True, True])
with patch.object(state, '_wait', mock):
mock = MagicMock(side_effect=[["A"], [], [], [], [], []])
with patch.object(state, '_disabled', mock):
with patch.dict(state.__context__, {"retcode": 1}):
self.assertEqual(
state.sls("core,edit.vim dev", None, None, None, True),
["A"])
mock = MagicMock(side_effect=[False, True, True, True, True])
with patch.object(state, '_check_pillar', mock):
with patch.dict(state.__context__, {"retcode": 5}):
with patch.dict(state.__pillar__, {"_errors": "E1"}):
self.assertListEqual(
state.sls("core,edit.vim dev", None, None,
None, True), ret)
with patch.dict(state.__opts__, {"test": None}):
mock = MagicMock(return_value={"test": ""})
with patch.object(state, '_get_opts', mock):
mock = MagicMock(return_value=True)
with patch.object(salt.utils, 'test_mode', mock):
self.assertRaises(SaltInvocationError,
state.sls,
"core,edit.vim dev",
None,
None,
None,
True,
pillar="A")
with patch.dict(state.__opts__,
{"cachedir": "/D/"}):
mock = MagicMock(
return_value="/D/cache.cache.p")
with patch.object(os.path, 'join', mock):
mock = MagicMock(return_value=True)
with patch.object(
os.path, 'isfile', mock):
with patch('salt.utils.fopen',
mock_open()):
self.assertTrue(
state.sls(arg,
None,
None,
None,
True,
cache=True))
MockState.HighState.flag = True
self.assertTrue(
state.sls("core,edit"
".vim dev", None, None,
None, True))
MockState.HighState.flag = False
mock = MagicMock(return_value=True)
with patch.dict(
state.__salt__,
{'config.option': mock}):
mock = MagicMock(return_value=True)
with patch.object(
state, '_filter_'
'running', mock):
with patch.dict(
state.__opts__,
{"cachedir": "/D/"}):
self.sub_test_sls()
def test_suse_os_from_cpe_data(self):
'''
Test if 'os' grain is parsed from CPE_NAME of /etc/os-release
'''
_path_exists_map = {'/proc/1/cmdline': False}
_path_isfile_map = {
'/etc/os-release': True,
}
_os_release_map = {
'NAME': 'SLES',
'VERSION': '12-SP1',
'VERSION_ID': '12.1',
'PRETTY_NAME': 'SUSE Linux Enterprise Server 12 SP1',
'ID': 'sles',
'ANSI_COLOR': '0;32',
'CPE_NAME': 'cpe:/o:suse:sles:12:sp1'
}
path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x])
path_isfile_mock = MagicMock(
side_effect=lambda x: _path_isfile_map.get(x, False))
empty_mock = MagicMock(return_value={})
osarch_mock = MagicMock(return_value="amd64")
os_release_mock = MagicMock(return_value=_os_release_map)
orig_import = __import__
if six.PY2:
built_in = '__builtin__'
else:
built_in = 'builtins'
def _import_mock(name, *args):
if name == 'lsb_release':
raise ImportError('No module named lsb_release')
return orig_import(name, *args)
# Skip the first if statement
with patch.object(salt.utils, 'is_proxy',
MagicMock(return_value=False)):
# Skip the selinux/systemd stuff (not pertinent)
with patch.object(core, '_linux_bin_exists',
MagicMock(return_value=False)):
# Skip the init grain compilation (not pertinent)
with patch.object(os.path, 'exists', path_exists_mock):
# Ensure that lsb_release fails to import
with patch('{0}.__import__'.format(built_in),
side_effect=_import_mock):
# Skip all the /etc/*-release stuff (not pertinent)
with patch.object(os.path, 'isfile', path_isfile_mock):
with patch.object(core, '_parse_os_release',
os_release_mock):
# Mock platform.linux_distribution to give us the
# OS name that we want.
distro_mock = MagicMock(return_value=(
'SUSE Linux Enterprise Server ', '12',
'x86_64'))
with patch.object(platform,
'linux_distribution',
distro_mock):
with patch.object(core, '_linux_gpu_data',
empty_mock):
with patch.object(
core, '_linux_cpudata',
empty_mock):
with patch.object(
core, '_virtual',
empty_mock):
# Mock the osarch
with patch.dict(
core.__salt__,
{'cmd.run': osarch_mock}):
os_grains = core.os_data()
self.assertEqual(os_grains.get('os_family'), 'Suse')
self.assertEqual(os_grains.get('os'), 'SUSE')
def test_set_locale_debian_localectl(self):
with patch.dict(localemod.__grains__, {'os_family': ['Debian']}):
with patch.object(localemod, '_localectl_set', return_value=True):
self.assertTrue(localemod.set_locale('C'))
def test_gnu_slash_linux_in_os_name(self):
'''
Test to return a list of all enabled services
'''
_path_exists_map = {'/proc/1/cmdline': False}
_path_isfile_map = {}
_cmd_run_map = {'dpkg --print-architecture': 'amd64'}
path_exists_mock = MagicMock(side_effect=lambda x: _path_exists_map[x])
path_isfile_mock = MagicMock(
side_effect=lambda x: _path_isfile_map.get(x, False))
cmd_run_mock = MagicMock(side_effect=lambda x: _cmd_run_map[x])
empty_mock = MagicMock(return_value={})
orig_import = __import__
if six.PY2:
built_in = '__builtin__'
else:
built_in = 'builtins'
def _import_mock(name, *args):
if name == 'lsb_release':
raise ImportError('No module named lsb_release')
return orig_import(name, *args)
# Skip the first if statement
with patch.object(salt.utils, 'is_proxy',
MagicMock(return_value=False)):
# Skip the selinux/systemd stuff (not pertinent)
with patch.object(core, '_linux_bin_exists',
MagicMock(return_value=False)):
# Skip the init grain compilation (not pertinent)
with patch.object(os.path, 'exists', path_exists_mock):
# Ensure that lsb_release fails to import
with patch('{0}.__import__'.format(built_in),
side_effect=_import_mock):
# Skip all the /etc/*-release stuff (not pertinent)
with patch.object(os.path, 'isfile', path_isfile_mock):
# Mock platform.linux_distribution to give us the
# OS name that we want.
distro_mock = MagicMock(
return_value=('Debian GNU/Linux', '8.3', ''))
with patch.object(platform, 'linux_distribution',
distro_mock):
# Make a bunch of functions return empty dicts,
# we don't care about these grains for the
# purposes of this test.
with patch.object(core, '_linux_cpudata',
empty_mock):
with patch.object(core, '_linux_gpu_data',
empty_mock):
with patch.object(
core, '_memdata', empty_mock):
with patch.object(
core, '_hw_data',
empty_mock):
with patch.object(
core, '_virtual',
empty_mock):
with patch.object(
core, '_ps',
empty_mock):
# Mock the osarch
with patch.dict(
core.__salt__,
{
'cmd.run':
cmd_run_mock
}):
os_grains = core.os_data(
)
self.assertEqual(os_grains.get('os_family'), 'Debian')
def test_blkid(self):
with patch.dict(disk.__salt__,
{'cmd.run_stdout': MagicMock(return_value=1)}):
self.assertDictEqual(STUB_DISK_BLKID, disk.blkid())
def test_present(self):
'''
Test to ensure the IAM role exists.
'''
name = 'myelb'
listeners = [{
'elb_port': 'ELBPORT',
'instance_port': 'PORT',
'elb_protocol': 'HTTPS',
'certificate': 'A'
}]
attributes = {
'alarm_actions': ['arn:aws:sns:us-east-1:12345:myalarm'],
'insufficient_data_actions': [],
'ok_actions': ['arn:aws:sns:us-east-1:12345:myalarm']
}
avail_zones = ['us-east-1a', 'us-east-1c', 'us-east-1d']
alarms = {
'alarm_actions': {
'name': name,
'attributes': {
'description': 'A'
}
}
}
ret = {'name': name, 'result': False, 'changes': {}, 'comment': ''}
ret1 = copy.deepcopy(ret)
mock = MagicMock(return_value={})
mock_bool = MagicMock(return_value=False)
with patch.dict(
boto_elb.__salt__, {
'config.option': mock,
'boto_elb.exists': mock_bool,
'boto_elb.create': mock_bool,
'boto_elb.get_attributes': mock
}):
with patch.dict(boto_elb.__opts__, {'test': False}):
comt = (' Failed to create myelb ELB.')
ret.update({'comment': comt})
self.assertDictEqual(
boto_elb.present(name,
listeners,
attributes=attributes,
availability_zones=avail_zones), ret)
mock = MagicMock(return_value={})
mock_ret = MagicMock(return_value={'result': {'result': False}})
comt1 = (' Failed to retrieve health_check for ELB myelb.')
with patch.dict(
boto_elb.__salt__, {
'config.option': mock,
'boto_elb.get_attributes': mock,
'boto_elb.get_health_check': mock,
'boto_elb.get_elb_config': mock,
'state.single': mock_ret
}):
with patch.dict(boto_elb.__opts__, {'test': False}):
ret1.update({'result': True})
mock_elb_present = MagicMock(return_value=ret1)
with patch.object(boto_elb, '_elb_present', mock_elb_present):
comt = (' Failed to retrieve attributes for ELB myelb.')
ret.update({'comment': comt})
self.assertDictEqual(boto_elb.present(name, listeners),
ret)
with patch.object(boto_elb, '_attributes_present',
mock_elb_present):
ret.update({'comment': comt1})
self.assertDictEqual(boto_elb.present(name, listeners),
ret)
with patch.object(boto_elb, '_health_check_present',
mock_elb_present):
comt = (' Failed to retrieve ELB myelb.')
ret.update({'comment': comt})
self.assertDictEqual(
boto_elb.present(name, listeners), ret)
with patch.object(boto_elb, '_cnames_present',
mock_elb_present):
comt = (' ')
ret.update({'comment': comt})
self.assertDictEqual(
boto_elb.present(name,
listeners,
alarms=alarms), ret)
with patch.object(boto_elb, '_alarms_present',
mock_elb_present):
ret.update({'result': True})
self.assertDictEqual(
boto_elb.present(name,
listeners,
alarms=alarms), ret)
def test_percent(self):
with patch.dict(disk.__grains__, {'kernel': 'Linux'}):
mock = MagicMock()
with patch.dict(disk.__salt__, {'cmd.run': mock}):
self.assertDictEqual(STUB_DISK_PERCENT,
disk.percent(args=None))
def test_wipe(self):
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(disk.__salt__, {'cmd.run_all': mock}):
disk.wipe('/dev/sda')
mock.assert_called_once_with('wipefs -a /dev/sda',
python_shell=False)
def test_usage_none(self):
with patch.dict(disk.__grains__, {'kernel': 'Linux'}):
mock_cmd = MagicMock(return_value=1)
with patch.dict(disk.__salt__, {'cmd.run': mock_cmd}):
self.assertEqual('', disk.usage(args=None))
def test_percent_args(self):
with patch.dict(disk.__grains__, {'kernel': 'Linux'}):
mock = MagicMock()
with patch.dict(disk.__salt__, {'cmd.run': mock}):
self.assertEqual('/', disk.percent('/'))
def test_present(self):
'''
Test to ensure that the named service is present.
'''
name = 'lvsrs'
ret = {'name': name, 'result': True, 'comment': '', 'changes': {}}
mock_check = MagicMock(side_effect=[
True, True, True, False, True, False, True, False, False, False,
False
])
mock_edit = MagicMock(side_effect=[True, False])
mock_add = MagicMock(side_effect=[True, False])
with patch.dict(
lvs_server.__salt__, {
'lvs.check_server': mock_check,
'lvs.edit_server': mock_edit,
'lvs.add_server': mock_add
}):
with patch.dict(lvs_server.__opts__, {'test': True}):
comt = ('LVS Server lvsrs in service None(None) is present')
ret.update({'comment': comt})
self.assertDictEqual(lvs_server.present(name), ret)
comt = ('LVS Server lvsrs in service None(None) is present '
'but some options should update')
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(lvs_server.present(name), ret)
with patch.dict(lvs_server.__opts__, {'test': False}):
comt = ('LVS Server lvsrs in service None(None) '
'has been updated')
ret.update({
'comment': comt,
'result': True,
'changes': {
'lvsrs': 'Update'
}
})
self.assertDictEqual(lvs_server.present(name), ret)
comt = ('LVS Server lvsrs in service None(None) '
'update failed(False)')
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(lvs_server.present(name), ret)
with patch.dict(lvs_server.__opts__, {'test': True}):
comt = (
'LVS Server lvsrs in service None(None) is not present '
'and needs to be created')
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(lvs_server.present(name), ret)
with patch.dict(lvs_server.__opts__, {'test': False}):
comt = ('LVS Server lvsrs in service None(None) '
'has been created')
ret.update({
'comment': comt,
'result': True,
'changes': {
'lvsrs': 'Present'
}
})
self.assertDictEqual(lvs_server.present(name), ret)
comt = ('LVS Service lvsrs in service None(None) '
'create failed(False)')
ret.update({'comment': comt, 'result': False, 'changes': {}})
self.assertDictEqual(lvs_server.present(name), ret)
def test_inodeusage(self):
with patch.dict(disk.__grains__, {'kernel': 'OpenBSD'}):
mock = MagicMock()
with patch.dict(disk.__salt__, {'cmd.run': mock}):
self.assertDictEqual(STUB_DISK_INODEUSAGE,
disk.inodeusage(args=None))
def test_get_permission_types(self):
'''
Test - Get the permission types that can be configured for communities.
'''
with patch.dict(win_snmp.__salt__):
self.assertIsInstance(win_snmp.get_permission_types(), list)
def test_install_with_multiple_find_links(self):
find_links = [
'http://g.pypi.python.org', 'http://c.pypi.python.org',
'http://pypi.crate.io'
]
pkg = 'pep8'
expected = ['pip', 'install']
for item in find_links:
expected.extend(['--find-links', item])
expected.append(pkg)
# Passing mirrors as a list
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=find_links)
mock.assert_called_once_with(
expected,
saltenv='base',
runas=None,
cwd=None,
use_vt=False,
python_shell=False,
)
# Passing mirrors as a comma separated list
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=','.join(find_links))
mock.assert_called_once_with(
expected,
saltenv='base',
runas=None,
cwd=None,
use_vt=False,
python_shell=False,
)
# As single string (just use the first element from find_links)
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=find_links[0])
mock.assert_called_once_with(
['pip', 'install', '--find-links', find_links[0], pkg],
saltenv='base',
runas=None,
cwd=None,
use_vt=False,
python_shell=False,
)
# Invalid proto raises exception
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError,
pip.install,
'\'' + pkg + '\'',
find_links='sftp://pypi.crate.io')
# Valid protos work?
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install(pkg, find_links=find_links)
mock.assert_called_once_with(
expected,
saltenv='base',
runas=None,
cwd=None,
use_vt=False,
python_shell=False,
)
def test_install_with_multiple_find_links(self):
find_links = [
'http://g.pypi.python.org', 'http://c.pypi.python.org',
'http://pypi.crate.io'
]
# Passing mirrors as a list
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install('pep8', find_links=find_links)
mock.assert_called_once_with(
'pip install '
'--find-links=http://g.pypi.python.org '
'--find-links=http://c.pypi.python.org '
'--find-links=http://pypi.crate.io \'pep8\'',
saltenv='base',
runas=None,
cwd=None,
use_vt=False)
# Passing mirrors as a comma separated list
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install('pep8', find_links=','.join(find_links))
mock.assert_called_once_with(
'pip install '
'--find-links=http://g.pypi.python.org '
'--find-links=http://c.pypi.python.org '
'--find-links=http://pypi.crate.io \'pep8\'',
saltenv='base',
runas=None,
cwd=None,
use_vt=False)
# Passing mirrors as a single string entry
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install('pep8', find_links=find_links[0])
mock.assert_called_once_with(
'pip install --find-links=http://g.pypi.python.org \'pep8\'',
saltenv='base',
runas=None,
cwd=None,
use_vt=False)
# Invalid proto raises exception
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
self.assertRaises(CommandExecutionError,
pip.install,
'\'pep8\'',
find_links='sftp://pypi.crate.io')
# Valid protos work?
mock = MagicMock(return_value={'retcode': 0, 'stdout': ''})
with patch.dict(pip.__salt__, {'cmd.run_all': mock}):
pip.install('pep8',
find_links=[
'ftp://g.pypi.python.org',
'http://c.pypi.python.org', 'https://pypi.crate.io'
])
mock.assert_called_once_with(
'pip install '
'--find-links=ftp://g.pypi.python.org '
'--find-links=http://c.pypi.python.org '
'--find-links=https://pypi.crate.io \'pep8\'',
saltenv='base',
runas=None,
cwd=None,
use_vt=False)
def test_extracted_tar(self):
'''
archive.extracted tar options
'''
source = 'file.tar.gz'
tmp_dir = os.path.join(tempfile.gettempdir(), 'test_archive', '')
test_tar_opts = [
'--no-anchored foo',
'v -p --opt',
'-v -p',
'--long-opt -z',
'z -v -weird-long-opt arg',
]
ret_tar_opts = [
['tar', 'x', '--no-anchored', 'foo', '-f'],
['tar', 'xv', '-p', '--opt', '-f'],
['tar', 'x', '-v', '-p', '-f'],
['tar', 'x', '--long-opt', '-z', '-f'],
['tar', 'xz', '-v', '-weird-long-opt', 'arg', '-f'],
]
mock_true = MagicMock(return_value=True)
mock_false = MagicMock(return_value=False)
ret = {
'stdout': ['saltines', 'cheese'],
'stderr': 'biscuits',
'retcode': '31337',
'pid': '1337'
}
mock_run = MagicMock(return_value=ret)
with patch('os.path.exists', mock_true):
with patch.dict(archive.__opts__, {
'test': False,
'cachedir': tmp_dir
}):
with patch.dict(
archive.__salt__, {
'file.directory_exists': mock_false,
'file.file_exists': mock_false,
'file.makedirs': mock_true,
'cmd.run_all': mock_run
}):
if HAS_PWD:
running_as = pwd.getpwuid(os.getuid()).pw_name
else:
running_as = 'root'
filename = os.path.join(
tmp_dir, 'files/test/_tmp{0}_test_archive_.tar'.format(
'' if running_as ==
'root' else '_{0}'.format(running_as)))
for test_opts, ret_opts in zip(test_tar_opts,
ret_tar_opts):
ret = archive.extracted(tmp_dir,
source,
'tar',
tar_options=test_opts)
ret_opts.append(filename)
mock_run.assert_called_with(ret_opts,
cwd=tmp_dir,
python_shell=False)
def test_spf(self):
dig.__salt__ = {}
dig_mock = MagicMock(side_effect=_spf_side_effect)
with patch.dict(dig.__salt__, {'cmd.run_all': dig_mock}):
self.assertEqual(dig.SPF('foo.com'),
['216.73.93.70/31', '216.73.93.72/31'])
def test_get_agent_service_types(self):
'''
Test - Get the sysServices types that can be configured.
'''
with patch.dict(win_snmp.__salt__):
self.assertIsInstance(win_snmp.get_agent_service_types(), list)
def test_volume_present(self):
'''
Test dockerng.volume_present
'''
volumes = []
default_driver = 'dummy_default'
def create_volume(name, driver=None, driver_opts=None):
for v in volumes:
# volume_present should never try to add a conflicting
# volume
self.assertNotEqual(v['Name'], name)
if driver is None:
driver = default_driver
new = {'Name': name, 'Driver': driver}
volumes.append(new)
return new
def remove_volume(name):
old_len = len(volumes)
removed = [v for v in volumes if v['Name'] == name]
# volume_present should not have tried to remove a volume
# that didn't exist
self.assertEqual(1, len(removed))
volumes.remove(removed[0])
return removed[0]
dockerng_create_volume = Mock(side_effect=create_volume)
__salt__ = {'dockerng.create_volume': dockerng_create_volume,
'dockerng.volumes': Mock(return_value={'Volumes': volumes}),
'dockerng.remove_volume': Mock(side_effect=remove_volume),
}
with patch.dict(dockerng_state.__dict__,
{'__salt__': __salt__}):
ret = dockerng_state.volume_present(
'volume_foo',
)
dockerng_create_volume.assert_called_with('volume_foo',
driver=None,
driver_opts=None)
self.assertEqual(
{
'name': 'volume_foo',
'comment': '',
'changes': {
'created': {
'Driver': default_driver,
'Name': 'volume_foo',
},
},
'result': True,
},
ret)
self.assertEqual(len(volumes), 1)
self.assertEqual(volumes[0]['Name'], 'volume_foo')
self.assertIs(volumes[0]['Driver'], default_driver)
# run it again with the same arguments
orig_volumes = [volumes[0].copy()]
ret = dockerng_state.volume_present('volume_foo')
self.assertEqual(
{
'name': 'volume_foo',
'comment': "Volume 'volume_foo' already exists.",
'changes': {},
'result': True,
},
ret)
self.assertEqual(orig_volumes, volumes)
# run it again with a different driver but don't force
ret = dockerng_state.volume_present('volume_foo', driver='local')
self.assertEqual(
{
'name': 'volume_foo',
'comment': ("Driver for existing volume 'volume_foo'"
" ('dummy_default') does not match specified"
" driver ('local') and force is False"),
'changes': {},
'result': False,
},
ret)
self.assertEqual(orig_volumes, volumes)
# run it again with a different driver and force
ret = dockerng_state.volume_present(
'volume_foo', driver='local', force=True)
self.assertEqual(
{
'name': 'volume_foo',
'comment': "",
'changes': {
'removed': {
'Driver': default_driver,
'Name': 'volume_foo',
},
'created': {
'Driver': 'local',
'Name': 'volume_foo',
},
},
'result': True,
},
ret)
mod_orig_volumes = [orig_volumes[0].copy()]
mod_orig_volumes[0]['Driver'] = 'local'
self.assertEqual(mod_orig_volumes, volumes)
def test_present(self):
'''
Test to ensure the IAM role exists.
'''
name = 'myelb'
listeners = [{
'elb_port': 'ELBPORT',
'instance_port': 'PORT',
'elb_protocol': 'HTTPS',
'certificate': 'A'
}]
alarms = {
'MyAlarm': {
'name': name,
'attributes': {
'description': 'A'
}
}
}
attrs = {
'alarm_actions': ['arn:aws:sns:us-east-1:12345:myalarm'],
'insufficient_data_actions': [],
'ok_actions': ['arn:aws:sns:us-east-1:12345:myalarm']
}
health_check = {'target:': 'HTTP:80/'}
avail_zones = ['us-east-1a', 'us-east-1c', 'us-east-1d']
cnames = [{'name': 'www.test.com', 'zone': 'test.com', 'ttl': 60}]
ret = {'name': name, 'result': True, 'changes': {}, 'comment': ''}
ret1 = copy.deepcopy(ret)
mock = MagicMock(return_value={})
mock_false_bool = MagicMock(return_value=False)
mock_true_bool = MagicMock(return_value=True)
mock_attributes = MagicMock(return_value=attrs)
mock_health_check = MagicMock(return_value=health_check)
with patch.dict(
boto_elb.__salt__, {
'config.option': mock,
'boto_elb.exists': mock_false_bool,
'boto_elb.create': mock_false_bool,
'pillar.get': MagicMock(return_value={})
}):
with patch.dict(boto_elb.__opts__, {'test': False}):
ret = boto_elb.present(name,
listeners,
availability_zones=avail_zones)
self.assertTrue(boto_elb.__salt__['boto_elb.exists'].called)
self.assertTrue(boto_elb.__salt__['boto_elb.create'].called)
self.assertIn('Failed to create myelb ELB.', ret['comment'])
self.assertFalse(ret['result'])
def mock_config_option(*args, **kwargs):
if args[0] == 'boto_elb_policies':
return []
return {}
mock = MagicMock(return_value={})
with patch.dict(
boto_elb.__salt__, {
'config.option':
MagicMock(side_effect=mock_config_option),
'boto_elb.exists':
mock_false_bool,
'boto_elb.create':
mock_true_bool,
'boto_elb.get_attributes':
mock_attributes,
'boto_elb.get_health_check':
mock_health_check,
'boto_elb.get_elb_config':
MagicMock(side_effect=[mock, MagicMock()]),
'pillar.get':
MagicMock(return_value={})
}):
with patch.dict(boto_elb.__opts__, {'test': False}):
with patch.dict(boto_elb.__states__, {
'boto_cloudwatch_alarm.present':
MagicMock(return_value=ret1)
}):
ret = boto_elb.present(name,
listeners,
availability_zones=avail_zones,
health_check=health_check,
alarms=alarms)
self.assertTrue(
boto_elb.__salt__['boto_elb.exists'].called)
self.assertTrue(
boto_elb.__salt__['boto_elb.create'].called)
self.assertTrue(
boto_elb.__states__['boto_cloudwatch_alarm.present'].
called)
self.assertFalse(
boto_elb.__salt__['boto_elb.get_attributes'].called)
self.assertTrue(
boto_elb.__salt__['boto_elb.get_health_check'].called)
self.assertIn('ELB myelb created.', ret['comment'])
import pprint
pprint.pprint(ret)
self.assertTrue(ret['result'])
mock = MagicMock(return_value={})
mock_elb = MagicMock(
return_value={
'dns_name': 'myelb.amazon.com',
'policies': [],
'listeners': [],
'backends': []
})
with patch.dict(
boto_elb.__salt__, {
'config.option': MagicMock(side_effect=mock_config_option),
'boto_elb.exists': mock_false_bool,
'boto_elb.create': mock_true_bool,
'boto_elb.get_attributes': mock_attributes,
'boto_elb.get_health_check': mock_health_check,
'boto_elb.get_elb_config': mock_elb,
'pillar.get': MagicMock(return_value={})
}):
with patch.dict(boto_elb.__opts__, {'test': False}):
with patch.dict(
boto_elb.__states__,
{'boto_route53.present': MagicMock(return_value=ret1)}):
ret = boto_elb.present(name,
listeners,
availability_zones=avail_zones,
health_check=health_check,
cnames=cnames)
mock_changes = {
'new': {
'elb': 'myelb'
},
'old': {
'elb': None
}
}
self.assertTrue(
boto_elb.__states__['boto_route53.present'].called)
self.assertEqual(mock_changes, ret['changes'])
self.assertTrue(ret['result'])
def test_command_defined_on_image_layer_dont_diff_if_attempted_to_blank(self):
'''
Assuming the docker image has a command defined, like ``sh``.
Erasing this value on sls level will not delete the command
in the container. And such the diff shouldn't be reported.
Assuming also the container is already running.
1. define your sls
.. code-block:: yaml
cont:
dockerng.running:
- image: image:latest
2. run state.highstate
No diff should be reported
'''
image_id = 'abcdefg'
dockerng_create = Mock(return_value=True)
dockerng_start = Mock()
dockerng_list_containers = Mock(return_value=['cont'])
dockerng_inspect_container = Mock(
side_effect=[{
'Config': {
'Image': 'image:latest',
'Tty': False,
'Labels': {},
'Domainname': '',
'User': '',
'AttachStderr': True,
'AttachStdout': True,
'Hostname': 'saltstack-container',
'Env': [],
'WorkingDir': '/',
'Cmd': None,
'Volumes': {},
'Entrypoint': None,
'ExposedPorts': {},
'OpenStdin': False,
},
'HostConfig': {
'PublishAllPorts': False,
'Dns': [],
'Links': None,
'CpusetCpus': '',
'RestartPolicy': {'MaximumRetryCount': 0, 'Name': ''},
'CapAdd': None,
'NetworkMode': 'default',
'PidMode': '',
'MemorySwap': 0,
'ExtraHosts': None,
'PortBindings': None,
'LxcConf': None,
'DnsSearch': [],
'Privileged': False,
'Binds': [],
'Memory': 0,
'VolumesFrom': None,
'CpuShares': 0,
'CapDrop': None,
},
'NetworkSettings': {
'MacAddress': '00:00:00:00:00:01',
},
'Image': image_id}]
)
dockerng_inspect_image = MagicMock(
return_value={
'Id': image_id,
'Config': {
'Hostname': 'saltstack-container',
'WorkingDir': '/',
'Cmd': ['bash'], # !!! Cmd defined on Image
'Volumes': {},
'Entrypoint': None,
'ExposedPorts': {},
},
})
__salt__ = {'dockerng.list_containers': dockerng_list_containers,
'dockerng.inspect_container': dockerng_inspect_container,
'dockerng.inspect_image': dockerng_inspect_image,
'dockerng.list_tags': MagicMock(side_effect=[['image:latest']]),
'dockerng.state': MagicMock(side_effect=['running']),
}
with patch.dict(dockerng_state.__dict__,
{'__salt__': __salt__}):
ret = dockerng_state.running(
'cont',
image='image:latest',
)
self.assertEqual(ret, {'name': 'cont',
'comment': "Container 'cont' is already"
" configured as specified",
'changes': {},
'result': True,
})
def test_removal_of_parameter_is_detected(self):
'''
Test dockerng.running with deleted parameter.
1. define your sls
.. code-block:: yaml
container:
dockerng.running:
- name: super-container
- binds:
- /path:/path:ro
2. run state.highstate
3. modify your sls by removing `- binds:`
.. code-block:: yaml
container:
dockerng.running:
- name: super-container
4. enjoy your new created container without mounted volumes.
'''
image_id = 'abcdefg'
dockerng_create = Mock(return_value=True)
dockerng_start = Mock()
dockerng_list_containers = Mock(return_value=['cont'])
dockerng_inspect_container = Mock(
side_effect=[{
'Config': {
'Image': 'image:latest',
'Tty': False,
'Labels': {},
'Domainname': '',
'User': '',
'AttachStderr': True,
'AttachStdout': True,
'Hostname': 'saltstack-container',
'Env': [],
'WorkingDir': '/',
'Cmd': ['bash'],
'Volumes': {'/path': {}},
'Entrypoint': None,
'ExposedPorts': {},
'OpenStdin': False,
},
'HostConfig': {
'PublishAllPorts': False,
'Dns': [],
'Links': None,
'CpusetCpus': '',
'RestartPolicy': {'MaximumRetryCount': 0, 'Name': ''},
'CapAdd': None,
'NetworkMode': 'default',
'PidMode': '',
'MemorySwap': 0,
'ExtraHosts': None,
'PortBindings': None,
'LxcConf': None,
'DnsSearch': [],
'Privileged': False,
'Binds': ['/path:/path:ro'],
'Memory': 0,
'VolumesFrom': None,
'CpuShares': 0,
'CapDrop': None,
},
'NetworkSettings': {
'MacAddress': '00:00:00:00:00:01',
},
'Image': image_id},
{'Config': {
'Image': 'image:latest',
'Tty': False,
'Labels': {},
'Domainname': '',
'User': '',
'AttachStderr': True,
'AttachStdout': True,
'Hostname': 'saltstack-container',
'Env': [],
'WorkingDir': '/',
'Cmd': ['bash'],
'Volumes': {'/path': {}},
'Entrypoint': None,
'ExposedPorts': {},
'OpenStdin': False,
},
'HostConfig': {
'PublishAllPorts': False,
'Dns': [],
'Links': None,
'CpusetCpus': '',
'RestartPolicy': {'MaximumRetryCount': 0, 'Name': ''},
'CapAdd': None,
'NetworkMode': 'default',
'PidMode': '',
'MemorySwap': 0,
'ExtraHosts': None,
'PortBindings': None,
'LxcConf': None,
'DnsSearch': [],
'Privileged': False,
'Binds': None,
'Memory': 0,
'VolumesFrom': None,
'CpuShares': 0,
'CapDrop': None,
},
'NetworkSettings': {
'MacAddress': '00:00:00:00:00:01',
},
'Image': image_id}]
)
dockerng_inspect_image = MagicMock(
return_value={
'Id': image_id,
'Config': {
'Hostname': 'saltstack-container',
'WorkingDir': '/',
'Cmd': ['bash'],
'Volumes': {'/path': {}},
'Entrypoint': None,
'ExposedPorts': {},
},
})
__salt__ = {'dockerng.list_containers': dockerng_list_containers,
'dockerng.inspect_container': dockerng_inspect_container,
'dockerng.inspect_image': dockerng_inspect_image,
'dockerng.list_tags': MagicMock(),
'dockerng.pull': MagicMock(return_value=True),
'dockerng.state': MagicMock(side_effect=['stopped',
'running']),
'dockerng.rm': MagicMock(return_value='cont'),
'dockerng.create': dockerng_create,
'dockerng.start': dockerng_start,
}
with patch.dict(dockerng_state.__dict__,
{'__salt__': __salt__}):
ret = dockerng_state.running(
'cont',
image='image:latest',
)
self.assertEqual(ret, {'name': 'cont',
'comment': "Container 'cont' changed state.."
" Container 'cont' was replaced.",
'changes': {
'diff': {'binds':
{'new': [],
'old': ['/path:/path:ro']}},
'image': True,
'removed': 'cont',
'state': {'new': 'running',
'old': 'stopped'},
'added': True,
},
'result': True,
})
dockerng_create.assert_called_with('image:latest',
validate_ip_addrs=False,
validate_input=False,
name='cont',
client_timeout=60)
def test__load_tab(self):
cron.__grains__ = __grains__
with patch.dict(cron.__grains__, {'os_family': 'Solaris'}):
crons1 = cron.list_tab('root')
crons2 = cron.list_tab('root')
crons3 = cron.list_tab('root')
crons4 = cron.list_tab('root')
crons5 = cron.list_tab('root')
self.assertEqual(crons1, {
'pre': [],
'crons': [],
'env': [],
'special': []
})
self.assertEqual(
crons2['crons'][0], {
'comment': None,
'commented': False,
'dayweek': '*',
'hour': '*',
'identifier': None,
'cmd': 'ls',
'daymonth': '*',
'minute': '*',
'month': '*'
})
self.assertEqual(
crons3['crons'][0], {
'comment': 'commented',
'commented': True,
'dayweek': '*',
'hour': '*',
'identifier': None,
'cmd': 'ls',
'daymonth': '*',
'minute': '*',
'month': '*'
})
self.assertEqual(
crons4['crons'][0], {
'comment': 'foo',
'commented': False,
'dayweek': '*',
'hour': '*',
'identifier': None,
'cmd': 'ls',
'daymonth': '*',
'minute': '*',
'month': '*'
})
self.assertEqual(
crons5['crons'][0], {
'comment': 'foo',
'commented': False,
'dayweek': '*',
'hour': '*',
'identifier': 'blah',
'cmd': 'ls',
'daymonth': '*',
'minute': '*',
'month': '*'
})
def test_check_start_true(self):
'''
If start is True, then dockerng.running will try
to start a container that is stopped.
'''
image_id = 'abcdefg'
dockerng_create = Mock()
dockerng_start = Mock()
dockerng_list_containers = Mock(return_value=['cont'])
dockerng_inspect_container = Mock(
return_value={
'Config': {
'Image': 'image:latest',
'Tty': False,
'Labels': {},
'Domainname': '',
'User': '',
'AttachStderr': True,
'AttachStdout': True,
'Hostname': 'saltstack-container',
'Env': [],
'WorkingDir': '/',
'Cmd': ['bash'],
'Volumes': {},
'Entrypoint': None,
'ExposedPorts': {},
'OpenStdin': False,
},
'HostConfig': {
'PublishAllPorts': False,
'Dns': [],
'Links': None,
'CpusetCpus': '',
'RestartPolicy': {'MaximumRetryCount': 0, 'Name': ''},
'CapAdd': None,
'NetworkMode': 'default',
'PidMode': '',
'MemorySwap': 0,
'ExtraHosts': None,
'PortBindings': None,
'LxcConf': None,
'DnsSearch': [],
'Privileged': False,
'Binds': None,
'Memory': 0,
'VolumesFrom': None,
'CpuShares': 0,
'CapDrop': None,
},
'NetworkSettings': {
'MacAddress': '00:00:00:00:00:01',
},
'Image': image_id})
dockerng_inspect_image = MagicMock(
return_value={
'Id': image_id,
'Config': {
'Hostname': 'saltstack-container',
'WorkingDir': '/',
'Cmd': ['bash'],
'Volumes': {},
'Entrypoint': None,
'ExposedPorts': {},
},
})
__salt__ = {'dockerng.list_containers': dockerng_list_containers,
'dockerng.inspect_container': dockerng_inspect_container,
'dockerng.inspect_image': dockerng_inspect_image,
'dockerng.list_tags': MagicMock(),
'dockerng.pull': MagicMock(return_value=True),
'dockerng.state': MagicMock(side_effect=['stopped',
'running']),
'dockerng.create': dockerng_create,
'dockerng.start': dockerng_start,
}
with patch.dict(dockerng_state.__dict__,
{'__salt__': __salt__}):
ret = dockerng_state.running(
'cont',
image='image:latest',
start=True,
)
self.assertEqual(ret, {'name': 'cont',
'comment': "Container 'cont' changed state.",
'changes': {'state': {'new': 'running',
'old': 'stopped'},
'image': True},
'result': True,
})
