Python verify.verifyObject函数代码示例

    def test_import_text_block_with_references(self):
        importer = self.assertImportFile(
            'test_import_text_block_with_references.silvaxml',
            ['/root/model',
             '/root/link'])
        self.assertEqual(importer.getProblems(), [])

        model = self.root._getOb('model')
        self.assertTrue(verifyObject(IPageModel, model))
        version = model.get_editable()
        self.assertTrue(verifyObject(IPageModelVersion, version))

        manager = IBlockManager(version)
        slot1 = manager.get_slot('one')
        self.assertEqual(1, len(slot1))
        _, text_block = slot1[0]
        self.assertIsInstance(text_block, TextBlock)
        references = list(
            getUtility(IReferenceService).get_references_from(version))
        self.assertEqual(1, len(references))
        reference = references[0]
        link = reference.target
        self.assertTrue(ILink.providedBy(link))
        self.assertEqual(2, len(reference.tags))
        reference_type = reference.tags[0]
        self.assertEqual("%s link" % text_block.identifier, reference_type)

    def registerPlugin(self, plugin):
        """Registers a plugin."""

        plugin_types = {
            'presence': IPresencePlugin,
            'chat': IChatPlugin,
            'population': IPopulationPlugin,
            'base_plugin': BaseInterface,
        }

        # Everything is, at least, a base plugin.
        valid_types = ['baseplugin']
        # Loop through the types of plugins and check for implentation of each.

        claimed_compliances = list(implementedBy(type(plugin)))
        # Can we use this as a map instead?
        for t, interface in plugin_types.iteritems():
            if interface in claimed_compliances:
                try:
                    verifyObject(interface, plugin)
                    # If the above succeeded, then `plugin` implementes `interface`.
                    self.plugins[t].append(plugin)
                    self.plugins[t].sort()
                    valid_types.append(t)
                except DoesNotImplement:
                    log.error('Plugin %s claims to be a %s, but is not!', plugin.name, t)

        plugin.setup(self)

        log.info('registered plugin %s as %s', plugin.name, valid_types)

    def test_configuration(self):
        """Verify slot block configuration.
        """
        context = self.root.page.get_editable()
        view = MockView(context)

        configurations = get_block_configuration(BlockSlot, context)
        self.assertTrue(verifyObject(IBlockConfigurations, configurations))
        self.assertEqual(len(configurations.get_all()), 1)

        configuration = configurations.get_by_identifier()
        self.assertTrue(verifyObject(IBlockConfiguration, configuration))
        self.assertEqual(
            configuration.identifier,
            'slot')
        self.assertEqual(
            configuration.title,
            'Slot')
        self.assertEqual(
            configuration.block,
            BlockSlot)
        self.assertEqual(
            configuration.get_icon(view),
            'http://localhost/++resource++icon-blocks-slot.png')

        # This block is only available on models.
        self.assertFalse(configuration.is_available(view))

        view = MockView(self.root.model.get_editable())
        self.assertTrue(configuration.is_available(view))

 def rpc_follow(self, sender, proto, signature):
     self.log.info("received follow request from %s" % sender)
     self.router.addContact(sender)
     try:
         verify_key = nacl.signing.VerifyKey(sender.signed_pubkey[64:])
         verify_key.verify(proto, signature)
         f = Followers.Follower()
         f.ParseFromString(proto)
         if f.guid != sender.id:
             raise Exception('GUID does not match sending node')
         if f.following != self.node.id:
             raise Exception('Following wrong node')
         f.signature = signature
         self.db.FollowData().set_follower(f)
         proto = Profile(self.db).get(False)
         m = Metadata()
         m.name = proto.name
         m.handle = proto.handle
         m.avatar_hash = proto.avatar_hash
         m.short_description = proto.short_description
         m.nsfw = proto.nsfw
         for listener in self.listeners:
             try:
                 verifyObject(NotificationListener, listener)
                 listener.notify(sender.id, f.metadata.handle, "follow", "", "", f.metadata.avatar_hash)
             except DoesNotImplement:
                 pass
         return ["True", m.SerializeToString(), self.signing_key.sign(m.SerializeToString())[:64]]
     except Exception:
         self.log.warning("failed to validate follower")
         return ["False"]

 def get_notification_listener(self):
     for listener in self.listeners:
         try:
             verifyObject(NotificationListener, listener)
             return listener
         except DoesNotImplement:
             pass

 def test_interface(self):
     """
     An instance of the reactor has all of the methods defined on
     L{IReactorWin32Events}.
     """
     reactor = self.buildReactor()
     verifyObject(IReactorWin32Events, reactor)

    def test_folder(self):
        """When pasting a folder as a ghost, its content is ghosted
        and any versioned content (ghost) in it are published.
        """
        manager = IContainerManager(self.root.target)
        with assertTriggersEvents('ObjectWillBeAddedEvent',
                                  'ObjectAddedEvent',
                                  'ContainerModifiedEvent'):
            with manager.ghoster() as ghoster:
                ghost = ghoster(self.root.source)

        self.assertTrue(verifyObject(IGhostFolder, ghost))
        self.assertEqual(ghost.get_link_status(), None)
        self.assertEqual(ghost.get_haunted(), self.root.source)
        self.assertIn('source', self.root.target.objectIds())

        # The ghost folder is created inside the target folder and is
        # already haunting the source.
        ghost = self.root.target.source
        self.assertTrue(verifyObject(IGhostFolder, ghost))
        self.assertEqual(ghost.get_link_status(), None)
        self.assertEqual(ghost.get_haunted(), self.root.source)
        self.assertItemsEqual(
            ghost.objectIds(),
            ['toc', 'data', 'folder', 'logo'])
        self.assertTrue(verifyObject(IGhost, ghost.toc))
        self.assertEqual(ghost.toc.get_haunted(), self.root.source.toc)
        self.assertTrue(verifyObject(IGhost, ghost.data))
        self.assertEqual(ghost.data.get_haunted(), self.root.source.data)
        self.assertEqual(ghost.data.is_published(), True)
        self.assertTrue(verifyObject(IGhostFolder, ghost.folder))
        self.assertEqual(ghost.folder.get_haunted(), self.root.source.folder)

 def test_implementsInterface(self):
     """
     L{checkers.UNIXAuthorizedKeysFiles} implements
     L{checkers.IAuthorizedKeysDB}.
     """
     keydb = checkers.UNIXAuthorizedKeysFiles(self.userdb)
     verifyObject(checkers.IAuthorizedKeysDB, keydb)

    def _add_formatter(self, formatter):
        try:
            verifyObject(IAnnotationFormatter, formatter)
        except DoesNotImplement:
            raise ValueError('formatter is not implementing IAnnotationFormatter interface')

        self._formatters.append(formatter)

    def test_instance_conforms_to_IUserLocator(self):
        from zope.interface.verify import verifyObject
        from ...interfaces import IUserLocator

        context = object()
        request = {}
        verifyObject(IUserLocator, self._makeOne())

 def test_writeConnectionLost(self):
     """
     The protocol created by L{flowFountFromEndpoint} provides half-close
     support, and when it receives an EOF (i.e.: C{writeConnectionLost}) it
     will signal the end of the flow to its drain's fount, but not to its
     fount's drain.
     """
     endpoint, ports = fakeEndpointWithPorts()
     fffep = flowFountFromEndpoint(endpoint)
     fffep.callback(None)
     flowFount = self.successResultOf(fffep)
     protocol = ports[0].factory.buildProtocol(None)
     verifyObject(IHalfCloseableProtocol, protocol)
     aTransport = StringTransport()
     protocol.makeConnection(aTransport)
     accepted = FakeDrain()
     flowFount.flowTo(accepted)
     [flow] = accepted.received
     receivedData = FakeDrain()
     dataSender = FakeFount()
     flow.fount.flowTo(receivedData)
     dataSender.flowTo(flow.drain)
     self.assertEqual(len(receivedData.stopped), 0)
     self.assertEqual(dataSender.flowIsStopped, False)
     protocol.writeConnectionLost()
     self.assertEqual(len(receivedData.stopped), 0)
     self.assertEqual(dataSender.flowIsStopped, 1)
     protocol.connectionLost(ConnectionDone())
     self.assertEqual(len(receivedData.stopped), 1)
     self.assertEqual(dataSender.flowIsStopped, 1)

def verify_plugin(interface, plugin):
    """
    Plugin interface verification.

    This function will call ``verifyObject()`` and ``validateInvariants()`` on
    the plugins passed to it.

    The primary purpose of this wrapper is to do logging, but it also permits
    code to be slightly cleaner, easier to test, and callable from other
    modules.
    """

    converted = interface(plugin, None)
    if converted is None:
        raise PluginException("Couldn't convert %s to %s" % (plugin,
            interface))

    try:
        verifyObject(interface, converted)
        interface.validateInvariants(converted)
        log.msg(" ( ^^) Plugin: %s" % converted.name)
    except BrokenImplementation, bi:
        if hasattr(plugin, "name"):
            log.msg(" ( ~~) Plugin %s is missing attribute %r!" %
                (plugin.name, bi.name))
        else:
            log.msg(" ( >&) Plugin %s is unnamed and useless!" % plugin)

    def test00_interface(self):
        portal_modifier = self.portal.portal_modifier

        # test interface conformance
        #verifyObject(IModifier, portal_modifier)
        verifyObject(IModifierRegistrySet, portal_modifier)
        verifyObject(IModifierRegistryQuery, portal_modifier)

    def test32(self):
        from zope.interface.verify import verifyObject
        import BTrees
        from BTrees.IOBTree import IOTreeSet
        verifyObject(BTrees.Interfaces.IBTreeFamily, BTrees.family32)
        self.assertEqual(
            BTrees.family32.IO, BTrees.IOBTree)
        self.assertEqual(
            BTrees.family32.OI, BTrees.OIBTree)
        self.assertEqual(
            BTrees.family32.II, BTrees.IIBTree)
        self.assertEqual(
            BTrees.family32.IF, BTrees.IFBTree)
        self.assertEqual(
            BTrees.family32.OO, BTrees.OOBTree)
        s = IOTreeSet()
        s.insert(BTrees.family32.maxint)
        self.assertTrue(BTrees.family32.maxint in s)
        s = IOTreeSet()
        s.insert(BTrees.family32.minint)
        self.assertTrue(BTrees.family32.minint in s)
        s = IOTreeSet()
        # this next bit illustrates an, um, "interesting feature".  If
        # the characteristics change to match the 64 bit version, please
        # feel free to change.
        with self.assertRaises((TypeError, OverflowError)):
            s.insert(BTrees.family32.maxint + 1)

        with self.assertRaises((TypeError, OverflowError)):
            s.insert(BTrees.family32.minint - 1)
        self.check_pickling(BTrees.family32)

 def test_interfaces(self):
     """
     L{Protocol} instances provide L{IProtocol} and L{ILoggingContext}.
     """
     proto = Protocol()
     self.assertTrue(verifyObject(IProtocol, proto))
     self.assertTrue(verifyObject(ILoggingContext, proto))