def test_get_error_lines_from_file(self): m = mock_open() m.return_value.readlines.return_value = ['this is line 1\n'] with patch('{0}.open'.format(BUILTINS), m): # this line will be found in the file self.obj.ansible_pos = ('foo.yml', 1, 1) e = AnsibleError(self.message, self.obj) self.assertEqual(e.message, ( "This is the error message\n\nThe error appears to be in 'foo.yml': line 1, column 1, but may\nbe elsewhere in the file depending on " "the exact syntax problem.\n\nThe offending line appears to be:\n\n\nthis is line 1\n^ here\n" )) # this line will not be found, as it is out of the index range self.obj.ansible_pos = ('foo.yml', 2, 1) e = AnsibleError(self.message, self.obj) self.assertEqual(e.message, ( "This is the error message\n\nThe error appears to be in 'foo.yml': line 2, column 1, but may\nbe elsewhere in the file depending on " "the exact syntax problem.\n\n(specified line no longer in file, maybe it changed?)" )) m = mock_open() m.return_value.readlines.return_value = [ 'this line has unicode \xf0\x9f\x98\xa8 in it!\n' ] with patch('{0}.open'.format(BUILTINS), m): # this line will be found in the file self.obj.ansible_pos = ('foo.yml', 1, 1) e = AnsibleError(self.unicode_message, self.obj) self.assertEqual(e.message, ( "This is an error with \xf0\x9f\x98\xa8 in it\n\nThe error appears to be in 'foo.yml': line 1, column 1, but may\nbe elsewhere in the " "file depending on the exact syntax problem.\n\nThe offending line appears to be:\n\n\nthis line has unicode \xf0\x9f\x98\xa8 in it!\n^ " "here\n"))
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', '10.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_is_firmware_bundled_pass(self): """Determine whether firmware file is bundled.""" self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"}) with patch(builtin_path, mock_open(read_data=b"firmwarexxxxxxxx")) as mock_file: firmware = NetAppESeriesFirmware() self.assertEqual(firmware.is_firmware_bundled(), False) self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"}) with patch(builtin_path, mock_open(read_data=self.BUNDLE_HEADER[:16])) as mock_file: firmware = NetAppESeriesFirmware() self.assertEqual(firmware.is_firmware_bundled(), True)
def test_firmware_update_success_case03(self, redfish_default_args, redfish_firmware_connection_mock, redfish_response_mock, mocker): mocker.patch( "ansible.modules.remote_management.dellemc.redfish_firmware._get_update_service_target", return_value=('2134', 'nhttp://dell.com', 'multipart/form-data')) mocker.patch( "ansible.modules.remote_management.dellemc.redfish_firmware._encode_form_data", return_value=({ "file": (3, "nhttp://dell.com", "multipart/form-data") }, "multipart/form-data")) redfish_default_args.update({ "image_uri": "nhttp://home/firmware_repo/component.exe", "transfer_protocol": "HTTP" }) f_module = self.get_module_mock(params=redfish_default_args) redfish_response_mock.status_code = 201 redfish_response_mock.success = True redfish_response_mock.json_data = { "image_uri": "nhttp://home/firmware_repo/component.exe", "transfer_protocol": "HTTP" } if sys.version_info.major == 3: builtin_module_name = 'builtins' else: builtin_module_name = '__builtin__' with patch("{0}.open".format(builtin_module_name), mock_open(read_data="data")) as mock_file: result = self.module.firmware_update( redfish_firmware_connection_mock, f_module) assert result == redfish_response_mock
def test_content_written(self): with patch.object(builtins, 'open', mock_open()) as m: password._write_password_file(b'/this/is/a/test/caf\xc3\xa9', u'Testing Café') m.assert_called_once_with(b'/this/is/a/test/caf\xc3\xa9', 'wb') m().write.assert_called_once_with(u'Testing Café\n'.encode('utf-8'))
def test_password_already_created_encrypt(self, mock_get_paths, mock_write_file): mock_get_paths.return_value = ['/path/one', '/path/two', '/path/three'] password.os.path.exists = lambda x: x == to_bytes('/path/to/somewhere') with patch.object(builtins, 'open', mock_open(read_data=b'hunter42 salt=87654321\n')) as m: results = self.password_lookup.run([u'/path/to/somewhere chars=anything encrypt=pbkdf2_sha256'], None) for result in results: self.assertEqual(result, u'$pbkdf2-sha256$20000$ODc2NTQzMjE$Uikde0cv0BKaRaAXMrUQB.zvG4GmnjClwjghwIRf2gU')
def test_password_already_created_no_encrypt(self, mock_get_paths, mock_write_file): mock_get_paths.return_value = ['/path/one', '/path/two', '/path/three'] password.os.path.exists = lambda x: x == to_bytes('/path/to/somewhere') with patch.object(builtins, 'open', mock_open(read_data=b'hunter42 salt=87654321\n')) as m: results = self.password_lookup.run([u'/path/to/somewhere chars=anything'], None) for result in results: self.assertEqual(result, u'hunter42')
def mock_open_with_iter(*args, **kwargs): mock = mock_open(*args, **kwargs) if six.PY2: mock.return_value.__iter__ = lambda x: iter(x.readline, "") else: mock.return_value.__iter__ = lambda x: x mock.return_value.__next__ = lambda x: iter(x.readline, "") return mock
def test_upload_file_raises_exception_when_invalid_response(self): self.connection_mock.send.return_value = self._connection_response('invalidJsonResponse') open_mock = mock_open() with patch('%s.open' % BUILTINS_NAME, open_mock): with self.assertRaises(ConnectionError) as res: self.ftd_plugin.upload_file('/tmp/test.txt', '/files') assert 'Invalid JSON response' in str(res.exception)
def test_is_firmware_bundles_fail(self): """Verify non-firmware fails.""" self._set_args({"firmware": "test.dlp", "nvsram": "test.dlp"}) with patch(builtin_path, mock_open(read_data=b"xxxxxxxxxxxxxxxx")) as mock_file: firmware = NetAppESeriesFirmware() with self.assertRaisesRegexp(AnsibleFailJson, "Firmware file is invalid."): firmware.is_firmware_bundled()
def test_download_file(self): self.connection_mock.send.return_value = self._connection_response('File content') open_mock = mock_open() with patch('%s.open' % BUILTINS_NAME, open_mock): self.ftd_plugin.download_file('/files/1', '/tmp/test.txt') open_mock.assert_called_once_with('/tmp/test.txt', 'wb') open_mock().write.assert_called_once_with(b'File content')
def test_systemid_with_requirements(capfd, mocker, patch_rhn): """Check 'msg' and 'changed' results""" mocker.patch.object(rhn_register.Rhn, 'enable') mock_isfile = mocker.patch('os.path.isfile', return_value=True) mocker.patch('ansible.modules.packaging.os.rhn_register.open', mock_open(read_data=SYSTEMID), create=True) rhn = rhn_register.Rhn() assert '123456789' == to_native(rhn.systemid)
def test_lock_been_held(self, mock_sleep): # pretend the lock file is here password.os.path.exists = lambda x: True try: with patch.object(builtins, 'open', mock_open(read_data=b'hunter42 salt=87654321\n')) as m: # should timeout here results = self.password_lookup.run([u'/path/to/somewhere chars=anything'], None) self.fail("Lookup didn't timeout when lock already been held") except AnsibleError: pass
def test_lock_not_been_held(self): # pretend now there is password file but no lock password.os.path.exists = lambda x: x == to_bytes('/path/to/somewhere') try: with patch.object(builtins, 'open', mock_open(read_data=b'hunter42 salt=87654321\n')) as m: # should not timeout here results = self.password_lookup.run([u'/path/to/somewhere chars=anything'], None) except AnsibleError: self.fail('Lookup timeouts when lock is free') for result in results: self.assertEqual(result, u'hunter42')
def test_download_file_should_extract_filename_from_headers(self): filename = 'test_file.txt' response = mock.Mock() response.info.return_value = {'Content-Disposition': 'attachment; filename="%s"' % filename} dummy, response_data = self._connection_response('File content') self.connection_mock.send.return_value = response, response_data open_mock = mock_open() with patch('%s.open' % BUILTINS_NAME, open_mock): self.ftd_plugin.download_file('/files/1', '/tmp/') open_mock.assert_called_once_with('/tmp/%s' % filename, 'wb') open_mock().write.assert_called_once_with(b'File content')
def test_validate_credentials_file(self): # TODO(supertom): Only dealing with p12 here, check the other states # of this function module = FakeModule() with mock.patch("ansible.module_utils.gcp.open", mock.mock_open(read_data='foobar'), create=True): # pem condition, warning is suppressed with the return_value credentials_file = '/foopath/pem.pem' with self.assertRaises(ValueError): _validate_credentials_file(module, credentials_file=credentials_file, require_valid_json=False, check_libcloud=False)
def test_upload_file(self): self.connection_mock.send.return_value = self._connection_response({'id': '123'}) open_mock = mock_open() with patch('%s.open' % BUILTINS_NAME, open_mock): resp = self.ftd_plugin.upload_file('/tmp/test.txt', '/files') assert {'id': '123'} == resp exp_headers = dict(BASE_HEADERS) exp_headers['Content-Length'] = len('--Encoded data--') exp_headers['Content-Type'] = 'multipart/form-data' self.connection_mock.send.assert_called_once_with('/files', data='--Encoded data--', headers=exp_headers, method=HTTPMethod.POST) open_mock.assert_called_once_with('/tmp/test.txt', 'rb')
def test_get_error_lines_error_in_last_line(self): m = mock_open() m.return_value.readlines.return_value = [ 'this is line 1\n', 'this is line 2\n', 'this is line 3\n' ] with patch('{0}.open'.format(BUILTINS), m): # If the error occurs in the last line of the file, use the correct index to get the line # and avoid the IndexError self.obj.ansible_pos = ('foo.yml', 4, 1) e = AnsibleError(self.message, self.obj) self.assertEqual(e.message, ( "This is the error message\n\nThe error appears to be in 'foo.yml': line 4, column 1, but may\nbe elsewhere in the file depending on " "the exact syntax problem.\n\nThe offending line appears to be:\n\nthis is line 2\nthis is line 3\n^ here\n" ))
def test_get_error_lines_error_empty_lines_around_error(self): """Test that trailing whitespace after the error is removed""" m = mock_open() m.return_value.readlines.return_value = [ 'this is line 1\n', 'this is line 2\n', 'this is line 3\n', ' \n', ' \n', ' ' ] with patch('{0}.open'.format(BUILTINS), m): self.obj.ansible_pos = ('foo.yml', 5, 1) e = AnsibleError(self.message, self.obj) self.assertEqual(e.message, ( "This is the error message\n\nThe error appears to be in 'foo.yml': line 5, column 1, but may\nbe elsewhere in the file depending on " "the exact syntax problem.\n\nThe offending line appears to be:\n\nthis is line 2\nthis is line 3\n^ here\n" ))
def test_systemid_requirements_missing(capfd, mocker, patch_rhn, import_libxml): """Check that missing dependencies are detected""" mocker.patch('os.path.isfile', return_value=True) mocker.patch('ansible.modules.packaging.os.rhn_register.open', mock_open(read_data=SYSTEMID), create=True) with pytest.raises(SystemExit): rhn_register.main() out, err = capfd.readouterr() results = json.loads(out) assert results['failed'] assert 'Missing arguments' in results['msg']
def test_parse_from_vault_1_1_file(self): vaulted_data = """$ANSIBLE_VAULT;1.1;AES256 33343734386261666161626433386662623039356366656637303939306563376130623138626165 6436333766346533353463636566313332623130383662340a393835656134633665333861393331 37666233346464636263636530626332623035633135363732623332313534306438393366323966 3135306561356164310a343937653834643433343734653137383339323330626437313562306630 3035 """ if PY3: builtins_name = 'builtins' else: builtins_name = '__builtin__' with patch(builtins_name + '.open', mock_open(read_data=vaulted_data.encode('utf-8'))): output = self._loader.load_from_file('dummy_vault.txt') self.assertEqual(output, dict(foo='bar'))
def test_verify_file_hash_matching_hash(manifest_info): data = to_bytes(json.dumps(manifest_info)) digest = sha256(data).hexdigest() namespace = manifest_info['collection_info']['namespace'] name = manifest_info['collection_info']['name'] version = manifest_info['collection_info']['version'] server = 'http://galaxy.ansible.com' error_queue = [] with patch.object(builtins, 'open', mock_open(read_data=data)) as m: with patch.object(collection.os.path, 'isfile', MagicMock(return_value=True)) as mock_isfile: collection._verify_file_hash(b'path/', 'file', digest, error_queue) assert mock_isfile.called_once assert error_queue == []
def test_create_gtm_irule_src(self, *args): set_module_args( dict(name='foo', module='gtm', src='{0}/create_ltm_irule.tcl'.format(fixture_path), partition='Common', server='localhost', password='******', user='******')) module = AnsibleModule( argument_spec=self.spec.argument_spec, supports_check_mode=self.spec.supports_check_mode, mutually_exclusive=self.spec.mutually_exclusive, ) if PY3: builtins_name = 'builtins' else: builtins_name = '__builtin__' with patch(builtins_name + '.open', mock_open(read_data='this is my content'), create=True): # Override methods in the specific type of manager tm = GtmManager(module=module, params=module.params) tm.exists = Mock(side_effect=[False, True]) tm.create_on_device = Mock(return_value=True) # Override methods to force specific logic in the module to happen mm = ModuleManager(module=module) mm.get_manager = Mock(return_value=tm) results = mm.exec_module() assert results['changed'] is True assert results['content'] == 'this is my content' assert results['module'] == 'gtm' assert results['src'] == '{0}/create_ltm_irule.tcl'.format( fixture_path) assert len(results.keys()) == 4
def test_encrypt_wrapped_crypt_algo(self, mock_write_file): password.os.path.exists = self.password_lookup._loader.path_exists with patch.object( builtins, 'open', mock_open(read_data=self.password_lookup._loader. _get_file_contents('/path/to/somewhere')[0])) as m: results = self.password_lookup.run( [u'/path/to/somewhere encrypt=ldap_sha256_crypt'], None) wrapper = getattr(passlib.hash, 'ldap_sha256_crypt') self.assertEqual(len(results), 1) result = results[0] self.assertIsInstance(result, text_type) expected_password_length = 76 self.assertEqual(len(result), expected_password_length) # result should have 5 parts split by '$' str_parts = result.split('$') self.assertEqual(len(str_parts), 5) # verify the string and passlib agree on the number of rounds self.assertEqual(str_parts[2], "rounds=%s" % wrapper.default_rounds) # verify it used the right algo type self.assertEqual(str_parts[0], '{CRYPT}') # verify it used the right algo type self.assertTrue( wrapper.verify( self.password_lookup._loader._get_file_contents( '/path/to/somewhere')[0], result)) # verify a password with a non default rounds value # generated with: echo test | mkpasswd -s --rounds 660000 -m sha-256 --salt testansiblepass. hashpw = '{CRYPT}$5$rounds=660000$testansiblepass.$KlRSdA3iFXoPI.dEwh7AixiXW3EtCkLrlQvlYA2sluD' self.assertTrue(wrapper.verify('test', hashpw))
def test_stategy_get_never_writes_in_check_mode(self, isfile): isfile.return_value = True set_module_args({'name': 'fooname', '_ansible_check_mode': True}) subclasses = get_all_subclasses(hostname.BaseStrategy) module = MagicMock() for cls in subclasses: instance = cls(module) instance.module.run_command = MagicMock() instance.module.run_command.return_value = (0, '', '') m = mock_open() builtins = 'builtins' if PY2: builtins = '__builtin__' with patch('%s.open' % builtins, m): instance.get_permanent_hostname() instance.get_current_hostname() self.assertFalse(m.return_value.write.called, msg='%s called write, should not have' % str(cls))
def manifest(manifest_info): b_data = to_bytes(json.dumps(manifest_info)) with patch.object(builtins, 'open', mock_open(read_data=b_data)) as m: with open('MANIFEST.json', mode='rb') as fake_file: yield fake_file, sha256(b_data).hexdigest()
def test_action_base__configure_module(self): fake_loader = DictDataLoader({}) # create our fake task mock_task = MagicMock() mock_task.action = "copy" mock_task.async_val = 0 mock_task.delegate_to = None # create a mock connection, so we don't actually try and connect to things mock_connection = MagicMock() # create a mock shared loader object def mock_find_plugin(name, options, collection_list=None): if name == 'badmodule': return None elif '.ps1' in options: return '/fake/path/to/%s.ps1' % name else: return '/fake/path/to/%s' % name mock_module_loader = MagicMock() mock_module_loader.find_plugin.side_effect = mock_find_plugin mock_shared_obj_loader = MagicMock() mock_shared_obj_loader.module_loader = mock_module_loader # we're using a real play context here play_context = PlayContext() # our test class action_base = DerivedActionBase( task=mock_task, connection=mock_connection, play_context=play_context, loader=fake_loader, templar=Templar(loader=fake_loader), shared_loader_obj=mock_shared_obj_loader, ) # test python module formatting with patch.object( builtins, 'open', mock_open(read_data=to_bytes(python_module_replacers.strip(), encoding='utf-8'))): with patch.object(os, 'rename'): mock_task.args = dict(a=1, foo='fö〩') mock_connection.module_implementation_preferences = ('', ) (style, shebang, data, path) = action_base._configure_module( mock_task.action, mock_task.args, task_vars=dict( ansible_python_interpreter='/usr/bin/python')) self.assertEqual(style, "new") self.assertEqual(shebang, u"#!/usr/bin/python") # test module not found self.assertRaises(AnsibleError, action_base._configure_module, 'badmodule', mock_task.args) # test powershell module formatting with patch.object( builtins, 'open', mock_open(read_data=to_bytes( powershell_module_replacers.strip(), encoding='utf-8'))): mock_task.action = 'win_copy' mock_task.args = dict(b=2) mock_connection.module_implementation_preferences = ('.ps1', ) (style, shebang, data, path) = action_base._configure_module('stat', mock_task.args) self.assertEqual(style, "new") self.assertEqual(shebang, u'#!powershell') # test module not found self.assertRaises(AnsibleError, action_base._configure_module, 'badmodule', mock_task.args)
def test_with_password_file(self): password.os.path.exists = lambda x: True with patch.object(builtins, 'open', mock_open(read_data=b'Testing\n')) as m: self.assertEqual(password._read_password_file(b'/etc/motd'), u'Testing')