How to use mock - 10 common examples

        new_callable=mock.PropertyMock)
    @mock.patch.object(
        jaeger_exporter.JaegerExporter,
        'collector',
        new_callable=mock.PropertyMock)
    @mock.patch.object(jaeger_exporter.JaegerExporter, 'translate_to_jaeger')
    def test_emit_succeeded(self, translate_mock, collector_mock, agent_mock):
        collector = collector_mock.return_value = MockTransport()
        agent = agent_mock.return_value = MockTransport()
        exporter = jaeger_exporter.JaegerExporter()
        translate_mock.return_value = {'test': 'mock'}
        exporter.emit([])
        self.assertTrue(agent.export_called)
        self.assertTrue(collector.export_called)

        collector_mock.return_value = None
        agent = agent_mock.return_value = MockTransport()

def test_attributes(dut, moku, attr, value):
    '''
    TODO Default test
    '''
    setattr(dut, attr, value)
    dut.commit()
    moku._write_regs.assert_called_with(ANY)

def test(self, default_mock):
        default_mock.return_value = (
            mock.sentinel.credentials, mock.sentinel.project)
        scopes = ['fake', 'scopes']

        got = _grpc_google_auth.get_default_credentials(scopes)

        self.assertEqual(got, mock.sentinel.credentials)
        default_mock.assert_called_once_with(scopes)

        @patch.object(Something, 'next_attribute', sentinel.Patched2)
        def test():
            self.assertEqual(Something.attribute, sentinel.Patched,
                             "unpatched")
            self.assertEqual(Something.next_attribute, sentinel.Patched2,
                             "unpatched")

  @mock.patch.multiple(macos, iokit=mock.DEFAULT, cf=mock.DEFAULT,
                       GetDeviceIntProperty=mock.DEFAULT)
  def testInitHidDevice(self, thread, iokit, cf, GetDeviceIntProperty):  # pylint: disable=invalid-name
    init_mock_iokit(iokit)
    init_mock_cf(cf)
    init_mock_get_int_property(GetDeviceIntProperty)

    device = macos.MacOsHidDevice('1')

    self.assertEqual(64, device.GetInReportDataLength())
    self.assertEqual(64, device.GetOutReportDataLength())

        @patch.multiple(foo_name, f=3, g=4)
        def test():
            self.assertIs(Foo, original_foo)
            self.assertEqual(Foo.f, 3)
            self.assertEqual(Foo.g, 4)

def test_run_test_matrix(do_tests, runner, continue_on_fail, result, expected):
    dt = do_tests.DoTests({}, {}, continue_on_fail=continue_on_fail)
    with mock.patch.multiple(do_tests, pytest_runner=mock.DEFAULT, shell_runner=mock.DEFAULT) as mock_rs:
        mock_r = mock_rs[runner + '_runner']
        mock_r.runner.return_value = result
        assert dt.run_test(sentinel.ssh, {runner: sentinel.path}, sentinel.config, sentinel.var) is expected
        assert mock_r.runner.called

def test_export(self):
        patch_worker = mock.patch(
            'opencensus.trace.exporters.transports.background_thread._Worker',
            autospec=True)
        exporter = mock.Mock()

        with patch_worker:
            transport = background_thread.BackgroundThreadTransport(exporter)

        trace = {
            'traceId': 'test',
            'spans': [{}, {}],
        }

        transport.export(trace)

        self.assertTrue(transport.worker.enqueue.called)

    @mock.patch('snaps_common.ansible_snaps.ansible_utils.apply_playbook')
    @mock.patch('time.sleep')
    @mock.patch('drp_python.translation_layer.machines_translation.'
                'MachineTranslation.add_machine_params')
    @mock.patch('snaps_boot.provision.rebar_utils.__create_machine_params')
    def test_setup_dhcp_service(self, m1, m2, m3, m4, m5, m6, m7, m8, m9, m10,
                                m11, m12):
        """
        Tests the rebar_utils.
        :return:
        """
        conf_file = pkg_resources.resource_filename('tests.conf', 'hosts.yaml')
        conf = file_utils.read_yaml(conf_file)
        rebar_utils.install_config_drp(None, conf)

    @patch("weibo_harvester.Weiboarc", autospec=True)
    def test_search_topic(self, mock_weiboarc_class):
        mock_weiboarc = MagicMock(spec=Weiboarc)
        # search_topic Expecting 2 results. First returns 1tweets. Second returns none.
        mock_weiboarc.search_topic.side_effect = [(weibo6, weibo7), ()]
        # Return mock_weiboarc when instantiating a weiboarc.
        mock_weiboarc_class.side_effect = [mock_weiboarc]

        self.harvester.message = base_search_message
        self.harvester.harvest_seeds()
        query = self.harvester.message["seeds"][0]["token"]

        self.assertDictEqual({"weibos": 2}, self.harvester.result.harvest_counter)
        mock_weiboarc_class.assert_called_once_with(tests.WEIBO_ACCESS_TOKEN)

        self.assertEqual([call(query, since_id=None)], mock_weiboarc.search_topic.mock_calls)