# Flon is a package for enabling hand picked Five features in Plone
# Copyright (C) 2004 Enfold Systems, LLC
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
"""
$Id: __init__.py,v 1.2 2004/07/14 22:23:16 dreamcatcher Exp $
"""

import os, sys

if __name__ == '__main__':
    execfile(os.path.join(sys.path[0], 'framework.py'))

# Load fixture
from Testing import ZopeTestCase
from Products.CMFPlone.tests import PloneTestCase

# Install our product
ZopeTestCase.installProduct('ProxyIndex')
ZopeTestCase.installProduct('Flon')
ZopeTestCase.installProduct('Five')

from Products.CMFCore.utils import getToolByName
from Products.CMFCore.CMFCatalogAware import CMFCatalogAware
from Products.Five.interfaces import IObjectManager
from zope.interface import implements, Interface
from zope.app.component.interface import provideInterface

class IDummy(Interface):
    """A dummy interface
    """
    def foo():
        """ """

class IAdvancedDummy(IDummy):
    """A marker interface for advanced dummy
    """

class ISpecialDummy(IDummy):
    """A marker interface for special dummy
    """

class IExtraSpecialDummy(ISpecialDummy):
    """A marker interface for special dummy
    """

class INonMarkerDummy(IDummy):
    """A non-marker interface for dummy
    """
    def bar():
        """ """
class IFolderMarker(IObjectManager):
    """A Folder Marker"""

class Dummy:
    implements(IDummy)
    def foo(self): pass

class InterfaceToolTest(PloneTestCase.PloneTestCase):

    def afterSetUp(self):
        self.qi = getToolByName(self.portal, 'portal_quickinstaller')
        self.qi.installProduct('Flon')
        self.ct = getToolByName(self.portal, 'portal_catalog')
        self.it = getToolByName(self.portal, 'portal_interface')
        provideInterface('test_tool.IAdvancedDummy', IAdvancedDummy)
        provideInterface('test_tool.IExtraSpecialDummy', IExtraSpecialDummy)
        provideInterface('test_tool.ISpecialDummy', ISpecialDummy)
        provideInterface('test_tool.INonMarkerDummy', INonMarkerDummy)
        provideInterface('test_tool.IDummy', IDummy)
        provideInterface('test_tool.IFolderMarker', IFolderMarker)
        self.dummy = Dummy()

    def test_marker_names(self):
        foo = self.dummy
        iface_names = self.it.getMarkerInterfaceNames(foo)
        self.failUnless('test_tool.IAdvancedDummy' in iface_names)
        self.failUnless('test_tool.ISpecialDummy' in iface_names)
        self.failUnless('test_tool.IExtraSpecialDummy' in iface_names)
        self.failIf('test_tool.INonMarkerDummy' in iface_names)

    def test_provided_names(self):
        foo = self.dummy
        provided = self.it.getDirectlyProvidedNames(foo)
        self.failIf('test_tool.IDummy' in provided)
        self.failIf('test_tool.ISpecialDummy' in provided)
        self.failIf('test_tool.IAdvancedDummy' in provided)
        self.failIf('test_tool.IExtraSpecialDummy' in provided)

    def test_add_markers(self):
        foo = self.dummy

        provided = self.it.getDirectlyProvidedNames(foo)
        self.failIf('test_tool.ISpecialDummy' in provided)
        self.it.update(foo, add=['test_tool.ISpecialDummy'])
        provided = self.it.getDirectlyProvidedNames(foo)
        self.failUnless('test_tool.ISpecialDummy' in provided)

        self.it.update(foo, add=['test_tool.IAdvancedDummy'])
        provided = self.it.getDirectlyProvidedNames(foo)
        self.failUnless('test_tool.IAdvancedDummy' in provided)
        self.failUnless('test_tool.ISpecialDummy' in provided)

        provided = self.it.getProvidedNames(foo)
        self.failUnless('test_tool.IAdvancedDummy' in provided)
        self.failUnless('test_tool.ISpecialDummy' in provided)

        provided = self.it.getProvided(foo)
        self.failUnless(IAdvancedDummy in provided)
        self.failUnless(ISpecialDummy in provided)

    def test_remove_markers(self):
        foo = self.dummy
        iface_names = self.it.getMarkerInterfaceNames(foo)
        self.it.update(foo, add=iface_names)

        provided = self.it.getDirectlyProvidedNames(foo)
        self.failUnless('test_tool.ISpecialDummy' in provided)
        self.it.update(foo, remove=['test_tool.ISpecialDummy'])
        provided = self.it.getDirectlyProvidedNames(foo)
        self.failIf('test_tool.ISpecialDummy' in provided)

        self.failUnless('test_tool.IAdvancedDummy' in provided)
        self.it.update(foo, remove=['test_tool.IAdvancedDummy'])
        provided = self.it.getDirectlyProvidedNames(foo)
        self.failIf('test_tool.IAdvancedDummy' in provided)

        provided = self.it.getProvidedNames(foo)
        self.failIf('test_tool.IAdvancedDummy' in provided)

        provided = self.it.getProvided(foo)
        self.failIf(IAdvancedDummy in provided)

    def test_add_markers_indexing(self):
        from Products.CMFPlone.PloneFolder import addPloneFolder
        addPloneFolder(self.portal, 'dummy')
        foo = self.portal.dummy
        ct = self.ct._catalog
        provided = 'test_tool.IFolderMarker'
        self.assertEquals(len(ct(directly_provided=[provided])), 0)
        self.it.update(foo, add=[provided])

        # Test for directly_provided index
        res = ct(directly_provided=[provided])
        self.assertEquals(len(res), 1)
        self.assertEquals(res[0]['directly_provided'], [provided])

        # Test for provided index
        res = ct(provided=[provided])
        self.assertEquals(len(res), 1)
        self.failUnless(provided in res[0]['provided'])

        # Now reindex passing the idxs keyword, should trigger
        # metadata indexing. Make sure provided and directly_provided
        # are still there.
        ct.catalogObject(foo, '/portal/dummy', idxs=['id'], update_metadata=1)

        # Test for directly_provided index
        res = ct(directly_provided=[provided])
        self.assertEquals(len(res), 1)
        self.assertEquals(res[0]['directly_provided'], [provided])

        # Test for provided index
        res = ct(provided=[provided])
        self.assertEquals(len(res), 1)
        self.failUnless(provided in res[0]['provided'])


def test_suite():
    import unittest
    suite = unittest.TestSuite()
    suite.addTest(unittest.makeSuite(InterfaceToolTest))
    return suite

if __name__ == '__main__':
    framework(descriptions=1, verbosity=1)