[Zope3-checkins] CVS: Zope3/src/zope/app/tree/tests - __init__.py:1.1 basetest.py:1.1 test_adapters.py:1.1 test_encoder.py:1.1 test_filters.py:1.1 test_node.py:1.1

Philipp von Weitershausen philikon at philikon.de
Thu Feb 19 15:43:08 EST 2004


Update of /cvs-repository/Zope3/src/zope/app/tree/tests
In directory cvs.zope.org:/tmp/cvs-serv12688/tests

Added Files:
	__init__.py basetest.py test_adapters.py test_encoder.py 
	test_filters.py test_node.py 
Log Message:
Bring over zope.products.statictree to zope.app.


=== Added File Zope3/src/zope/app/tree/tests/__init__.py ===
# make this directory a package


=== Added File Zope3/src/zope/app/tree/tests/basetest.py ===
##############################################################################
#
# Copyright (c) 2004 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""
$Id: basetest.py,v 1.1 2004/02/19 20:43:06 philikon Exp $
"""

import unittest
from zope.interface import implements, Interface, Attribute
from zope.app.tests.placelesssetup import PlacelessSetup
from zope.app.tests import ztapi

from zope.app.tree.interfaces import IUniqueId, IChildObjects, \
     ITreeStateEncoder
from zope.app.tree.node import Node
from zope.app.tree.utils import TreeStateEncoder

__metaclass__ = type

class IItem(Interface):
    """Simple object that can have an id and a set of children
    """
    id = Attribute("id")
    children = Attribute("children")

class Item:
    implements(IItem)

    def __init__(self, id, children=[]):
        self.id = id
        self.children = children

class ItemUniqueId:
    """Simplistic adapter from IItem to IUniqueId
    """
    implements(IUniqueId)

    def __init__(self, context):
        self.id = context.id

    def getId(self):
        return self.id

class ItemChildObjects:
    """Simplistic adapter from IItem to IChildObjects
    """
    implements(IChildObjects)

    def __init__(self, context):
        self.children = context.children

    def getChildObjects(self):
        return self.children

    def hasChildren(self):
        return len(self.children) > 0

# function used to convert a set of nested tuples to items and
# children items.
def make_item_from_tuple(item_tuple, dict):
    children = []
    if len(item_tuple) > 1:
        for child in item_tuple[1]:
            children.append(make_item_from_tuple(child, dict))
    item = Item(item_tuple[0], children)
    dict[item_tuple[0]] = item
    return item

tree = ('a', [
           ('b', [
               ('d',), ('e',)
               ]),
           ('c', [
               ('f', [
                   ('h',), ('i',)
                   ]),
               ('g')]
           ) ]
       )

class BaseTestCase(PlacelessSetup, unittest.TestCase):
    """Base class for most static tree tests
    """

    expanded_nodes = ['a', 'c']

    def setUp(self):
        super(BaseTestCase, self).setUp()
        # provide necessary components
        ztapi.provideAdapter(IItem, IUniqueId, ItemUniqueId)
        ztapi.provideAdapter(IItem, IChildObjects, ItemChildObjects)
        ztapi.provideUtility(ITreeStateEncoder, TreeStateEncoder())

    def makeItems(self):
        # this mapping will provide shortcuts to each object
        self.items = {}
        self.root_obj = make_item_from_tuple(tree, self.items)
        self.root_node = Node(self.root_obj, self.expanded_nodes)


=== Added File Zope3/src/zope/app/tree/tests/test_adapters.py ===
##############################################################################
#
# Copyright (c) 2004 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""
$Id: test_adapters.py,v 1.1 2004/02/19 20:43:06 philikon Exp $
"""

import unittest

from zope.interface import implements, directlyProvides
from zope.component.exceptions import ComponentLookupError

from zope.app.interfaces.location import ILocation
from zope.app.interfaces.container import IReadContainer
from zope.app.interfaces.services.service import ISite
from zope.app.interfaces.traversing import IContainmentRoot

from zope.app.container.sample import SampleContainer
from zope.app.container.contained import setitem
from zope.app.tests.placelesssetup import PlacelessSetup
from zope.app import zapi
from zope.app.tests import ztapi

from zope.app.tree.interfaces import IUniqueId, IChildObjects, \
     ITreeStateEncoder
from zope.app.tree.utils import TreeStateEncoder
from zope.app.tree.adapters import StubUniqueId, StubChildObjects, \
     LocationUniqueId, ContainerChildObjects, ContainerSiteChildObjects

__metaclass__ = type

class SampleContent:
    pass

class SampleSite(SampleContainer):
    implements(ISite)

    def setSiteManager(self, sm):
        self._sm = sm

    def getSiteManager(self):
        try:
            return self._sm
        except AttributeError:
            raise ComponentLookupError

class AdapterTestCase(PlacelessSetup, unittest.TestCase):

    def setUp(self):
        super(AdapterTestCase, self).setUp()
        # provide necessary components
        ztapi.provideAdapter(None, IUniqueId, StubUniqueId)
        ztapi.provideAdapter(None, IChildObjects, StubChildObjects)
        ztapi.provideAdapter(ILocation, IUniqueId, LocationUniqueId)
        ztapi.provideAdapter(IReadContainer, IChildObjects, ContainerChildObjects)
        ztapi.provideAdapter(ISite, IChildObjects, ContainerSiteChildObjects)
        ztapi.provideUtility(ITreeStateEncoder, TreeStateEncoder())
        self.makeObjects()

    def makeObjects(self):
        self.futurama = futurama = SampleSite()
        directlyProvides(futurama, IContainmentRoot)
        planetexpress = SampleContainer()
        robotfactory = SampleContainer()
        nimbus = SampleContainer()
        omicronpersei = SampleSite()

        bender = SampleContent()
        fry = SampleContent()
        leela = SampleContent()
        mom = SampleContent()
        zapp = SampleContent()
        kif = SampleContent()

        setitem(futurama, futurama.__setitem__, 'planetexpress', planetexpress)
        setitem(futurama, futurama.__setitem__, 'robotfactory', robotfactory)
        setitem(futurama, futurama.__setitem__, 'nimbus', nimbus)
        setitem(futurama, futurama.__setitem__, 'omicronpersei', omicronpersei)

        setitem(planetexpress, planetexpress.__setitem__, 'bender', bender)
        setitem(planetexpress, planetexpress.__setitem__, 'fry', fry)
        setitem(planetexpress, planetexpress.__setitem__, 'leela', leela)
        setitem(robotfactory, robotfactory.__setitem__, 'mom', mom)
        setitem(nimbus, nimbus.__setitem__, 'zapp', zapp)
        setitem(nimbus, nimbus.__setitem__, 'kif', kif)

    def test_stub_adapters(self):
        # test content unique id
        farnesworth = SampleContent()
        elzar = SampleContent()
        adapter = zapi.getAdapter(farnesworth, IUniqueId)
        adapter2 = zapi.getAdapter(elzar, IUniqueId)
        self.failIf(adapter.getId() == 'farnesworth')
        self.failIf(adapter2.getId() == 'elzar')
        # test for uniqueness
        self.failIf(adapter.getId() == adapter2.getId())

        # test content child objects
        adapter = zapi.getAdapter(elzar, IChildObjects)
        self.failIf(adapter.hasChildren())
        self.assert_(len(adapter.getChildObjects()) == 0)
        # test with acquired content
        bender = self.futurama['planetexpress']['bender']
        adapter = zapi.getAdapter(bender, IChildObjects)
        self.failIf(adapter.hasChildren())
        self.assert_(len(adapter.getChildObjects()) == 0)

    def test_location_uniqueid(self):
        # futurama does not have a name
        futurama = self.futurama
        adapter = zapi.getAdapter(futurama, IUniqueId)
        self.assertEqual(adapter.getId(), str(id(futurama)))

        # test container
        planetexpress = self.futurama['planetexpress']
        adapter = zapi.getAdapter(planetexpress, IUniqueId)
        self.assertEqual(adapter.getId(), 'planetexpress')

        # test content
        bender = self.futurama['planetexpress']['bender']
        adapter = zapi.getAdapter(bender, IUniqueId)
        self.assertEqual(adapter.getId(), r'bender\planetexpress')

    def test_container_childobjects(self):
        # test container with children
        futurama = self.futurama
        adapter = zapi.getAdapter(futurama, IChildObjects)
        self.assert_(adapter.hasChildren())
        self.assertEqual(adapter.getChildObjects(), futurama.values())

        # test acquired container with children
        planetexpress = self.futurama['planetexpress']
        adapter = zapi.getAdapter(planetexpress, IChildObjects)
        self.assert_(adapter.hasChildren())
        self.assertEqual(adapter.getChildObjects(), planetexpress.values())

        # test acquired container w/o children
        omicronpersei = self.futurama['omicronpersei']
        adapter = zapi.getAdapter(omicronpersei, IChildObjects)
        self.failIf(adapter.hasChildren())
        self.assertEqual(adapter.getChildObjects(), [])

    def test_container_site(self):
        sm = object()
        futurama = self.futurama
        omicronpersei = self.futurama['omicronpersei']

        # test behaviour before and after setting a site
        adapter = zapi.getAdapter(futurama, IChildObjects)
        self.assert_(adapter.hasChildren())
        self.assertEqual(adapter.getChildObjects(), futurama.values())
        futurama.setSiteManager(sm)
        self.assert_(sm in adapter.getChildObjects())

        adapter = zapi.getAdapter(omicronpersei, IChildObjects)
        self.failIf(adapter.hasChildren())
        omicronpersei.setSiteManager(sm)
        self.assert_(adapter.hasChildren())
        self.assertEqual(adapter.getChildObjects(), [sm])

def test_suite():
    return unittest.makeSuite(AdapterTestCase)

if __name__ == '__main__':
    unittest.main(defaultTest='test_suite')


=== Added File Zope3/src/zope/app/tree/tests/test_encoder.py ===
##############################################################################
#
# Copyright (c) 2004 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""
$Id: test_encoder.py,v 1.1 2004/02/19 20:43:06 philikon Exp $
"""

import unittest
from zope.testing.doctestunit import DocTestSuite

def test_suite():
    return unittest.TestSuite((
        DocTestSuite('zope.app.tree.utils'),
        ))

if __name__ == '__main__':
    unittest.main(defaultTest='test_suite')


=== Added File Zope3/src/zope/app/tree/tests/test_filters.py ===
##############################################################################
#
# Copyright (c) 2004 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""
$Id: test_filters.py,v 1.1 2004/02/19 20:43:06 philikon Exp $
"""

import unittest

from zope.interface import implements, directlyProvides
from zope.interface.interface import InterfaceClass
from zope.app import zapi

from zope.app.tree.filters import OnlyInterfacesFilter, AllButInterfacesFilter

from test_adapters import SampleContent

__metaclass__ = type

IRobot = InterfaceClass('IRobot', (), {})
IHuman = InterfaceClass('IHuman', (), {})
IAlien = InterfaceClass('IAlien', (), {})
ISpaceShipCaptain = InterfaceClass('ISpaceShipCaptain', (), {})
IDeliveryBoy = InterfaceClass('IDeliveryBoy', (IHuman,), {})
IProfessor = InterfaceClass('IProfessor', (IHuman,), {})

class FilterTestCase(unittest.TestCase):

    def setUp(self):
        self.makeObjects()

    def makeObjects(self):
        to_be_made = {
            'bender':      IRobot,
            'fry':         IDeliveryBoy,
            'farnesworth': IProfessor,
            'zapp':        (IHuman, ISpaceShipCaptain),
            'lur':         (IAlien, ISpaceShipCaptain),
            'kif':         IAlien,
            }
        self.items = items = {}
        for name, iface in to_be_made.items():
            items[name] = obj = SampleContent()
            directlyProvides(obj, iface)

    def filterAndCompare(self, filter, expected):
        items = self.items
        result = [name for name, obj in items.items()
                  if filter.matches(obj)]
        for name in expected:
            if name not in result:
                return False
            result.remove(name)
        if len(result):
            return False
        return True

    def test_only_interfaces_filter(self):
        filter = OnlyInterfacesFilter(IHuman)
        self.assert_(self.filterAndCompare(filter, ('fry', 'farnesworth', 'zapp')))

        # even if we add delivery boy to it, the list shouldn't change
        filter = OnlyInterfacesFilter(IHuman, IDeliveryBoy)
        self.assert_(self.filterAndCompare(filter, ('fry', 'farnesworth', 'zapp')))

        # Lur from Omicron Persei 8 is a starship captain too
        # (he also likes to eating hippies and destroying earth)
        filter = OnlyInterfacesFilter(IHuman, ISpaceShipCaptain)
        self.assert_(self.filterAndCompare(filter, ('fry', 'farnesworth', 'zapp', 'lur')))

    def test_all_but_interfaces_filter(self):
        # "death to all humans!"
        filter = AllButInterfacesFilter(IHuman)
        self.assert_(self.filterAndCompare(filter, ('lur', 'kif', 'bender')))

        # and to all spaceship captains...
        filter = AllButInterfacesFilter(IHuman, ISpaceShipCaptain)
        self.assert_(self.filterAndCompare(filter, ('kif', 'bender')))

def test_suite():
    return unittest.makeSuite(FilterTestCase)

if __name__ == '__main__':
    unittest.main(defaultTest='test_suite')


=== Added File Zope3/src/zope/app/tree/tests/test_node.py ===
##############################################################################
#
# Copyright (c) 2004 Zope Corporation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE.
#
##############################################################################
"""
$Id: test_node.py,v 1.1 2004/02/19 20:43:06 philikon Exp $
"""

import unittest
from basetest import BaseTestCase
from zope.interface import implements
from zope.app.interfaces.find import IObjectFindFilter
from zope.app.tree.node import Node

__metaclass__ = type

class FilterByObject:
    """Simple filter that filters out any objects that wasn't passed
    in as a valid object before
    """
    implements(IObjectFindFilter)

    def __init__(self, *objects):
        self.objects = objects

    def match(self, obj):
        return obj in self.objects

class NodeTestCase(BaseTestCase):

    def setUp(self):
        super(NodeTestCase, self).setUp()
        self.makeItems()

    def test_expand_collapse(self):
        # first the node is expanded
        root_node = self.root_node
        self.failUnless(root_node.expanded)
        # now collapse it
        root_node.collapse()
        self.failIf(root_node.expanded)
        # make sure there are no children nodes returned!
        self.assertEqual(root_node.getChildNodes(), [])
        # expand it again
        root_node.expand()
        self.failUnless(root_node.expanded)

    def test_children(self):
        # test hasChildren()
        root_node = self.root_node
        self.failUnless(root_node.hasChildren())
        
        # test getChildNodes()
        children = [node.context for node in root_node.getChildNodes()]
        expected = [self.items['b'], self.items['c']]
        self.assertEqual(children, expected)

        # test with filter
        expand_all = self.items.keys() # expand all nodes
        # emulate node expansion with the FilterByObject filter
        filter = FilterByObject([self.items[id] for id in self.expanded_nodes])
        filtered_root = Node(self.root_obj, expand_all, filter)
        children = [node.context for node in root_node.getChildNodes()]
        expected = [self.items['b'], self.items['c']]
        self.assertEqual(children, expected)

    def test_flat(self):
        # test getFlatNodes()
        root_node = self.root_node
        flat = root_node.getFlatNodes()
        children = [node.context for node in flat]
        # 'a' is not expected because the node on which getFlatNodes()
        # is called is not in the list
        expected = [self.items[i] for i in "bcfg"]
        self.assertEqual(children, expected)

    def test_pre_expanded(self):
        # 'a' is not expected because the node on which getFlatNodes()
        # is called is not in the list
        expected = [self.items[i] for i in "bcfg"]
        # test against to getFlatNodes()
        flat = [node.context for node in self.root_node.getFlatNodes()]
        self.assertEqual(flat, expected)

    def test_flat_dicts(self):
        flat, maxdepth = self.root_node.getFlatDicts()
        self.assertEqual(maxdepth, 2)
        self.assertEqual(len(flat), len(self.root_node.getFlatNodes()))
        bdict = flat[0]
        node = bdict['node']
        self.assertEqual(bdict['row-state'], [])
        self.assertEqual(node.getId(), 'b')
        self.assert_(node.hasChildren())
        self.assert_(node.context is self.items['b'])

    def test_depth(self):
        expanded = ['a', 'c', 'f']
        root_node = Node(self.root_obj, expanded)
        flat, maxdepth = root_node.getFlatDicts()

def test_suite():
    return unittest.makeSuite(NodeTestCase)

if __name__ == '__main__':
    unittest.main(defaultTest='test_suite')




More information about the Zope3-Checkins mailing list