Python mock.patch函数代码示例

 def test_list_under_parent(self):
     """Establish that listing with a parent specified works."""
     with mock.patch(
             'tower_cli.models.base.ResourceMethods.list') as mock_list:
         with mock.patch(
                 'tower_cli.resources.group.Resource.lookup_with_inventory'
                 ):
             self.gr.list(parent="foo_group")
             mock_list.assert_called_once_with()

    def test_post_save_hook_was_connected(self):
        with mock.patch('django.db.models.signals.post_save') as mocked_post_save, \
                mock.patch('django.db.models.signals.pre_delete'):
            caching_framework.register(TestModel)

            mocked_post_save.connect.assert_called_once_with(mock.ANY,
                                                             sender=TestModel,
                                                             weak=False,
                                                             dispatch_uid='%s_cache_object' % TestModel._meta.db_table)

 def test_associate(self):
     """Establish that associate commands work."""
     with mock.patch(
             'tower_cli.models.base.ResourceMethods._assoc') as mock_assoc:
         with mock.patch(
                 'tower_cli.resources.group.Resource.lookup_with_inventory'
                 ) as mock_lookup:
             mock_lookup.return_value = {'id': 1}
             self.gr.associate(group=1, parent=2)
             mock_assoc.assert_called_once_with('children', 1, 1)

 def test_reading_invalid_token_from_server(self):
     self.expires += timedelta(hours=-1)
     expires = self.expires.strftime(TOWER_DATETIME_FMT)
     with mock.patch('six.moves.builtins.open', new_callable=mock.mock_open()):
         with mock.patch('tower_cli.api.json.load', return_value={'token': 'foobar', 'expires': expires}):
             with client.test_mode as t:
                 with self.assertRaises(exc.AuthError):
                     t.register('/authtoken/', json.dumps({}), status_code=200, method='OPTIONS')
                     t.register('/authtoken/', json.dumps({'invalid': 'invalid'}), status_code=200, method='POST')
                     self.auth(self.req)

 def test_role_write_user_exists_FOF(self):
     """Simulate granting user permission where they already have it."""
     with mock.patch(
             'tower_cli.models.base.ResourceMethods.read') as mock_read:
         mock_read.return_value = {'results': [copy(example_role_data)],
                                   'count': 1}
         with mock.patch('tower_cli.api.Client.post'):
             with self.assertRaises(exc.NotFound):
                 self.res.role_write(user=2, inventory=3, type='admin',
                                     fail_on_found=True)

 def test_role_grant_user(self):
     """Simulate granting user permission."""
     with mock.patch(
             'tower_cli.models.base.ResourceMethods.read') as mock_read:
         mock_read.return_value = {
             'results': [copy(example_role_data)], 'count': 0}
         with mock.patch('tower_cli.api.Client.post') as mock_post:
             self.res.role_write(user=2, inventory=3, type='admin')
             mock_post.assert_called_once_with(
                 'users/2/roles/', data={'id': 1})

 def test_reading_invalid_token(self):
     self.expires += timedelta(hours=1)
     expires = self.expires.strftime(TOWER_DATETIME_FMT)
     with mock.patch('six.moves.builtins.open', new_callable=mock.mock_open()):
         with mock.patch('tower_cli.api.json.load', return_value="invalid"):
             with client.test_mode as t:
                 t.register('/authtoken/', json.dumps({}), status_code=200, method='OPTIONS')
                 t.register('/authtoken/', json.dumps({'token': 'barfoo', 'expires': expires}), status_code=200,
                            method='POST')
                 self.auth(self.req)
                 self.assertEqual(self.req.headers['Authorization'], 'Token barfoo')

 def setUp(self):
     super(MockServiceWithConfigTestCase, self).setUp()
     self.environ = {}
     self.config = {}
     self.config_patch = mock.patch('boto.provider.config.get',
                                    self.get_config)
     self.has_config_patch = mock.patch('boto.provider.config.has_option',
                                        self.has_config)
     self.environ_patch = mock.patch('os.environ', self.environ)
     self.config_patch.start()
     self.has_config_patch.start()
     self.environ_patch.start()

 def test_concurrent_upload_file(self):
     v = vault.Vault(None, None)
     with mock.patch("boto.glacier.vault.ConcurrentUploader") as c:
         c.return_value.upload.return_value = "archive_id"
         archive_id = v.concurrent_create_archive_from_file("filename", "my description")
         c.return_value.upload.assert_called_with("filename", "my description")
     self.assertEqual(archive_id, "archive_id")

 def test_create_without_special_fields(self):
     """Establish that a create without user, team, or credential works"""
     with mock.patch(
             'tower_cli.models.base.Resource.create') as mock_create:
         cred_res = tower_cli.get_resource('credential')
         cred_res.create(name="foobar")
         mock_create.assert_called_once_with(name="foobar")

    def setUp(self, _orig_class=orig_class):
        _orig_class.setUp(self)

        def find_near_matches_dropin(subsequence, sequence, *args, **kwargs):
            if isinstance(sequence, (tuple, list)):
                self.skipTest('skipping word-list tests with find_near_matches_in_file')
            try:
                from Bio.Seq import Seq
            except ImportError:
                pass
            else:
                if isinstance(sequence, Seq):
                    self.skipTest('skipping BioPython Seq tests with find_near_matches_in_file')

            tempfilepath = tempfile.mktemp()
            if isinstance(sequence, text_type):
                f = io.open(tempfilepath, 'w+', encoding='utf-8')
            else:
                f = open(tempfilepath, 'w+b')
            try:
                f.write(sequence)
                f.seek(0)
                return find_near_matches_in_file(subsequence, f, *args, **kwargs)
            finally:
                f.close()
                os.remove(tempfilepath)

        patcher = mock.patch(
            'tests.test_find_near_matches.find_near_matches',
            find_near_matches_dropin)
        self.addCleanup(patcher.stop)
        patcher.start()

 def test_grant_user_role(self):
     """Assure that super method is called granting role"""
     with mock.patch(
             'tower_cli.resources.role.Resource.role_write') as mock_write:
         kwargs = dict(user=1, type='read', project=3)
         self.res.grant(**kwargs)
         mock_write.assert_called_once_with(fail_on_found=False, **kwargs)

 def test_list_user(self):
     """Assure that super method is called with right parameters"""
     with mock.patch(
             'tower_cli.models.base.ResourceMethods.list') as mock_list:
         mock_list.return_value = {'results': [example_role_data]}
         self.res.list(user=1)
         mock_list.assert_called_once_with(members__in=1)

    def test_write_global_setting(self):
        """Establish that if we attempt to write a valid setting, that
        the parser's write method is run.
        """
        # Invoke the command, but trap the file-write at the end
        # so we don't plow over real things.
        mock_open = mock.mock_open()
        with mock.patch('tower_cli.commands.config.open', mock_open,
                        create=True):
            with mock.patch.object(os.path, 'isdir') as isdir:
                isdir.return_value = True
                result = self.runner.invoke(config,
                    ['username', 'luke', '--scope=global'],
                )
                isdir.assert_called_once_with('/etc/awx/')

        # Ensure that the command completed successfully.
        self.assertEqual(result.exit_code, 0)
        self.assertEqual(result.output.strip(),
                         'Configuration updated successfully.')

        # Ensure that the output seems to be correct.
        self.assertIn(mock.call('/etc/awx/tower_cli.cfg', 'w'),
                      mock_open.mock_calls)
        self.assertIn(mock.call().write('username = luke\n'),
                      mock_open.mock_calls)

 def setUp(self):
     with mock.patch(
         GCS_STRING.format('GoogleCloudBaseHook.__init__'),
         new=mock_base_gcp_hook_default_project_id,
     ):
         self.gcs_hook = gcs_hook.GoogleCloudStorageHook(
             google_cloud_storage_conn_id='test')