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))

 def test64(self):
     from zope.interface.verify import verifyObject
     import BTrees
     from BTrees.LOBTree import LOTreeSet
     verifyObject(BTrees.Interfaces.IBTreeFamily, BTrees.family64)
     self.assertEqual(
         BTrees.family64.IO, BTrees.LOBTree)
     self.assertEqual(
         BTrees.family64.OI, BTrees.OLBTree)
     self.assertEqual(
         BTrees.family64.II, BTrees.LLBTree)
     self.assertEqual(
         BTrees.family64.IF, BTrees.LFBTree)
     self.assertEqual(
         BTrees.family64.OO, BTrees.OOBTree)
     s = LOTreeSet()
     s.insert(BTrees.family64.maxint)
     self.assertTrue(BTrees.family64.maxint in s)
     s = LOTreeSet()
     s.insert(BTrees.family64.minint)
     self.assertTrue(BTrees.family64.minint in s)
     s = LOTreeSet()
     # XXX why oh why do we expect ValueError here, but TypeError in test32?
     self.assertRaises(ValueError, s.insert, BTrees.family64.maxint + 1)
     self.assertRaises(ValueError, s.insert, BTrees.family64.minint - 1)
     self.check_pickling(BTrees.family64)

    def test_instance_implements_ITemplate(self):
        from zope.interface.verify import verifyObject
        from pyramid.interfaces import ITemplateRenderer

        path = self._getTemplatePath("minimal.pt")
        lookup = DummyLookup()
        verifyObject(ITemplateRenderer, self._makeOne(path, lookup))

    def test_interfaces(self):
        """The serivce maker implements both IServiceMaker and IPlugin.

        """
        sm = WebsiteServiceMaker()
        verifyObject(IServiceMaker, sm)
        verifyObject(IPlugin, sm)

 def test_collection_provides_ICollection(self):
     """
     The return value of .get_row_collection() is an object that provides
     ICollection.
     """
     collection = yield self.mk_collection("owner-1")
     verifyObject(ICollection, collection)

def retrieve_plugins(interface, cached=True, cache={}):
    """
    Look up all plugins for a certain interface.

    If the plugin cache is enabled, this function will not attempt to reload
    plugins from disk or discover new plugins.

    :param interface interface: the interface to use
    :param bool cached: whether to use the in-memory plugin cache

    :returns: a dict of plugins, keyed by name
    :raises PluginException: no plugins could be found for the given interface
    """

    if cached and interface in cache:
        return cache[interface]

    log.msg("Discovering %s..." % interface)
    d = {}
    for p in getPlugins(interface, bravo.plugins):
        try:
            verifyObject(interface, p)
            log.msg(" ( ^^) Plugin: %s" % p.name)
            d[p.name] = p
        except BrokenImplementation, bi:
            if hasattr(p, "name"):
                log.msg(" ( ~~) Plugin %s is missing attribute %r!" %
                    (p.name, bi.name))
            else:
                log.msg(" ( >&) Plugin %s is unnamed and useless!" % p)
        except BrokenMethodImplementation, bmi:
            log.msg(" ( Oo) Plugin %s has a broken %s()!" % (p.name,
                bmi.method))
            log.err()