zopefoundation / zope.configuration / 16248876899

coverage: 99.857%. Remained the same
16248876899

push

github

icemac 
Back to development: 6.1

350 of 356 branches covered (98.31%)

Branch coverage included in aggregate %.

3850 of 3850 relevant lines covered (100.0%)

1.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.89
/src/zope/configuration/tests/test_xmlconfig.py
1 
##############################################################################
2 
#
3 
# Copyright (c) 2003 Zope Foundation and Contributors.
4 
# All Rights Reserved.
5 
#
6 
# This software is subject to the provisions of the Zope Public License,
7 
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
8 
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
9 
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
10 
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
11 
# FOR A PARTICULAR PURPOSE.
12 
#
13 
##############################################################################
14 
"""Test zope.configuration.xmlconfig.
15 
"""
16 
import unittest
1✔
17 









18












19



NS = 'ns'




1✔





20



FOO = 'foo'




1✔





21



XXX = 'xxx'




1✔





22



SPLAT = 'splat'




1✔





23



SPLATV = 'splatv'




1✔





24



A = 'a'




1✔





25



AVALUE = 'avalue'




1✔





26



B = 'b'




1✔





27



BVALUE = 'bvalue'




1✔





28












29



# pylint:disable=protected-access










30












31












32



class ZopeXMLConfigurationErrorTests(unittest.TestCase):




1✔





33



    maxDiff = None




1✔





34












35



    def _getTargetClass(self):




1✔





36



        from zope.configuration.xmlconfig import ZopeXMLConfigurationError




1✔





37



        return ZopeXMLConfigurationError




1✔





38












39



    def _makeOne(self, *args, **kw):




1✔





40



        return self._getTargetClass()(*args, **kw)




1✔





41












42



    def test___str___uses_repr_of_info(self):




1✔





43



        zxce = self._makeOne('info', Exception('value'))




1✔





44



        self.assertEqual(




1✔





45



            str(zxce),










46



            "'info'\n    Exception: value"










47



        )










48












49












50



class ZopeSAXParseExceptionTests(unittest.TestCase):




1✔





51



    maxDiff = None




1✔





52












53



    def _getTargetClass(self):




1✔





54



        from zope.configuration.xmlconfig import ZopeSAXParseException




1✔





55



        return ZopeSAXParseException




1✔





56












57



    def _makeOne(self, *args, **kw):




1✔





58



        return self._getTargetClass()(*args, **kw)




1✔





59












60



    def test___str___not_a_sax_error(self):




1✔





61



        zxce = self._makeOne("info", Exception('Not a SAX error'))




1✔





62



        self.assertEqual(




1✔





63



            str(zxce),










64



            "info\n    Exception: Not a SAX error")










65












66



    def test___str___w_a_sax_error(self):




1✔





67



        zxce = self._makeOne("info", Exception('filename.xml:24:32:WAAA'))




1✔





68



        self.assertEqual(




1✔





69



            str(zxce),










70



            'info\n    Exception: filename.xml:24:32:WAAA')










71












72












73



class ParserInfoTests(unittest.TestCase):




1✔





74












75



    def _getTargetClass(self):




1✔





76



        from zope.configuration.xmlconfig import ParserInfo




1✔





77



        return ParserInfo




1✔





78












79



    def _makeOne(self, *args, **kw):




1✔





80



        return self._getTargetClass()(*args, **kw)




1✔





81












82



    def test___repr___w_eline_ecolumn_match_line_column(self):




1✔





83



        pi = self._makeOne('filename.xml', 24, 32)




1✔





84



        pi.end(24, 32)




1✔





85



        self.assertEqual(repr(pi), 'File "filename.xml", line 24.32')




1✔





86












87



    def test___repr___w_eline_ecolumn_dont_match_line_column(self):




1✔





88



        pi = self._makeOne('filename.xml', 24, 32)




1✔





89



        pi.end(33, 21)




1✔





90



        self.assertEqual(repr(pi), 'File "filename.xml", line 24.32-33.21')




1✔





91












92



    def test___str___w_eline_ecolumn_match_line_column(self):




1✔





93



        pi = self._makeOne('filename.xml', 24, 32)




1✔





94



        pi.end(24, 32)




1✔





95



        self.assertEqual(str(pi), 'File "filename.xml", line 24.32')




1✔





96












97



    def test___str___w_eline_ecolumn_dont_match_line_column_bad_file(self):




1✔





98



        pi = self._makeOne('/path/to/nonesuch.xml', 24, 32)




1✔





99



        pi.end(33, 21)




1✔





100



        self.assertEqual(str(pi),




1✔





101



                         'File "/path/to/nonesuch.xml", line 24.32-33.21\n'










102



                         '  Could not read source.')










103












104



    def test___str___w_good_file(self):




1✔





105



        pi = self._makeOne('tests//sample.zcml', 3, 2)




1✔





106



        pi.end(3, 57)




1✔





107



        self.assertEqual(




1✔





108



            str(pi),










109



            'File "tests//sample.zcml", line 3.2-3.57\n'










110



            '    <directives namespace="http://namespaces.zope.org/zope">')










111












112












113



class ConfigurationHandlerTests(unittest.TestCase):




1✔





114












115



    def _getTargetClass(self):




1✔





116



        from zope.configuration.xmlconfig import ConfigurationHandler




1✔





117



        return ConfigurationHandler




1✔





118












119



    def _makeOne(self, *args, **kw):




1✔





120



        return self._getTargetClass()(*args, **kw)




1✔





121












122



    def test_ctor_defaults(self):




1✔





123



        context = FauxContext()




1✔





124



        handler = self._makeOne(context)




1✔





125



        self.assertIs(handler.context, context)




1✔





126



        self.assertFalse(handler.testing)




1✔





127



        self.assertEqual(handler.ignore_depth, 0)




1✔





128












129



    def test_ctor_explicit(self):




1✔





130



        context = FauxContext()




1✔





131



        handler = self._makeOne(context, True)




1✔





132



        self.assertIs(handler.context, context)




1✔





133



        self.assertTrue(handler.testing)




1✔





134



        self.assertEqual(handler.ignore_depth, 0)




1✔





135



        self.assertIsNone(handler.locator)




1✔





136












137



    def test_setDocumentLocator(self):




1✔





138



        context = FauxContext()




1✔





139



        locator = FauxLocator('tests//sample.zcml', 1, 1)




1✔





140



        handler = self._makeOne(context, True)




1✔





141



        handler.setDocumentLocator(locator)




1✔





142



        self.assertIs(handler.locator, locator)




1✔





143












144



    def test_startElementNS_w_zcml_condition_failing(self):




1✔





145



        from zope.configuration.xmlconfig import ZCML_CONDITION




1✔





146



        context = FauxContext()




1✔





147



        handler = self._makeOne(context, True)




1✔





148



        # No locator set:  we won't need it, due to a failed condition.










149



        handler.startElementNS((NS, FOO), FOO,




1✔





150



                               {ZCML_CONDITION: 'have nonesuch',










151



                                (None, A): AVALUE,










152



                                (None, B): BVALUE,










153



                                })










154



        self.assertEqual(handler.ignore_depth, 1)




1✔





155












156



    def test_startElementNS_w_ignore_depth_already_set(self):




1✔





157



        context = FauxContext()




1✔





158



        handler = self._makeOne(context, True)




1✔





159



        handler.ignore_depth = 1




1✔





160



        # No locator set:  we won't need it, as an ancestor had a










161



        # failed condition.










162



        handler.startElementNS((NS, FOO), FOO,




1✔





163



                               {(XXX, SPLAT): SPLATV,










164



                                (None, A): AVALUE,










165



                                (None, B): BVALUE,










166



                                })










167



        self.assertEqual(handler.ignore_depth, 2)




1✔





168












169



    def _check_elementNS_context_raises(self, raises, catches,




1✔





170



                                        testing=False,










171



                                        meth='endElementNS',










172



                                        meth_args=((NS, FOO), FOO)):










173



        class ErrorContext(FauxContext):




1✔





174



            def end(self, *args):




1✔





175



                raise raises("xxx")




1✔





176



            begin = end




1✔





177












178



        class Info:




1✔





179



            _line = _col = None




1✔





180












181



            def end(self, line, col):




1✔





182



                self._line, self._col = line, col




1✔





183



        context = ErrorContext()




1✔





184



        info = Info()




1✔





185



        context.setInfo(info)




1✔





186



        locator = FauxLocator('tests//sample.zcml', 1, 1)




1✔





187



        handler = self._makeOne(context, testing)




1✔





188



        handler.setDocumentLocator(locator)




1✔





189



        locator.line, locator.column = 7, 16




1✔





190



        meth = getattr(handler, meth)




1✔





191



        with self.assertRaises(catches) as exc:




1✔





192



            meth(*meth_args)




1✔





193



        return exc.exception, info




1✔





194












195



    def _check_startElementNS_context_begin_raises(




1✔





196



            self, raises, catches, testing=False):










197



        return self._check_elementNS_context_raises(




1✔





198



            raises, catches, testing,










199



            meth='startElementNS',










200



            meth_args=((NS, FOO),










201



                       FOO,










202



                       {(XXX, SPLAT): SPLATV,










203



                        (None, A): AVALUE,










204



                        (None, B): BVALUE,










205



                        })










206



        )










207












208



    def test_startElementNS_context_begin_raises_wo_testing(self):




1✔





209



        from zope.configuration.xmlconfig import ZopeXMLConfigurationError




1✔





210



        raised, _ = self._check_startElementNS_context_begin_raises(




1✔





211



            AttributeError, ZopeXMLConfigurationError)










212



        info = raised.info




1✔





213



        self.assertEqual(info.file, 'tests//sample.zcml')




1✔





214



        self.assertEqual(info.line, 7)




1✔





215



        self.assertEqual(info.column, 16)




1✔





216












217



    def test_startElementNS_context_begin_raises_w_testing(self):




1✔





218



        self._check_startElementNS_context_begin_raises(AttributeError,




1✔





219



                                                        AttributeError,










220



                                                        True)










221












222



    def test_startElementNS_context_begin_raises_BaseException(self):




1✔





223



        class Bex(BaseException):




1✔





224



            pass




1✔





225



        self._check_startElementNS_context_begin_raises(Bex,




1✔





226



                                                        Bex)










227












228



    def test_startElementNS_normal(self):




1✔





229



        # Integration test of startElementNS / endElementNS pair.










230



        context = FauxContext()




1✔





231



        locator = FauxLocator('tests//sample.zcml', 1, 1)




1✔





232



        handler = self._makeOne(context)




1✔





233



        handler.setDocumentLocator(locator)




1✔





234












235



        handler.startElementNS((NS, FOO), FOO,




1✔





236



                               {(XXX, SPLAT): SPLATV,










237



                                (None, A): AVALUE,










238



                                (None, B): BVALUE,










239



                                })










240



        self.assertEqual(context.info.file, 'tests//sample.zcml')




1✔





241



        self.assertEqual(context.info.line, 1)




1✔





242



        self.assertEqual(context.info.column, 1)




1✔





243



        self.assertEqual(context.begin_args,




1✔





244



                         ((NS, FOO),










245



                          {'a': AVALUE, 'b': BVALUE}))










246



        self.assertFalse(context._end_called)




1✔





247












248



    def test_endElementNS_w_ignore_depth_already_set(self):




1✔





249



        context = FauxContext()




1✔





250



        handler = self._makeOne(context, True)




1✔





251



        handler.ignore_depth = 1




1✔





252



        # No locator set:  we won't need it, as we had a










253



        # failed condition.










254



        handler.endElementNS((NS, FOO), FOO)




1✔





255



        self.assertEqual(handler.ignore_depth, 0)




1✔





256












257



    def _check_endElementNS_context_end_raises(




1✔





258



            self, raises, catches, testing=False):










259



        return self._check_elementNS_context_raises(raises, catches, testing)




1✔





260












261



    def test_endElementNS_context_end_raises_wo_testing(self):




1✔





262



        from zope.configuration.xmlconfig import ZopeXMLConfigurationError




1✔





263












264



        raised, info = self._check_endElementNS_context_end_raises(




1✔





265



            AttributeError, ZopeXMLConfigurationError)










266












267



        self.assertIs(raised.info, info)




1✔





268



        self.assertEqual(raised.info._line, 7)




1✔





269



        self.assertEqual(raised.info._col, 16)




1✔





270












271



    def test_endElementNS_context_end_raises_w_testing(self):




1✔





272



        _, info = self._check_endElementNS_context_end_raises(AttributeError,




1✔





273



                                                              AttributeError,










274



                                                              True)










275



        self.assertEqual(info._line, 7)




1✔





276



        self.assertEqual(info._col, 16)




1✔





277












278



    def test_endElementNS_context_end_raises_BaseException(self):




1✔





279



        class Bex(BaseException):




1✔





280



            pass




1✔





281



        self._check_endElementNS_context_end_raises(Bex,




1✔





282



                                                    Bex)










283












284



    def test_evaluateCondition_w_have_no_args(self):




1✔





285



        context = FauxContext()




1✔





286



        handler = self._makeOne(context)




1✔





287



        with self.assertRaises(ValueError) as exc:




1✔





288



            handler.evaluateCondition('have')




1✔





289



        self.assertEqual(str(exc.exception.args[0]),




1✔





290



                         "Feature name missing: 'have'")










291












292



    def test_evaluateCondition_w_not_have_too_many_args(self):




1✔





293



        context = FauxContext()




1✔





294



        handler = self._makeOne(context)




1✔





295



        with self.assertRaises(ValueError) as exc:




1✔





296



            handler.evaluateCondition('not-have a b')




1✔





297



        self.assertEqual(str(exc.exception.args[0]),




1✔





298



                         "Only one feature allowed: 'not-have a b'")










299












300



    def test_evaluateCondition_w_have_miss(self):




1✔





301



        context = FauxContext()




1✔





302



        handler = self._makeOne(context)




1✔





303



        self.assertFalse(handler.evaluateCondition('have feature'))




1✔





304












305



    def test_evaluateCondition_w_have_hit(self):




1✔





306



        context = FauxContext()




1✔





307



        context._features = ('feature',)




1✔





308



        handler = self._makeOne(context)




1✔





309



        self.assertTrue(handler.evaluateCondition('have feature'))




1✔





310












311



    def test_evaluateCondition_w_not_have_miss(self):




1✔





312



        context = FauxContext()




1✔





313



        context._features = ('feature',)




1✔





314



        handler = self._makeOne(context)




1✔





315



        self.assertFalse(handler.evaluateCondition('not-have feature'))




1✔





316












317



    def test_evaluateCondition_w_not_have_hit(self):




1✔





318



        context = FauxContext()




1✔





319



        handler = self._makeOne(context)




1✔





320



        self.assertTrue(handler.evaluateCondition('not-have feature'))




1✔





321












322



    def test_evaluateCondition_w_installed_no_args(self):




1✔





323



        context = FauxContext()




1✔





324



        handler = self._makeOne(context)




1✔





325



        with self.assertRaises(ValueError) as exc:




1✔





326



            handler.evaluateCondition('installed')




1✔





327



        self.assertEqual(str(exc.exception.args[0]),




1✔





328



                         "Package name missing: 'installed'")










329












330



    def test_evaluateCondition_w_not_installed_too_many_args(self):




1✔





331



        context = FauxContext()




1✔





332



        handler = self._makeOne(context)




1✔





333



        with self.assertRaises(ValueError) as exc:




1✔





334



            handler.evaluateCondition('not-installed a b')




1✔





335



        self.assertEqual(str(exc.exception.args[0]),




1✔





336



                         "Only one package allowed: 'not-installed a b'")










337












338



    def test_evaluateCondition_w_installed_miss(self):




1✔





339



        context = FauxContext()




1✔





340



        handler = self._makeOne(context)




1✔





341



        self.assertFalse(




1✔





342



            handler.evaluateCondition('installed nonsuch.package'))










343












344



    def test_evaluateCondition_w_installed_hit(self):




1✔





345



        context = FauxContext()




1✔





346



        handler = self._makeOne(context)




1✔





347



        self.assertTrue(handler.evaluateCondition('installed os'))




1✔





348












349



    def test_evaluateCondition_w_not_installed_miss(self):




1✔





350



        context = FauxContext()




1✔





351



        handler = self._makeOne(context)




1✔





352



        self.assertFalse(handler.evaluateCondition('not-installed os'))




1✔





353












354



    def test_evaluateCondition_w_not_installed_hit(self):




1✔





355



        context = FauxContext()




1✔





356



        handler = self._makeOne(context)




1✔





357



        self.assertTrue(




1✔





358



            handler.evaluateCondition('not-installed nonsuch.package'))










359












360



    def test_evaluateCondition_w_unknown_verb(self):




1✔





361



        context = FauxContext()




1✔





362



        handler = self._makeOne(context)




1✔





363



        with self.assertRaises(ValueError) as exc:




1✔





364



            handler.evaluateCondition('nonesuch')




1✔





365



        self.assertEqual(str(exc.exception.args[0]),




1✔





366



                         "Invalid ZCML condition: 'nonesuch'")










367












368



    def test_endElementNS_normal(self):




1✔





369



        class Info:




1✔





370



            _line = _col = None




1✔





371












372



            def end(self, line, col):




1✔





373



                self._line, self._col = line, col




1✔





374



        context = FauxContext()




1✔





375



        info = Info()




1✔





376



        context.setInfo(info)




1✔





377



        locator = FauxLocator('tests//sample.zcml', 7, 16)




1✔





378



        handler = self._makeOne(context, True)




1✔





379



        handler.setDocumentLocator(locator)




1✔





380



        handler.endElementNS((NS, FOO), FOO)




1✔





381



        self.assertEqual(context.info._line, 7)




1✔





382



        self.assertEqual(context.info._col, 16)




1✔





383



        self.assertTrue(context._end_called)




1✔





384












385












386



class Test_processxmlfile(unittest.TestCase):




1✔





387












388



    def _callFUT(self, *args, **kw):




1✔





389



        from zope.configuration.xmlconfig import processxmlfile




1✔





390



        return processxmlfile(*args, **kw)




1✔





391












392



    def test_w_empty_xml(self):




1✔





393



        from io import StringIO




1✔





394












395



        from zope.configuration.config import ConfigurationMachine




1✔





396



        from zope.configuration.xmlconfig import ZopeSAXParseException




1✔





397



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





398












399



        context = ConfigurationMachine()




1✔





400



        registerCommonDirectives(context)




1✔





401



        with self.assertRaises(ZopeSAXParseException) as exc:




1✔





402



            self._callFUT(StringIO(), context)




1✔





403



        self.assertEqual(str(exc.exception.evalue),




1✔





404



                         '<string>:1:0: no element found')










405












406



    def test_w_valid_xml_fp(self):




1✔





407



        # Integration test, really










408



        from zope.configuration.config import ConfigurationMachine




1✔





409



        from zope.configuration.tests.samplepackage import foo




1✔





410



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





411












412



        context = ConfigurationMachine()




1✔





413



        registerCommonDirectives(context)




1✔





414












415



        with open(path("samplepackage", "configure.zcml")) as file:




1✔





416



            self._callFUT(file, context)




1✔





417



        self.assertEqual(foo.data, [])




1✔





418



        context.execute_actions()




1✔





419



        data = foo.data.pop()




1✔





420



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





421



        self.assertEqual(




1✔





422



            clean_info_path(repr(data.info)),










423



            'File "tests/samplepackage/configure.zcml", line 12.2-12.29')










424



        self.assertEqual(




1✔





425



            clean_info_path(str(data.info)),










426



            'File "tests/samplepackage/configure.zcml", line 12.2-12.29\n'










427



            '    <test:foo x="blah" y="0" />')










428



        self.assertEqual(data.package, None)




1✔





429



        self.assertEqual(data.basepath, None)




1✔





430












431












432



class Test_openInOrPlain(unittest.TestCase):




1✔





433












434



    def _callFUT(self, *args, **kw):




1✔





435



        from zope.configuration.xmlconfig import openInOrPlain




1✔





436



        return openInOrPlain(*args, **kw)




1✔





437












438



    def _makeFilename(self, fn):




1✔





439



        import os




1✔





440












441



        from zope.configuration.tests.samplepackage import __file__




1✔





442



        return os.path.join(os.path.dirname(__file__), fn)




1✔





443












444



    def test_file_present(self):




1✔





445



        import os




1✔





446



        with self._callFUT(self._makeFilename('configure.zcml')) as fp:




1✔





447



            self.assertEqual(os.path.basename(fp.name), 'configure.zcml')




1✔





448












449



    def test_file_missing_but_dot_in_present(self):




1✔





450



        import os




1✔





451



        with self._callFUT(self._makeFilename('foo.zcml')) as fp:




1✔





452



            self.assertEqual(os.path.basename(fp.name), 'foo.zcml.in')




1✔





453












454



    def test_file_missing_and_dot_in_not_present(self):




1✔





455



        import errno




1✔





456



        with self.assertRaises(IOError) as exc:




1✔





457



            self._callFUT(self._makeFilename('nonesuch.zcml'))




1✔





458



        self.assertEqual(exc.exception.errno, errno.ENOENT)




1✔





459












460












461



class Test_include(unittest.TestCase):




1✔





462












463



    def _callFUT(self, *args, **kw):




1✔





464



        from zope.configuration.xmlconfig import include




1✔





465



        return include(*args, **kw)




1✔





466












467



    def test_both_file_and_files_passed(self):




1✔





468



        context = FauxContext()




1✔





469



        with self.assertRaises(ValueError) as exc:




1✔





470



            self._callFUT(




1✔





471



                context, 'tests//sample.zcml', files=['tests/*.zcml'])










472



        self.assertEqual(str(exc.exception),




1✔





473



                         "Must specify only one of file or files")










474












475



    def test_neither_file_nor_files_passed_already_seen(self):




1✔





476



        from zope.configuration import xmlconfig




1✔





477



        from zope.configuration.config import ConfigurationMachine




1✔





478



        from zope.configuration.tests import samplepackage




1✔





479



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





480



        context = ConfigurationMachine()




1✔





481



        registerCommonDirectives(context)




1✔





482



        context.package = samplepackage




1✔





483



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





484



        context._seen_files.add(fqn)




1✔





485



        logger = LoggerStub()




1✔





486



        with _Monkey(xmlconfig, logger=logger):




1✔





487



            self._callFUT(context)  # skips




1✔





488



        self.assertEqual(len(logger.debugs), 0)




1✔





489



        self.assertEqual(len(context.actions), 0)




1✔





490












491



    def test_neither_file_nor_files_passed(self):




1✔





492



        from zope.configuration import xmlconfig




1✔





493



        from zope.configuration.config import ConfigurationMachine




1✔





494



        from zope.configuration.tests import samplepackage




1✔





495



        from zope.configuration.tests.samplepackage import foo




1✔





496



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





497



        context = ConfigurationMachine()




1✔





498



        registerCommonDirectives(context)




1✔





499



        before_stack = context.stack[:]




1✔





500



        context.package = samplepackage




1✔





501



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





502



        logger = LoggerStub()




1✔





503



        with _Monkey(xmlconfig, logger=logger):




1✔





504



            self._callFUT(context)




1✔





505



        self.assertEqual(len(logger.debugs), 1)




1✔





506



        self.assertEqual(logger.debugs[0], ('include %s', (fqn,), {}))




1✔





507



        self.assertEqual(len(context.actions), 1)




1✔





508



        action = context.actions[0]




1✔





509



        self.assertEqual(action['callable'], foo.data.append)




1✔





510



        self.assertEqual(action['includepath'], (fqn,))




1✔





511



        self.assertEqual(context.stack, before_stack)




1✔





512



        self.assertEqual(len(context._seen_files), 1)




1✔





513



        self.assertIn(fqn, context._seen_files)




1✔





514












515



    def test_w_file_passed(self):




1✔





516



        from zope.configuration import tests




1✔





517



        from zope.configuration import xmlconfig




1✔





518



        from zope.configuration.config import ConfigurationMachine




1✔





519



        from zope.configuration.tests import simple




1✔





520



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





521



        context = ConfigurationMachine()




1✔





522



        registerCommonDirectives(context)




1✔





523



        before_stack = context.stack[:]




1✔





524



        context.package = tests




1✔





525



        fqn = _packageFile(tests, 'simple.zcml')




1✔





526



        logger = LoggerStub()




1✔





527



        with _Monkey(xmlconfig, logger=logger):




1✔





528



            self._callFUT(context, 'simple.zcml')




1✔





529



        self.assertEqual(len(logger.debugs), 1)




1✔





530



        self.assertEqual(logger.debugs[0], ('include %s', (fqn,), {}))




1✔





531



        self.assertEqual(len(context.actions), 3)




1✔





532



        action = context.actions[0]




1✔





533



        self.assertEqual(action['callable'], simple.file_registry.append)




1✔





534



        self.assertEqual(action['includepath'], (fqn,))




1✔





535



        self.assertEqual(action['args'][0].path,




1✔





536



                         _packageFile(tests, 'simple.py'))










537



        action = context.actions[1]




1✔





538



        self.assertEqual(action['callable'], simple.file_registry.append)




1✔





539



        self.assertEqual(action['includepath'], (fqn,))




1✔





540



        self.assertEqual(action['args'][0].path,




1✔





541



                         _packageFile(tests, 'simple.zcml'))










542



        action = context.actions[2]




1✔





543



        self.assertEqual(action['callable'], simple.file_registry.append)




1✔





544



        self.assertEqual(action['includepath'], (fqn,))




1✔





545



        self.assertEqual(action['args'][0].path,




1✔





546



                         _packageFile(tests, '__init__.py'))










547



        self.assertEqual(context.stack, before_stack)




1✔





548



        self.assertEqual(len(context._seen_files), 1)




1✔





549



        self.assertIn(fqn, context._seen_files)




1✔





550












551



    def test_w_files_passed_and_package(self):




1✔





552



        from zope.configuration import xmlconfig




1✔





553



        from zope.configuration.config import ConfigurationMachine




1✔





554



        from zope.configuration.tests import samplepackage




1✔





555



        from zope.configuration.tests.samplepackage import foo




1✔





556



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





557



        context = ConfigurationMachine()




1✔





558



        registerCommonDirectives(context)




1✔





559



        before_stack = context.stack[:]




1✔





560



        fqn1 = _packageFile(samplepackage, 'baz1.zcml')




1✔





561



        fqn2 = _packageFile(samplepackage, 'baz2.zcml')




1✔





562



        fqn3 = _packageFile(samplepackage, 'baz3.zcml')




1✔





563



        logger = LoggerStub()




1✔





564



        with _Monkey(xmlconfig, logger=logger):




1✔





565



            self._callFUT(context, package=samplepackage, files='baz*.zcml')




1✔





566



        self.assertEqual(len(logger.debugs), 3)




1✔





567



        self.assertEqual(logger.debugs[0], ('include %s', (fqn1,), {}))




1✔





568



        self.assertEqual(logger.debugs[1], ('include %s', (fqn2,), {}))




1✔





569



        self.assertEqual(logger.debugs[2], ('include %s', (fqn3,), {}))




1✔





570



        self.assertEqual(len(context.actions), 2)




1✔





571



        action = context.actions[0]




1✔





572



        self.assertEqual(action['callable'], foo.data.append)




1✔





573



        self.assertEqual(action['includepath'], (fqn2,))




1✔





574



        self.assertIsInstance(action['args'][0], foo.stuff)




1✔





575



        self.assertEqual(action['args'][0].args, (('x', (b'foo')), ('y', 2)))




1✔





576



        action = context.actions[1]




1✔





577



        self.assertEqual(action['callable'], foo.data.append)




1✔





578



        self.assertEqual(action['includepath'], (fqn3,))




1✔





579



        self.assertIsInstance(action['args'][0], foo.stuff)




1✔





580



        self.assertEqual(action['args'][0].args, (('x', (b'foo')), ('y', 3)))




1✔





581



        self.assertEqual(context.stack, before_stack)




1✔





582



        self.assertEqual(len(context._seen_files), 3)




1✔





583



        self.assertIn(fqn1, context._seen_files)




1✔





584



        self.assertIn(fqn2, context._seen_files)




1✔





585



        self.assertIn(fqn3, context._seen_files)




1✔





586












587












588



class Test_exclude(unittest.TestCase):




1✔





589












590



    def _callFUT(self, *args, **kw):




1✔





591



        from zope.configuration.xmlconfig import exclude




1✔





592



        return exclude(*args, **kw)




1✔





593












594



    def test_both_file_and_files_passed(self):




1✔





595



        context = FauxContext()




1✔





596



        with self.assertRaises(ValueError) as exc:




1✔





597



            self._callFUT(




1✔





598



                context, 'tests//sample.zcml', files=['tests/*.zcml'])










599



        self.assertEqual(str(exc.exception),




1✔





600



                         "Must specify only one of file or files")










601












602



    def test_neither_file_nor_files_passed(self):




1✔





603



        from zope.configuration.config import ConfigurationMachine




1✔





604



        from zope.configuration.tests import samplepackage




1✔





605



        context = ConfigurationMachine()




1✔





606



        context.package = samplepackage




1✔





607



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





608



        self._callFUT(context)




1✔





609



        self.assertEqual(len(context.actions), 0)




1✔





610



        self.assertEqual(len(context._seen_files), 1)




1✔





611



        self.assertIn(fqn, context._seen_files)




1✔





612












613



    def test_w_file_passed(self):




1✔





614



        from zope.configuration import tests




1✔





615



        from zope.configuration.config import ConfigurationMachine




1✔





616



        context = ConfigurationMachine()




1✔





617



        context.package = tests




1✔





618



        fqn = _packageFile(tests, 'simple.zcml')




1✔





619



        self._callFUT(context, 'simple.zcml')




1✔





620



        self.assertEqual(len(context.actions), 0)




1✔





621



        self.assertEqual(len(context._seen_files), 1)




1✔





622



        self.assertIn(fqn, context._seen_files)




1✔





623












624



    def test_w_files_passed_and_package(self):




1✔





625



        from zope.configuration.config import ConfigurationMachine




1✔





626



        from zope.configuration.tests import samplepackage




1✔





627



        context = ConfigurationMachine()




1✔





628



        fqn1 = _packageFile(samplepackage, 'baz1.zcml')




1✔





629



        fqn2 = _packageFile(samplepackage, 'baz2.zcml')




1✔





630



        fqn3 = _packageFile(samplepackage, 'baz3.zcml')




1✔





631



        self._callFUT(context, package=samplepackage, files='baz*.zcml')




1✔





632



        self.assertEqual(len(context.actions), 0)




1✔





633



        self.assertEqual(len(context._seen_files), 3)




1✔





634



        self.assertIn(fqn1, context._seen_files)




1✔





635



        self.assertIn(fqn2, context._seen_files)




1✔





636



        self.assertIn(fqn3, context._seen_files)




1✔





637












638



    def test_w_subpackage(self):




1✔





639



        from zope.configuration.config import ConfigurationMachine




1✔





640



        from zope.configuration.tests import excludedemo




1✔





641



        from zope.configuration.tests.excludedemo import sub




1✔





642



        context = ConfigurationMachine()




1✔





643



        fqne_spam = _packageFile(excludedemo, 'spam.zcml')




1✔





644



        fqne_config = _packageFile(excludedemo, 'configure.zcml')




1✔





645



        fqns_config = _packageFile(sub, 'configure.zcml')




1✔





646



        self._callFUT(context, package=sub)




1✔





647



        self.assertEqual(len(context.actions), 0)




1✔





648



        self.assertEqual(len(context._seen_files), 1)




1✔





649



        self.assertNotIn(fqne_spam, context._seen_files)




1✔





650



        self.assertNotIn(fqne_config, context._seen_files)




1✔





651



        self.assertIn(fqns_config, context._seen_files)




1✔





652












653












654



class Test_includeOverrides(unittest.TestCase):




1✔





655












656



    def _callFUT(self, *args, **kw):




1✔





657



        from zope.configuration.xmlconfig import includeOverrides




1✔





658



        return includeOverrides(*args, **kw)




1✔





659












660



    def test_actions_have_parents_includepath(self):




1✔





661



        from zope.configuration import tests




1✔





662



        from zope.configuration import xmlconfig




1✔





663



        from zope.configuration.config import ConfigurationMachine




1✔





664



        from zope.configuration.tests import simple




1✔





665



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





666



        context = ConfigurationMachine()




1✔





667



        fqp = _packageFile(tests, 'configure.zcml')




1✔





668



        registerCommonDirectives(context)




1✔





669



        before_stack = context.stack[:]




1✔





670



        context.package = tests




1✔





671



        # dummy action, path from "previous" include










672



        context.includepath = (fqp,)




1✔





673












674



        def _callable():




1✔





675



            raise AssertionError("should not be called")










676



        context.actions.append({'discriminator': None,




1✔





677



                                'callable': _callable,










678



                                })










679



        fqn = _packageFile(tests, 'simple.zcml')




1✔





680



        logger = LoggerStub()




1✔





681



        with _Monkey(xmlconfig, logger=logger):




1✔





682



            self._callFUT(context, 'simple.zcml')




1✔





683



        self.assertEqual(len(logger.debugs), 1)




1✔





684



        self.assertEqual(logger.debugs[0], ('include %s', (fqn,), {}))




1✔





685



        self.assertEqual(len(context.actions), 4)




1✔





686



        action = context.actions[0]




1✔





687



        self.assertEqual(action['discriminator'], None)




1✔





688



        self.assertEqual(action['callable'], _callable)




1✔





689



        action = context.actions[1]




1✔





690



        self.assertEqual(action['callable'], simple.file_registry.append)




1✔





691



        self.assertEqual(action['includepath'], (fqp,))




1✔





692



        self.assertEqual(action['args'][0].path,




1✔





693



                         _packageFile(tests, 'simple.py'))










694



        action = context.actions[2]




1✔





695



        self.assertEqual(action['callable'], simple.file_registry.append)




1✔





696



        self.assertEqual(action['includepath'], (fqp,))




1✔





697



        self.assertEqual(action['args'][0].path,




1✔





698



                         _packageFile(tests, 'simple.zcml'))










699



        action = context.actions[3]




1✔





700



        self.assertEqual(action['callable'], simple.file_registry.append)




1✔





701



        self.assertEqual(action['includepath'], (fqp,))




1✔





702



        self.assertEqual(action['args'][0].path,




1✔





703



                         _packageFile(tests, '__init__.py'))










704



        self.assertEqual(context.stack, before_stack)




1✔





705



        self.assertEqual(len(context._seen_files), 1)




1✔





706



        self.assertIn(fqn, context._seen_files)




1✔





707












708












709



class Test_file(unittest.TestCase):




1✔





710












711



    def _callFUT(self, *args, **kw):




1✔





712



        from zope.configuration.xmlconfig import file




1✔





713



        return file(*args, **kw)




1✔





714












715



    def test_wo_execute_wo_context_wo_package(self):




1✔





716



        from zope.configuration import xmlconfig




1✔





717



        from zope.configuration.tests.samplepackage import foo




1✔





718



        file_name = path("samplepackage", "configure.zcml")




1✔





719



        logger = LoggerStub()




1✔





720



        with _Monkey(xmlconfig, logger=logger):




1✔





721



            context = self._callFUT(file_name, execute=False)




1✔





722



        self.assertEqual(len(logger.debugs), 1)




1✔





723



        self.assertEqual(logger.debugs[0], ('include %s', (file_name,), {}))




1✔





724



        self.assertEqual(len(foo.data), 0)




1✔





725



        self.assertEqual(len(context.actions), 1)




1✔





726



        action = context.actions[0]




1✔





727



        self.assertEqual(action['discriminator'],




1✔





728



                         (('x', (b'blah')), ('y', 0)))










729



        self.assertEqual(action['callable'], foo.data.append)




1✔





730












731



    def test_wo_execute_wo_context_w_package(self):




1✔





732



        from zope.configuration import xmlconfig




1✔





733



        from zope.configuration.tests import samplepackage




1✔





734



        from zope.configuration.tests.samplepackage import foo




1✔





735



        file_name = path("samplepackage", "configure.zcml")




1✔





736



        logger = LoggerStub()




1✔





737



        with _Monkey(xmlconfig, logger=logger):




1✔





738



            context = self._callFUT('configure.zcml', package=samplepackage,




1✔





739



                                    execute=False)










740



        self.assertEqual(len(logger.debugs), 1)




1✔





741



        self.assertEqual(logger.debugs[0], ('include %s', (file_name,), {}))




1✔





742



        self.assertEqual(len(foo.data), 0)




1✔





743



        self.assertIs(context.package, samplepackage)




1✔





744



        self.assertEqual(len(context.actions), 1)




1✔





745



        action = context.actions[0]




1✔





746



        self.assertEqual(action['discriminator'],




1✔





747



                         (('x', (b'blah')), ('y', 0)))










748



        self.assertEqual(action['callable'], foo.data.append)




1✔





749












750



    def test_wo_execute_w_context(self):




1✔





751



        from zope.configuration import xmlconfig




1✔





752



        from zope.configuration.config import ConfigurationMachine




1✔





753



        from zope.configuration.tests import samplepackage




1✔





754



        from zope.configuration.tests.samplepackage import foo




1✔





755



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





756



        context = ConfigurationMachine()




1✔





757



        context.package = samplepackage




1✔





758



        registerCommonDirectives(context)




1✔





759



        file_name = path("samplepackage", "configure.zcml")




1✔





760



        logger = LoggerStub()




1✔





761



        with _Monkey(xmlconfig, logger=logger):




1✔





762



            ret = self._callFUT('configure.zcml', context=context,




1✔





763



                                execute=False)










764



        self.assertIs(ret, context)




1✔





765



        self.assertEqual(len(logger.debugs), 1)




1✔





766



        self.assertEqual(logger.debugs[0], ('include %s', (file_name,), {}))




1✔





767



        self.assertEqual(len(foo.data), 0)




1✔





768



        self.assertEqual(len(context.actions), 1)




1✔





769



        action = context.actions[0]




1✔





770



        self.assertEqual(action['discriminator'],




1✔





771



                         (('x', (b'blah')), ('y', 0)))










772



        self.assertEqual(action['callable'], foo.data.append)




1✔





773












774



    def test_w_execute(self):




1✔





775



        import os




1✔





776












777



        from zope.configuration import xmlconfig




1✔





778



        from zope.configuration.tests.samplepackage import foo




1✔





779



        file_name = path("samplepackage", "configure.zcml")




1✔





780



        logger = LoggerStub()




1✔





781



        with _Monkey(xmlconfig, logger=logger):




1✔





782



            self._callFUT(file_name)




1✔





783



        self.assertEqual(len(logger.debugs), 1)




1✔





784



        self.assertEqual(logger.debugs[0], ('include %s', (file_name,), {}))




1✔





785



        data = foo.data.pop()




1✔





786



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





787



        self.assertTrue(




1✔





788



            data.info.file.endswith(










789



                os.path.normpath('tests/samplepackage/configure.zcml')))










790



        self.assertEqual(data.info.line, 12)




1✔





791



        self.assertEqual(data.info.column, 2)




1✔





792



        self.assertEqual(data.info.eline, 12)




1✔





793



        self.assertEqual(data.info.ecolumn, 29)




1✔





794



        self.assertEqual(data.package, None)




1✔





795



        self.assertTrue(data.basepath.endswith(




1✔





796



            os.path.normpath('tests/samplepackage')))










797












798












799



class Test_string(unittest.TestCase):




1✔





800












801



    def _callFUT(self, *args, **kw):




1✔





802



        from zope.configuration.xmlconfig import string




1✔





803



        return string(*args, **kw)




1✔





804












805



    def test_wo_execute_wo_context(self):




1✔





806



        from zope.configuration.tests.samplepackage import foo




1✔





807



        file_name = path("samplepackage", "configure.zcml")




1✔





808



        with open(file_name) as f:




1✔





809



            xml = f.read()




1✔





810



        context = self._callFUT(xml, execute=False)




1✔





811



        self.assertEqual(len(foo.data), 0)




1✔





812



        self.assertEqual(len(context.actions), 1)




1✔





813



        action = context.actions[0]




1✔





814



        self.assertEqual(action['discriminator'],




1✔





815



                         (('x', (b'blah')), ('y', 0)))










816



        self.assertEqual(action['callable'], foo.data.append)




1✔





817












818



    def test_wo_execute_w_context(self):




1✔





819



        from zope.configuration.config import ConfigurationMachine




1✔





820



        from zope.configuration.tests.samplepackage import foo




1✔





821



        from zope.configuration.xmlconfig import registerCommonDirectives




1✔





822



        context = ConfigurationMachine()




1✔





823



        registerCommonDirectives(context)




1✔





824



        file_name = path("samplepackage", "configure.zcml")




1✔





825



        with open(file_name) as f:




1✔





826



            xml = f.read()




1✔





827



        ret = self._callFUT(xml, context=context, execute=False)




1✔





828



        self.assertIs(ret, context)




1✔





829



        self.assertEqual(len(foo.data), 0)




1✔





830



        self.assertEqual(len(context.actions), 1)




1✔





831



        action = context.actions[0]




1✔





832



        self.assertEqual(action['discriminator'],




1✔





833



                         (('x', (b'blah')), ('y', 0)))










834



        self.assertEqual(action['callable'], foo.data.append)




1✔





835












836



    def test_w_execute(self):




1✔





837



        from zope.configuration.tests.samplepackage import foo




1✔





838



        file_name = path("samplepackage", "configure.zcml")




1✔





839



        with open(file_name) as f:




1✔





840



            xml = f.read()




1✔





841



        self._callFUT(xml)




1✔





842



        data = foo.data.pop()




1✔





843



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





844



        self.assertTrue(data.info.file, '<string>')




1✔





845



        self.assertEqual(data.info.line, 12)




1✔





846



        self.assertEqual(data.info.column, 2)




1✔





847



        self.assertEqual(data.info.eline, 12)




1✔





848



        self.assertEqual(data.info.ecolumn, 29)




1✔





849



        self.assertEqual(data.package, None)




1✔





850



        self.assertEqual(data.basepath, None)




1✔





851












852












853



class XMLConfigTests(unittest.TestCase):




1✔





854












855



    def setUp(self):




1✔





856



        from zope.configuration.tests.samplepackage.foo import data




1✔





857



        from zope.configuration.xmlconfig import _clearContext




1✔





858



        _clearContext()




1✔





859



        del data[:]




1✔





860












861



    def tearDown(self):




1✔





862



        from zope.configuration.tests.samplepackage.foo import data




1✔





863



        from zope.configuration.xmlconfig import _clearContext




1✔





864



        _clearContext()




1✔





865



        del data[:]




1✔





866












867



    def _getTargetClass(self):




1✔





868



        from zope.configuration.xmlconfig import XMLConfig




1✔





869



        return XMLConfig




1✔





870












871



    def _makeOne(self, *args, **kw):




1✔





872



        return self._getTargetClass()(*args, **kw)




1✔





873












874



    def test_ctor_w_global_context_missing(self):




1✔





875



        import os




1✔





876












877



        from zope.configuration import xmlconfig




1✔





878



        from zope.configuration.tests.samplepackage import foo




1✔





879



        here = os.path.dirname(__file__)




1✔





880



        path = os.path.join(here, "samplepackage", "configure.zcml")




1✔





881



        logger = LoggerStub()




1✔





882



        xmlconfig._context = None




1✔





883



        with _Monkey(xmlconfig, logger=logger):




1✔





884



            xc = self._makeOne(path)




1✔





885



        self.assertEqual(len(logger.debugs), 1)




1✔





886



        self.assertEqual(logger.debugs[0], ('include %s', (path,), {}))




1✔





887



        self.assertEqual(len(foo.data), 0)  # no execut_actions




1✔





888



        self.assertEqual(len(xc.context.actions), 1)




1✔





889



        action = xc.context.actions[0]




1✔





890



        self.assertEqual(action['discriminator'],




1✔





891



                         (('x', (b'blah')), ('y', 0)))










892



        self.assertEqual(action['callable'], foo.data.append)




1✔





893












894



    def test_ctor(self):




1✔





895



        from zope.configuration import xmlconfig




1✔





896



        from zope.configuration.tests import samplepackage




1✔





897



        from zope.configuration.tests.samplepackage import foo




1✔





898



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





899



        logger = LoggerStub()




1✔





900



        with _Monkey(xmlconfig, logger=logger):




1✔





901



            xc = self._makeOne(fqn)




1✔





902



        self.assertEqual(len(logger.debugs), 1)




1✔





903



        self.assertEqual(logger.debugs[0], ('include %s', (fqn,), {}))




1✔





904



        self.assertEqual(len(foo.data), 0)  # no execut_actions




1✔





905



        self.assertEqual(len(xc.context.actions), 1)




1✔





906



        action = xc.context.actions[0]




1✔





907



        self.assertEqual(action['discriminator'],




1✔





908



                         (('x', (b'blah')), ('y', 0)))










909



        self.assertEqual(action['callable'], foo.data.append)




1✔





910












911



    def test_ctor_w_module(self):




1✔





912



        from zope.configuration import xmlconfig




1✔





913



        from zope.configuration.tests import samplepackage




1✔





914



        from zope.configuration.tests.samplepackage import foo




1✔





915



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





916



        logger = LoggerStub()




1✔





917



        with _Monkey(xmlconfig, logger=logger):




1✔





918



            xc = self._makeOne("configure.zcml", samplepackage)




1✔





919



        self.assertEqual(len(logger.debugs), 1)




1✔





920



        self.assertEqual(logger.debugs[0], ('include %s', (fqn,), {}))




1✔





921



        self.assertEqual(len(foo.data), 0)  # no execut_actions




1✔





922



        self.assertEqual(len(xc.context.actions), 1)




1✔





923



        action = xc.context.actions[0]




1✔





924



        self.assertEqual(action['discriminator'],




1✔





925



                         (('x', (b'blah')), ('y', 0)))










926



        self.assertEqual(action['callable'], foo.data.append)




1✔





927












928



    def test___call__(self):




1✔





929



        import os




1✔





930












931



        from zope.configuration import xmlconfig




1✔





932



        from zope.configuration.tests import samplepackage




1✔





933



        from zope.configuration.tests.samplepackage import foo




1✔





934



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





935



        logger = LoggerStub()




1✔





936



        with _Monkey(xmlconfig, logger=logger):




1✔





937



            xc = self._makeOne(fqn)




1✔





938



        self.assertEqual(len(logger.debugs), 1)




1✔





939



        self.assertEqual(logger.debugs[0], ('include %s', (fqn,), {}))




1✔





940



        self.assertEqual(len(foo.data), 0)




1✔





941



        xc()  # call to process the actions




1✔





942



        self.assertEqual(len(foo.data), 1)




1✔





943



        data = foo.data.pop(0)




1✔





944



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





945



        self.assertTrue(




1✔





946



            data.info.file.endswith(










947



                os.path.normpath('tests/samplepackage/configure.zcml')))










948



        self.assertEqual(data.info.line, 12)




1✔





949



        self.assertEqual(data.info.column, 2)




1✔





950



        self.assertEqual(data.info.eline, 12)




1✔





951



        self.assertEqual(data.info.ecolumn, 29)




1✔





952












953












954



class Test_xmlconfig(unittest.TestCase):




1✔





955












956



    def setUp(self):




1✔





957



        from zope.configuration.tests.samplepackage.foo import data




1✔





958



        from zope.configuration.xmlconfig import _clearContext




1✔





959



        _clearContext()




1✔





960



        del data[:]




1✔





961












962



    def tearDown(self):




1✔





963



        from zope.configuration.tests.samplepackage.foo import data




1✔





964



        from zope.configuration.xmlconfig import _clearContext




1✔





965



        _clearContext()




1✔





966



        del data[:]




1✔





967












968



    def _callFUT(self, *args, **kw):




1✔





969



        from zope.configuration.xmlconfig import xmlconfig




1✔





970



        return xmlconfig(*args, **kw)




1✔





971












972



    def test_wo_testing_passed(self):




1✔





973



        import os




1✔





974












975



        from zope.configuration import xmlconfig




1✔





976



        from zope.configuration.tests import samplepackage




1✔





977



        from zope.configuration.tests.samplepackage import foo




1✔





978












979



        def _assertTestingFalse(func):




1✔





980



            def _wrapper(*args, **kw):




1✔





981



                assert not kw['testing']




1✔





982



                return func(*args, **kw)




1✔





983



            return _wrapper




1✔





984



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





985



        context = xmlconfig._getContext()




1✔





986



        context.execute_actions = _assertTestingFalse(context.execute_actions)




1✔





987



        with _Monkey(xmlconfig,




1✔





988



                     processxmlfile=_assertTestingFalse(










989



                         xmlconfig.processxmlfile)):










990



            self._callFUT(open(fqn), False)




1✔





991



        self.assertEqual(len(foo.data), 1)




1✔





992



        data = foo.data.pop(0)




1✔





993



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





994



        self.assertTrue(




1✔





995



            data.info.file.endswith(










996



                os.path.normpath('tests/samplepackage/configure.zcml')))










997



        self.assertEqual(data.info.line, 12)




1✔





998



        self.assertEqual(data.info.column, 2)




1✔





999



        self.assertEqual(data.info.eline, 12)




1✔





1000



        self.assertEqual(data.info.ecolumn, 29)




1✔





1001












1002



    def test_w_testing_passed(self):




1✔





1003



        import os




1✔





1004












1005



        from zope.configuration import xmlconfig




1✔





1006



        from zope.configuration.tests import samplepackage




1✔





1007



        from zope.configuration.tests.samplepackage import foo




1✔





1008












1009



        def _assertTestingTrue(func):




1✔





1010



            def _wrapper(*args, **kw):




1✔





1011



                assert kw['testing']




1✔





1012



                return func(*args, **kw)




1✔





1013



            return _wrapper




1✔





1014



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





1015



        context = xmlconfig._getContext()




1✔





1016



        context.execute_actions = _assertTestingTrue(context.execute_actions)




1✔





1017



        with _Monkey(xmlconfig,




1✔





1018



                     processxmlfile=_assertTestingTrue(










1019



                         xmlconfig.processxmlfile)):










1020



            self._callFUT(open(fqn), True)




1✔





1021



        self.assertEqual(len(foo.data), 1)




1✔





1022



        data = foo.data.pop(0)




1✔





1023



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





1024



        self.assertTrue(




1✔





1025



            data.info.file.endswith(










1026



                os.path.normpath('tests/samplepackage/configure.zcml')))










1027



        self.assertEqual(data.info.line, 12)




1✔





1028



        self.assertEqual(data.info.column, 2)




1✔





1029



        self.assertEqual(data.info.eline, 12)




1✔





1030



        self.assertEqual(data.info.ecolumn, 29)




1✔





1031












1032












1033



class Test_testxmlconfig(unittest.TestCase):




1✔





1034












1035



    def setUp(self):




1✔





1036



        from zope.configuration.tests.samplepackage.foo import data




1✔





1037



        from zope.configuration.xmlconfig import _clearContext




1✔





1038



        _clearContext()




1✔





1039



        del data[:]




1✔





1040












1041



    def tearDown(self):




1✔





1042



        from zope.configuration.tests.samplepackage.foo import data




1✔





1043



        from zope.configuration.xmlconfig import _clearContext




1✔





1044



        _clearContext()




1✔





1045



        del data[:]




1✔





1046












1047



    def _callFUT(self, *args, **kw):




1✔





1048



        from zope.configuration.xmlconfig import testxmlconfig




1✔





1049



        return testxmlconfig(*args, **kw)




1✔





1050












1051



    def test_w_testing_passed(self):




1✔





1052



        import os




1✔





1053












1054



        from zope.configuration import xmlconfig




1✔





1055



        from zope.configuration.tests import samplepackage




1✔





1056



        from zope.configuration.tests.samplepackage import foo




1✔





1057












1058



        def _assertTestingTrue(func):




1✔





1059



            def _wrapper(*args, **kw):




1✔





1060



                assert kw['testing']




1✔





1061



                return func(*args, **kw)




1✔





1062



            return _wrapper




1✔





1063



        fqn = _packageFile(samplepackage, 'configure.zcml')




1✔





1064



        context = xmlconfig._getContext()




1✔





1065



        context.execute_actions = _assertTestingTrue(context.execute_actions)




1✔





1066



        with _Monkey(xmlconfig,




1✔





1067



                     processxmlfile=_assertTestingTrue(










1068



                         xmlconfig.processxmlfile)):










1069



            self._callFUT(open(fqn))




1✔





1070



        self.assertEqual(len(foo.data), 1)




1✔





1071



        data = foo.data.pop(0)




1✔





1072



        self.assertEqual(data.args, (('x', (b'blah')), ('y', 0)))




1✔





1073



        self.assertTrue(




1✔





1074



            data.info.file.endswith(










1075



                os.path.normpath('tests/samplepackage/configure.zcml')))










1076



        self.assertEqual(data.info.line, 12)




1✔





1077



        self.assertEqual(data.info.column, 2)




1✔





1078



        self.assertEqual(data.info.eline, 12)




1✔





1079



        self.assertEqual(data.info.ecolumn, 29)




1✔





1080












1081












1082



class FauxLocator:




1✔





1083



    def __init__(self, file, line, column):




1✔





1084



        self.file, self.line, self.column = file, line, column




1✔





1085












1086



    def getSystemId(self):




1✔





1087



        return self.file




1✔





1088












1089



    def getLineNumber(self):




1✔





1090



        return self.line




1✔





1091












1092



    def getColumnNumber(self):




1✔





1093



        return self.column




1✔





1094












1095












1096



class FauxContext:




1✔





1097



    includepath = ()




1✔





1098



    _features = ()




1✔





1099



    _end_called = False




1✔





1100












1101



    def setInfo(self, info):




1✔





1102



        self.info = info




1✔





1103












1104



    def getInfo(self):




1✔





1105



        return self.info




1✔





1106












1107



    def begin(self, name, data, info):




1✔





1108



        self.begin_args = name, data




1✔





1109



        self.info = info




1✔





1110












1111



    def end(self):




1✔





1112



        self._end_called = 1




1✔





1113












1114



    def hasFeature(self, feature):




1✔





1115



        return feature in self._features




1✔





1116












1117












1118



def path(*p):




1✔





1119



    import os




1✔





1120



    return os.path.join(os.path.dirname(__file__), *p)




1✔





1121












1122












1123



def clean_info_path(s):




1✔





1124



    import os




1✔





1125



    part1 = s[:6]




1✔





1126



    part2 = s[6:s.find('"', 6)]




1✔





1127



    part2 = part2[part2.rfind("tests"):]




1✔





1128



    part2 = part2.replace(os.sep, '/')




1✔





1129



    part3 = s[s.find('"', 6):].rstrip()




1✔





1130



    return part1 + part2 + part3




1✔





1131












1132












1133



def clean_path(s):




1✔





1134



    import os




1✔





1135



    s = s[s.rfind("tests"):]




1✔





1136



    s = s.replace(os.sep, '/')




1✔





1137



    return s




1✔





1138












1139












1140



def clean_actions(actions):




1✔





1141



    return [




1✔





1142



        {










1143



            'discriminator': action['discriminator'],










1144



            'info': clean_info_path(repr(action['info'])),










1145



            'includepath': [clean_path(p) for p in action['includepath']],










1146



        }










1147



        for action in actions










1148



    ]










1149












1150












1151



def clean_text_w_paths(error):




1✔





1152



    r = []




1✔





1153



    for line in str(error).split("\n"):





1✔





1154



        line = line.rstrip()




1✔





1155



        if not line:





1✔





1156



            continue




1✔





1157



        l_ = line.find('File "')




1✔





1158



        if l_ >= 0:





1✔





1159



            line = line[:l_] + clean_info_path(line[l_:])




1✔





1160



        r.append(line)




1✔





1161



    return '\n'.join(r)




1✔





1162












1163












1164



def _packageFile(package, filename):




1✔





1165



    import os




1✔





1166



    return os.path.join(os.path.dirname(package.__file__), filename)




1✔





1167












1168












1169



class _Monkey:




1✔





1170












1171



    def __init__(self, module, **replacements):




1✔





1172



        self.module = module




1✔





1173



        self.orig = {}




1✔





1174



        self.replacements = replacements




1✔





1175












1176



    def __enter__(self):




1✔





1177



        for k, v in self.replacements.items():





1✔





1178



            orig = getattr(self.module, k, self)




1✔





1179



            if orig is not self:





1!





1180



                self.orig[k] = orig




1✔





1181



            setattr(self.module, k, v)




1✔





1182












1183



    def __exit__(self, *exc_info):




1✔





1184



        for k in self.replacements:





1✔





1185



            if k in self.orig:




1✔





1186



                setattr(self.module, k, self.orig[k])




1✔





1187



            else:  # pragma: no cover










1188



                delattr(self.module, k)










1189












1190












1191



class LoggerStub:




1✔





1192












1193



    debugs = errors = warnings = infos = ()




1✔





1194












1195



    def __init__(self):




1✔





1196



        def make_append(lst):




1✔





1197



            return lambda msg, *args, **kwargs: lst.append((msg, args, kwargs))




1✔





1198












1199



        for name in 'error', 'warning', 'info', 'debug':





1✔





1200



            lst = []




1✔





1201



            setattr(self, name + 's', lst)




1✔





1202












1203



            func = make_append(lst)




1✔





1204



            setattr(self, name, func)




1✔



















    

  • 

    •