def setUp(self): """Set up a class ready for testing""" super(ReviewUgQnViewTest, self).setUp() self.loghandlers = dict( sqlalchemy=InstalledHandler('sqlalchemy.engine'), sync=InstalledHandler('tutorweb.quizdb.browser.sync') )
def setUp(self): """Set up a class ready for testing""" super(SyncClassSubscriptionsTest, self).setUp() portal = self.layer['portal'] self.loghandlers = dict( sqlalchemy=InstalledHandler('sqlalchemy.engine'), sync=InstalledHandler('tutorweb.quizdb.browser.sync'))
def setUp(self): super(FunctionalTestCase, self).setUp() self.loghandlers = dict( sqlalchemy=InstalledHandler('sqlalchemy.engine'), sync=InstalledHandler('tutorweb.quizdb.browser.sync'), syncm=InstalledHandler('tutorweb.quizdb.sync'), ) self.objectPublish(self.layer['portal']['dept1']['tut1']['lec1']) self.objectPublish(self.layer['portal']['dept1']['tut1']['lec2'])
def setUp(test): test.globs['root'] = ZopeTestCase.base.app() # As task will be run in different threads, we cannot rely on print # results. We need to log calls to prove correctness. log_info = InstalledHandler('z3c.taskqueue') test.globs['log_info'] = log_info # We pass the ZPublisher conflict logger to prove that no conflict # happened. conflict_logger = InstalledHandler('ZPublisher.Conflict') test.globs['conflict_logger'] = conflict_logger # Make sure ZPublisher conflict error log level is setup. _configure_conflict_error_log_level() test.origArgs = service.TaskService.processorArguments service.TaskService.processorArguments = {'waitTime': 0.0} # Make tests predictable random.seed(27)
def setUp(self): """Set up a class ready for testing""" portal = self.layer['portal'] login(portal, MANAGER_ID) self.loghandlers = dict( sqlalchemy=InstalledHandler('sqlalchemy.engine'), sync=InstalledHandler('tutorweb.quizdb.browser.sync')) # Create an extra test tutorial portal['dept1'].invokeFactory( type_name="tw_tutorial", id="tut_extra", title="Unittest D1 tutExtra", ) self.extra_lec = self.createTestLecture(qnCount=1)
def test_ActionExecutor(self): self.createIFTTTAction() # configure easyform actions self.assertTrue('ifttt' in get_actions(self.ff1)) ifttt_trigger = get_actions(self.ff1)['ifttt'] ifttt_trigger.ifttt_event_name = u'ifttt applet' ifttt_trigger.payload_fields = ['replyto', 'topic', 'comments'] request = FakeRequest( add_auth=True, method='POST', topic='test subject', replyto='*****@*****.**', comments='test comments' ) self.assertFalse(ifttt_trigger.onSuccess(request.form, request)) # set secret key api.portal.set_registry_record( name='ifttt.ifttt_secret_key', value=u'secret', ) # inspect logs handler = InstalledHandler('collective.ifttt.requests') # execute action self.assertTrue(ifttt_trigger.onSuccess(request.form, request)) messages = [record.getMessage() for record in handler.records] self.assertGreater(len(messages), 0) self.assertTrue(messages[0].startswith('Dispatched requests.post'))
def test_detect_delete_trigger(self): # Cause the delete trigger to be deleted by opening a newt.db # connection: import newt.db self.ex("drop table object_state") newt.db.storage(self.dsn).close() # Verify the trigger is there: from newt.db._util import trigger_exists from newt.db._adapter import DELETE_TRIGGER self.assertTrue(trigger_exists(self.cursor, DELETE_TRIGGER)) from zope.testing.loggingsupport import InstalledHandler handler = InstalledHandler('newt.db.updater') self.assertEqual(1, updater.main([self.dsn])) self.assertEqual( "newt.db.updater ERROR\n" " The Newt DB delete trigger exists.\n" "It is incompatible with the updater.\n" "Use -T to remove it.", str(handler)) handler.clear() # Now run the updater with the -T option, which causes the # trigger to be deleted. (We also use -g, which causes it to # to GC and nothing else, which makes it stop, so we don't # have to run in a thread.) self.assertEqual(0, updater.main([self.dsn, '-Tg'])) self.assertEqual("", str(handler)) # And the trigger is gone. self.assertFalse(trigger_exists(self.cursor, DELETE_TRIGGER))
def testCookieErrorToLog(self): from zope.testing.loggingsupport import InstalledHandler cookies = { 'HTTP_COOKIE': 'foo=bar; path=/; spam="eggs"; ldap/OU="Williams"' } handler = InstalledHandler('eventlog') try: req = self._createRequest(extra_env=cookies) finally: handler.uninstall() self.assertEqual(len(handler.records), 1) message = handler.records[0].getMessage() self.assertTrue(message.startswith('Illegal key')) self.assertIn('ldap/OU', message) self.assertNotIn('foo', req.cookies) self.assertNotIn('foo', req) self.assertNotIn('spam', req.cookies) self.assertNotIn('spam', req) self.assertNotIn('ldap/OU', req.cookies) self.assertNotIn('ldap/OU', req) # Reserved key self.assertNotIn('path', req.cookies)
def setUp(self): from Products.LongRequestLogger.patch import do_patch from Products.LongRequestLogger.dumper import logger_name from zope.testing.loggingsupport import InstalledHandler self.setTestEnvironment() do_patch() self.loghandler = InstalledHandler(logger_name) self.requests = []
def setUp(self): from Products.LongRequestLogger import do_patch, monitor, dumper from zope.testing.loggingsupport import InstalledHandler dumper.config = dict(logfile=os.devnull) log = dumper.getLogger() self.monitor = monitor.Monitor(log, **dumper.get_configuration()) do_patch(self.monitor) self.loghandler = InstalledHandler(log.name) self.requests = []
def setUp(test): root = placefulSetUp(site=True) test.globs['root'] = root log_info = InstalledHandler('z3c.taskqueue') test.globs['log_info'] = log_info test.origArgs = service.TaskService.processorArguments service.TaskService.processorArguments = {'waitTime': 0.0} # Make tests predictable random.seed(27)
def test_search_for_factory_updates_search_set(self): from zope.testing.loggingsupport import InstalledHandler with warnings.catch_warnings(record=True): INT.register_legacy_search_module(__name__) # The cache is initialized lazily assert_that(__name__, is_in(INT.LEGACY_FACTORY_SEARCH_MODULES)) assert_that(INT.find_factory_for_class_name('testfunctions'), is_(none())) # And we have been examined and removed assert_that(__name__, is_not(is_in(INT.LEGACY_FACTORY_SEARCH_MODULES))) assert_that(INT.LEGACY_FACTORY_SEARCH_MODULES, is_(set())) # Now we're going to fiddle with our public classes and try again. # This will force re-registration to occur. Note we do this before # we make ourself public, so that we can assert it's lazy INT.register_legacy_search_module(__name__) TestFunctions.__external_can_create__ = True handler = InstalledHandler(INT.__name__) try: assert_that(INT.find_factory_for_class_name('testfunctions'), equal_to(TestFunctions)) # Now lets register ourself again, to trigger the logged warnings. assert_that(__name__, is_not(is_in(INT.LEGACY_FACTORY_SEARCH_MODULES))) assert_that(INT.LEGACY_FACTORY_SEARCH_MODULES, is_(set())) # Now we're going to fiddle with our public classes and try again. # This will force re-registration to occur. Note we do this before # we make ourself public, so that we can assert it's lazy INT.register_legacy_search_module(__name__) assert_that(INT.find_factory_for_class_name('testfunctions'), equal_to(TestFunctions)) # case doesn't matter assert_that(INT.find_factory_for_class_name('TeStfUnctIons'), equal_to(TestFunctions)) assert_that( str(handler), contains_string( "Found duplicate registration for legacy search path.") ) assert_that(INT.legacy_factories.count_legacy_classes_found(), greater_than_or_equal_to) finally: del TestFunctions.__external_can_create__ handler.uninstall()
def test_database_events(self): from Zope2.App.startup import startup from zope.component import provideHandler from zope.processlifetime import IDatabaseOpened from zope.processlifetime import IDatabaseOpenedWithRoot handler = InstalledHandler('Zope2.App.test_startup') provideHandler(logevent, [IDatabaseOpenedWithRoot]) provideHandler(logevent, [IDatabaseOpened]) startup() self.assertEqual(str(handler), logged)
def test_remove_words_in_already_corrupted_index(self): from zope.testing.loggingsupport import InstalledHandler handler = InstalledHandler('nti.zope_catalog.index') self.addCleanup(handler.uninstall) index = self.index index.index_doc(1, ('aizen', )) index.index_doc(2, ['ichigo']) index.index_doc(3, ['Kuchiki', 'rukia']) del index._rev_index[3] index.remove_words(('Kuchiki', )) assert_that(handler.records[0].msg, is_("Your index is corrupted: %s"))
def testConsumeFromQueue(self): self.assertEqual(len(self.task_queue), 0) taskqueue.add("/", queue=self.queue) taskqueue.add("/Plone", queue=self.queue) transaction.commit() self.assertEqual(len(self.task_queue), 2) handler = InstalledHandler("collective.taskqueue") runAsyncTest(self._testConsumeFromQueue) messages = [record.getMessage() for record in handler.records] self.assertEqual(messages[-2:], ["http://nohost:/", "http://nohost:/Plone"])
def test_log_info(self): from zope.server import zlogintegration from zope.testing.loggingsupport import InstalledHandler handler = InstalledHandler('zope.server') try: zlogintegration.log_info(None, "Some Info") finally: handler.uninstall() self.assertEqual(1, len(handler.records)) self.assertEqual("Some Info", str(handler.records[0].getMessage()))
def setUp(self): """Set up a class ready for testing""" portal = self.layer['portal'] login(portal, MANAGER_ID) if 'classa' not in portal: portal.invokeFactory( type_name="tw_class", id="classa", title="Unittest ClassA", students=[USER_A_ID, USER_C_ID, USER_B_ID], lectures=[], ) else: portal['classa'].lectures = [] self.loghandlers = dict( sqlalchemy=InstalledHandler('sqlalchemy.engine'), sync=InstalledHandler('tutorweb.quizdb.browser.sync')) self.objectPublish(portal['dept1']['tut1']['lec1']) self.objectPublish(portal['dept1']['tut1']['lec2'])
def test_update_index_with_error(self): from zope.testing.loggingsupport import InstalledHandler handler = InstalledHandler('nti.zope_catalog.catalog') self.addCleanup(handler.uninstall) cat = self._makeOne() cat._PERSISTENCE_EXCEPTIONS = AttributeError cat.updateIndex(42, ignore_persistence_exceptions=True) assert_that(handler.records, has_length(1)) assert_that(handler.records[0].msg, is_("Error indexing object %s(%s); %s"))
def testConsume100FromQueue(self): self.assertEqual(len(self.task_queue), 0) expected_result = [] for i in range(100): taskqueue.add("/{0:02d}".format(i), queue=self.queue) expected_result.append("http://nohost:/{0:02d}".format(i)) transaction.commit() self.assertEqual(len(self.task_queue), 100) handler = InstalledHandler("collective.taskqueue") runAsyncTest(self._testConsumeFromQueue) messages = [record.getMessage() for record in handler.records] self.assertEqual(sorted(messages[-100:]), expected_result)
def test_warnings_are_shown(self): import warnings import logging from zope.testing.loggingsupport import InstalledHandler handler = InstalledHandler("py.warnings", level=logging.WARNING) self.addCleanup(handler.uninstall) logging.captureWarnings(True) self.addCleanup(logging.captureWarnings, False) msg = "This should be visible by default" warnings.warn(msg, DeprecationWarning) self.assertEqual(1, len(handler.records)) self.assertIn('DeprecationWarning', handler.records[0].getMessage()) self.assertIn(msg, handler.records[0].getMessage())
def test_suite(): suite = unittest.TestSuite() my_dir = os.path.dirname(__file__) docs = os.path.join('..', '..', '..', 'docs') registerConfiguration = PLONEBLUEPRINTS_FUNCTIONAL_TESTING \ .baseResolutionOrder[1].registerConfiguration for filename in os.listdir(os.path.join(my_dir, docs)): path = os.path.join(docs, filename) globs = { 'registerConfiguration': registerConfiguration, 'ITransmogrifier': ITransmogrifier, 'api': api, 'logger': InstalledHandler('logger', level=logging.INFO) } flags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS suite.addTests([ layered(doctest.DocFileSuite(path, globs=globs, optionflags=flags), layer=PLONEBLUEPRINTS_FUNCTIONAL_TESTING) ]) return suite
def test_ActionExecutor(self): element = IftttTriggerAction() context = self.portal.restrictedTraverse('') api.portal.set_registry_record( name='ifttt.ifttt_secret_key', value=u'secret', ) element.ifttt_event_name = 'ifttt_applet' for option in payload_options: # inspect logs handler = InstalledHandler('collective.ifttt.requests') element.payload_option = option.value ex = getMultiAdapter((context, element, DummyEvent(self.folder)), IExecutable) self.assertTrue(ex()) messages = [record.getMessage() for record in handler.records] self.assertGreater(len(messages), 0) self.assertTrue(messages[0].startswith('Dispatched requests.post'))
def test_jsonifier(self): from zope.testing.loggingsupport import InstalledHandler handler = InstalledHandler('newt.db.jsonpickle') from ..jsonpickle import Jsonifier jsonifier = Jsonifier() p, tid = self.conn._storage.load(z64) class_name, ghost_pickle, state = jsonifier('0', p) self.assertEqual('persistent.mapping.PersistentMapping', class_name) self.assertEqual('{"data": {}}', state) self.assertTrue( p.startswith(ghost_pickle) and ghost_pickle[-1:] == b'.' and b'persistent.mapping' in ghost_pickle) # custon skip_class jsonifier2 = Jsonifier(skip_class=lambda c: 1) self.assertEqual((None, None, None), jsonifier2('0', p)) # empty records are skipped: self.assertEqual((None, None, None), jsonifier('0', '')) # BTrees are skipped by default from BTrees.OOBTree import BTree self.root.x = BTree() self.conn.transaction_manager.commit() p, tid = self.conn._storage.load(self.root.x._p_oid) self.assertEqual((None, None, None), jsonifier('0', p)) # errors are logged, and return Nones: self.assertEqual(handler.records, []) self.assertEqual((None, None, None), jsonifier('foo', b'badness')) self.assertEqual( [r.getMessage().replace("b'", "'") for r in handler.records], ["Failed pickle load, oid: 'foo', pickle starts: 'badness'"]) handler.uninstall()
def setUp(self): super(TestLogActivityMonitor, self).setUp() self.handler = InstalledHandler('nti.zodb.activitylog') self.addCleanup(self.handler.uninstall)
# -*- coding: utf-8 -*- """Tests for pyramid_bimt events.""" from pyramid import testing from pyramid_bimt.security import SymmetricEncryption import mock import unittest from zope.testing.loggingsupport import InstalledHandler # noqa handler = InstalledHandler('pyramid_bimt.security') class TestVerify(unittest.TestCase): def setUp(self): testing.setUp() def tearDown(self): testing.tearDown() def test_invalid_cyphertext(self): """Test handling of an invalid cyphertext stored in DB.""" from pyramid_bimt.security import verify self.assertFalse(verify('foo', 'invalid')) # error is not raised, but it is written to log so we get notified self.assertEqual(len(handler.records), 1) self.assertEqual(handler.records[0].message, 'hash could not be identified') def test_verify(self):
def setUp(self): self.handler = InstalledHandler('zope.i18n') self.addCleanup(self.handler.uninstall)
from sqlalchemy import Column from sqlalchemy import Enum from sqlalchemy import ForeignKey from sqlalchemy import Integer from sqlalchemy import String from sqlalchemy import Unicode from sqlalchemy.orm import backref from sqlalchemy.orm import relationship from zope.testing.loggingsupport import InstalledHandler import json import mock import transaction import unittest handler = InstalledHandler('pyramid_bimt.task') class FooTaskModel(Base, BaseMixin): """A dummy celery task backend.""" __tablename__ = 'foo_tasks' user_id = Column(Integer, ForeignKey('users.id')) user = relationship( User, backref=backref('tasks'), ) task_id = Column( String,
def setUp(self): Test_ro.setUp(self) from zope.testing.loggingsupport import InstalledHandler self.log_handler = handler = InstalledHandler('zope.interface.ro') self.addCleanup(handler.uninstall)
"""Tests for HerokuappAccess tween.""" from pyramid import testing from zope.testing.loggingsupport import InstalledHandler import mock import unittest tweens_handler = InstalledHandler('pyramid_heroku.herokuapp_access') class TestHerokuappAccessTween(unittest.TestCase): def setUp(self): tweens_handler.clear() self.config = testing.setUp() self.handler = mock.Mock() self.request = testing.DummyRequest() self.request.registry.settings = { 'pyramid_heroku.herokuapp_whitelist': [ '1.2.3.4', ] } def tearDown(self): tweens_handler.clear() testing.tearDown() def test_whitelisted_ip(self): from pyramid_heroku.herokuapp_access import HerokuappAccess self.request.client_addr = '1.2.3.4' self.request.headers = {
def setUp(self): """Set up a class ready for testing""" self.loghandlers = dict( errorlog=InstalledHandler('tutorweb.quizdb.browser') )