def test_repo_noadd_mod_noref(self):
'''
Test mod_repo detects the repository exists,
calls modify to update 'autorefresh' but does not call refresh
:return:
'''
url = self.new_repo_config['url']
name = self.new_repo_config['name']
self.zypper_patcher_config['_get_configured_repos'] = Mock(
**{'return_value.sections.return_value': [name]})
zypper_patcher = patch.multiple('salt.modules.zypper',
**self.zypper_patcher_config)
with zypper_patcher:
zypper.mod_repo(name, **{'url': url, 'refresh': True})
zypper.__zypper__.xml.call.assert_not_called()
zypper.__zypper__.refreshable.xml.call.assert_called_once_with(
'mr', '--refresh', name)
def test_device_no_repeat_with_not_found_state(self):
config = {'states': ['offline'], 'battery_low': 30}
out = [
'List of devices attached\nHTC\tdevice', '25',
'List of devices attached\nHTC\tdevice', '25'
]
mock = Mock(side_effect=out)
with patch.dict(adb.__salt__, {'cmd.run': mock}):
ret = adb.beacon(config)
self.assertEqual(ret, [{
'device': 'HTC',
'battery_level': 25,
'tag': 'battery_low'
}])
ret = adb.beacon(config)
self.assertEqual(ret, [])
def test_version(self, popen_mock):
'''
Test that salt.utils.systemd.booted() returns True when minion is
systemd-booted.
'''
_version = 231
output = 'systemd {0}\n-SYSVINIT'.format(_version)
popen_mock.return_value = Mock(
communicate=lambda *args, **kwargs: (output, None),
pid=lambda: 12345,
retcode=0
)
# Test without context dict passed
self.assertEqual(_systemd.version(), _version)
# Test that context key is set when context dict is passed
context = {}
self.assertTrue(_systemd.version(context))
self.assertEqual(context, {'salt.utils.systemd.version': _version})
def test_multiple_low_batteries(self):
config = {'states': ['device'], 'battery_low': 30}
out = [
'List of devices attached\nHTC\tdevice',
'25\n14',
]
mock = Mock(side_effect=out)
with patch.dict(adb.__salt__, {'cmd.run': mock}):
ret = adb.beacon(config)
self.assertEqual(ret, [{
'device': 'HTC',
'state': 'device',
'tag': 'device'
}, {
'device': 'HTC',
'battery_level': 25,
'tag': 'battery_low'
}])
def test_has_scope_version_parse_problem(self, popen_mock):
'''
Test the case where the system is systemd-booted, but we failed to
parse the "systemctl --version" output.
'''
popen_mock.return_value = Mock(
communicate=lambda *args, **kwargs: ('invalid', None),
pid=lambda: 12345,
retcode=0
)
with patch('os.stat', side_effect=_booted_effect):
# Test without context dict passed
self.assertFalse(_systemd.has_scope())
# Test that context key is set when context dict is passed. A
# failure to parse the systemctl output should not set a context
# key, so it should not be present in the context dict.
context = {}
self.assertFalse(_systemd.has_scope(context))
self.assertEqual(context, {'salt.utils.systemd.booted': True})
def test_running_with_labels_from_image(self):
'''
Test dockerng.running with labels parameter supports also
labels carried by the image.
'''
dockerng_create = Mock()
image_id = 'a' * 128
dockerng_inspect_image = MagicMock(
return_value={
'Id': image_id,
'Config': {
'Hostname': 'saltstack-container',
'WorkingDir': '/',
'Cmd': ['bash'],
'Volumes': {'/path': {}},
'Entrypoint': None,
'ExposedPorts': {},
'Labels': {'IMAGE_LABEL': 'image_foo',
'LABEL1': 'label1'},
},
})
__salt__ = {'dockerng.list_containers': MagicMock(),
'dockerng.list_tags': MagicMock(),
'dockerng.pull': MagicMock(),
'dockerng.state': MagicMock(),
'dockerng.inspect_image': dockerng_inspect_image,
'dockerng.create': dockerng_create,
}
with patch.dict(dockerng_state.__dict__,
{'__salt__': __salt__}):
dockerng_state.running(
'cont',
image='image:latest',
labels=[{'LABEL1': 'foo1'}, {'LABEL2': 'foo2'}],
)
dockerng_create.assert_called_with(
'image:latest',
validate_input=False,
validate_ip_addrs=False,
name='cont',
labels={'LABEL1': 'foo1', 'LABEL2': 'foo2'},
client_timeout=60)
def test_repo_noadd_nomod_noref(self):
'''
Test mod_repo detects the repo already exists,
no modification was requested and no refresh requested either
:return:
'''
url = self.new_repo_config['url']
name = self.new_repo_config['name']
self.zypper_patcher_config['_get_configured_repos'] = Mock(
**{'return_value.sections.return_value': [name]}
)
zypper_patcher = patch.multiple(
'salt.modules.zypper', **self.zypper_patcher_config)
with zypper_patcher:
self.assertEqual(zypper.mod_repo(name, **{'url': url}),
{'comment': 'Specified arguments did not result in modification of repo'})
zypper.__zypper__.xml.call.assert_not_called()
zypper.__zypper__.refreshable.xml.call.assert_not_called()
def test_repo_noadd_nomod_ref(self):
'''
Test mod_repo detects the repo already exists,
has nothing to modify and refreshes the repo with
`zypper --gpg-auto-import-keys refresh <repo-name>`
:return:
'''
url = self.new_repo_config['url']
name = self.new_repo_config['name']
self.zypper_patcher_config['_get_configured_repos'] = Mock(
**{'return_value.sections.return_value': [name]})
zypper_patcher = patch.multiple('salt.modules.zypper',
**self.zypper_patcher_config)
with zypper_patcher:
zypper.mod_repo(name, **{'url': url, 'gpgautoimport': True})
self.assertEqual(zypper.__zypper__.xml.call.call_args_list,
[call('--gpg-auto-import-keys', 'refresh', name)])
zypper.__zypper__.refreshable.xml.call.assert_not_called()
def test_device_state_change(self):
config = {'states': ['offline']}
out = [
'List of devices attached\nHTC\tdevice',
'List of devices attached\nHTC\toffline'
]
mock = Mock(side_effect=out)
with patch.dict(adb.__salt__, {'cmd.run': mock}):
ret = adb.beacon(config)
self.assertEqual(ret, [])
ret = adb.beacon(config)
self.assertEqual(ret, [{
'device': 'HTC',
'state': 'offline',
'tag': 'offline'
}])
def test_running_compare_images_by_id(self):
'''
Make sure the container is running
against expected image.
Here the local image is named 'image:latest' and the container
is also running against an image called 'image:latest'.
Therefore the image ids are diverging because the tag 'image:latest'
moved to a fresher image.
Thus this test make sure the old container is droped and recreated.
'''
new_fake_image_id = 'abcdefgh'
old_fake_image_id = '123456789'
dockerng_inspect_image = Mock(return_value={'Id': new_fake_image_id})
dockerng_inspect_container = Mock(
return_value={'Image': old_fake_image_id,
'Config': {'Image': 'image:latest'}})
dockerng_list_containers = Mock(return_value=['cont'])
dockerng__state = Mock(return_value='running')
dockerng_stop = Mock(return_value={'result': True})
dockerng_rm = Mock(return_value=['container-id'])
__salt__ = {'dockerng.list_containers': dockerng_list_containers,
'dockerng.inspect_container': dockerng_inspect_container,
'dockerng.inspect_image': dockerng_inspect_image,
'dockerng.list_tags': MagicMock(),
'dockerng.state': dockerng__state,
'dockerng.pull': MagicMock(return_value=new_fake_image_id),
'dockerng.create': MagicMock(return_value='new_container'),
'dockerng.start': MagicMock(),
'dockerng.stop': dockerng_stop,
'dockerng.rm': dockerng_rm,
}
with patch.dict(dockerng_state.__dict__,
{'__salt__': __salt__}):
ret = dockerng_state.running(
'cont',
image='image:latest',
)
dockerng_stop.assert_called_with('cont', timeout=10, unpause=True)
dockerng_rm.assert_called_with('cont')
self.assertEqual(ret, {'name': 'cont',
'comment': "Container 'cont' was replaced",
'result': True,
'changes': {'added': 'new_container',
'image': new_fake_image_id,
'removed': ['container-id']}
})
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)
client = MagicMock()
client.api_version = '1.12'
get_client_mock = MagicMock(return_value=client)
with patch.dict(
dockerng_mod.__salt__, {
'mine.send': mine_send,
'container_resource.run': MagicMock(),
'cp.cache_file': MagicMock(return_value=False)
}):
with patch.object(dockerng_mod, '_get_client',
get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
command('container', *args)
mine_send.assert_called_with('dockerng.ps',
verbose=True,
all=True,
host=True)
def test_device_no_repeat_capacity_increase(self):
config = {'states': ['device'], 'battery_low': 75}
out = [
'List of devices attached\nHTC\tdevice', '25',
'List of devices attached\nHTC\tdevice', '30'
]
mock = Mock(side_effect=out)
with patch.dict(adb.__salt__, {'cmd.run': mock}):
ret = adb.beacon(config)
self.assertEqual(ret, [{
'device': 'HTC',
'state': 'device',
'tag': 'device'
}, {
'device': 'HTC',
'battery_level': 25,
'tag': 'battery_low'
}])
ret = adb.beacon(config)
self.assertEqual(ret, [])
def test_no_devices_no_repeat(self):
config = {'states': ['offline', 'device'], 'no_devices_event': True}
out = [
'List of devices attached\nHTC\tdevice',
'List of devices attached', 'List of devices attached'
]
mock = Mock(side_effect=out)
with patch.dict(adb.__salt__, {'cmd.run': mock}):
ret = adb.beacon(config)
self.assertEqual(ret, [{
'device': 'HTC',
'state': 'device',
'tag': 'device'
}])
ret = adb.beacon(config)
self.assertEqual(ret, [{'tag': 'no_devices'}])
ret = adb.beacon(config)
self.assertEqual(ret, [])
def test_os_environment_remains_intact(self, loads_mock, popen_mock,
getpwnam_mock):
'''
Make sure the OS environment is not tainted after running a command
that specifies runas.
'''
environment = os.environ.copy()
popen_mock.return_value = Mock(
communicate=lambda *args, **kwags: ['{}', None],
pid=lambda: 1,
retcode=0)
loads_mock.return_value = {'data': {'USER': '******'}}
from salt.modules import cmdmod
cmdmod.__grains__ = {'os': 'darwin'}
if sys.platform.startswith('freebsd'):
shell = '/bin/sh'
else:
shell = '/bin/bash'
try:
cmdmod._run('ls',
cwd=tempfile.gettempdir(),
runas='foobar',
shell=shell)
environment2 = os.environ.copy()
self.assertEqual(environment, environment2)
getpwnam_mock.assert_called_with('foobar')
loads_mock.assert_called_with('{}')
finally:
delattr(cmdmod, '__grains__')
def test_running_with_labels(self):
'''
Test dockerng.running with labels parameter.
'''
dockerng_create = Mock()
__salt__ = {
'dockerng.list_containers': MagicMock(),
'dockerng.list_tags': MagicMock(),
'dockerng.pull': MagicMock(),
'dockerng.state': MagicMock(),
'dockerng.inspect_image': MagicMock(),
'dockerng.create': dockerng_create,
}
with patch.dict(dockerng_state.__dict__, {'__salt__': __salt__}):
dockerng_state.running(
'cont',
image='image:latest',
labels=['LABEL1', 'LABEL2'],
)
dockerng_create.assert_called_with('image:latest',
validate_input=False,
name='cont',
labels=['LABEL1', 'LABEL2'],
client_timeout=60)
def make_decryption_mock(self):
decrypted_data_mock = Mock()
decrypted_data_mock.ok = True
decrypted_data_mock.__str__ = lambda x: DECRYPTED_STRING
return decrypted_data_mock
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,
})
class DockerngTestCase(TestCase):
'''
Validate dockerng module
'''
def setUp(self):
'''
Ensure we aren't persisting context dunders between tests
'''
dockerng_mod.__context__ = {'docker.docker_version': ''}
try:
docker_version = dockerng_mod.docker.version_info
except AttributeError:
docker_version = 0,
client_args_mock = MagicMock(
return_value={
'create_container': [
'image', 'command', 'hostname', 'user', 'detach', 'stdin_open',
'tty', 'ports', 'environment', 'volumes', 'network_disabled',
'name', 'entrypoint', 'working_dir', 'domainname', 'cpuset',
'host_config', 'mac_address', 'labels', 'volume_driver',
'stop_signal', 'networking_config', 'healthcheck',
'stop_timeout'
],
'host_config': [
'binds', 'port_bindings', 'lxc_conf', 'publish_all_ports',
'links', 'privileged', 'dns', 'dns_search', 'volumes_from',
'network_mode', 'restart_policy', 'cap_add', 'cap_drop',
'devices', 'extra_hosts', 'read_only', 'pid_mode', 'ipc_mode',
'security_opt', 'ulimits', 'log_config', 'mem_limit',
'memswap_limit', 'mem_reservation', 'kernel_memory',
'mem_swappiness', 'cgroup_parent', 'group_add', 'cpu_quota',
'cpu_period', 'blkio_weight', 'blkio_weight_device',
'device_read_bps', 'device_write_bps', 'device_read_iops',
'device_write_iops', 'oom_kill_disable', 'shm_size', 'sysctls',
'tmpfs', 'oom_score_adj', 'dns_opt', 'cpu_shares',
'cpuset_cpus', 'userns_mode', 'pids_limit', 'isolation',
'auto_remove', 'storage_opt'
],
'networking_config': [
'aliases', 'links', 'ipv4_address', 'ipv6_address',
'link_local_ips'
],
})
def test_ps_with_host_true(self):
'''
Check that dockerng.ps called with host is ``True``,
include resutlt of ``network.interfaces`` command in returned result.
'''
client = Mock()
client.containers = MagicMock(return_value=[])
get_client_mock = MagicMock(return_value=client)
network_interfaces = Mock(return_value={'mocked': None})
with patch.dict(dockerng_mod.__salt__,
{'network.interfaces': network_interfaces}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
ret = dockerng_mod.ps_(host=True)
self.assertEqual(ret,
{'host': {
'interfaces': {
'mocked': None
}
}})
def test_ps_with_filters(self):
'''
Check that dockerng.ps accept filters parameter.
'''
client = Mock()
client.containers = MagicMock(return_value=[])
get_client_mock = MagicMock(return_value=client)
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.ps_(filters={'label': 'KEY'})
client.containers.assert_called_once_with(all=True,
filters={'label': 'KEY'})
@patch.object(dockerng_mod, '_get_exec_driver')
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)
client = MagicMock()
client.api_version = '1.12'
get_client_mock = MagicMock(return_value=client)
with patch.dict(
dockerng_mod.__salt__, {
'mine.send': mine_send,
'container_resource.run': MagicMock(),
'cp.cache_file': MagicMock(return_value=False)
}):
with patch.object(dockerng_mod, '_get_client',
get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
command('container', *args)
mine_send.assert_called_with('dockerng.ps',
verbose=True,
all=True,
host=True)
@skipIf(docker_version < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_arg_cmd(self, *args):
'''
When cmd argument is passed check it is renamed to command.
'''
__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 = {}
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
dockerng_mod.create('image', cmd='ls', name='ctn')
client.create_container.assert_called_once_with(
command='ls', host_config=host_config, image='image', name='ctn')
@skipIf(docker_version < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_send_host_config(self, *args):
'''
Check host_config object is passed to create_container.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {'PublishAllPorts': True}
client = Mock()
client.api_version = '1.19'
client.create_host_config.return_value = host_config
client.create_container.return_value = {}
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
dockerng_mod.create('image',
name='ctn',
publish_all_ports=True)
client.create_container.assert_called_once_with(
host_config=host_config, image='image', name='ctn')
@skipIf(docker_version < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_dict(self, *args):
'''
Create container with labels dictionary.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
'dockerng.version': MagicMock(return_value={}),
}
host_config = {}
client = Mock()
client.api_version = '1.19'
client.create_host_config.return_value = host_config
client.create_container.return_value = {}
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
dockerng_mod.create(
'image',
name='ctn',
labels={'KEY': 'VALUE'},
validate_input=True,
)
client.create_container.assert_called_once_with(
labels={'KEY': 'VALUE'},
host_config=host_config,
image='image',
name='ctn',
)
@skipIf(docker_version < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_list(self, *args):
'''
Create container with labels list.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
'dockerng.version': MagicMock(return_value={}),
}
host_config = {}
client = Mock()
client.api_version = '1.19'
client.create_host_config.return_value = host_config
client.create_container.return_value = {}
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
dockerng_mod.create(
'image',
name='ctn',
labels=['KEY1', 'KEY2'],
validate_input=True,
)
client.create_container.assert_called_once_with(
labels=['KEY1', 'KEY2'],
host_config=host_config,
image='image',
name='ctn',
)
@skipIf(docker_version < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_error(self, *args):
'''
Create container with invalid labels.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
'dockerng.version': MagicMock(return_value={}),
}
host_config = {}
client = Mock()
client.api_version = '1.19'
client.create_host_config.return_value = host_config
client.create_container.return_value = {}
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
self.assertRaises(
SaltInvocationError,
dockerng_mod.create,
'image',
name='ctn',
labels=22,
validate_input=True,
)
@skipIf(docker_version < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_dictlist(self, *args):
'''
Create container with labels dictlist.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
'dockerng.version': MagicMock(return_value={}),
}
host_config = {}
client = Mock()
client.api_version = '1.19'
client.create_host_config.return_value = host_config
client.create_container.return_value = {}
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
with patch.object(dockerng_mod, 'get_client_args',
self.client_args_mock):
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',
)
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_list_networks(self, *args):
'''
test list networks.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.networks(
names=['foo'],
ids=['01234'],
)
client.networks.assert_called_once_with(
names=['foo'],
ids=['01234'],
)
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_create_network(self, *args):
'''
test create network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.create_network('foo', driver='bridge')
client.create_network.assert_called_once_with('foo', driver='bridge')
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_remove_network(self, *args):
'''
test remove network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.remove_network('foo')
client.remove_network.assert_called_once_with('foo')
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_inspect_network(self, *args):
'''
test inspect network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.inspect_network('foo')
client.inspect_network.assert_called_once_with('foo')
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_connect_container_to_network(self, *args):
'''
test inspect network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.connect_container_to_network('container', 'foo')
client.connect_container_to_network.assert_called_once_with(
'container', 'foo')
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_disconnect_container_from_network(self, *args):
'''
test inspect network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.disconnect_container_from_network(
'container', 'foo')
client.disconnect_container_from_network.assert_called_once_with(
'container', 'foo')
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_list_volumes(self, *args):
'''
test list volumes.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.volumes(filters={'dangling': [True]})
client.volumes.assert_called_once_with(filters={'dangling': [True]})
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_create_volume(self, *args):
'''
test create volume.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.create_volume(
'foo',
driver='bridge',
driver_opts={},
)
client.create_volume.assert_called_once_with(
'foo',
driver='bridge',
driver_opts={},
)
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_remove_volume(self, *args):
'''
test remove volume.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.remove_volume('foo')
client.remove_volume.assert_called_once_with('foo')
@skipIf(docker_version < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
@patch('salt.modules.dockerng._get_docker_py_versioninfo',
MagicMock(return_value=docker_version))
def test_inspect_volume(self, *args):
'''
test inspect volume.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod.inspect_volume('foo')
client.inspect_volume.assert_called_once_with('foo')
def test_wait_success(self):
client = Mock()
client.api_version = '1.21'
client.wait = Mock(return_value=0)
get_client_mock = MagicMock(return_value=client)
dockerng_inspect_container = Mock(side_effect=[{
'State': {
'Running': True
}
}, {
'State': {
'Stopped': True
}
}])
with patch.object(dockerng_mod, 'inspect_container',
dockerng_inspect_container):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.wait('foo')
self.assertEqual(
result, {
'result': True,
'exit_status': 0,
'state': {
'new': 'stopped',
'old': 'running'
}
})
def test_wait_fails_already_stopped(self):
client = Mock()
client.api_version = '1.21'
client.wait = Mock(return_value=0)
get_client_mock = MagicMock(return_value=client)
dockerng_inspect_container = Mock(side_effect=[
{
'State': {
'Stopped': True
}
},
{
'State': {
'Stopped': True
}
},
])
with patch.object(dockerng_mod, 'inspect_container',
dockerng_inspect_container):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.wait('foo')
self.assertEqual(
result, {
'result': False,
'comment': "Container 'foo' already stopped",
'exit_status': 0,
'state': {
'new': 'stopped',
'old': 'stopped'
}
})
def test_wait_success_already_stopped(self):
client = Mock()
client.api_version = '1.21'
client.wait = Mock(return_value=0)
get_client_mock = MagicMock(return_value=client)
dockerng_inspect_container = Mock(side_effect=[
{
'State': {
'Stopped': True
}
},
{
'State': {
'Stopped': True
}
},
])
with patch.object(dockerng_mod, 'inspect_container',
dockerng_inspect_container):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.wait('foo', ignore_already_stopped=True)
self.assertEqual(
result, {
'result': True,
'comment': "Container 'foo' already stopped",
'exit_status': 0,
'state': {
'new': 'stopped',
'old': 'stopped'
}
})
def test_wait_success_absent_container(self):
client = Mock()
client.api_version = '1.21'
get_client_mock = MagicMock(return_value=client)
dockerng_inspect_container = Mock(side_effect=CommandExecutionError)
with patch.object(dockerng_mod, 'inspect_container',
dockerng_inspect_container):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.wait('foo', ignore_already_stopped=True)
self.assertEqual(result, {
'result': True,
'comment': "Container 'foo' absent"
})
def test_wait_fails_on_exit_status(self):
client = Mock()
client.api_version = '1.21'
client.wait = Mock(return_value=1)
get_client_mock = MagicMock(return_value=client)
dockerng_inspect_container = Mock(side_effect=[{
'State': {
'Running': True
}
}, {
'State': {
'Stopped': True
}
}])
with patch.object(dockerng_mod, 'inspect_container',
dockerng_inspect_container):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.wait('foo', fail_on_exit_status=True)
self.assertEqual(
result, {
'result': False,
'exit_status': 1,
'state': {
'new': 'stopped',
'old': 'running'
}
})
def test_wait_fails_on_exit_status_and_already_stopped(self):
client = Mock()
client.api_version = '1.21'
client.wait = Mock(return_value=1)
get_client_mock = MagicMock(return_value=client)
dockerng_inspect_container = Mock(side_effect=[{
'State': {
'Stopped': True
}
}, {
'State': {
'Stopped': True
}
}])
with patch.object(dockerng_mod, 'inspect_container',
dockerng_inspect_container):
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.wait('foo',
ignore_already_stopped=True,
fail_on_exit_status=True)
self.assertEqual(
result, {
'result': False,
'comment': "Container 'foo' already stopped",
'exit_status': 1,
'state': {
'new': 'stopped',
'old': 'stopped'
}
})
def test_sls_build(self, *args):
'''
test build sls image.
'''
docker_start_mock = MagicMock(return_value={})
docker_create_mock = MagicMock(return_value={
'Id': 'ID',
'Name': 'NAME'
})
docker_stop_mock = MagicMock(return_value={
'state': {
'old': 'running',
'new': 'stopped'
},
'result': True
})
docker_commit_mock = MagicMock(return_value={
'Id': 'ID2',
'Image': 'foo',
'Time_Elapsed': 42
})
docker_sls_mock = MagicMock(
return_value={
"file_|-/etc/test.sh_|-/etc/test.sh_|-managed": {
"comment": "File /etc/test.sh is in the correct state",
"name": "/etc/test.sh",
"start_time": "07:04:26.834792",
"result": True,
"duration": 13.492,
"__run_num__": 0,
"changes": {}
},
"test_|-always-passes_|-foo_|-succeed_without_changes": {
"comment": "Success!",
"name": "foo",
"start_time": "07:04:26.848915",
"result": True,
"duration": 0.363,
"__run_num__": 1,
"changes": {}
}
})
ret = None
with patch.dict(
dockerng_mod.__salt__, {
'dockerng.start': docker_start_mock,
'dockerng.create': docker_create_mock,
'dockerng.stop': docker_stop_mock,
'dockerng.commit': docker_commit_mock,
'dockerng.sls': docker_sls_mock
}):
ret = dockerng_mod.sls_build(
'foo',
mods='foo',
)
docker_create_mock.assert_called_once_with(cmd='sleep infinity',
image='opensuse/python',
interactive=True,
name='foo',
tty=True)
docker_start_mock.assert_called_once_with('ID')
docker_sls_mock.assert_called_once_with('ID', 'foo', 'base')
docker_stop_mock.assert_called_once_with('ID')
docker_commit_mock.assert_called_once_with('ID', 'foo')
self.assertEqual({
'Id': 'ID2',
'Image': 'foo',
'Time_Elapsed': 42
}, ret)
def test_sls_build_dryrun(self, *args):
'''
test build sls image in dryrun mode.
'''
docker_start_mock = MagicMock(return_value={})
docker_create_mock = MagicMock(return_value={
'Id': 'ID',
'Name': 'NAME'
})
docker_stop_mock = MagicMock(return_value={
'state': {
'old': 'running',
'new': 'stopped'
},
'result': True
})
docker_rm_mock = MagicMock(return_value={})
docker_sls_mock = MagicMock(
return_value={
"file_|-/etc/test.sh_|-/etc/test.sh_|-managed": {
"comment": "File /etc/test.sh is in the correct state",
"name": "/etc/test.sh",
"start_time": "07:04:26.834792",
"result": True,
"duration": 13.492,
"__run_num__": 0,
"changes": {}
},
"test_|-always-passes_|-foo_|-succeed_without_changes": {
"comment": "Success!",
"name": "foo",
"start_time": "07:04:26.848915",
"result": True,
"duration": 0.363,
"__run_num__": 1,
"changes": {}
}
})
ret = None
with patch.dict(
dockerng_mod.__salt__, {
'dockerng.start': docker_start_mock,
'dockerng.create': docker_create_mock,
'dockerng.stop': docker_stop_mock,
'dockerng.rm': docker_rm_mock,
'dockerng.sls': docker_sls_mock
}):
ret = dockerng_mod.sls_build('foo', mods='foo', dryrun=True)
docker_create_mock.assert_called_once_with(cmd='sleep infinity',
image='opensuse/python',
interactive=True,
name='foo',
tty=True)
docker_start_mock.assert_called_once_with('ID')
docker_sls_mock.assert_called_once_with('ID', 'foo', 'base')
docker_stop_mock.assert_called_once_with('ID')
docker_rm_mock.assert_called_once_with('ID')
self.assertEqual(
{
"file_|-/etc/test.sh_|-/etc/test.sh_|-managed": {
"comment": "File /etc/test.sh is in the correct state",
"name": "/etc/test.sh",
"start_time": "07:04:26.834792",
"result": True,
"duration": 13.492,
"__run_num__": 0,
"changes": {}
},
"test_|-always-passes_|-foo_|-succeed_without_changes": {
"comment": "Success!",
"name": "foo",
"start_time": "07:04:26.848915",
"result": True,
"duration": 0.363,
"__run_num__": 1,
"changes": {}
}
}, ret)
def test_call_success(self):
'''
test module calling inside containers
'''
docker_run_all_mock = MagicMock(
return_value={
'retcode': 0,
'stdout': '{"retcode": 0, "comment": "container cmd"}',
'stderr': 'err',
})
docker_copy_to_mock = MagicMock(return_value={'retcode': 0})
docker_config_mock = MagicMock(return_value='')
client = Mock()
client.put_archive = Mock()
with nested(
patch.dict(dockerng_mod.__opts__, {'cachedir': '/tmp'}),
patch.dict(
dockerng_mod.__salt__, {
'dockerng.run_all': docker_run_all_mock,
'dockerng.copy_to': docker_copy_to_mock,
'config.option': docker_config_mock
}),
patch.dict(dockerng_mod.__context__,
{'docker.client': client})):
# call twice to verify tmp path later
for i in range(2):
ret = dockerng_mod.call('ID', 'test.arg', 1, 2, arg1='val1')
# Check that the directory is different each time
# [ call(name, [args]), ...
self.assertIn('mkdir', docker_run_all_mock.mock_calls[0][1][1])
self.assertIn('mkdir', docker_run_all_mock.mock_calls[3][1][1])
self.assertNotEqual(docker_run_all_mock.mock_calls[0][1][1],
docker_run_all_mock.mock_calls[3][1][1])
self.assertIn('salt-call', docker_run_all_mock.mock_calls[1][1][1])
self.assertIn('salt-call', docker_run_all_mock.mock_calls[4][1][1])
self.assertNotEqual(docker_run_all_mock.mock_calls[1][1][1],
docker_run_all_mock.mock_calls[4][1][1])
# check directory cleanup
self.assertIn('rm -rf', docker_run_all_mock.mock_calls[2][1][1])
self.assertIn('rm -rf', docker_run_all_mock.mock_calls[5][1][1])
self.assertNotEqual(docker_run_all_mock.mock_calls[2][1][1],
docker_run_all_mock.mock_calls[5][1][1])
self.assertEqual({"retcode": 0, "comment": "container cmd"}, ret)
def test_images_with_empty_tags(self):
"""
docker 1.12 reports also images without tags with `null`.
"""
client = Mock()
client.api_version = '1.24'
client.images = Mock(return_value=[{
'Id': 'sha256:abcde',
'RepoTags': None
}, {
'Id': 'sha256:abcdef'
}, {
'Id': 'sha256:abcdefg',
'RepoTags': ['image:latest']
}])
get_client_mock = MagicMock(return_value=client)
with patch.object(dockerng_mod, '_get_client', get_client_mock):
dockerng_mod._clear_context()
result = dockerng_mod.images()
self.assertEqual(result,
{'sha256:abcdefg': {
'RepoTags': ['image:latest']
}})
server accepts handled requests
46756 46756 89318
Reading: 0 Writing: 7 Waiting: 0"""
class MockUrllibStatus(object):
"""Mock of urllib2 call for Nginx status"""
def read(self):
return MOCK_STATUS_OUTPUT
def close(self):
pass
@skipIf(NO_MOCK, NO_MOCK_REASON)
@patch('salt.utils.which', Mock(return_value='/usr/bin/nginx'))
class NginxTestCase(TestCase):
@patch('salt.modules.nginx._urlopen',
Mock(return_value=MockUrllibStatus()))
def test_nginx_status(self):
result = nginx.status()
nginx._urlopen.assert_called_once_with('http://127.0.0.1/status')
self.assertEqual(
result, {
'active connections': 7,
'accepted': 46756,
'handled': 46756,
'requests': 89318,
'reading': 0,
'writing': 7,
'waiting': 0,
class PostgresUserTestCase(TestCase):
@patch.dict(
SALT_STUB, {
'postgres.role_get': Mock(return_value=None),
'postgres.user_create': MagicMock(),
})
def test_present__creation(self):
# test=True
with patch.dict(OPTS, {'test': True}):
ret = postgres_user.present('foo')
self.assertEqual(
ret, {
'comment': 'User foo is set to be created',
'changes': {},
'name': 'foo',
'result': None
})
self.assertEqual(SALT_STUB['postgres.user_create'].call_count, 0)
# test=False
ret = postgres_user.present('foo')
self.assertEqual(
ret, {
'comment': 'The user foo has been created',
'changes': {
'foo': 'Present'
},
'name': 'foo',
'result': True
})
SALT_STUB['postgres.user_create'].assert_called_once_with(
username='******',
superuser=None,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
replication=None,
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=None,
password=None,
createdb=None)
@patch.dict(
SALT_STUB, {
'postgres.role_get':
Mock(
return_value={
'can create databases': False,
'can create roles': False,
'can login': False,
'can update system catalogs': False,
'connections': None,
'defaults variables': {},
'expiry time': None,
'inherits privileges': True,
'replication': False,
'superuser': False,
}),
'postgres.user_update':
MagicMock(),
})
def test_present__update(self):
# test=True
with patch.dict(OPTS, {'test': True}):
ret = postgres_user.present('foo', login=True, replication=False)
self.assertEqual(
ret, {
'comment': 'User foo is set to be updated',
'changes': {
'foo': {
'login': True
}
},
'name': 'foo',
'result': None
})
self.assertEqual(SALT_STUB['postgres.user_update'].call_count, 0)
# test=False
ret = postgres_user.present('foo', login=True, replication=False)
self.assertEqual(
ret, {
'comment': 'The user foo has been updated',
'changes': {
'foo': {
'login': True
}
},
'name': 'foo',
'result': True
})
SALT_STUB['postgres.user_update'].assert_called_once_with(
username='******',
superuser=None,
encrypted=True,
runas=None,
inherit=None,
rolepassword=None,
port=None,
replication=False,
host=None,
createroles=None,
user=None,
groups=None,
maintenance_db=None,
login=True,
password=None,
createdb=None)
@patch.dict(
SALT_STUB, {
'postgres.role_get':
Mock(
return_value={
'can create databases': False,
'can create roles': False,
'can login': False,
'can update system catalogs': False,
'connections': None,
'defaults variables': {},
'expiry time': None,
'inherits privileges': True,
'replication': False,
'superuser': False,
}),
'postgres.user_update':
MagicMock(),
})
def test_present__no_update(self):
# test=True
with patch.dict(OPTS, {'test': True}):
ret = postgres_user.present('foo', login=False, replication=False)
self.assertEqual(
ret, {
'comment': 'User foo is already present',
'changes': {},
'name': 'foo',
'result': True
})
self.assertEqual(SALT_STUB['postgres.user_update'].call_count, 0)
# test=False
ret = postgres_user.present('foo', login=False, replication=False)
self.assertEqual(
ret, {
'comment': 'User foo is already present',
'changes': {},
'name': 'foo',
'result': True
})
self.assertEqual(SALT_STUB['postgres.user_update'].call_count, 0)
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)
class DockerngTestCase(TestCase):
'''
Validate dockerng module
'''
def test_ps_with_host_true(self):
'''
Check that dockerng.ps called with host is ``True``,
include resutlt of ``network.interfaces`` command in returned result.
'''
network_interfaces = Mock(return_value={'mocked': None})
with patch.dict(dockerng_mod.__salt__,
{'network.interfaces': network_interfaces}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': MagicMock()}):
ret = dockerng_mod.ps_(host=True)
self.assertEqual(ret,
{'host': {
'interfaces': {
'mocked': None
}
}})
def test_ps_with_filters(self):
'''
Check that dockerng.ps accept filters parameter.
'''
client = MagicMock()
with patch.dict(dockerng_mod.__context__, {'docker.client': client}):
dockerng_mod.ps_(filters={'label': 'KEY'})
client.containers.assert_called_once_with(all=True,
filters={'label': 'KEY'})
@patch.object(dockerng_mod, '_get_exec_driver')
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)
@skipIf(_docker_py_version() < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_arg_cmd(self, *args):
'''
When cmd argument is passed check it is renamed to command.
'''
__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', cmd='ls', name='ctn')
client.create_container.assert_called_once_with(
command='ls', host_config=host_config, image='image', name='ctn')
@skipIf(_docker_py_version() < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_send_host_config(self, *args):
'''
Check host_config object is passed to create_container.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {'PublishAllPorts': True}
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',
publish_all_ports=True)
client.create_container.assert_called_once_with(
host_config=host_config, image='image', name='ctn')
@skipIf(_docker_py_version() < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_dict(self, *args):
'''
Create container with labels dictionary.
'''
__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={'KEY': 'VALUE'},
validate_input=True,
)
client.create_container.assert_called_once_with(
labels={'KEY': 'VALUE'},
host_config=host_config,
image='image',
name='ctn',
)
@skipIf(_docker_py_version() < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_list(self, *args):
'''
Create container with labels list.
'''
__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', 'KEY2'],
validate_input=True,
)
client.create_container.assert_called_once_with(
labels=['KEY1', 'KEY2'],
host_config=host_config,
image='image',
name='ctn',
)
@skipIf(_docker_py_version() < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
def test_create_with_labels_error(self, *args):
'''
Create container with invalid labels.
'''
__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}):
self.assertRaises(
SaltInvocationError,
dockerng_mod.create,
'image',
name='ctn',
labels=22,
validate_input=True,
)
@skipIf(_docker_py_version() < (
1, 4, 0
), 'docker module must be installed to run this test or is too old. >=1.4.0'
)
@patch.object(dockerng_mod, 'images', MagicMock())
@patch.object(dockerng_mod, 'inspect_image')
@patch.object(dockerng_mod, 'version',
Mock(return_value={'ApiVersion': '1.19'}))
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',
)
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_list_networks(self, *args):
'''
test list networks.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.networks(
names=['foo'],
ids=['01234'],
)
client.networks.assert_called_once_with(
names=['foo'],
ids=['01234'],
)
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_create_network(self, *args):
'''
test create network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.create_network(
'foo',
driver='bridge',
)
client.create_network.assert_called_once_with(
'foo',
driver='bridge',
)
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_remove_network(self, *args):
'''
test remove network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.remove_network('foo')
client.remove_network.assert_called_once_with('foo')
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_inspect_network(self, *args):
'''
test inspect network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.inspect_network('foo')
client.inspect_network.assert_called_once_with('foo')
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_connect_container_to_network(self, *args):
'''
test inspect network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.connect_container_to_network('container', 'foo')
client.connect_container_to_network.assert_called_once_with(
'container', 'foo')
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_disconnect_container_from_network(self, *args):
'''
test inspect network.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
host_config = {}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.disconnect_container_from_network(
'container', 'foo')
client.disconnect_container_from_network.assert_called_once_with(
'container', 'foo')
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_list_volumes(self, *args):
'''
test list volumes.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.volumes(filters={'dangling': [True]}, )
client.volumes.assert_called_once_with(filters={'dangling': [True]}, )
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_create_volume(self, *args):
'''
test create volume.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.create_volume(
'foo',
driver='bridge',
driver_opts={},
)
client.create_volume.assert_called_once_with(
'foo',
driver='bridge',
driver_opts={},
)
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_remove_volume(self, *args):
'''
test remove volume.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.remove_volume('foo')
client.remove_volume.assert_called_once_with('foo')
@skipIf(_docker_py_version() < (
1, 5, 0
), 'docker module must be installed to run this test or is too old. >=1.5.0'
)
def test_inspect_volume(self, *args):
'''
test inspect volume.
'''
__salt__ = {
'config.get': Mock(),
'mine.send': Mock(),
}
client = Mock()
client.api_version = '1.21'
with patch.dict(dockerng_mod.__dict__, {'__salt__': __salt__}):
with patch.dict(dockerng_mod.__context__,
{'docker.client': client}):
dockerng_mod.inspect_volume('foo')
client.inspect_volume.assert_called_once_with('foo')
'Name,Owner,Encoding,Collate,Ctype,Access privileges,Tablespace\n'
'template1,postgres,LATIN1,en_US,en_US'
',"{=c/postgres,postgres=CTc/postgres}",pg_default\n'
'template0,postgres,LATIN1,en_US,en_US'
',"{=c/postgres,postgres=CTc/postgres}",pg_default\n'
'postgres,postgres,LATIN1,en_US,en_US,,pg_default\n'
'test_db,postgres,LATIN1,en_US,en_US,,pg_default')
test_list_schema_csv = (
'name,owner,acl\n'
'public,postgres,"{postgres=UC/postgres,=UC/postgres}"\n'
'pg_toast,postgres,""')
if NO_MOCK is False:
SALT_STUB = {
'config.option': Mock(),
'cmd.run_all': Mock(),
'file.chown': Mock(),
'file.remove': Mock(),
}
else:
SALT_STUB = {}
@skipIf(NO_MOCK, NO_MOCK_REASON)
@patch.multiple(postgres,
__grains__={'os_family': 'Linux'},
__salt__=SALT_STUB)
@patch('salt.utils.which', Mock(return_value='/usr/bin/pgsql'))
class PostgresTestCase(TestCase):
def test_run_psql(self):
def mock_json_response(data):
response = MagicMock()
response.json = MagicMock(return_value=data)
return Mock(return_value=response)
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)
# Import Salt Testing libs
from salttesting import skipIf, TestCase
from salttesting.helpers import ensure_in_syspath
from salttesting.mock import NO_MOCK, NO_MOCK_REASON, Mock, patch
ensure_in_syspath('../../')
# Import salt libs
from salt.modules import postgres
postgres.__grains__ = None # in order to stub it w/patch below
postgres.__salt__ = None # in order to stub it w/patch below
if NO_MOCK is False:
SALT_STUB = {
'config.option': Mock(),
'cmd.run_all': Mock(),
'file.chown': Mock(),
'file.remove': Mock(),
}
else:
SALT_STUB = {}
@skipIf(NO_MOCK, NO_MOCK_REASON)
class PostgresTestCase(TestCase):
@patch.multiple(postgres,
__grains__={'os_family': 'Linux'},
__salt__=SALT_STUB)
def test_run_psql(self):
postgres._run_psql('echo "hi"')
cmd = SALT_STUB['cmd.run_all']
class PostgresTestCase(TestCase):
def test_run_psql(self):
postgres._run_psql('echo "hi"')
cmd = SALT_STUB['cmd.run_all']
self.assertEqual('postgres', cmd.call_args[1]['runas'])
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
def test_db_alter(self):
postgres.db_alter('dbname',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
tablespace='testspace',
owner='otheruser',
runas='foo')
postgres._run_psql.assert_has_calls([
call([
'/usr/bin/pgsql', '--no-align', '--no-readline',
'--no-password', '--username', 'testuser', '--host',
'testhost', '--port', 'testport', '--dbname', 'maint_db', '-c',
'ALTER DATABASE "dbname" OWNER TO "otheruser"'
],
host='testhost',
user='******',
password='******',
runas='foo',
port='testport'),
call([
'/usr/bin/pgsql', '--no-align', '--no-readline',
'--no-password', '--username', 'testuser', '--host',
'testhost', '--port', 'testport', '--dbname', 'maint_db', '-c',
'ALTER DATABASE "dbname" SET TABLESPACE "testspace"'
],
host='testhost',
user='******',
password='******',
runas='foo',
port='testport')
])
@patch('salt.modules.postgres.owner_to',
Mock(return_value={'retcode': None}))
def test_db_alter_owner_recurse(self):
postgres.db_alter('dbname',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
tablespace='testspace',
owner='otheruser',
owner_recurse=True,
runas='foo')
postgres.owner_to.assert_called_once_with('dbname',
'otheruser',
user='******',
host='testhost',
port='testport',
password='******',
runas='foo')
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
def test_db_create(self):
postgres.db_create('dbname',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
tablespace='testspace',
owner='otheruser',
runas='foo')
postgres._run_psql.assert_called_once_with([
'/usr/bin/pgsql', '--no-align', '--no-readline', '--no-password',
'--username', 'testuser', '--host', 'testhost', '--port',
'testport', '--dbname', 'maint_db', '-c',
'CREATE DATABASE "dbname" WITH TABLESPACE = testspace '
'OWNER = "otheruser"'
],
host='testhost',
user='******',
password='******',
runas='foo',
port='testport')
@patch('salt.modules.postgres._run_psql',
Mock(return_value={
'retcode': 0,
'stdout': test_list_db_csv
}))
def test_db_exists(self):
ret = postgres.db_exists('test_db',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
runas='foo')
self.assertTrue(ret)
@patch('salt.modules.postgres._run_psql',
Mock(return_value={
'retcode': 0,
'stdout': test_list_db_csv
}))
def test_db_list(self):
ret = postgres.db_list(user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
runas='foo')
self.assertDictEqual(
ret, {
'test_db': {
'Encoding': 'LATIN1',
'Ctype': 'en_US',
'Tablespace': 'pg_default',
'Collate': 'en_US',
'Owner': 'postgres',
'Access privileges': ''
},
'template1': {
'Encoding': 'LATIN1',
'Ctype': 'en_US',
'Tablespace': 'pg_default',
'Collate': 'en_US',
'Owner': 'postgres',
'Access privileges':
('{=c/postgres,postgres=CTc/postgres}')
},
'template0': {
'Encoding': 'LATIN1',
'Ctype': 'en_US',
'Tablespace': 'pg_default',
'Collate': 'en_US',
'Owner': 'postgres',
'Access privileges':
('{=c/postgres,postgres=CTc/postgres}')
},
'postgres': {
'Encoding': 'LATIN1',
'Ctype': 'en_US',
'Tablespace': 'pg_default',
'Collate': 'en_US',
'Owner': 'postgres',
'Access privileges': ''
}
})
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
def test_db_remove(self):
postgres.db_remove('test_db',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
runas='foo')
postgres._run_psql.assert_called_once_with([
'/usr/bin/pgsql', '--no-align', '--no-readline', '--no-password',
'--username', 'testuser', '--host', 'testhost', '--port',
'testport', '--dbname', 'maint_db', '-c', 'DROP DATABASE "test_db"'
],
host='testhost',
user='******',
password='******',
runas='foo',
port='testport')
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.user_exists', Mock(return_value=False))
def test_group_create(self):
postgres.group_create('testgroup',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
createdb=False,
createuser=False,
encrypted=False,
superuser=False,
replication=False,
rolepassword='******',
groups='testgroup',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
postgres._run_psql.call_args[0][0][13].startswith('CREATE ROLE'))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.user_exists', Mock(return_value=True))
def test_group_remove(self):
postgres.group_remove('testgroup',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
runas='foo')
postgres._run_psql.assert_called_once_with([
'/usr/bin/pgsql', '--no-align', '--no-readline', '--no-password',
'--username', 'testuser', '--host', 'testhost', '--port',
'testport', '--dbname', 'maint_db', '-c', 'DROP ROLE "testgroup"'
],
host='testhost',
user='******',
password='******',
runas='foo',
port='testport')
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.role_get',
Mock(return_value={'superuser': False}))
def test_group_update(self):
postgres.group_update('testgroup',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
createdb=False,
createuser=False,
encrypted=False,
replication=False,
rolepassword='******',
groups='testgroup',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
re.match('ALTER.* "testgroup" .* UNENCRYPTED PASSWORD',
postgres._run_psql.call_args[0][0][13]))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.user_exists', Mock(return_value=False))
def test_user_create(self):
postgres.user_create('testuser',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_test',
password='******',
login=True,
createdb=False,
createroles=False,
createuser=False,
encrypted=False,
superuser=False,
replication=False,
rolepassword='******',
groups='test_groups',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
call = postgres._run_psql.call_args[0][0][13]
self.assertTrue(re.match('CREATE ROLE "testuser"', call))
for i in ('INHERIT NOCREATEDB NOCREATEROLE '
'NOSUPERUSER NOREPLICATION LOGIN UNENCRYPTED PASSWORD'
).split():
self.assertTrue(i in call, '{0} not in {1}'.format(i, call))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.version', Mock(return_value='9.1'))
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'name': 'test_user',
'superuser': '******',
'inherits privileges': 't',
'can create roles': 't',
'can create databases': 't',
'can update system catalogs': 't',
'can login': '******',
'replication': None,
'password': '******',
'connections': '-1',
'defaults variables': None
}]))
def test_user_exists(self):
ret = postgres.user_exists('test_user',
user='******',
host='test_host',
port='test_port',
maintenance_db='maint_db',
password='******',
runas='foo')
self.assertTrue(ret)
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.version', Mock(return_value='9.1'))
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'name': 'test_user',
'superuser': '******',
'inherits privileges': 't',
'can create roles': 't',
'can create databases': 't',
'can update system catalogs': 't',
'can login': '******',
'replication': None,
'connections': '-1',
'defaults variables': None
}]))
def test_user_list(self):
ret = postgres.user_list('test_user',
host='test_host',
port='test_port',
maintenance_db='maint_db',
password='******',
runas='foo')
self.assertDictEqual(
ret, {
'test_user': {
'superuser': True,
'defaults variables': None,
'can create databases': True,
'can create roles': True,
'connections': None,
'replication': None,
'expiry time': None,
'can login': True,
'can update system catalogs': True,
'groups': [],
'inherits privileges': True
}
})
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.version', Mock(return_value='9.1'))
@patch('salt.modules.postgres.user_exists', Mock(return_value=True))
def test_user_remove(self):
postgres.user_remove('testuser',
user='******',
host='testhost',
port='testport',
maintenance_db='maint_db',
password='******',
runas='foo')
postgres._run_psql.assert_called_once_with([
'/usr/bin/pgsql', '--no-align', '--no-readline', '--no-password',
'--username', 'testuser', '--host', 'testhost', '--port',
'testport', '--dbname', 'maint_db', '-c', 'DROP ROLE "testuser"'
],
host='testhost',
port='testport',
user='******',
password='******',
runas='foo')
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.role_get',
Mock(return_value={'superuser': False}))
def test_user_update(self):
postgres.user_update('test_username',
user='******',
host='test_host',
port='test_port',
maintenance_db='test_maint',
password='******',
createdb=False,
createroles=False,
createuser=False,
encrypted=False,
inherit=True,
login=True,
replication=False,
rolepassword='******',
groups='test_groups',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
re.match(
'ALTER ROLE "test_username" WITH INHERIT NOCREATEDB '
'NOCREATEROLE NOREPLICATION LOGIN '
'UNENCRYPTED PASSWORD [\'"]{0,5}test_role_pass[\'"]{0,5};'
' GRANT "test_groups" TO "test_username"',
postgres._run_psql.call_args[0][0][13]))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.role_get',
Mock(return_value={'superuser': False}))
def test_user_update2(self):
postgres.user_update('test_username',
user='******',
host='test_host',
port='test_port',
maintenance_db='test_maint',
password='******',
createdb=False,
createroles=True,
createuser=False,
encrypted=False,
inherit=True,
login=True,
replication=False,
groups='test_groups',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
re.match(
'ALTER ROLE "test_username" WITH INHERIT NOCREATEDB '
'CREATEROLE NOREPLICATION LOGIN;'
' GRANT "test_groups" TO "test_username"',
postgres._run_psql.call_args[0][0][13]))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.role_get',
Mock(return_value={'superuser': False}))
def test_user_update3(self):
postgres.user_update('test_username',
user='******',
host='test_host',
port='test_port',
maintenance_db='test_maint',
password='******',
createdb=False,
createroles=True,
createuser=False,
encrypted=False,
inherit=True,
login=True,
rolepassword=False,
replication=False,
groups='test_groups',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
re.match(
'ALTER ROLE "test_username" WITH INHERIT NOCREATEDB '
'CREATEROLE NOREPLICATION LOGIN NOPASSWORD;'
' GRANT "test_groups" TO "test_username"',
postgres._run_psql.call_args[0][0][13]))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.role_get',
Mock(return_value={'superuser': False}))
def test_user_update_encrypted_passwd(self):
postgres.user_update('test_username',
user='******',
host='test_host',
port='test_port',
maintenance_db='test_maint',
password='******',
createdb=False,
createroles=True,
createuser=False,
encrypted=True,
inherit=True,
login=True,
rolepassword='******',
replication=False,
groups='test_groups',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
re.match(
'ALTER ROLE "test_username" WITH INHERIT NOCREATEDB '
'CREATEROLE NOREPLICATION LOGIN '
'ENCRYPTED PASSWORD '
'[\'"]{0,5}md531c27e68d3771c392b52102c01be1da1[\'"]{0,5}'
'; GRANT "test_groups" TO "test_username"',
postgres._run_psql.call_args[0][0][13]))
@patch('salt.modules.postgres._run_psql',
Mock(return_value={
'retcode': 0,
'stdout': '9.1.9'
}))
def test_version(self):
postgres.version(user='******',
host='test_host',
port='test_port',
maintenance_db='test_maint',
password='******',
runas='foo')
# postgres._run_psql.call_args[0][0] will contain the list of CLI args.
# The first 13 elements of this list are initial args used in all (or
# virtually all) commands run through _run_psql(), so the actual SQL
# query will be in the 14th argument.
self.assertTrue(
re.match('SELECT setting FROM pg_catalog.pg_settings',
postgres._run_psql.call_args[0][0][13]))
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'extname': "foo",
'extversion': "1"
}]))
def test_installed_extensions(self):
exts = postgres.installed_extensions()
self.assertEqual(exts, {'foo': {'extversion': '1', 'extname': 'foo'}})
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'name': "foo",
'default_version': "1"
}]))
def test_available_extensions(self):
exts = postgres.available_extensions()
self.assertEqual(exts,
{'foo': {
'default_version': '1',
'name': 'foo'
}})
@patch('salt.modules.postgres.installed_extensions',
Mock(side_effect=[{}, {}]))
@patch('salt.modules.postgres._psql_prepare_and_run',
Mock(return_value=None))
@patch('salt.modules.postgres.available_extensions',
Mock(return_value={'foo': {
'default_version': '1',
'name': 'foo'
}}))
def test_drop_extension2(self):
self.assertEqual(postgres.drop_extension('foo'), True)
@patch('salt.modules.postgres.installed_extensions',
Mock(side_effect=[{
'foo': {
'extversion': '1',
'extname': 'foo'
}
}, {}]))
@patch('salt.modules.postgres._psql_prepare_and_run',
Mock(return_value=None))
@patch('salt.modules.postgres.available_extensions',
Mock(return_value={'foo': {
'default_version': '1',
'name': 'foo'
}}))
def test_drop_extension3(self):
self.assertEqual(postgres.drop_extension('foo'), True)
@patch('salt.modules.postgres.installed_extensions',
Mock(side_effect=[{
'foo': {
'extversion': '1',
'extname': 'foo'
}
}, {
'foo': {
'extversion': '1',
'extname': 'foo'
}
}]))
@patch('salt.modules.postgres._psql_prepare_and_run',
Mock(return_value=None))
@patch('salt.modules.postgres.available_extensions',
Mock(return_value={'foo': {
'default_version': '1',
'name': 'foo'
}}))
def test_drop_extension1(self):
self.assertEqual(postgres.drop_extension('foo'), False)
@patch('salt.modules.postgres.installed_extensions',
Mock(return_value={
'foo': {
'extversion': '0.8',
'extrelocatable': 't',
'schema_name': 'foo',
'extname': 'foo'
}
}, ))
@patch(
'salt.modules.postgres.available_extensions',
Mock(return_value={'foo': {
'default_version': '1.4',
'name': 'foo'
}}))
def test_create_mtdata(self):
ret = postgres.create_metadata('foo', schema='bar', ext_version='1.4')
self.assertTrue(postgres._EXTENSION_INSTALLED in ret)
self.assertTrue(postgres._EXTENSION_TO_UPGRADE in ret)
self.assertTrue(postgres._EXTENSION_TO_MOVE in ret)
ret = postgres.create_metadata('foo', schema='foo', ext_version='0.4')
self.assertTrue(postgres._EXTENSION_INSTALLED in ret)
self.assertFalse(postgres._EXTENSION_TO_UPGRADE in ret)
self.assertFalse(postgres._EXTENSION_TO_MOVE in ret)
ret = postgres.create_metadata('foo')
self.assertTrue(postgres._EXTENSION_INSTALLED in ret)
self.assertFalse(postgres._EXTENSION_TO_UPGRADE in ret)
self.assertFalse(postgres._EXTENSION_TO_MOVE in ret)
ret = postgres.create_metadata('foobar')
self.assertTrue(postgres._EXTENSION_NOT_INSTALLED in ret)
self.assertFalse(postgres._EXTENSION_INSTALLED in ret)
self.assertFalse(postgres._EXTENSION_TO_UPGRADE in ret)
self.assertFalse(postgres._EXTENSION_TO_MOVE in ret)
@patch(
'salt.modules.postgres.create_metadata',
Mock(side_effect=[
# create succeeded
[postgres._EXTENSION_NOT_INSTALLED],
[postgres._EXTENSION_INSTALLED],
[postgres._EXTENSION_NOT_INSTALLED],
[postgres._EXTENSION_INSTALLED],
# create failed
[postgres._EXTENSION_NOT_INSTALLED],
[postgres._EXTENSION_NOT_INSTALLED],
# move+upgrade succeeded
[
postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_TO_UPGRADE,
postgres._EXTENSION_INSTALLED
],
[postgres._EXTENSION_INSTALLED],
# move succeeded
[postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_INSTALLED],
[postgres._EXTENSION_INSTALLED],
# upgrade succeeded
[postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED],
[postgres._EXTENSION_INSTALLED],
# upgrade failed
[postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED],
[postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED],
# move failed
[postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_INSTALLED],
[postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_INSTALLED],
]))
@patch('salt.modules.postgres._psql_prepare_and_run',
Mock(return_value=None))
@patch(
'salt.modules.postgres.available_extensions',
Mock(return_value={'foo': {
'default_version': '1.4',
'name': 'foo'
}}))
def test_create_extension_newerthan(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
self.assertTrue(postgres.create_extension('foo'))
self.assertTrue(
re.match('CREATE EXTENSION IF NOT EXISTS "foo" ;',
postgres._psql_prepare_and_run.call_args[0][0][1]))
self.assertTrue(
postgres.create_extension('foo',
schema='a',
ext_version='b',
from_version='c'))
self.assertTrue(
re.match(
'CREATE EXTENSION IF NOT EXISTS "foo" '
'WITH SCHEMA "a" VERSION b FROM c ;',
postgres._psql_prepare_and_run.call_args[0][0][1]))
self.assertFalse(postgres.create_extension('foo'))
ret = postgres.create_extension('foo', ext_version='a', schema='b')
self.assertTrue(ret)
self.assertTrue(
re.match(
'ALTER EXTENSION "foo" SET SCHEMA "b";'
' ALTER EXTENSION "foo" UPDATE TO a;',
postgres._psql_prepare_and_run.call_args[0][0][1]))
ret = postgres.create_extension('foo', ext_version='a', schema='b')
self.assertTrue(ret)
self.assertTrue(
re.match('ALTER EXTENSION "foo" SET SCHEMA "b";',
postgres._psql_prepare_and_run.call_args[0][0][1]))
ret = postgres.create_extension('foo', ext_version='a', schema='b')
self.assertTrue(ret)
self.assertTrue(
re.match('ALTER EXTENSION "foo" UPDATE TO a;',
postgres._psql_prepare_and_run.call_args[0][0][1]))
self.assertFalse(
postgres.create_extension('foo', ext_version='a', schema='b'))
self.assertFalse(
postgres.create_extension('foo', ext_version='a', schema='b'))
def test_encrypt_passwords(self):
self.assertEqual(postgres._maybe_encrypt_password('foo', 'bar', False),
'bar')
self.assertEqual(postgres._maybe_encrypt_password('foo', 'bar', True),
'md596948aad3fcae80c08a35c9b5958cd89')
@patch('salt.modules.postgres._run_psql',
Mock(return_value={
'retcode': 0,
'stdout': test_list_schema_csv
}))
def test_schema_list(self):
ret = postgres.schema_list('maint_db',
db_user='******',
db_host='testhost',
db_port='testport',
db_password='******')
self.assertDictEqual(
ret, {
'public': {
'acl': '{postgres=UC/postgres,=UC/postgres}',
'owner': 'postgres'
},
'pg_toast': {
'acl': '',
'owner': 'postgres'
}
})
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'name': 'public',
'acl': '{postgres=UC/postgres,=UC/postgres}',
'owner': 'postgres'
}]))
def test_schema_exists(self):
ret = postgres.schema_exists('template1', 'public')
self.assertTrue(ret)
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'name': 'public',
'acl': '{postgres=UC/postgres,=UC/postgres}',
'owner': 'postgres'
}]))
def test_schema_get(self):
ret = postgres.schema_get('template1', 'public')
self.assertTrue(ret)
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.psql_query',
Mock(return_value=[{
'name': 'public',
'acl': '{postgres=UC/postgres,=UC/postgres}',
'owner': 'postgres'
}]))
def test_schema_get_again(self):
ret = postgres.schema_get('template1', 'pg_toast')
self.assertFalse(ret)
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.schema_exists', Mock(return_value=False))
def test_schema_create(self):
postgres.schema_create('maint_db',
'testschema',
user='******',
db_host='testhost',
db_port='testport',
db_user='******',
db_password='******')
postgres._run_psql.assert_called_once_with([
'/usr/bin/pgsql', '--no-align', '--no-readline', '--no-password',
'--username', 'testuser', '--host', 'testhost', '--port',
'testport', '--dbname', 'maint_db', '-c',
'CREATE SCHEMA "testschema"'
],
host='testhost',
port='testport',
password='******',
user='******',
runas='user')
@patch('salt.modules.postgres.schema_exists', Mock(return_value=True))
def test_schema_create2(self):
ret = postgres.schema_create('test_db',
'test_schema',
user='******',
db_host='test_host',
db_port='test_port',
db_user='******',
db_password='******')
self.assertFalse(ret)
@patch('salt.modules.postgres._run_psql',
Mock(return_value={'retcode': 0}))
@patch('salt.modules.postgres.schema_exists', Mock(return_value=True))
def test_schema_remove(self):
postgres.schema_remove('maint_db',
'testschema',
user='******',
db_host='testhost',
db_port='testport',
db_user='******',
db_password='******')
postgres._run_psql.assert_called_once_with([
'/usr/bin/pgsql', '--no-align', '--no-readline', '--no-password',
'--username', 'testuser', '--host', 'testhost', '--port',
'testport', '--dbname', 'maint_db', '-c',
'DROP SCHEMA "testschema"'
],
host='testhost',
port='testport',
password='******',
user='******',
runas='user')
@patch('salt.modules.postgres.schema_exists', Mock(return_value=False))
def test_schema_remove2(self):
ret = postgres.schema_remove('test_db',
'test_schema',
user='******',
db_host='test_host',
db_port='test_port',
db_user='******',
db_password='******')
self.assertFalse(ret)
# Import Salt Testing libs
from salttesting import skipIf, TestCase
from salttesting.helpers import ensure_in_syspath
ensure_in_syspath('../../')
# wmi and pythoncom modules are platform specific...
wmi = new.module('wmi')
sys.modules['wmi'] = wmi
pythoncom = new.module('pythoncom')
sys.modules['pythoncom'] = pythoncom
from salttesting.mock import NO_MOCK, NO_MOCK_REASON, Mock, patch, ANY
if NO_MOCK is False:
WMI = Mock()
wmi.WMI = Mock(return_value=WMI)
pythoncom.CoInitialize = Mock()
pythoncom.CoUninitialize = Mock()
# This is imported late so mock can do its job
import salt.modules.win_status as status
@skipIf(NO_MOCK, NO_MOCK_REASON)
class TestProcsBase(TestCase):
def __init__(self, *args, **kwargs):
TestCase.__init__(self, *args, **kwargs)
self.__processes = []
def add_process(self,
def call_procs(self):
WMI.win32_process = Mock(return_value=self.__processes)
self.result = status.procs()
class PostgresExtensionTestCase(TestCase):
@patch.dict(
SALT_STUB, {
'postgres.create_metadata':
Mock(side_effect=[
[postgresmod._EXTENSION_NOT_INSTALLED],
[
postgresmod._EXTENSION_TO_MOVE,
postgresmod._EXTENSION_INSTALLED
],
]),
'postgres.create_extension':
Mock(side_effect=[
False,
False,
]),
})
def test_present_failed(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.present('foo')
self.assertEqual(
ret,
{
'comment': 'Failed to install extension foo',
'changes': {},
'name': 'foo',
'result': False
},
)
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': 'Failed to upgrade extension foo',
'changes': {},
'name': 'foo',
'result': False
})
@patch.dict(
SALT_STUB, {
'postgres.create_metadata':
Mock(side_effect=[
[postgresmod._EXTENSION_NOT_INSTALLED],
[postgresmod._EXTENSION_INSTALLED],
[
postgresmod._EXTENSION_TO_MOVE,
postgresmod._EXTENSION_INSTALLED
],
]),
'postgres.create_extension':
Mock(side_effect=[
True,
True,
True,
]),
})
def test_present(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': 'The extension foo has been installed',
'changes': {},
'name': 'foo',
'result': True
})
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': 'Extention foo is already present',
'changes': {},
'name': 'foo',
'result': True
})
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': 'The extension foo has been upgradeed',
'changes': {},
'name': 'foo',
'result': True
})
@patch.dict(OPTS, {'test': True})
@patch.dict(
SALT_STUB, {
'postgres.create_metadata':
Mock(side_effect=[
[postgresmod._EXTENSION_NOT_INSTALLED],
[postgresmod._EXTENSION_INSTALLED],
[
postgresmod._EXTENSION_TO_MOVE,
postgresmod._EXTENSION_INSTALLED
],
]),
'postgres.create_extension':
Mock(side_effect=[
True,
True,
True,
]),
})
def test_presenttest(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': 'Extension foo is set to be installed',
'changes': {},
'name': 'foo',
'result': None
})
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': "Extension foo is set to be created",
'changes': {},
'name': 'foo',
'result': None
})
ret = postgres_extension.present('foo')
self.assertEqual(
ret, {
'comment': "Extension foo is set to be upgraded",
'changes': {},
'name': 'foo',
'result': None
})
@patch.dict(
SALT_STUB, {
'postgres.is_installed_extension': Mock(side_effect=[
True,
False,
]),
'postgres.drop_extension': Mock(side_effect=[
True,
True,
]),
})
def test_absent(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': 'Extension foo has been removed',
'changes': {
'foo': 'Absent'
},
'name': 'foo',
'result': True
})
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': ('Extension foo is not present, '
'so it cannot be removed'),
'changes': {},
'name':
'foo',
'result':
True
})
@patch.dict(OPTS, {'test': False})
@patch.dict(
SALT_STUB, {
'postgres.is_installed_extension': Mock(side_effect=[
True,
True,
]),
'postgres.drop_extension': Mock(side_effect=[
False,
False,
]),
})
def test_absent_failed(self):
'''
scenario of creating upgrading extensions with possible schema and
version specifications
'''
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': 'Extension foo failed to be removed',
'changes': {},
'name': 'foo',
'result': False
})
@patch.dict(OPTS, {'test': True})
@patch.dict(
SALT_STUB, {
'postgres.is_installed_extension': Mock(side_effect=[
True,
True,
]),
'postgres.drop_extension': Mock(side_effect=[
False,
False,
]),
})
def test_absent_failedtest(self):
ret = postgres_extension.absent('foo')
self.assertEqual(
ret, {
'comment': 'Extension foo is set to be removed',
'changes': {},
'name': 'foo',
'result': None
})
