import unittest
from Testing import ZopeTestCase as ztc
from Products.Five import zcml
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from Products.PloneTestCase.layer import onsetup
from Products.PloneGetPaid.tests.base import PloneGetPaidFunctionalTestCase
ztc.installProduct('DataGridField')
ztc.installProduct('PloneGetPaid')
ztc.installProduct('PloneFormGen')
@onsetup
def load_zcml():
import getpaid.formgen
zcml.load_config('configure.zcml', getpaid.formgen)
ztc.installPackage('getpaid.formgen')
load_zcml()
setupPloneSite(products=['getpaid.formgen'])
def test_suite():
"""This sets up a test suite that actually runs the tests in the class
above
"""
suite = unittest.TestSuite()
suite.addTest(ztc.FunctionalDocFileSuite('test_functional_oneshot_success.txt',
package='getpaid.formgen.tests',
test_class=PloneGetPaidFunctionalTestCase))
return suite
"""
Load and install packages required for the collective.contentlicensing tests
"""
fiveconfigure.debug_mode = True
import collective.contentlicensing
zcml.load_config('configure.zcml',collective.contentlicensing)
fiveconfigure.debug_mode = False
ztc.installPackage('collective.contentlicensing')
setup_contentlicensing_project()
setupPloneSite(with_default_memberarea=0,extension_profiles=['collective.contentlicensing:default'])
oflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
prod = "collective.contentlicensing"
class ContentLicensingTestCase(PloneTestCase):
""" Test Class """
def _setupHomeFolder(self):
""" Ugly hack to keep the underlying testing framework from trying to create a user folder."""
pass
class BlobContentLicensingTestCase(PloneTestCase):
""" Test Class with blob support """
fiveconfigure.debug_mode = False
# We need to tell the testing framework that these products
# should be available. This can't happen until after we have loaded
# the ZCML. Notice the extra package=True argument passed to
# installProduct() - this tells it that these packages are *not* in the
# Products namespace.
ztc.installPackage('collective.oaiintercom')
# The order here is important: We first call the (deferred) function which
# installs the products we need for the package. Then, we let
# PloneTestCase set up on installation.
setup_oaiintercom_project()
setupPloneSite(with_default_memberarea=0, extension_profiles=['collective.oaiintercom:default',])
oflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
prod = 'collective.oaiintercom'
class oaiintercomTestCase(PloneTestCase):
""" Base Test Case"""
class oaiintercomFunctionalTestCase(Functional, oaiintercomTestCase):
""" Base class for functional integration tests. """
from plone.app.users.tests import TestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from Testing.ZopeTestCase import FunctionalDocFileSuite
from unittest import TestSuite
import doctest
import os
setupPloneSite()
OPTIONFLAGS = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
class DocTestCase(TestCase):
# Just here to work around a weird error message.
# And now an extra helper method.
def get_test_file(self, filename):
return open(os.path.join(os.path.dirname(__file__), filename))
def test_suite():
tests = [
'flexible_user_registration.txt', 'forms_navigationroot.txt',
'registration_forms.txt', 'userdata.txt',
'userdata_prefs_user_details.txt', 'personal_preferences.txt',
'personal_preferences_prefs_user_details.txt', 'password.txt'
]
suite = TestSuite()
for test in tests:
suite.addTest(
@onsetup
def setup_plonebookmarklets_project():
"""
Load and install packages required for the collective.plonebookmarklets tests
"""
fiveconfigure.debug_mode = True
import collective.plonebookmarklets
zcml.load_config('configure.zcml',collective.plonebookmarklets)
zcml.load_config('browser/configure.zcml',collective.plonebookmarklets)
fiveconfigure.debug_mode = False
ztc.installPackage('collective.plonebookmarklets')
setup_plonebookmarklets_project()
setupPloneSite(with_default_memberarea=0,extension_profiles=['collective.plonebookmarklets:default'])
oflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
prod = "collective.plonebookmarklets"
class PloneBookmarkletsTestCase(PloneTestCase):
""" Test Class """
class PloneBookmarkletsFunctionalTestCase(FunctionalTestCase, PloneBookmarkletsTestCase):
""" Functional test class """
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase, setupPloneSite, installProduct
installProduct('ContentLicensing')
installProduct('ZipFileTransport')
installProduct('IMSTransport')
installProduct('PloneBookmarklets')
installProduct('leftskin')
installProduct('ProxyIndex')
installProduct('eduCommons')
installProduct('LinguaPlone')
setupPloneSite(with_default_memberarea=0,
extension_profiles=['Products.ContentLicensing:default',
'Products.ZipFileTransport:default',
'Products.IMSTransport:default',
'Products.PloneBookmarklets:default',
'Products.LinguaPlone:LinguaPlone',
'Products.leftskin:default',
'Products.eduCommons:default'])
oflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
prod = 'Products.eduCommons'
class eduCommonsTestCase(PloneTestCase):
""" Base class for integration tests. """
# Let Zope know about the products we need. Only "old style" products with
# the "Products" prefix need to appear here.
ZopeTestCase.installProduct('fatsyndication')
ZopeTestCase.installProduct('QuillsEnabled')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from quills.core.interfaces import IWeblog
from quills.app.tests.base import BrowserMixin
from Products.QuillsEnabled.browser.activation import Toggle as BlogToggle
# Set up a Plone site, and apply the Quills extension profile
setupPloneSite(products=['QuillsEnabled'])
class QuillsTestCaseMixin(BrowserMixin):
"""Base class for integration tests for the 'Quills' product. This may
provide specific set-up and tear-down operations, or provide convenience
methods.
"""
def afterSetUp(self):
self.loginAsPortalOwner()
self.weblog = self.createBlog('weblog')
self.weblog_content = self.portal.weblog
def createBlog(self, id):
"""Create a weblog instance."""
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from Products.PloneTestCase.layer import onsetup
@onsetup
def setup_entitiesdirectory():
fiveconfigure.debug_mode = True
import collective.entitiesdirectory
zcml.load_config('configure.zcml', collective.entitiesdirectory)
fiveconfigure.debug_mode = False
# Let Zope know about the products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installPackage('collective.entitiesdirectory')
# Set up a Plone site, and quick-install the relevant products
setup_entitiesdirectory()
setupPloneSite(products=('collective.entitiesdirectory',))
class EntitiesDirectoryTestCase(PloneTestCase):
"""Base class for integration tests.
This may provide specific set-up and tear-down operations, or provide
convenience methods.
"""
class EntitiesDirectoryFunctionalTestCase(FunctionalTestCase):
"""Base class for functional integration tests.
This may provide specific set-up and tear-down operations, or provide
convenience methods.
"""
"""
fiveconfigure.debug_mode = True
import eea.reports
zcml.load_config('configure.zcml', eea.reports)
try:
import eea.rdfmarshaller
zcml.load_config('configure.zcml', eea.rdfmarshaller)
except ImportError:
logger.warning("Could not import eea.rdfmarshaller")
fiveconfigure.debug_mode = False
setup_eea_reports()
setupPloneSite(extension_profiles=('eea.reports:default',))
class ReportFunctionalTestCase(FunctionalTestCase):
"""Base class for functional integration tests for the 'Report' product.
"""
def loadfile(self, rel_filename, ctype='application/pdf'):
""" load a file
"""
home = package_home(product_globals)
filename = os.path.sep.join([home, rel_filename])
data = open(filename, 'r').read()
fp = StringIO(data)
fp.seek(0)
env = {'REQUEST_METHOD':'PUT'}
class layer(PloneSite):
@classmethod
def setUp(cls):
import bda.broschuerenshop
fiveconfigure.debug_mode = True
zcml.load_config('configure.zcml',
bda.broschuerenshop)
fiveconfigure.debug_mode = False
@classmethod
def tearDown(cls):
pass
ZopeTestCase.installProduct('izBroschueren')
setupPloneSite(extension_profiles=['bda.broschuerenshop:default'])
def test_suite():
import unittest
suite = unittest.TestSuite()
from Testing.ZopeTestCase import FunctionalDocFileSuite as FileSuite
return unittest.TestSuite([
FileSuite(
file,
test_class=TestCase,
optionflags=optionflags,
globs={'interact': interact,
'pprint': pprint,},
) for file in TESTFILES
])
Load and install packages required for the collective.searchandreplace tests
"""
fiveconfigure.debug_mode = True
import collective.searchandreplace
zcml.load_config('configure.zcml', collective.searchandreplace)
fiveconfigure.debug_mode = False
ztc.installPackage('collective.searchandreplace')
setup_searchandreplace_project()
setupPloneSite(
with_default_memberarea=0,
extension_profiles=['collective.searchandreplace:default'])
oflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
prod = "collective.searchandreplace"
class SearchAndReplaceTestCase(PloneTestCase):
""" Test Class """
def _setupHomeFolder(self):
""" Ugly hack to keep the underlying testing framework from trying to create a user folder."""
pass
"""
from Testing import ZopeTestCase
from Products.Five.testbrowser import Browser as BaseBrowser
# Let Zope know about the products we need. Only "old style" products with
# the "Products" prefix need to appear here.
ZopeTestCase.installProduct('fatsyndication')
ZopeTestCase.installProduct('Quills')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site, and apply the Quills extension profile
setupPloneSite(products=['Quills'])
class Browser(BaseBrowser):
def addAuthorizationHeader(self,
user=PloneTestCase.default_user,
password=PloneTestCase.default_password):
"""Add an authorization header using the given or default credentials.
"""
self.addHeader('Authorization', 'Basic %s:%s' % (user, password))
return self
class QuillsTestCaseMixin:
"""Base class for integration tests for the 'Quills' product. This may
provide specific set-up and tear-down operations, or provide convenience
# -*- coding: utf-8 -*-
from Testing.ZopeTestCase import installPackage
from Products.Five import zcml, fiveconfigure
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from Products.PloneTestCase.layer import onsetup
@onsetup
def setup_product():
"""Setting up the package and including the ZCML
"""
import sd.app
fiveconfigure.debug_mode = True
zcml.load_config('configure.zcml', sd.app)
fiveconfigure.debug_mode = False
installPackage('sd.app')
setup_product()
setupPloneSite(products=('sd.app',))
"""
from Testing import ZopeTestCase
from Products.Five.testbrowser import Browser as BaseBrowser
# Let Zope know about the products we need. Only "old style" products with
# the "Products" prefix need to appear here.
ZopeTestCase.installProduct('fatsyndication')
ZopeTestCase.installProduct('Quills')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site, and apply the Quills extension profile
setupPloneSite(products=['Quills'])
class Browser(BaseBrowser):
def addAuthorizationHeader(self, user=PloneTestCase.default_user,
password=PloneTestCase.default_password):
"""Add an authorization header using the given or default credentials.
"""
self.addHeader('Authorization', 'Basic %s:%s' % (user, password))
return self
class QuillsTestCaseMixin:
"""Base class for integration tests for the 'Quills' product. This may
provide specific set-up and tear-down operations, or provide convenience
products installed.
"""
from Testing import ZopeTestCase
# Let Zope know about the products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installProduct('ArchAddOn')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site, and install the ArchAddOn product.
setupPloneSite(products=('ArchAddOn', ))
class ArchAddOnTestCase(PloneTestCase):
"""Base class for integration tests for the 'ArchAddOn' product. This may
provide specific set-up and tear-down operations, or provide convenience
methods.
"""
class ArchAddOnFunctionalTestCase(FunctionalTestCase):
"""Base class for functional integration tests for the 'ArchAddOn' product.
This may provide specific set-up and tear-down operations, or provide
convenience methods.
"""
import unittest, doctest
from DateTime.DateTime import DateTime
from Testing.ZopeTestCase import FunctionalDocFileSuite as Suite
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase, \
setupPloneSite
setupPloneSite(extension_profiles=['upfront.diet:default'])
optionflags = doctest.REPORT_ONLY_FIRST_FAILURE | doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE
def addMember(self, username, fullname="", email="", roles=('Member',), last_login_time=None):
self.portal.portal_membership.addMember(username, 'secret', roles, [])
member = self.portal.portal_membership.getMemberById(username)
member.setMemberProperties({'fullname': fullname, 'email': email,
'last_login_time': DateTime(last_login_time),})
def setUp(self):
addMember(self, 'member1', 'Member one')
def test_suite():
tests = (
Suite(
'docs/foldercontents.txt',
package="upfront.foldercontents",
setUp=setUp,
optionflags=optionflags,
test_class=FunctionalTestCase
),
)
return unittest.TestSuite(tests)
from zope.testing import doctest
from Products.PloneTestCase.PloneTestCase import setupPloneSite, installProduct
from Products.PloneTestCase.PloneTestCase import PloneTestCase, FunctionalTestCase
installProduct("ContentLicensing")
setupPloneSite(extension_profiles=["Products.ContentLicensing:default"])
oflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE
prod = "Products.ContentLicensing"
class ContentLicensingTestCase(PloneTestCase):
""" Test Class """
class ContentLicensingFunctionalTestCase(FunctionalTestCase):
""" Functional test class """
# Let Zope know about the two products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installProduct(PROJECT_NAME)
# Let Zope know about the two products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
#ZopeTestCase.installProduct('PageCacheManager')
ZopeTestCase.installProduct('CMFSquidTool')
#ZopeTestCase.installProduct('PythonScripts')
#ZopeTestCase.installProduct(PROJECT_NAME)
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site
setupPloneSite(products=[PROJECT_NAME])
class CacheFuTestCase(PloneTestCase):
"""Base class for integration tests for the 'CacheSetup' product. This may
provide specific set-up and tear-down operations, or provide convenience
methods.
"""
class CacheFuFunctionalTestCase(FunctionalTestCase):
"""Base class for functional integration tests for the 'CacheSetup' product.
This may provide specific set-up and tear-down operations, or provide
convenience methods.
"""
from zope.testing import doctest
from unittest import TestSuite
from zope.testing.doctestunit import DocFileSuite
from Testing.ZopeTestCase import FunctionalDocFileSuite
from Testing.ZopeTestCase import ZopeDocFileSuite
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite, installProduct
installProduct('PloneBookmarklets')
setupPloneSite(extension_profiles=['Products.PloneBookmarklets:default'])
oflags = (doctest.ELLIPSIS |
doctest.NORMALIZE_WHITESPACE)
prod = 'Products.PloneBookmarklets'
# Set up a Plone site - note that the portlets branch of CMFPlone applies
# a portlets profile.
ZopeTestCase.installProduct('ATVocabularyManager')
@onsetup
def setup():
fiveconfigure.debug_mode = True
import slc.treecategoriesexample
import slc.treecategories
zcml.load_config('configure.zcml', slc.treecategoriesexample)
zcml.load_config('configure.zcml', slc.treecategories)
fiveconfigure.debug_mode = False
ZopeTestCase.installPackage('slc.treecategoriesexample')
setup()
setupPloneSite(products=['slc.treecategories', 'Products.ATVocabularyManager', 'slc.treecategoriesexample'])
class PortletsTestCase(PloneTestCase):
"""
Base class for integration tests for plone.app.portlets. This may
provide specific set-up and tear-down operations, or provide convenience
methods.
"""
class PortletsFunctionalTestCase(FunctionalTestCase):
"""
Base class for functional integration tests for plone.app.portlets.
This may provide specific set-up and tear-down operations, or provide
convenience methods.
"""
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from Products.Five import fiveconfigure
from Products.Five import zcml
from Products.PloneTestCase.layer import onsetup
from Products.PloneTestCase.layer import PloneSite
@onsetup
def install_plugins():
ZopeTestCase.installPackage('collective.psc.externalstorage')
install_plugins()
setupPloneSite(products=('PloneSoftwareCenter',))
class DeveloperWarning(Warning):
pass
def developer_warning(msg):
warnings.warn(msg, DeveloperWarning)
class PSCTestCase(PloneTestCase):
"""Base class for integration tests
"""
def warning(self, msg):
developer_warning(msg)
class layer(PloneSite):
@classmethod
Note that importing this module has various side-effects: it registers a set of
products with Zope, and it sets up a sandbox Plone site with the appropriate
products installed.
"""
from Testing import ZopeTestCase
# Let Zope know about the products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installProduct('ArchAddOn')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site, and install the ArchAddOn product.
setupPloneSite(products=('ArchAddOn',))
class ArchAddOnTestCase(PloneTestCase):
"""Base class for integration tests for the 'ArchAddOn' product. This may
provide specific set-up and tear-down operations, or provide convenience
methods.
"""
class ArchAddOnFunctionalTestCase(FunctionalTestCase):
"""Base class for functional integration tests for the 'ArchAddOn' product.
This may provide specific set-up and tear-down operations, or provide
convenience methods.
"""
"""
Load and install packages required for the collective.contentlicensing tests
"""
fiveconfigure.debug_mode = True
import collective.contentlicensing
zcml.load_config('configure.zcml', collective.contentlicensing)
fiveconfigure.debug_mode = False
ztc.installPackage('collective.contentlicensing')
setup_contentlicensing_project()
setupPloneSite(with_default_memberarea=0,
extension_profiles=['collective.contentlicensing:default'])
oflags = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
prod = "collective.contentlicensing"
class ContentLicensingTestCase(PloneTestCase):
""" Test Class """
def _setupHomeFolder(self):
""" Ugly hack to keep the underlying testing framework from trying to create a user folder."""
pass
class BlobContentLicensingTestCase(PloneTestCase):
""" Test Class with blob support """
from Testing import ZopeTestCase
# Let Zope know about the products we require above and beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installProduct('DataGridField')
ZopeTestCase.installProduct('ECQuiz')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site, and apply the membrane and borg extension profiles
# to make sure they are installed.
#setupPloneSite(extension_profiles=('membrane:default', 'borg:default'))
setupPloneSite(products=('ECQuiz',))
from Products.ECQuiz.tools import createObject
def getAccessor(obj, prop_name, getter_p):
if getter_p:
prefix = 'get'
else:
prefix = 'set'
name = prefix + prop_name[0].upper() + prop_name[1:]
return getattr(obj, name)
def setProp(obj, prop_name, value):
f = getAccessor(obj, prop_name, False)
f(value)
# Let Zope know about the two products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installProduct('PloneSurvey')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from Products.PloneSurvey.config import DEFAULT_SURVEY_INVITE
from Products.PloneSurvey.tests import utils
from utils import MockMailHost
# Set up a Plone site, and apply the extension profiles
# to make sure they are installed.
setupPloneSite(extension_profiles=('Products.PloneSurvey:default',))
class PloneSurveyTestCase(PloneTestCase):
"""Base class for integration tests for the 'PloneSurvey' product.
"""
def addMember(self, username, fullname, email, roles, last_login_time):
self.portal.portal_membership.addMember(username, 'secret', roles, [])
member = self.portal.portal_membership.getMemberById(username)
member.setMemberProperties({'fullname': fullname, 'email': email,
'last_login_time': DateTime(last_login_time),})
def useMockMailHost(self):
self.portal.MailHost = MockMailHost('MailHost')
def createAnonSurvey(self):
"""Base class for integration tests, based on ZopeTestCase and PloneTestCase.
Note that importing this module has various side-effects: it registers a set of
products with Zope, and it sets up a sandbox Plone site with the appropriate
products installed.
"""
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
from zope.component import getMultiAdapter
# Set up a Plone site - note that the portlets branch of CMFPlone applies
# a portlets profile.
setupPloneSite()
class ContentRulesTestCase(PloneTestCase):
"""Base class for integration tests for plone.app.contentrules. This may
provide specific set-up and tear-down operations, or provide convenience
methods.
"""
def addAuthToRequest(self):
portal = self.portal
request = portal.REQUEST
authenticator = getMultiAdapter((portal, request), name=u"authenticator")
auth = authenticator.authenticator().split('value="')[1].rstrip('"/>')
request.form["_authenticator"] = auth
from Testing import ZopeTestCase
# Let Zope know about the two products we require above-and-beyond a basic
# Plone install (PloneTestCase takes care of these).
ZopeTestCase.installProduct('Relations')
ZopeTestCase.installProduct('PloneOntology')
# Import PloneTestCase - this registers more products with Zope as a side effect
from Products.PloneTestCase.PloneTestCase import PloneTestCase
from Products.PloneTestCase.PloneTestCase import FunctionalTestCase
from Products.PloneTestCase.PloneTestCase import setupPloneSite
# Set up a Plone site, and apply the Relations and PloneOntology extension
# profiles to make sure they are installed.
setupPloneSite(products=('Relations', 'PloneOntology'))
class PloneOntologyTestCase(PloneTestCase):
"""Base class for integration tests for the 'PloneOntology' product.
"""
def tearDown(self):
self.portal.portal_classification._p_deactivate() # Drop _v_relcache
super(PloneOntologyTestCase, self).tearDown()
class PloneOntologyFunctionalTestCase(FunctionalTestCase):
"""Base class for functional integration tests for the 'PloneOntology' product.
"""
def tearDown(self):
self.portal.portal_classification._p_deactivate() # Drop _v_relcache
super(PloneOntologyFunctionalTestCase, self).tearDown()