Python Mock.name方法代码示例

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
def test_multiple_plugins(iter_entry_points):
    plugin1 = Mock()
    plugin1.name = 'plugin1'
    plugin1.dist.project_name = 'mymodule'
    plugin2 = Mock()
    plugin2.name = 'plugin2'
    plugin2.dist.project_name = 'mymodule'
    plugin3 = Mock()
    plugin3.name = 'plugin3'
    plugin3.dist.project_name = 'mymodule'
    iter_entry_points.return_value = [plugin2, plugin3, plugin1]
    config = ConfigParser()
    config.read_dict({
        'whatever': dict(plugins='mymodule#plugin1,mymodule#plugin2'),
        'whatever_reverse': dict(plugins='mymodule#plugin2,mymodule#plugin1'),
        'other': dict(plugins='mymodule#plugin2,mymodule#plugin3'),
            })
    plugins = load(config, 'whatever')
    plugin1.load.assert_called_once_with(require=False)
    assert plugins == [('mymodule#plugin1', plugin1.load()), ('mymodule#plugin2', plugin2.load())]
    # reverse order in the config file and you see the plugins are returned in that order
    plugins = load(config, 'whatever_reverse')
    assert plugins == [('mymodule#plugin2', plugin2.load()), ('mymodule#plugin1', plugin1.load())]
    # try now with only one plugin configured
    assert not plugin3.load.called
    plugins = load(config, 'other')
    plugin3.load.assert_called_once_with(require=False)
    assert plugins == [('mymodule#plugin2', plugin2.load()), ('mymodule#plugin3', plugin3.load())]

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
def model():
    artist = Mock()
    artist.name = 'Test Artist'

    album = Mock(ignored=False, artist=artist)
    album.name = 'Test Album'

    return library.AlbumModel(album, 1.0)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
    def test_str(self):
        """Test string reprezentation of an instance."""
        source_node = Mock()
        source_node.name = 'node_S'

        target_node = Mock()
        target_node.name = 'node_T'

        event = self._make_instance(source_node, target_node, 'replica_XYZ')

        self.assertEqual(
            str(event),
            "<ReceiveReplicaRequest event> (node_S --> node_T, replica_XYZ)"
        )

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
    def test_str_target_is_none(self):
        """Test string reprezentation of an instance when target node is None.
        """
        source_node = Mock()
        source_node.name = 'node_S'

        replica = Mock()
        replica.name = 'replica_XYZ'

        event = self._make_instance(source_node, None, replica)

        self.assertEqual(
            str(event),
            "<SendReplica event> (None <-- node_S, replica_XYZ)"
        )

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
def test_refresh_job_outdated(JENKINS):
    from jenkins_epo.extensions.jenkins import CreateJobsExtension
    from jenkins_epo.bot import Instruction

    ext = CreateJobsExtension('createjob', Mock())
    ext.current = ext.bot.current
    ext.current.errors = []
    ext.current.refresh_jobs = None
    ext.current.job_specs = {'job': Mock(config={})}
    ext.current.job_specs['job'].name = 'job'
    job = Mock(updated_at=datetime.now() - timedelta(hours=1))
    job.name = 'job'
    job.spec.contains.return_value = True
    job.update = CoroutineMock()
    ext.current.jobs = {'job': job}

    ext.process_instruction(Instruction(
        author='author', name='refresh-jobs', date=datetime.now()
    ))

    assert ext.current.refresh_jobs

    items = list(ext.process_job_specs())
    assert 1 == len(items)
    action, spec = items[0]
    assert job.update == action

    ext.current.jobs['job'].updated_at = datetime.now() + timedelta(hours=1)
    items = list(ext.process_job_specs())
    assert 0 == len(items)

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
 def setUp(self):
     """
     Set up values for the unit tests that follow
     """
     mock_type = Mock()
     mock_type.name = 'textBlockItemType'
     mock_qname = Mock(
         return_value=(
             '{http://xbrl.sec.gov/dei/2014-01-31}DocumentFiscalPeriodFocus'
         ),
         namespaceURI='http://xbrl.sec.gov/dei/2014-01-31',
         localName='DocumentFiscalPeriodFocus'
     )
     mock_concept = Mock(qname=mock_qname, type=mock_type)
     mock_nameconcepts = {'DocumentFiscalPeriodFocus': [mock_concept]}
     mock_context = Mock()
     mock_fact = Mock(
         context=mock_context,
         concept=mock_concept,
         qname=mock_qname,
         xValue='Q3'
     )
     mock_factsbyqname = {mock_concept.qname: [mock_fact]}
     self.mock_model = Mock(
         factsByQname=mock_factsbyqname,
         facts=[mock_fact],
         nameConcepts=mock_nameconcepts
     )

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
 def setUp(self):
     """
     Sets up values for the unit tests
     """
     mock_type = Mock()
     mock_type.name = 'textBlockItemType'
     mock_qname = Mock(
         return_value=(
             '{http://fasb.org/us-gaap/2015-01-31}DocumentPeriodEndDate'
         ),
         namespaceURI='http://fasb.org/us-gaap/2015-01-31',
         localName='DocumentPeriodEndDate')
     mock_concept = Mock(qname=mock_qname,
                         type=mock_type)
     mock_nameconcepts = {'DocumentPeriodEndDate': [mock_concept]}
     mock_segdimval = {}
     mock_context = Mock(
         endDatetime=date(2015, 1, 1),
         segDimValues=mock_segdimval
     )
     mock_fact = Mock(
         context=mock_context,
         concept=mock_concept,
         xValue=date(2015, 1, 1)
     )
     mock_factsbyqname = {mock_concept.qname: [mock_fact]}
     self.mock_disclosure = Mock(
         standardTaxonomiesDict={'http://fasb.org/us-gaap/2015-01-31': None}
     )
     self.mock_model = Mock(
         factsByQname=mock_factsbyqname,
         facts=[mock_fact],
         nameConcepts=mock_nameconcepts
     )

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
 def setUp(self):
     mock_type = Mock()
     mock_type.name = 'textBlockItemType'
     mock_qname = Mock(
         return_value=(
             '{http://xbrl.sec.gov/dei/2014-01-31}DocumentPeriodEndDate'
         ),
         namespaceURI='http://xbrl.sec.gov/dei/2014-01-31',
         localName='DocumentPeriodEndDate'
     )
     mock_concept = Mock(
         qname=mock_qname, type=mock_type
     )
     mock_nameConcepts = {'DocumentPeriodEndDate': [mock_concept]}
     mock_segDimVal = {}
     mock_context = Mock(
         endDatetime=date(2015, 1, 1),
         segDimValues=mock_segDimVal
     )
     mock_fact = Mock(
         context=mock_context,
         concept=mock_concept,
         xValue=date(2015, 1, 1)
     )
     mock_factsByQname = {mock_concept.qname: [mock_fact]}
     self.mock_disclosure = Mock(
         standardTaxonomiesDict={'http://xbrl.sec.gov/dei/2014-01-31': None}
     )
     self.mock_model = Mock(
         factsByQname=mock_factsByQname,
         facts=[mock_fact],
         nameConcepts=mock_nameConcepts
     )

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
def test_build_failed(mocker, SETTINGS):
    JENKINS = mocker.patch('jenkins_epo.extensions.jenkins.JENKINS')

    from jenkins_epo.extensions.jenkins import BuilderExtension

    ext = BuilderExtension('builder', Mock())
    ext.current = ext.bot.current
    job = Mock()
    job.build = CoroutineMock(side_effect=Exception('POUET'))
    spec = Mock(config=dict())
    spec.name = 'job'
    ext.current.SETTINGS = SETTINGS
    ext.current.head.ref = 'refs/heads/pr'
    ext.current.last_commit.filter_not_built_contexts.return_value = ['job']
    ext.current.last_commit.maybe_update_status = CoroutineMock(return_value={
        'description': 'Queued'
    })
    ext.current.jobs_match = []
    ext.current.job_specs = {'job': spec}
    ext.current.jobs = {'job': job}
    ext.current.statuses = {}

    JENKINS.is_queue_empty = CoroutineMock(return_value=True)

    yield from ext.run()

    assert ext.current.last_commit.maybe_update_status.mock_calls
    assert job.build.mock_calls

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
 def test_add_gene_logs_debug_message(self, mock_getLogger):
     mock_logger = Mock()
     mock_getLogger.return_value = mock_logger
     foo_enabler = self.TestEnabler()
     mock_organism_1 = Mock(spec=Organism())
     mock_organism_1.name = 'mock_organism_name'
     foo_enabler.decorate(mock_organism_1)
     mock_logger.debug.assert_called_with('Adding gene TestEnabler to organism "mock_organism_name"')

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
 def test_issue_icon_color(self):
     issue = models.Issue()
     self.assertEqual("", issue.icon_color("blue"))
     mock_file = Mock()
     mock_file.name = 'somepath/to/icons/area/filename.bob.sVG'
     issue.icon = mock_file
     self.assertEqual('somepath/to/icons/area/filename.bob-blue.sVG',
                      issue.icon_color('blue'))

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
    def resolve_view(req, res, tail):
        async def view_call():
            return 'view_result'

        mock = Mock(name='view')
        mock.name = 'view'
        mock.return_value = view_call()
        return mock

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
async def test_create_event():
    """Successfully created a deCONZ event."""
    hass = Mock()
    remote = Mock()
    remote.name = 'Name'

    event = gateway.DeconzEvent(hass, remote)

    assert event._id == 'name'

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
async def test_do_not_add_deconz_groups(hass):
    """Test that clip sensors can be ignored."""
    await setup_gateway(hass, {}, allow_deconz_groups=False)
    group = Mock()
    group.name = 'name'
    group.register_async_callback = Mock()
    async_dispatcher_send(hass, 'deconz_new_group', [group])
    await hass.async_block_till_done()
    assert len(hass.data[deconz.DOMAIN].deconz_ids) == 0

# 需要导入模块: from unittest.mock import Mock [as 别名]
# 或者: from unittest.mock.Mock import name [as 别名]
def _mock_calendar(name):
    events = []
    for idx, event in enumerate(EVENTS):
        events.append(Event(None, "%d.ics" % idx, event, None, str(idx)))

    calendar = Mock()
    calendar.date_search = MagicMock(return_value=events)
    calendar.name = name
    return calendar