Merge pull request #3388 from mmerickel/black

Michael Merickel

2018-10-15 bda1306749c62ef4f11cfe567ed7d56c8ad94240

 tests/test_path.py

@@ -4,14 +4,17 @@

here = os.path.abspath(os.path.dirname(__file__))


class TestCallerPath(unittest.TestCase):
    def tearDown(self):
        from . import test_path

        if hasattr(test_path, '__abspath__'):
            del test_path.__abspath__

    def _callFUT(self, path, level=2):
        from pyramid.path import caller_path

        return caller_path(path, level)

    def test_isabs(self):
@@ -20,12 +23,14 @@

    def test_pkgrelative(self):
        import os

        result = self._callFUT('a/b/c')
        self.assertEqual(result, os.path.join(here, 'a/b/c'))

    def test_memoization_has_abspath(self):
        import os
        from . import test_path

        test_path.__abspath__ = '/foo/bar'
        result = self._callFUT('a/b/c')
        self.assertEqual(result, os.path.join('/foo/bar', 'a/b/c'))
@@ -33,37 +38,46 @@
    def test_memoization_success(self):
        import os
        from . import test_path

        result = self._callFUT('a/b/c')
        self.assertEqual(result, os.path.join(here, 'a/b/c'))
        self.assertEqual(test_path.__abspath__, here)


class TestCallerModule(unittest.TestCase):
    def _callFUT(self, *arg, **kw):
        from pyramid.path import caller_module

        return caller_module(*arg, **kw)

    def test_it_level_1(self):
        from . import test_path

        result = self._callFUT(1)
        self.assertEqual(result, test_path)

    def test_it_level_2(self):
        from . import test_path

        result = self._callFUT(2)
        self.assertEqual(result, test_path)

    def test_it_level_3(self):
        from . import test_path

        result = self._callFUT(3)
        self.assertNotEqual(result, test_path)

    def test_it_no___name__(self):
        class DummyFrame(object):
            f_globals = {}

        class DummySys(object):
            def _getframe(self, level):
                return DummyFrame()
            modules = {'__main__':'main'}

            modules = {'__main__': 'main'}

        dummy_sys = DummySys()
        result = self._callFUT(3, sys=dummy_sys)
        self.assertEqual(result, 'main')
@@ -72,67 +86,82 @@
class TestCallerPackage(unittest.TestCase):
    def _callFUT(self, *arg, **kw):
        from pyramid.path import caller_package

        return caller_package(*arg, **kw)

    def test_it_level_1(self):
        import tests

        result = self._callFUT(1)
        self.assertEqual(result, tests)

    def test_it_level_2(self):
        import tests

        result = self._callFUT(2)
        self.assertEqual(result, tests)

    def test_it_level_3(self):
        import unittest

        result = self._callFUT(3)
        self.assertEqual(result, unittest)

    def test_it_package(self):
        import tests

        def dummy_caller_module(*arg):
            return tests

        result = self._callFUT(1, caller_module=dummy_caller_module)
        self.assertEqual(result, tests)
        


class TestPackagePath(unittest.TestCase):
    def _callFUT(self, package):
        from pyramid.path import package_path

        return package_path(package)

    def test_it_package(self):
        import tests

        package = DummyPackageOrModule(tests)
        result = self._callFUT(package)
        self.assertEqual(result, package.package_path)
        

    def test_it_module(self):
        from . import test_path

        module = DummyPackageOrModule(test_path)
        result = self._callFUT(module)
        self.assertEqual(result, module.package_path)

    def test_memoization_success(self):
        from . import test_path

        module = DummyPackageOrModule(test_path)
        self._callFUT(module)
        self.assertEqual(module.__abspath__, module.package_path)
        

    def test_memoization_fail(self):
        from . import test_path

        module = DummyPackageOrModule(test_path, raise_exc=TypeError)
        result = self._callFUT(module)
        self.assertFalse(hasattr(module, '__abspath__'))
        self.assertEqual(result, module.package_path)


class TestPackageOf(unittest.TestCase):
    def _callFUT(self, package):
        from pyramid.path import package_of

        return package_of(package)

    def test_it_package(self):
        import tests

        package = DummyPackageOrModule(tests)
        result = self._callFUT(package)
        self.assertEqual(result, tests)
@@ -140,29 +169,35 @@
    def test_it_module(self):
        import tests.test_path
        import tests

        package = DummyPackageOrModule(tests.test_path)
        result = self._callFUT(package)
        self.assertEqual(result, tests)


class TestPackageName(unittest.TestCase):
    def _callFUT(self, package):
        from pyramid.path import package_name

        return package_name(package)

    def test_it_package(self):
        import tests

        package = DummyPackageOrModule(tests)
        result = self._callFUT(package)
        self.assertEqual(result, 'tests')

    def test_it_namespace_package(self):
        import tests

        package = DummyNamespacePackage(tests)
        result = self._callFUT(package)
        self.assertEqual(result, 'tests')
        

    def test_it_module(self):
        from . import test_path

        module = DummyPackageOrModule(test_path)
        result = self._callFUT(module)
        self.assertEqual(result, 'tests')
@@ -173,12 +208,15 @@

    def test_it_main(self):
        import __main__

        result = self._callFUT(__main__)
        self.assertEqual(result, '__main__')


class TestResolver(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.path import Resolver

        return Resolver

    def _makeOne(self, package):
@@ -187,26 +225,29 @@
    def test_get_package_caller_package(self):
        import tests
        from pyramid.path import CALLER_PACKAGE
        self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package(),
                         tests)

        self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package(), tests)

    def test_get_package_name_caller_package(self):
        from pyramid.path import CALLER_PACKAGE
        self.assertEqual(self._makeOne(CALLER_PACKAGE).get_package_name(),
                         'tests')

        self.assertEqual(
            self._makeOne(CALLER_PACKAGE).get_package_name(), 'tests'
        )

    def test_get_package_string(self):
        import tests
        self.assertEqual(self._makeOne('tests').get_package(),
                         tests)

        self.assertEqual(self._makeOne('tests').get_package(), tests)

    def test_get_package_name_string(self):
        self.assertEqual(self._makeOne('tests').get_package_name(),
                         'tests')
        self.assertEqual(self._makeOne('tests').get_package_name(), 'tests')


class TestAssetResolver(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.path import AssetResolver

        return AssetResolver

    def _makeOne(self, package='tests'):
@@ -214,18 +255,21 @@

    def test_ctor_as_package(self):
        import sys

        tests = sys.modules['tests']
        inst = self._makeOne(tests)
        self.assertEqual(inst.package, tests)

    def test_ctor_as_str(self):
        import sys

        tests = sys.modules['tests']
        inst = self._makeOne('tests')
        self.assertEqual(inst.package, tests)

    def test_resolve_abspath(self):
        from pyramid.path import FSAssetDescriptor

        inst = self._makeOne(None)
        r = inst.resolve(os.path.join(here, 'test_asset.py'))
        self.assertEqual(r.__class__, FSAssetDescriptor)
@@ -233,6 +277,7 @@

    def test_resolve_absspec(self):
        from pyramid.path import PkgResourcesAssetDescriptor

        inst = self._makeOne(None)
        r = inst.resolve('tests:test_asset.py')
        self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
@@ -240,6 +285,7 @@

    def test_resolve_relspec_with_pkg(self):
        from pyramid.path import PkgResourcesAssetDescriptor

        inst = self._makeOne('tests')
        r = inst.resolve('test_asset.py')
        self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
@@ -252,14 +298,17 @@
    def test_resolve_relspec_caller_package(self):
        from pyramid.path import PkgResourcesAssetDescriptor
        from pyramid.path import CALLER_PACKAGE

        inst = self._makeOne(CALLER_PACKAGE)
        r = inst.resolve('test_asset.py')
        self.assertEqual(r.__class__, PkgResourcesAssetDescriptor)
        self.assertTrue(r.exists())
        


class TestPkgResourcesAssetDescriptor(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.path import PkgResourcesAssetDescriptor

        return PkgResourcesAssetDescriptor

    def _makeOne(self, pkg='tests', path='test_asset.py'):
@@ -268,11 +317,13 @@
    def test_class_conforms_to_IAssetDescriptor(self):
        from pyramid.interfaces import IAssetDescriptor
        from zope.interface.verify import verifyClass

        verifyClass(IAssetDescriptor, self._getTargetClass())
        

    def test_instance_conforms_to_IAssetDescriptor(self):
        from pyramid.interfaces import IAssetDescriptor
        from zope.interface.verify import verifyObject

        verifyObject(IAssetDescriptor, self._makeOne())

    def test_absspec(self):
@@ -288,33 +339,31 @@
        inst.pkg_resources = DummyPkgResource()
        inst.pkg_resources.resource_stream = lambda x, y: '%s:%s' % (x, y)
        s = inst.stream()
        self.assertEqual(s,
                         '%s:%s' % ('tests', 'test_asset.py'))
        self.assertEqual(s, '%s:%s' % ('tests', 'test_asset.py'))

    def test_isdir(self):
        inst = self._makeOne()
        inst.pkg_resources = DummyPkgResource()
        inst.pkg_resources.resource_isdir = lambda x, y: '%s:%s' % (x, y)
        self.assertEqual(inst.isdir(),
                         '%s:%s' % ('tests', 'test_asset.py'))
        self.assertEqual(inst.isdir(), '%s:%s' % ('tests', 'test_asset.py'))

    def test_listdir(self):
        inst = self._makeOne()
        inst.pkg_resources = DummyPkgResource()
        inst.pkg_resources.resource_listdir = lambda x, y: '%s:%s' % (x, y)
        self.assertEqual(inst.listdir(),
                         '%s:%s' % ('tests', 'test_asset.py'))
        self.assertEqual(inst.listdir(), '%s:%s' % ('tests', 'test_asset.py'))

    def test_exists(self):
        inst = self._makeOne()
        inst.pkg_resources = DummyPkgResource()
        inst.pkg_resources.resource_exists = lambda x, y: '%s:%s' % (x, y)
        self.assertEqual(inst.exists(),
                         '%s:%s' % ('tests', 'test_asset.py'))
        self.assertEqual(inst.exists(), '%s:%s' % ('tests', 'test_asset.py'))


class TestFSAssetDescriptor(unittest.TestCase):
    def _getTargetClass(self):
        from pyramid.path import FSAssetDescriptor

        return FSAssetDescriptor

    def _makeOne(self, path=os.path.join(here, 'test_asset.py')):
@@ -323,11 +372,13 @@
    def test_class_conforms_to_IAssetDescriptor(self):
        from pyramid.interfaces import IAssetDescriptor
        from zope.interface.verify import verifyClass

        verifyClass(IAssetDescriptor, self._getTargetClass())
        

    def test_instance_conforms_to_IAssetDescriptor(self):
        from pyramid.interfaces import IAssetDescriptor
        from zope.interface.verify import verifyObject

        verifyObject(IAssetDescriptor, self._makeOne())

    def test_absspec(self):
@@ -361,9 +412,11 @@
        inst = self._makeOne()
        self.assertTrue(inst.exists())


class TestDottedNameResolver(unittest.TestCase):
    def _makeOne(self, package=None):
        from pyramid.path import DottedNameResolver

        return DottedNameResolver(package)

    def config_exc(self, func, *arg, **kw):
@@ -372,7 +425,7 @@
        except ValueError as e:
            return e
        else:
            raise AssertionError('Invalid not raised') # pragma: no cover
            raise AssertionError('Invalid not raised')  # pragma: no cover

    def test_zope_dottedname_style_resolve_builtin(self):
        typ = self._makeOne()
@@ -385,30 +438,40 @@
    def test_zope_dottedname_style_resolve_absolute(self):
        typ = self._makeOne()
        result = typ._zope_dottedname_style(
            'tests.test_path.TestDottedNameResolver', None)
            'tests.test_path.TestDottedNameResolver', None
        )
        self.assertEqual(result, self.__class__)

    def test_zope_dottedname_style_irrresolveable_absolute(self):
        typ = self._makeOne()
        self.assertRaises(ImportError, typ._zope_dottedname_style,
            'pyramid.test_path.nonexisting_name', None)
        self.assertRaises(
            ImportError,
            typ._zope_dottedname_style,
            'pyramid.test_path.nonexisting_name',
            None,
        )

    def test__zope_dottedname_style_resolve_relative(self):
        import tests

        typ = self._makeOne()
        result = typ._zope_dottedname_style(
            '.test_path.TestDottedNameResolver', tests)
            '.test_path.TestDottedNameResolver', tests
        )
        self.assertEqual(result, self.__class__)

    def test__zope_dottedname_style_resolve_relative_leading_dots(self):
        import tests.test_path

        typ = self._makeOne()
        result = typ._zope_dottedname_style(
            '..tests.test_path.TestDottedNameResolver', tests)
            '..tests.test_path.TestDottedNameResolver', tests
        )
        self.assertEqual(result, self.__class__)

    def test__zope_dottedname_style_resolve_relative_is_dot(self):
        import tests

        typ = self._makeOne()
        result = typ._zope_dottedname_style('.', tests)
        self.assertEqual(result, tests)
@@ -417,24 +480,28 @@
        typ = self._makeOne()
        e = self.config_exc(typ._zope_dottedname_style, '.', None)
        self.assertEqual(
            e.args[0],
            "relative name '.' irresolveable without package")
            e.args[0], "relative name '.' irresolveable without package"
        )

    def test_zope_dottedname_style_resolve_relative_nocurrentpackage(self):
        typ = self._makeOne()
        e = self.config_exc(typ._zope_dottedname_style, '.whatever', None)
        self.assertEqual(
            e.args[0],
            "relative name '.whatever' irresolveable without package")
            "relative name '.whatever' irresolveable without package",
        )

    def test_zope_dottedname_style_irrresolveable_relative(self):
        import tests

        typ = self._makeOne()
        self.assertRaises(ImportError, typ._zope_dottedname_style,
                          '.notexisting', tests)
        self.assertRaises(
            ImportError, typ._zope_dottedname_style, '.notexisting', tests
        )

    def test__zope_dottedname_style_resolveable_relative(self):
        import tests

        typ = self._makeOne()
        result = typ._zope_dottedname_style('.', tests)
        self.assertEqual(result, tests)
@@ -442,49 +509,58 @@
    def test__zope_dottedname_style_irresolveable_absolute(self):
        typ = self._makeOne()
        self.assertRaises(
            ImportError,
            typ._zope_dottedname_style, 'pyramid.fudge.bar', None)
            ImportError, typ._zope_dottedname_style, 'pyramid.fudge.bar', None
        )

    def test__zope_dottedname_style_resolveable_absolute(self):
        typ = self._makeOne()
        result = typ._zope_dottedname_style(
            'tests.test_path.TestDottedNameResolver', None)
            'tests.test_path.TestDottedNameResolver', None
        )
        self.assertEqual(result, self.__class__)

    def test__pkg_resources_style_resolve_absolute(self):
        typ = self._makeOne()
        result = typ._pkg_resources_style(
            'tests.test_path:TestDottedNameResolver', None)
            'tests.test_path:TestDottedNameResolver', None
        )
        self.assertEqual(result, self.__class__)

    def test__pkg_resources_style_irrresolveable_absolute(self):
        typ = self._makeOne()
        self.assertRaises(ImportError, typ._pkg_resources_style,
            'tests:nonexisting', None)
        self.assertRaises(
            ImportError, typ._pkg_resources_style, 'tests:nonexisting', None
        )

    def test__pkg_resources_style_resolve_relative(self):
        import tests

        typ = self._makeOne()
        result = typ._pkg_resources_style(
            '.test_path:TestDottedNameResolver', tests)
            '.test_path:TestDottedNameResolver', tests
        )
        self.assertEqual(result, self.__class__)

    def test__pkg_resources_style_resolve_relative_is_dot(self):
        import tests

        typ = self._makeOne()
        result = typ._pkg_resources_style('.', tests)
        self.assertEqual(result, tests)

    def test__pkg_resources_style_resolve_relative_nocurrentpackage(self):
        typ = self._makeOne()
        self.assertRaises(ValueError, typ._pkg_resources_style,
                          '.whatever', None)
        self.assertRaises(
            ValueError, typ._pkg_resources_style, '.whatever', None
        )

    def test__pkg_resources_style_irrresolveable_relative(self):
        import pyramid

        typ = self._makeOne()
        self.assertRaises(ImportError, typ._pkg_resources_style,
                          ':notexisting', pyramid)
        self.assertRaises(
            ImportError, typ._pkg_resources_style, ':notexisting', pyramid
        )

    def test_resolve_not_a_string(self):
        typ = self._makeOne()
@@ -493,14 +569,12 @@

    def test_resolve_using_pkgresources_style(self):
        typ = self._makeOne()
        result = typ.resolve(
            'tests.test_path:TestDottedNameResolver')
        result = typ.resolve('tests.test_path:TestDottedNameResolver')
        self.assertEqual(result, self.__class__)

    def test_resolve_using_zope_dottedname_style(self):
        typ = self._makeOne()
        result = typ.resolve(
            'tests.test_path:TestDottedNameResolver')
        result = typ.resolve('tests.test_path:TestDottedNameResolver')
        self.assertEqual(result, self.__class__)

    def test_resolve_missing_raises(self):
@@ -509,23 +583,30 @@

    def test_resolve_caller_package(self):
        from pyramid.path import CALLER_PACKAGE

        typ = self._makeOne(CALLER_PACKAGE)
        self.assertEqual(typ.resolve('.test_path.TestDottedNameResolver'),
                         self.__class__)
        self.assertEqual(
            typ.resolve('.test_path.TestDottedNameResolver'), self.__class__
        )

    def test_maybe_resolve_caller_package(self):
        from pyramid.path import CALLER_PACKAGE

        typ = self._makeOne(CALLER_PACKAGE)
        self.assertEqual(typ.maybe_resolve('.test_path.TestDottedNameResolver'),
                         self.__class__)
        self.assertEqual(
            typ.maybe_resolve('.test_path.TestDottedNameResolver'),
            self.__class__,
        )

    def test_ctor_string_module_resolveable(self):
        import tests

        typ = self._makeOne('tests.test_path')
        self.assertEqual(typ.package, tests)

    def test_ctor_string_package_resolveable(self):
        import tests

        typ = self._makeOne('tests')
        self.assertEqual(typ.package, tests)

@@ -535,11 +616,13 @@
    def test_ctor_module(self):
        import tests
        from . import test_path

        typ = self._makeOne(test_path)
        self.assertEqual(typ.package, tests)

    def test_ctor_package(self):
        import tests

        typ = self._makeOne(tests)
        self.assertEqual(typ.package, tests)

@@ -547,16 +630,20 @@
        typ = self._makeOne(None)
        self.assertEqual(typ.package, None)


class DummyPkgResource(object):
    pass


class DummyPackageOrModule:
    def __init__(self, real_package_or_module, raise_exc=None):
        self.__dict__['raise_exc'] = raise_exc
        self.__dict__['__name__'] = real_package_or_module.__name__
        import os

        self.__dict__['package_path'] = os.path.dirname(
            os.path.abspath(real_package_or_module.__file__))
            os.path.abspath(real_package_or_module.__file__)
        )
        self.__dict__['__file__'] = real_package_or_module.__file__

    def __setattr__(self, key, val):
@@ -564,12 +651,15 @@
            raise self.raise_exc
        self.__dict__[key] = val


class DummyNamespacePackage:
    """Has no __file__ attribute.
    """
    

    def __init__(self, real_package_or_module):
        self.__name__ = real_package_or_module.__name__
        import os

        self.package_path = os.path.dirname(
            os.path.abspath(real_package_or_module.__file__))
            os.path.abspath(real_package_or_module.__file__)
        )