def test_ensure_command_called(self, mock_ems_log):
''' calling get_all will raise a KeyError exception '''
set_module_args({
'hostname': 'hostname',
'username': '******',
'password': '******',
})
module = basic.AnsibleModule(
argument_spec=netapp_utils.na_ontap_host_argument_spec(),
supports_check_mode=True
)
my_obj = my_module(module)
my_obj.server = MockONTAPConnection('vserver', 'SVMadmin')
with pytest.raises(KeyError) as exc:
my_obj.get_all()
if sys.version_info >= (2, 7):
msg = 'net-interface-info'
assert exc.value.args[0] == msg
def main():
# Parsing argument file
module = basic.AnsibleModule(argument_spec=dict(
src=dict(required=True, type='str'),
dest=dict(required=False, type='str'),
operations=dict(required=True, type='list'),
backup=dict(required=False, default=False, type='bool'),
unsafe_writes=dict(required=False, default=False, type='bool'),
pretty=dict(required=False, default=False, type='bool'),
create=dict(required=False, default=False, type='bool'),
create_type=dict(required=False, default='object', type='str'),
),
supports_check_mode=True)
manager = PatchManager(module)
result = manager.run()
module.exit_json(**result)
def test_module_utils_basic_ansible_module_set_group_if_different(self):
from ansible.module_utils import basic
basic.MODULE_COMPLEX_ARGS = '{}'
am = basic.AnsibleModule(argument_spec=dict(), )
self.assertEqual(
am.set_group_if_different('/path/to/file', None, True), True)
self.assertEqual(
am.set_group_if_different('/path/to/file', None, False), False)
am.user_and_group = MagicMock(return_value=(500, 500))
with patch('os.lchown', return_value=None) as m:
self.assertEqual(
am.set_group_if_different('/path/to/file', 0, False), True)
m.assert_called_with('/path/to/file', -1, 0)
def _mock_getgrnam(*args, **kwargs):
mock_gr = MagicMock()
mock_gr.gr_gid = 0
return mock_gr
m.reset_mock()
with patch('grp.getgrnam', side_effect=_mock_getgrnam):
self.assertEqual(
am.set_group_if_different('/path/to/file', 'root', False),
True)
m.assert_called_with('/path/to/file', -1, 0)
with patch('grp.getgrnam', side_effect=KeyError):
self.assertRaises(SystemExit, am.set_group_if_different,
'/path/to/file', 'root', False)
m.reset_mock()
am.check_mode = True
self.assertEqual(
am.set_group_if_different('/path/to/file', 0, False), True)
self.assertEqual(m.called, False)
am.check_mode = False
with patch('os.lchown', side_effect=OSError) as m:
self.assertRaises(SystemExit, am.set_group_if_different,
'/path/to/file', 'root', False)
def test_module_utils_basic_ansible_module_set_owner_if_different(self):
from ansible.module_utils import basic
reload(basic)
am = basic.AnsibleModule(argument_spec=dict(), )
self.assertEqual(
am.set_owner_if_different('/path/to/file', None, True), True)
self.assertEqual(
am.set_owner_if_different('/path/to/file', None, False), False)
am.user_and_group = MagicMock(return_value=(500, 500))
with patch('os.lchown', return_value=None) as m:
self.assertEqual(
am.set_owner_if_different('/path/to/file', 0, False), True)
m.assert_called_with('/path/to/file', 0, -1)
def _mock_getpwnam(*args, **kwargs):
mock_pw = MagicMock()
mock_pw.pw_uid = 0
return mock_pw
m.reset_mock()
with patch('pwd.getpwnam', side_effect=_mock_getpwnam):
self.assertEqual(
am.set_owner_if_different('/path/to/file', 'root', False),
True)
m.assert_called_with('/path/to/file', 0, -1)
with patch('pwd.getpwnam', side_effect=KeyError):
self.assertRaises(SystemExit, am.set_owner_if_different,
'/path/to/file', 'root', False)
m.reset_mock()
am.check_mode = True
self.assertEqual(
am.set_owner_if_different('/path/to/file', 0, False), True)
self.assertEqual(m.called, False)
am.check_mode = False
with patch('os.lchown', side_effect=OSError) as m:
self.assertRaises(SystemExit, am.set_owner_if_different,
'/path/to/file', 'root', False)
def test_module_utils_basic_ansible_module_set_mode_if_different(self):
from ansible.module_utils import basic
basic.MODULE_COMPLEX_ARGS = '{}'
am = basic.AnsibleModule(argument_spec=dict(), )
mock_stat1 = MagicMock()
mock_stat1.st_mode = 0o444
mock_stat2 = MagicMock()
mock_stat2.st_mode = 0o660
with patch('os.lstat', side_effect=[mock_stat1]):
self.assertEqual(
am.set_mode_if_different('/path/to/file', None, True), True)
with patch('os.lstat', side_effect=[mock_stat1]):
self.assertEqual(
am.set_mode_if_different('/path/to/file', None, False), False)
with patch('os.lstat') as m:
with patch('os.lchmod', return_value=None, create=True) as m_os:
m.side_effect = [mock_stat1, mock_stat2, mock_stat2]
self.assertEqual(
am.set_mode_if_different('/path/to/file', 0o660, False),
True)
m_os.assert_called_with('/path/to/file', 0o660)
m.side_effect = [mock_stat1, mock_stat2, mock_stat2]
am._symbolic_mode_to_octal = MagicMock(return_value=0o660)
self.assertEqual(
am.set_mode_if_different('/path/to/file', 'o+w,g+w,a-r',
False), True)
m_os.assert_called_with('/path/to/file', 0o660)
m.side_effect = [mock_stat1, mock_stat2, mock_stat2]
am._symbolic_mode_to_octal = MagicMock(side_effect=Exception)
self.assertRaises(SystemExit, am.set_mode_if_different,
'/path/to/file', 'o+w,g+w,a-r', False)
m.side_effect = [mock_stat1, mock_stat2, mock_stat2]
am.check_mode = True
self.assertEqual(
am.set_mode_if_different('/path/to/file', 0o660, False),
True)
am.check_mode = False
def test_module_utils_basic_ansible_module_set_context_if_different(self):
from ansible.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
basic.HAVE_SELINUX = False
am.selinux_enabled = MagicMock(return_value=False)
self.assertEqual(am.set_context_if_different('/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], True), True)
self.assertEqual(am.set_context_if_different('/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], False), False)
basic.HAVE_SELINUX = True
am.selinux_enabled = MagicMock(return_value=True)
am.selinux_context = MagicMock(return_value=['bar_u', 'bar_r', None, None])
am.is_special_selinux_path = MagicMock(return_value=(False, None))
basic.selinux = Mock()
with patch.dict('sys.modules', {'selinux': basic.selinux}):
with patch('selinux.lsetfilecon', return_value=0) as m:
self.assertEqual(am.set_context_if_different('/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], False), True)
m.assert_called_with('/path/to/file', 'foo_u:foo_r:foo_t:s0')
m.reset_mock()
am.check_mode = True
self.assertEqual(am.set_context_if_different('/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], False), True)
self.assertEqual(m.called, False)
am.check_mode = False
with patch('selinux.lsetfilecon', return_value=1) as m:
self.assertRaises(SystemExit, am.set_context_if_different, '/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], True)
with patch('selinux.lsetfilecon', side_effect=OSError) as m:
self.assertRaises(SystemExit, am.set_context_if_different, '/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], True)
am.is_special_selinux_path = MagicMock(return_value=(True, ['sp_u', 'sp_r', 'sp_t', 's0']))
with patch('selinux.lsetfilecon', return_value=0) as m:
self.assertEqual(am.set_context_if_different('/path/to/file', ['foo_u', 'foo_r', 'foo_t', 's0'], False), True)
m.assert_called_with('/path/to/file', 'sp_u:sp_r:sp_t:s0')
delattr(basic, 'selinux')
def test_module_utils_basic_ansible_module_is_special_selinux_path(self):
from ansible.module_utils import basic
args = json.dumps(dict(ANSIBLE_MODULE_ARGS={'_ansible_selinux_special_fs': "nfs,nfsd,foos",
'_ansible_remote_tmp': "/tmp",
'_ansible_keep_remote_files': False}))
with swap_stdin_and_argv(stdin_data=args):
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
def _mock_find_mount_point(path):
if path.startswith('/some/path'):
return '/some/path'
elif path.startswith('/weird/random/fstype'):
return '/weird/random/fstype'
return '/'
am.find_mount_point = MagicMock(side_effect=_mock_find_mount_point)
am.selinux_context = MagicMock(return_value=['foo_u', 'foo_r', 'foo_t', 's0'])
m = mock_open()
m.side_effect = OSError
with patch.object(builtins, 'open', m, create=True):
self.assertEqual(am.is_special_selinux_path('/some/path/that/should/be/nfs'), (False, None))
mount_data = [
'/dev/disk1 / ext4 rw,seclabel,relatime,data=ordered 0 0\n',
'1.1.1.1:/path/to/nfs /some/path nfs ro 0 0\n',
'whatever /weird/random/fstype foos rw 0 0\n',
]
# mock_open has a broken readlines() implementation apparently...
# this should work by default but doesn't, so we fix it
m = mock_open(read_data=''.join(mount_data))
m.return_value.readlines.return_value = mount_data
with patch.object(builtins, 'open', m, create=True):
self.assertEqual(am.is_special_selinux_path('/some/random/path'), (False, None))
self.assertEqual(am.is_special_selinux_path('/some/path/that/should/be/nfs'), (True, ['foo_u', 'foo_r', 'foo_t', 's0']))
self.assertEqual(am.is_special_selinux_path('/weird/random/fstype/path'), (True, ['foo_u', 'foo_r', 'foo_t', 's0']))
def test_module_utils_basic_safe_eval(self):
from ansible.module_utils import basic
args = json.dumps(
dict(ANSIBLE_MODULE_ARGS={}, ANSIBLE_MODULE_CONSTANTS={}))
with swap_stdin_and_argv(stdin_data=args):
reload(basic)
am = basic.AnsibleModule(argument_spec=dict(), )
# test some basic usage
# string (and with exceptions included), integer, bool
self.assertEqual(am.safe_eval("'a'"), 'a')
self.assertEqual(am.safe_eval("'a'", include_exceptions=True),
('a', None))
self.assertEqual(am.safe_eval("1"), 1)
self.assertEqual(am.safe_eval("True"), True)
self.assertEqual(am.safe_eval("False"), False)
self.assertEqual(am.safe_eval("{}"), {})
# not passing in a string to convert
self.assertEqual(am.safe_eval({'a': 1}), {'a': 1})
self.assertEqual(am.safe_eval({'a': 1}, include_exceptions=True),
({
'a': 1
}, None))
# invalid literal eval
self.assertEqual(am.safe_eval("a=1"), "a=1")
res = am.safe_eval("a=1", include_exceptions=True)
self.assertEqual(res[0], "a=1")
self.assertEqual(type(res[1]), SyntaxError)
self.assertEqual(am.safe_eval("a.foo()"), "a.foo()")
res = am.safe_eval("a.foo()", include_exceptions=True)
self.assertEqual(res[0], "a.foo()")
self.assertEqual(res[1], None)
self.assertEqual(am.safe_eval("import foo"), "import foo")
res = am.safe_eval("import foo", include_exceptions=True)
self.assertEqual(res[0], "import foo")
self.assertEqual(res[1], None)
self.assertEqual(am.safe_eval("__import__('foo')"),
"__import__('foo')")
res = am.safe_eval("__import__('foo')", include_exceptions=True)
self.assertEqual(res[0], "__import__('foo')")
self.assertEqual(type(res[1]), ValueError)
def test_module_utils_basic_ansible_module_selinux_mls_enabled(self):
from ansible.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
basic.HAVE_SELINUX = False
self.assertEqual(am.selinux_mls_enabled(), False)
basic.HAVE_SELINUX = True
basic.selinux = Mock()
with patch.dict('sys.modules', {'selinux': basic.selinux}):
with patch('selinux.is_selinux_mls_enabled', return_value=0):
self.assertEqual(am.selinux_mls_enabled(), False)
with patch('selinux.is_selinux_mls_enabled', return_value=1):
self.assertEqual(am.selinux_mls_enabled(), True)
delattr(basic, 'selinux')
def test_exit_json_removes_values(self):
self.maxDiff = None
for args, return_val, expected in self.dataset:
params = dict(ANSIBLE_MODULE_ARGS=args)
params = json.dumps(params)
with swap_stdin_and_argv(stdin_data=params):
with swap_stdout():
basic._ANSIBLE_ARGS = None
module = basic.AnsibleModule(
argument_spec=dict(
username=dict(),
password=dict(no_log=True),
token=dict(no_log=True),
),
)
with self.assertRaises(SystemExit) as ctx:
self.assertEquals(module.exit_json(**return_val), expected)
self.assertEquals(json.loads(sys.stdout.getvalue()), expected)
def setUp(self):
self.complex_args_token = basic.MODULE_COMPLEX_ARGS
basic.MODULE_COMPLEX_ARGS = '{}'
self.am = basic.AnsibleModule(
argument_spec = dict(),
)
self.has_journal = basic.has_journal
basic.has_journal = True
self.module_patcher = None
# In case systemd-python is not installed
if not self.has_journal:
self.module_patcher = patch.dict('sys.modules', {'systemd': MagicMock(), 'systemd.journal': MagicMock()})
self.module_patcher.start()
try:
reload(basic)
except NameError:
self._fake_out_reload(basic)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update({
"hostname": {
"required": True,
"type": "str"
},
"username": {
"required": True,
"type": "str"
},
"password": {
"required": True,
"type": "str",
"no_log": True
},
"datacenter": {
"required": True,
"type": "str"
},
"cluster": {
"required": True,
"type": "str"
},
"folder": {
"required": True,
"type": "str"
},
"state": {
"default": "present",
"choices": ["present", "absent"],
"type": "str",
},
})
module = basic.AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
vmware_folder = VMwareFolder(module)
vmware_folder.process_state()
def resource_factory(cls):
params = basic._load_params()
storage_data = cls._pop_param(common.STORAGE_DATA)
specs = {'resource': {'choices': list(cls.RESOURCES.keys())},
'provider': {'type': 'str', 'choices': ['cinderlib',
'cinderclient']},
'backend': {'type': 'str'}}
resource = params.get('resource')
resource_class = cls.RESOURCES.get(resource)
if resource_class and resource_class.STATES:
specs['state'] = {'choices': resource_class.STATES,
'default': resource_class.DEFAULT_STATE}
module = basic.AnsibleModule(specs,
check_invalid_arguments=False,
supports_check_mode=False)
resource = cls.RESOURCES[resource](module, storage_data)
return resource
def _validate(self, size_required=False, require_id=False, **kwargs):
specs = self.module.argument_spec.copy()
specs.update(name={'type': 'str'},
id={'type': 'str'},
size={
'type': 'int',
'required': size_required
},
host={
'type': 'str',
'default': ''
},
**kwargs)
required_one_of = []
if require_id:
required_one_of.append(('name', 'id'))
self.module = basic.AnsibleModule(specs,
check_invalid_arguments=True,
required_one_of=required_one_of)
def test_distribution_version(testcase):
"""tests the distribution parsing code of the Facts class
testsets have
* a name (for output/debugging only)
* input files that are faked
* those should be complete and also include "irrelevant" files that might be mistaken as coming from other distributions
* all files that are not listed here are assumed to not exist at all
* the output of pythons platform.dist()
* results for the ansible variables distribution* and os_family
"""
from ansible.module_utils import basic
args = json.dumps(dict(ANSIBLE_MODULE_ARGS={}))
with swap_stdin_and_argv(stdin_data=args):
basic._ANSIBLE_ARGS = None
module = basic.AnsibleModule(argument_spec=dict())
_test_one_distribution(facts, module, testcase)
def test_set_cwd(self, monkeypatch):
'''make sure /tmp is used'''
def mock_getcwd():
return '/tmp'
def mock_access(path, perm):
return True
def mock_chdir(path):
pass
monkeypatch.setattr(os, 'getcwd', mock_getcwd)
monkeypatch.setattr(os, 'access', mock_access)
monkeypatch.setattr(basic, '_ANSIBLE_ARGS',
to_bytes(json.dumps({'ANSIBLE_MODULE_ARGS': {}})))
with patch('time.time', return_value=42):
am = basic.AnsibleModule(argument_spec={})
result = am._set_cwd()
assert result == '/tmp'
def test_module_utils_basic_ansible_module_selinux_default_context(self):
from ansible.module_utils import basic
basic.MODULE_COMPLEX_ARGS = '{}'
basic.MODULE_CONSTANTS = '{}'
am = basic.AnsibleModule(argument_spec=dict(), )
am.selinux_initial_context = MagicMock(
return_value=[None, None, None, None])
am.selinux_enabled = MagicMock(return_value=True)
# we first test the cases where the python selinux lib is not installed
basic.HAVE_SELINUX = False
self.assertEqual(am.selinux_default_context(path='/foo/bar'),
[None, None, None, None])
# all following tests assume the python selinux bindings are installed
basic.HAVE_SELINUX = True
basic.selinux = Mock()
with patch.dict('sys.modules', {'selinux': basic.selinux}):
# next, we test with a mocked implementation of selinux.matchpathcon to simulate
# an actual context being found
with patch('selinux.matchpathcon',
return_value=[0, 'unconfined_u:object_r:default_t:s0']):
self.assertEqual(
am.selinux_default_context(path='/foo/bar'),
['unconfined_u', 'object_r', 'default_t', 's0'])
# we also test the case where matchpathcon returned a failure
with patch('selinux.matchpathcon', return_value=[-1, '']):
self.assertEqual(am.selinux_default_context(path='/foo/bar'),
[None, None, None, None])
# finally, we test where an OSError occurred during matchpathcon's call
with patch('selinux.matchpathcon', side_effect=OSError):
self.assertEqual(am.selinux_default_context(path='/foo/bar'),
[None, None, None, None])
delattr(basic, 'selinux')
def test_exit_json_removes_values(self):
self.maxDiff = None
for args, return_val, expected in self.dataset:
sys.stdout = BytesIO()
params = dict(ANSIBLE_MODULE_ARGS=args, ANSIBLE_MODULE_CONSTANTS={})
params = json.dumps(params)
if PY3:
sys.stdin = StringIO(params)
sys.stdin.buffer = BytesIO(to_bytes(params))
else:
sys.stdin = BytesIO(to_bytes(params))
module = basic.AnsibleModule(
argument_spec = dict(
username=dict(),
password=dict(no_log=True),
token=dict(no_log=True),
),
)
with self.assertRaises(SystemExit) as ctx:
self.assertEquals(module.exit_json(**return_val), expected)
self.assertEquals(json.loads(sys.stdout.getvalue()), expected)
def test_fail_json_removes_values(self):
self.maxDiff = None
for args, return_val, expected in self.dataset:
expected = copy.deepcopy(expected)
del expected['changed']
expected['failed'] = True
params = dict(ANSIBLE_MODULE_ARGS=args,
ANSIBLE_MODULE_CONSTANTS={})
params = json.dumps(params)
with swap_stdin_and_argv(stdin_data=params):
with swap_stdout():
module = basic.AnsibleModule(argument_spec=dict(
username=dict(),
password=dict(no_log=True),
token=dict(no_log=True),
), )
with self.assertRaises(SystemExit) as ctx:
self.assertEquals(module.fail_json(**return_val),
expected)
self.assertEquals(json.loads(sys.stdout.getvalue()),
expected)
def main():
consumer_config = {common.CONSUMER_CONFIG: {'type': 'dict'}}
module = basic.AnsibleModule(
argument_spec={
'resource': {
'required': True,
'choices': ('node', 'volume')
},
common.STORAGE_DATA: {
'type': 'dict',
'options': consumer_config
},
},
supports_check_mode=False,
check_invalid_arguments=False,
)
_set_priv_helper('sudo')
method = globals()[module.params['resource']]
module.exit_json(**method(module))
def main():
argument_spec = vmware_argument_spec()
argument_spec.update(
dict(datacenter=dict(required=True, type='str'),
cluster=dict(required=True, type='str'),
folder=dict(required=True, type='str'),
hostname=dict(required=True, type='str'),
username=dict(required=True, type='str'),
password=dict(required=True, type='str', no_log=True),
state=dict(default='present',
choices=['present', 'absent'],
type='str')))
module = basic.AnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
vmware_folder = VMwareFolder(module)
vmware_folder.process_state()
def test_module_utils_basic_ansible_module_is_special_selinux_path(self):
from ansible.module_utils import basic
basic.MODULE_COMPLEX_ARGS = '{}'
basic.SELINUX_SPECIAL_FS = 'nfs,nfsd,foos'
am = basic.AnsibleModule(
argument_spec = dict(),
)
def _mock_find_mount_point(path):
if path.startswith('/some/path'):
return '/some/path'
elif path.startswith('/weird/random/fstype'):
return '/weird/random/fstype'
return '/'
am.find_mount_point = MagicMock(side_effect=_mock_find_mount_point)
am.selinux_context = MagicMock(return_value=['foo_u', 'foo_r', 'foo_t', 's0'])
m = mock_open()
m.side_effect = OSError
with patch('__builtin__.open', m, create=True):
self.assertEqual(am.is_special_selinux_path('/some/path/that/should/be/nfs'), (False, None))
mount_data = [
'/dev/disk1 / ext4 rw,seclabel,relatime,data=ordered 0 0\n',
'1.1.1.1:/path/to/nfs /some/path nfs ro 0 0\n',
'whatever /weird/random/fstype foos rw 0 0\n',
]
# mock_open has a broken readlines() implementation apparently...
# this should work by default but doesn't, so we fix it
m = mock_open(read_data=''.join(mount_data))
m.return_value.readlines.return_value = mount_data
with patch('__builtin__.open', m, create=True):
self.assertEqual(am.is_special_selinux_path('/some/random/path'), (False, None))
self.assertEqual(am.is_special_selinux_path('/some/path/that/should/be/nfs'), (True, ['foo_u', 'foo_r', 'foo_t', 's0']))
self.assertEqual(am.is_special_selinux_path('/weird/random/fstype/path'), (True, ['foo_u', 'foo_r', 'foo_t', 's0']))
def run(self, tmp=None, task_vars=None):
''' handler for cli operations '''
if task_vars is None:
task_vars = dict()
result = super(ActionModule, self).run(tmp, task_vars)
del tmp # tmp no longer has any effect
try:
spec = self._task.args['spec']
except KeyError as exc:
raise AnsibleModuleError(to_text(exc))
if not spec:
raise AnsibleModuleError('missing required argument: spec')
spec_fp = os.path.join(task_vars['role_path'], 'meta/%s' % spec)
display.vvv('using role spec %s' % spec_fp)
spec = self._loader.load_from_file(spec_fp)
argument_spec = spec.get('argument_spec') or {}
args = {}
self._handle_options(task_vars, args, argument_spec)
basic._ANSIBLE_ARGS = to_bytes(
json.dumps({'ANSIBLE_MODULE_ARGS': args}))
basic.AnsibleModule.fail_json = self.fail_json
spec = dict([(k, v) for k, v in iteritems(spec)
if k in self.VALID_MODULE_KWARGS])
validated_spec = basic.AnsibleModule(**spec)
result['role_params'] = validated_spec.params
result['changed'] = False
self._remove_tmp_path(self._connection._shell.tmpdir)
return result
def test_set_cwd_unreadable_use_gettempdir(self, monkeypatch):
'''fallback to tempfile.gettempdir'''
thisdir = None
def mock_getcwd():
return '/tmp'
def mock_access(path, perm):
if path in ['/tmp', '/tmp2', '/home/foobar'] and perm == 4:
return False
return True
def mock_expandvars(var):
if var == '$HOME':
return '/home/foobar'
return var
def mock_gettempdir():
return '/tmp3'
def mock_chdir(path):
if path == '/tmp':
raise Exception()
thisdir = path
monkeypatch.setattr(os, 'getcwd', mock_getcwd)
monkeypatch.setattr(os, 'chdir', mock_chdir)
monkeypatch.setattr(os, 'access', mock_access)
monkeypatch.setattr(os.path, 'expandvars', mock_expandvars)
monkeypatch.setattr(basic, '_ANSIBLE_ARGS',
to_bytes(json.dumps({'ANSIBLE_MODULE_ARGS': {}})))
with patch('time.time', return_value=42):
am = basic.AnsibleModule(argument_spec={})
am._tmpdir = '/tmp2'
monkeypatch.setattr(tempfile, 'gettempdir', mock_gettempdir)
result = am._set_cwd()
assert result == '/tmp3'
def test_module_utils_basic_ansible_module__symbolic_mode_to_octal(self):
from ansible.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec = dict(),
)
mock_stat = MagicMock()
# FIXME: trying many more combinations here would be good
# directory, give full perms to all, then one group at a time
mock_stat.st_mode = 0o040000
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'a+rwx'), 0o0777)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'u+rwx,g+rwx,o+rwx'), 0o0777)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'o+rwx'), 0o0007)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'g+rwx'), 0o0070)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'u+rwx'), 0o0700)
# same as above, but in reverse so removing permissions
mock_stat.st_mode = 0o040777
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'a-rwx'), 0o0000)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'u-rwx,g-rwx,o-rwx'), 0o0000)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'o-rwx'), 0o0770)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'g-rwx'), 0o0707)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'u-rwx'), 0o0077)
# now using absolute assignment
mock_stat.st_mode = 0o040000
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'a=rwx'), 0o0777)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'u=rwx,g=rwx,o=rwx'), 0o0777)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'o=rwx'), 0o0007)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'g=rwx'), 0o0070)
self.assertEqual(am._symbolic_mode_to_octal(mock_stat, 'u=rwx'), 0o0700)
# invalid modes
mock_stat.st_mode = 0o0400000
self.assertRaises(ValueError, am._symbolic_mode_to_octal, mock_stat, 'a=foo')
def test_module_utils_basic_safe_eval(self):
from ansible.module_utils import basic
basic.MODULE_COMPLEX_ARGS = '{}'
am = basic.AnsibleModule(argument_spec=dict(), )
# test some basic usage
# string (and with exceptions included), integer, bool
self.assertEqual(am.safe_eval("'a'"), 'a')
self.assertEqual(am.safe_eval("'a'", include_exceptions=True),
('a', None))
self.assertEqual(am.safe_eval("1"), 1)
self.assertEqual(am.safe_eval("True"), True)
self.assertEqual(am.safe_eval("False"), False)
self.assertEqual(am.safe_eval("{}"), {})
# not passing in a string to convert
self.assertEqual(am.safe_eval({'a': 1}), {'a': 1})
self.assertEqual(am.safe_eval({'a': 1}, include_exceptions=True),
({
'a': 1
}, None))
# invalid literal eval
self.assertEqual(am.safe_eval("a=1"), "a=1")
res = am.safe_eval("a=1", include_exceptions=True)
self.assertEqual(res[0], "a=1")
self.assertEqual(type(res[1]), SyntaxError)
self.assertEqual(am.safe_eval("a.foo()"), "a.foo()")
res = am.safe_eval("a.foo()", include_exceptions=True)
self.assertEqual(res[0], "a.foo()")
self.assertEqual(res[1], None)
self.assertEqual(am.safe_eval("import foo"), "import foo")
res = am.safe_eval("import foo", include_exceptions=True)
self.assertEqual(res[0], "import foo")
self.assertEqual(res[1], None)
self.assertEqual(am.safe_eval("__import__('foo')"),
"__import__('foo')")
res = am.safe_eval("__import__('foo')", include_exceptions=True)
self.assertEqual(res[0], "__import__('foo')")
self.assertEqual(type(res[1]), ValueError)
def main():
argument_spec = vmware_argument_spec()
argument_spec.update({
"hostname": {"required": True, "type": "str"},
"username": {"required": True, "type": "str"},
"password": {"required": True, "type": "str", "no_log": True},
"datacenter": {"required": True, "type": "str"},
"cluster": {"required": True, "type": "str"},
"resource_pool": {"required": True, "type": "str"},
"mem_shares": {
"type": "str", "default": "normal",
"choices": ["high", "custom", "normal", "low"],
},
"mem_limit": {"type": "int", "default": "-1"},
"mem_reservation": {"type": "int", "default": "0"},
"mem_expandable_reservations": {"type": "bool", "default": "True"},
"cpu_shares": {
"type": "str", "default": "normal",
"choices": ["high", "custom", "normal", "low"]
},
"cpu_limit": {"type": "int", "default": "-1"},
"cpu_reservation": {"type": "int", "default": "0"},
"cpu_expandable_reservations": {"type": "bool", "default": "True"},
"state": {
"default": "present",
"choices": ["present", "absent"],
"type": "str",
},
})
module = basic.AnsibleModule(
argument_spec=argument_spec, supports_check_mode=True)
if not HAS_PYVMOMI:
module.fail_json(msg='pyvmomi is required for this module')
vmware_rp = VMwareResourcePool(module)
vmware_rp.process_state()
def test_module_utils_basic_ansible_module_set_directory_attributes_if_different(self):
from ansible.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
file_args = {
'path': '/path/to/file',
'mode': None,
'owner': None,
'group': None,
'seuser': None,
'serole': None,
'setype': None,
'selevel': None,
'secontext': [None, None, None],
'attributes': None,
}
self.assertEqual(am.set_directory_attributes_if_different(file_args, True), True)
self.assertEqual(am.set_directory_attributes_if_different(file_args, False), False)
def get_info_mock_object(self, kind=None):
"""
Helper method to return an na_ontap_info object
"""
argument_spec = netapp_utils.na_ontap_host_argument_spec()
argument_spec.update(dict(
state=dict(type='str', default='info', choices=['info']),
gather_subset=dict(default=['all'], type='list'),
vserver=dict(type='str', default=None, required=False),
max_records=dict(type='int', default=1024, required=False)
))
module = basic.AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
max_records = module.params['max_records']
obj = info_module(module, max_records)
obj.netapp_info = dict()
if kind is None:
obj.server = MockONTAPConnection()
else:
obj.server = MockONTAPConnection(kind)
return obj
def test_distribution_version():
"""tests the distribution parsing code of the Facts class
testsets have
* a name (for output/debugging only)
* input files that are faked
* those should be complete and also include "irrelevant" files that might be mistaken as coming from other distributions
* all files that are not listed here are assumed to not exist at all
* the output of pythons platform.dist()
* results for the ansible variables distribution*
"""
from ansible.module_utils import basic
args = json.dumps(dict(ANSIBLE_MODULE_ARGS={}))
with swap_stdin_and_argv(stdin_data=args):
module = basic.AnsibleModule(argument_spec=dict())
for t in TESTSETS:
# run individual tests via generator
# set nicer stdout output for nosetest
_test_one_distribution.description = "check distribution_version for %s" % t['name']
yield _test_one_distribution, facts, module, t