mock.patch.start

Here are the examples of the python api mock.patch.start taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

151 Examples 7

Example 1

Project: astara-appliance Source File: test_hostname.py
    def setUp(self):
        self.mock_execute = mock.patch('astara_router.utils.execute').start()
        self.mock_replace_file = mock.patch(
            'astara_router.utils.replace_file'
        ).start()
        self.addCleanup(mock.patch.stopall)

        self.mgr = hostname.HostnameManager()

Example 2

Project: group-based-policy Source File: test_tscp_resource_mapping.py
    def setUp(self):
        cfg.CONF.set_override(
            'extension_drivers', ['proxy_group'], group='group_policy')
        cfg.CONF.set_override('node_plumber', 'stitching_plumber',
                              group='node_composition_plugin')
        ml2_opts = {'mechanism_drivers': ['stitching_gbp']}
        host_agents = mock.patch('neutron.plugins.ml2.driver_context.'
                                 'PortContext.host_agents').start()
        host_agents.return_value = [self.agent_conf]
        super(ResourceMappingStitchingPlumberGBPTestCase, self).setUp(
            sc_plugin=base.SC_PLUGIN_KLASS, ml2_options=ml2_opts)

        def get_plumbing_info(context):
            return info_mapping.get(context.current_profile['service_type'])

        self.node_driver = self.sc_plugin.driver_manager.ordered_drivers[0].obj
        self.node_driver.get_plumbing_info = get_plumbing_info

Example 3

Project: aws-monocyte Source File: ec2_tests.py
Function: set_up
    def setUp(self):
        self.ec2_mock = patch("monocyte.handler.ec2.ec2").start()
        self.positive_fake_region = Mock(boto.ec2.regioninfo.EC2RegionInfo)
        self.positive_fake_region.name = "allowed_region"
        self.negative_fake_region = Mock(boto.ec2.regioninfo.EC2RegionInfo)
        self.negative_fake_region.name = "forbidden_region"
        self.resource_type = "ec2 Volume"

        self.ec2_mock.regions.return_value = [self.positive_fake_region, self.negative_fake_region]
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.ec2_handler = ec2.Volume(lambda region_name: region_name == self.positive_fake_region.name)

        self.volume_mock = self._given_volume_mock()

Example 4

Project: saleor Source File: test_registration.py
    def setUp(self):
        self.parse_mock = patch(
            'saleor.registration.utils.parse_response').start()
        self.requests_mock = patch(
            'saleor.registration.utils.requests').start()
        self.requests_mock.codes.ok = sentinel.ok

Example 5

Project: aws-monocyte Source File: rds2_tests.py
Function: set_up
    def setUp(self):
        self.rds2_mock = patch("monocyte.handler.rds2.rds2").start()
        self.snapshot_mock = self._given_snapshot_mock()

        self.positive_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.positive_fake_region.name = "allowed_region"
        self.negative_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.negative_fake_region.name = "forbidden_region"
        self.resource_type = "rds2 Snapshot"
        self.rds2_mock.regions.return_value = [self.positive_fake_region, self.negative_fake_region]
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.rds_snapshot = rds2.Snapshot(lambda region_name: True)

Example 6

Project: aws-monocyte Source File: cli_tests.py
Function: set_up
    def setUp(self):
        self.expected_whitelist = {'foo':'bar'}
        self.boto3_mock = patch('monocyte.cli.boto3').start()
        self.body_mock = MagicMock()
        self.body_mock.read.return_value = "foo: bar"
        self.object_mock = MagicMock()
        self.object_mock.get.return_value = {'Body': self.body_mock}

        def side_effect(bucket_name, key):
            if(bucket_name == 'any_bucket' and key == 'any_key/test'):
                return self.object_mock

        self.s3_mock = MagicMock(side_effect=side_effect)
        self.s3_mock.Object.side_effect = side_effect
        self.boto3_mock.resource.return_value = self.s3_mock

Example 7

Project: freezer Source File: test_vss.py
    def mock_process(self, process):
        fakesubprocesspopen = process.Popen()
        mock.patch('subprocess.Popen.communicate',
                   new_callable=fakesubprocesspopen.communicate).start()
        mock.patch('subprocess.Popen', new_callable=fakesubprocesspopen)\
            .start()

Example 8

Project: gtg Source File: test_config.py
Function: set_up
    def setUp(self):
        self.mock_parser = patch(
            'GTG.core.config.configparser.ConfigParser.read').start()
        self.mock_os = patch('GTG.core.config.os').start()
        self.mock_path = patch('GTG.core.config.os.path').start()
        self.mock_open = patch(
            'GTG.core.config.open', mock_open(), create=True).start()

Example 9

Project: networking-bigswitch Source File: test_restproxy_agent.py
Function: set_up
    def setUp(self):
        super(TestRestProxyAgentOVS, self).setUp()
        self.plapi = mock.patch(PLUGINAPI).start()
        self.ovsbridge_p = mock.patch(OVSBRIDGE)
        self.ovsbridge = self.ovsbridge_p.start()
        self.context = mock.patch(CONTEXT).start()
        self.rpc = mock.patch(CONSUMERCREATE).start()
        self.sg_agent = mock.patch(SGAGENT).start()
        self.sg_rpc = mock.patch(SGRPC).start()

Example 10

Project: vault Source File: test_keystone.py
Function: set_up
    def setUp(self):
        self.request = fake_request()

        self.mock_filter = patch('identity.keystone.GroupProjects.objects.filter').start()

        self.mock_model_project_get = patch('identity.keystone.Project.objects.get').start()
        self.mock_model_project_get.return_value = ProjectFactory()

        self.mock_keystone_client = patch('identity.keystone.client').start()

Example 11

Project: udocker Source File: unit_tests.py
    def test_07a_get_containers_list(self):
        """Test LocalRepository().get_containers_list()"""
        localrepo = self._localrepo(UDOCKER_TOPDIR)
        mock_isdir = mock.patch('os.path.isdir').start()
        mock_isdir.return_value = True
        mock_listdir = mock.patch('os.listdir').start()
        mock_listdir.return_value = ['LINK']
        with mock.patch(BUILTINS + '.open',
                        mock.mock_open(read_data='REPONAME')):
            containers_list = localrepo.get_containers_list()
            self.assertEqual(os.path.basename(containers_list[0]), "LINK")

Example 12

Project: aws-monocyte Source File: s3_tests.py
    def setUp(self):
        # self.boto_mock = patch("monocyte.handler.s3.boto").start()
        # self.key_mock = self._given_key_mock()
        # self.resource_type = "s3 Bucket"
        # self.negative_fake_region = Mock(boto.regioninfo.RegionInfo)
        # self.negative_fake_region.name = "forbidden_region"
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.s3_handler = s3.Bucket(lambda region_name: region_name not in [
            'cn-north-1', 'us-gov-west-1'])

Example 13

Project: Data-Pipeline Source File: hadoopshutdown_test.py
  def setUp(self):
    super(basetest.TestCase, self).setUp()
    self.mock_hadoop_cluster_class = mock.patch(
        'src.'
        'hadoop.hadoop_cluster.HadoopCluster').start()
    self.mock_hadoop_cluster = self.mock_hadoop_cluster_class.return_value

Example 14

Project: astara-appliance Source File: test_bird.py
    def setUp(self):
        self.mock_execute = mock.patch('astara_router.utils.execute').start()
        self.mock_replace_file = mock.patch(
            'astara_router.utils.replace_file'
        ).start()
        self.addCleanup(mock.patch.stopall)

        self.mgr = bird.BirdManager()

Example 15

Project: pypicloud Source File: test_auth.py
Function: set_up
    def setUp(self):
        super(TestBasicAuthPolicy, self).setUp()
        self.policy = auth.BasicAuthenticationPolicy()
        self.request.access = MagicMock()
        self.get_creds = patch(
            'pypicloud.auth.get_basicauth_credentials').start()

Example 16

Project: ceilometer Source File: test_client.py
Function: test_other_error
    def test_other_error(self):

        class _Exception(Exception):
            pass

        self.get = mock.patch('requests.get',
                              side_effect=_Exception).start()

        self.assertRaises(_Exception,
                          self.client.statistics.get_flow_statistics,
                          'default')

Example 17

Project: aws-monocyte Source File: dynamodb_tests.py
Function: set_up
    def setUp(self):
        self.dynamodb_mock = patch("monocyte.handler.dynamodb.dynamodb2").start()
        self.positive_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.positive_fake_region.name = "allowed_region"
        self.negative_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.negative_fake_region.name = "forbidden_region"

        self.dynamodb_mock.regions.return_value = [self.positive_fake_region, self.negative_fake_region]
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.dynamodb_handler = dynamodb.Table(
            lambda region_name: region_name == self.positive_fake_region.name)

        self.instance_mock = self._given_instance_mock()
        connection = self.dynamodb_mock.connect_to_region.return_value
        connection.list_tables.return_value = {"TableNames": ["mock_table"]}
        connection.describe_table.return_value = self.instance_mock

Example 18

Project: group-based-policy Source File: test_heat_node_driver.py
    def test_stack_not_found_ignored(self):
        mock.patch(heatclient.__name__ + ".client.Client",
                   new=MockHeatClientDeleteNotFound).start()

        provider, _, _ = self._create_simple_service_chain()

        # Removing the PRSs will make the PTG deletable again
        self.update_policy_target_group(provider['id'],
                                        provided_policy_rule_sets={},
                                        expected_res_status=200)
        self.delete_policy_target_group(provider['id'],
                                        expected_res_status=204)

Example 19

Project: diff-cover Source File: test_snippets.py
Function: set_up
    def setUp(self):
        """
        Create a temporary source file.
        """
        _, self._src_path = tempfile.mkstemp()

        # Path tool should not be aware of testing command
        path_mock = mock.patch('diff_cover.violationsreporters.violations_reporter.GitPathTool').start()
        path_mock.absolute_path = lambda path: path
        path_mock.relative_path = lambda path: path

Example 20

Project: group-based-policy Source File: test_simple_chain_driver.py
    def test_stack_not_found_ignored(self):
        name = "scs1"
        scn = self._create_profiled_servicechain_node()
        scn_id = scn['servicechain_node']['id']
        scs = self.create_servicechain_spec(name=name, nodes=[scn_id])
        sc_spec_id = scs['servicechain_spec']['id']

        mock.patch(heatclient.__name__ + ".client.Client",
                   new=MockHeatClient).start()
        sc_instance = self.create_servicechain_instance(
                                    name="sc_instance_1",
                                    servicechain_specs=[sc_spec_id])
        req = self.new_delete_request(
                            'servicechain_instances',
                            sc_instance['servicechain_instance']['id'])
        res = req.get_response(self.ext_api)
        self.assertEqual(webob.exc.HTTPNoContent.code, res.status_int)

Example 21

Project: aws-monocyte Source File: iam_tests.py
Function: set_up
    def setUp(self):
        def mock_region_filter(ignore):
            return True

        self.boto3Mock = patch("monocyte.handler.iam.boto3").start()
        self.iamClientMock = MagicMock()
        self.boto3Mock.client.return_value = self.iamClientMock
        self.iamResourceMock = MagicMock()
        self.boto3Mock.resource.return_value = self.iamResourceMock
        self.policy_handler = self.class_to_test(mock_region_filter)

        def mock_whitelist():
            return {}

        self.policy_handler.get_whitelist = mock_whitelist

Example 22

Project: aws-monocyte Source File: rds2_tests.py
Function: set_up
    def setUp(self):
        self.rds2_mock = patch("monocyte.handler.rds2.rds2").start()
        self.instance_mock = self._given_instance_mock()

        self.positive_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.positive_fake_region.name = "allowed_region"
        self.negative_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.negative_fake_region.name = "forbidden_region"
        self.resource_type = "rds2 Instance"
        self.rds2_mock.regions.return_value = [self.positive_fake_region, self.negative_fake_region]
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.rds_instance = rds2.Instance(lambda region_name: True)

Example 23

Project: diff-cover Source File: test_violations_reporter.py
Function: set_up
    def setUp(self):
        # Mock patch the installation of the linter
        self._mock_command_simple = patch('diff_cover.violationsreporters.violations_reporter.run_command_for_code').start()
        self._mock_command_simple.return_value = 0
        # Mock patch the linter results
        self._mock_communicate = patch.object(subprocess, 'Popen').start()
        self.subproc_mock = MagicMock()
        self.subproc_mock.returncode = 0

Example 24

Project: aws-monocyte Source File: s3_tests.py
    def setUp(self):
        self.boto_mock = patch("monocyte.handler.s3.boto").start()
        self.bucket_mock = self._given_bucket_mock()
        self.key_mock = self._given_key_mock()
        self.resource_type = "s3 Bucket"
        self.negative_fake_region = Mock(boto.regioninfo.RegionInfo)
        self.negative_fake_region.name = "forbidden_region"
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.s3_handler = s3.Bucket(lambda region_name: True)

Example 25

Project: vault Source File: test_project_views.py
    def setUp(self):
        self.view = views.ListProjectView.as_view()
        self.request = fake_request(method='GET')

        self.mock_keystone_is_allowed = patch('identity.keystone.Keystone._is_allowed_to_connect').start()

        self.mock_area = patch('identity.forms.Area.objects.all').start()
        self.mock_area.return_value = [AreaFactory(id=1)]

        patch('identity.keystone.Keystone._keystone_conn',
              Mock(return_value=None)).start()

Example 26

Project: udocker Source File: unit_tests.py
    def test_06_get_container_name(self):
        """Test LocalRepository().get_container_name()"""
        localrepo = self._localrepo(UDOCKER_TOPDIR)
        mock_isdir = mock.patch('os.path.isdir').start()
        mock_isdir.return_value = True
        mock_listdir = mock.patch('os.listdir').start()
        mock_listdir.return_value = ['LINK']
        mock_islink = mock.patch('os.path.islink').start()
        mock_islink.return_value = True
        mock_readlink = mock.patch('os.readlink').start()
        mock_readlink.return_value = "/a/b/IMAGE:TAG"
        name_list = localrepo.get_container_name("IMAGE:TAG")
        self.assertEqual(name_list, ["LINK"])

Example 27

Project: aws-monocyte Source File: monocyte_tests.py
Function: set_up
    def setUp(self):
        self.logger_mock = patch("monocyte.logging").start()
        self.logger_mock.INFO = 20
        self.config = {
            "handler_names": ["dummy"]
        }
        apply_default_config(self.config)
        self.monocyte = Monocyte(**self.config)

        self.allowed_region = "EU"
        self.not_allowed_region = "US"
        self.ignored_region = "us-gov-west-1"

Example 28

Project: vault Source File: test_user_views.py
    def setUp(self):
        self.view = UpdateProjectUserPasswordView.as_view()

        self.request = fake_request(method='GET')
        self.request.user.is_superuser = True

        self.mock_keystone_find_user = patch('identity.keystone.Keystone.return_find_u_user').start()
        # Retorna objeto usuário similar ao do request
        self.mock_keystone_find_user.return_value = fake_request(method='GET').user

        self.mock_users_list = patch('identity.keystone.Keystone.user_list').start()
        self.mock_users_list.return_value = [fake_request(method='GET').user]

        patch('identity.keystone.Keystone._keystone_conn',
              Mock(return_value=None)).start()

Example 29

Project: shipper Source File: test_client.py
Function: set_up
    def setUp(self):
        """
        Wraps treq so that actual calls are mostly made, but that certain
        results can be stubbed out
        """
        self.treq = mock.patch('shipper.client.treq', wraps=treq).start()
        self.addCleanup(mock.patch.stopall)

Example 30

Project: pyzor Source File: test_redis.py
Function: set_up
    def setUp(self):
        unittest.TestCase.setUp(self)
        logger = logging.getLogger("pyzord")
        logger.addHandler(logging.NullHandler())
        self.mredis = patch("pyzor.engines.redis_.redis", create=True).start()
        patch("pyzor.engines.redis_.RedisDBHandle._encode_record",
              side_effect=lambda x: x).start()
        patch("pyzor.engines.redis_.RedisDBHandle._decode_record",
              side_effect=lambda x: x).start()

Example 31

Project: mwclient Source File: test_page.py
    def setUp(self):
        title = 'Some page'
        self.page_text = 'Hello world'

        MockSite = mock.patch('mwclient.client.Site').start()
        self.site = MockSite()

        self.site.get.return_value = {'query': {'pages': {'1': {'title': title}}}}
        self.site.rights = ['read']

        self.page = Page(self.site, title)

        self.site.get.return_value = {'query': {'pages': {'2': {
            'ns': 0, 'pageid': 2, 'revisions': [{'*': 'Hello world', 'timestamp': '2014-08-29T22:25:15Z'}], 'title': title
        }}}}

Example 32

Project: Solutions-Using-ETL-tool-on-Google-Compute-Engine Source File: etl_demo_test.py
  def testStartInstance_created(self):
    mock_api = MagicMock(name='Mock API')
    self.manager.GetApi = MagicMock(return_value=mock_api)
    mock_builtin_open = patch('__builtin__.open').start()
    property_mock = PropertyMock(side_effect=HttpError(
        'resp', 'content'))
    mock_api.GetInstance = property_mock

    self.assertTrue(self.manager.StartInstance())
    mock_api.GetInstance.assert_called_once_with('myinstance')
    self.assertTrue(mock_api.CreateInstance.called)
    self.assertTrue(mock_builtin_open.called)

Example 33

Project: astara-appliance Source File: test_dnsmasq.py
    def setUp(self):
        self.mock_execute = mock.patch('astara_router.utils.execute').start()
        self.mock_replace_file = mock.patch(
            'astara_router.utils.replace_file'
        ).start()
        self.addCleanup(mock.patch.stopall)

        self.mgr = dnsmasq.DHCPManager()

Example 34

Project: diff-cover Source File: test_integration.py
    def setUp(self):
        """
        Patch the output of `git` commands and `os.getcwd`
        set the cwd to the fixtures dir
        """
        # Set the CWD to the fixtures dir
        self._old_cwd = os.getcwd()
        os.chdir(fixture_path(''))
        cwd = os.getcwd()

        self._mock_popen = patch('subprocess.Popen').start()
        self._mock_sys = patch('diff_cover.tool.sys').start()
        try:
            self._mock_getcwd = patch('diff_cover.tool.os.getcwdu').start()
        except AttributeError:
            self._mock_getcwd = patch('diff_cover.tool.os.getcwd').start()
        self._git_root_path = cwd
        self._mock_getcwd.return_value = self._git_root_path

Example 35

Project: astara-appliance Source File: test_strongswan.py
    def setUp(self):
        self.mock_execute = mock.patch('astara_router.utils.execute').start()
        self.mock_replace_file = mock.patch(
            'astara_router.utils.replace_file'
        ).start()
        self.addCleanup(mock.patch.stopall)

        self.mgr = ipsec.StrongswanManager()

Example 36

Project: aws-monocyte Source File: cloudformation_tests.py
    def setUp(self):
        self.cloudformation_mock = patch("monocyte.handler.cloudformation.cloudformation").start()
        self.positive_fake_region = Mock(boto.cloudformation.regions)
        self.positive_fake_region.name = "allowed_region"
        self.negative_fake_region = Mock(boto.cloudformation.regions)
        self.negative_fake_region.name = "forbbiden_region"
        self.resource_type = "cloudformation Stack"
        self.cloudformation_mock.regions.return_value = [self.positive_fake_region, self.negative_fake_region]
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.cloudformation_handler = cloudformation.Stack(
            lambda region_name: region_name == self.positive_fake_region.name)

        self.stack_mock = self._given_stack_mock()

Example 37

Project: dragonflow Source File: test_mech_driver.py
Function: set_up
    def setUp(self):
        config.cfg.CONF.set_override('extension_drivers',
                                     self._extension_drivers,
                                     group='ml2')
        mock.patch('dragonflow.db.neutron.lockedobjects_db.wrap_db_lock',
                   side_effect=empty_wrapper).start()
        nbapi_instance = mock.patch('dragonflow.db.api_nb.NbApi').start()
        nbapi_instance.get_instance.return_value = mock.MagicMock()
        super(DFMechanismDriverTestCase, self).setUp()

        mm = self.driver.mechanism_manager
        self.mech_driver = mm.mech_drivers['df'].obj
        self.mech_driver.post_fork_initialize(None, None, None)

Example 38

Project: pypicloud Source File: test_simple.py
Function: set_up
    def setUp(self):
        get = patch('pypicloud.views.simple.get_fallback_packages').start()
        p2 = self.package2
        self.fallback_packages = get.return_value = {
            p2.filename: self.fallback_url + p2.filename
        }

Example 39

Project: group-based-policy Source File: test_heat_node_driver.py
    def setUp(self):
        config.cfg.CONF.set_override('stack_action_wait_time',
                                     STACK_ACTION_WAIT_TIME,
                                     group='heat_node_driver')
        mock.patch(heatclient.__name__ + ".client.Client",
                   new=MockHeatClient).start()
        super(HeatNodeDriverTestCase, self).setUp(
            node_drivers=['heat_node_driver'],
            node_plumber='stitching_plumber',
            core_plugin=test_gp_driver.CORE_PLUGIN)

Example 40

Project: aws-monocyte Source File: ec2_tests.py
Function: set_up
    def setUp(self):
        self.ec2_mock = patch("monocyte.handler.ec2.ec2").start()
        self.positive_fake_region = Mock(boto.ec2.regioninfo.EC2RegionInfo)
        self.positive_fake_region.name = "allowed_region"
        self.negative_fake_region = Mock(boto.ec2.regioninfo.EC2RegionInfo)
        self.negative_fake_region.name = "forbidden_region"
        self.resource_type = "ec2 Instance"
        self.ec2_mock.regions.return_value = [self.positive_fake_region, self.negative_fake_region]
        self.logger_mock = patch("monocyte.handler.logging").start()
        self.ec2_handler = ec2.Instance(lambda region_name: region_name == self.positive_fake_region.name)

        self.instance_mock = self._given_instance_mock()

Example 41

Project: group-based-policy Source File: test_traffic_stitching_plumber.py
    def setUp(self):
        cfg.CONF.set_override('policy_drivers', ['implicit_policy',
                                                 'resource_mapping'],
                              group='group_policy')
        cfg.CONF.set_override('allow_overlapping_ips', True)
        cfg.CONF.set_override(
            'extension_drivers', ['proxy_group'], group='group_policy')
        super(TrafficStitchingPlumberTestCase, self).setUp(
            node_drivers=['node_dummy'], node_plumber='stitching_plumber',
            core_plugin=test_gp_driver.CORE_PLUGIN)
        res = mock.patch('neutron.db.l3_db.L3_NAT_dbonly_mixin.'
                         '_check_router_needs_rescheduling').start()
        res.return_value = None
        self.driver = self.sc_plugin.driver_manager.ordered_drivers[0].obj
        self.driver.get_plumbing_info = mock.Mock()
        self.driver.get_plumbing_info.return_value = {}

Example 42

Project: ripe-atlas-cousteau Source File: test_api_listing.py
    def test_wrong_api_output(self):
        arequest = mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get').start()
        arequest.return_value = True, {}
        probe_generator = ProbeRequest(**{})
        probes_list = list(probe_generator)
        expected_value = []

        self.assertEqual(probes_list, expected_value)
        self.assertEqual(probe_generator.total_count, 0)

Example 43

Project: group-based-policy Source File: test_simple_chain_driver.py
Function: set_up
    def setUp(self):
        config.cfg.CONF.set_override('servicechain_drivers',
                                     ['simplechain_driver'],
                                     group='servicechain')
        config.cfg.CONF.set_override('stack_delete_retries',
                                     STACK_DELETE_RETRIES,
                                     group='simplechain')
        config.cfg.CONF.set_override('stack_delete_retry_wait',
                                     STACK_DELETE_RETRY_WAIT,
                                     group='simplechain')
        super(SimpleChainDriverTestCase, self).setUp()
        key_client = mock.patch(
            'gbpservice.neutron.services.servicechain.plugins.msc.drivers.'
            'simplechain_driver.HeatClient._get_auth_token').start()
        key_client.return_value = 'mysplendidtoken'

Example 44

Project: aws-monocyte Source File: handler_tests.py
Function: set_up
    def setUp(self):
        self.identity_mock = Mock()
        self.identity_mock.get.return_value = 'any account id'
        self.sts_mock = Mock()
        self.sts_mock.get_caller_identity.return_value = self.identity_mock
        self.boto_mock = patch('monocyte.handler.boto3').start()
        self.boto_mock.client.return_value = self.sts_mock

        def mock_region_filter():
            return True
        self.handler = TestHandler(mock_region_filter)

Example 45

Project: vault Source File: test_keystone.py
Function: set_up
    def setUp(self):
        self.request = fake_request()

        self.project_id = 'rstuvwxyz'
        self.user_id = 'abcdefghiklmnopq'
        self.user_name = 'user_name'

        self.mock_keystone_conn = patch('identity.keystone.Keystone._keystone_conn').start()

        self.mock_project_delete = patch('identity.keystone.Keystone.project_delete').start()
        self.mock_user_delete = patch('identity.keystone.Keystone.user_delete').start()

        self.mock_return_find_u_user = patch('identity.keystone.Keystone.return_find_u_user').start()
        self.mock_return_find_u_user.return_value = FakeResource(self.user_id, name=self.user_name)

Example 46

Project: ripe-atlas-cousteau Source File: test_api_listing.py
    def test_empty_response_with_no_success(self):
        arequest = mock.patch('ripe.atlas.cousteau.request.AtlasRequest.get').start()
        arequest.return_value = False, {}
        kwargs = {"id__in": range(1, 10)}
        r = ProbeRequest(**kwargs)
        self.assertRaises(APIResponseError, lambda: list(r))

Example 47

Project: ripe-atlas-tools Source File: test_ipdetails.py
Function: set_up
    def setUp(self):
        fake_cache.clear()

        self.mock_cache = mock.patch(
            "ripe.atlas.tools.ipdetails.cache", wraps=fake_cache
        ).start()
        self.mock_get = mock.patch(
            'ripe.atlas.tools.ipdetails.requests.get'
        ).start()
        self.mock_get.return_value = FakeResponse(
            json_return=self.MOCK_RESULTS[self.IP]
        )

Example 48

Project: diff-cover Source File: test_violations_reporter.py
Function: test_not_installed
    def test_not_installed(self):
        """
        If linter is not available via commandline, it should raise
        an EnvironmentError
        """
        self._mock_command_simple = patch('diff_cover.violationsreporters.violations_reporter.run_command_for_code').start()
        self._mock_command_simple.return_value = 1
        with self.assertRaises(EnvironmentError):
            QualityReporter(self._get_out()).violations('test.js')

Example 49

Project: vault Source File: test_project_views.py
    def setUp(self):
        self.view = views.CreateProjectSuccessView.as_view()

        self.request = fake_request(method='GET')
        self.request.META.update({
            'SERVER_NAME': 'globo.com',
            'SERVER_PORT': '80'
        })
        self.request.user.is_superuser = True
        self.request.user.is_authenticated = lambda: True

        self.mock_keystone_conn = patch('identity.keystone.Keystone._keystone_conn').start()
        self.mock_is_allowed_to_connect = patch('identity.keystone.Keystone._is_allowed_to_connect').start()

Example 50

Project: udocker Source File: unit_tests.py
Function: local_repo
    def _localrepo(self, topdir):
        """Instantiate a local repository class"""
        topdir_path = os.getenv("HOME") + "/" + topdir
        udocker.conf = mock.patch('udocker.Config').start()
        udocker.conf.tmpdir = "/tmp"
        localrepo = udocker.LocalRepository(topdir_path)
        return localrepo
See More Examples - Go to Next Page
Page 1 Selected Page 2 Page 3 Page 4