zope.pytestlayer 8.2__py3-none-any.whl

zope/pytestlayer/tests/fixture/keep_layer_across_test_classes/test_core.py

@@ -0,0 +1,101 @@
+import unittest
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+class BarLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_bar = 'layer bar'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_bar
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp bar')
+        cls.test_bar = 'test bar'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown bar')
+        del cls.test_bar
+
+
+class FooBarLayer(FooLayer, BarLayer):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foobar = 'layer foobar'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foobar
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foobar')
+        cls.test_foobar = 'test foobar'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foobar')
+        del cls.test_foobar
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+        self.assertFalse(hasattr(self.layer, 'layer_bar'))
+        self.assertFalse(hasattr(self.layer, 'test_bar'))
+
+
+class FooBarTest(unittest.TestCase):
+
+    layer = FooBarLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)
+        self.assertEqual('layer foobar', self.layer.layer_foobar)
+        self.assertEqual('test foobar', self.layer.test_foobar)
+
+
+class BarTest(unittest.TestCase):
+
+    layer = BarLayer
+
+    def test_dummy(self):
+        self.assertFalse(hasattr(self.layer, 'layer_foo'))
+        self.assertFalse(hasattr(self.layer, 'test_foo'))
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)

zope/pytestlayer/tests/fixture/layers_with_same_name/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/layers_with_same_name/test_core.py

@@ -0,0 +1,40 @@
+import unittest
+
+
+class Layer(object):
+
+    def __init__(self, value, bases=()):
+        self.__name__ = 'TestLayer'
+        self.__bases__ = bases
+        self.value = value
+
+    def setUp(self):
+        self.set_up_value = self.value
+
+    def tearDown(self):
+        del self.set_up_value
+
+
+FooLayer = Layer('foo-layer')
+BarLayer = Layer('bar-layer')
+FooBarLayer = Layer('foobar-layer', bases=(FooLayer, BarLayer))
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('foo-layer', self.layer.set_up_value)
+
+
+class BarTest(unittest.TestCase):
+
+    layer = BarLayer
+
+    def test_dummy(self):
+        self.assertEqual('bar-layer', self.layer.set_up_value)
+
+
+del FooLayer
+del BarLayer

zope/pytestlayer/tests/fixture/no_setup_or_teardown/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/no_setup_or_teardown/test_core.py

@@ -0,0 +1,14 @@
+import unittest
+
+
+class FooLayer(object):
+    pass
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertFalse(hasattr(self.layer, 'layer_foo'))
+        self.assertFalse(hasattr(self.layer, 'test_foo'))

zope/pytestlayer/tests/fixture/order_by_layer/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/order_by_layer/test_core.py

@@ -0,0 +1,112 @@
+import unittest
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+class BarLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_bar = 'layer bar'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_bar
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp bar')
+        cls.test_bar = 'test bar'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown bar')
+        del cls.test_bar
+
+
+class FooBarLayer(FooLayer, BarLayer):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foobar = 'layer foobar'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foobar
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foobar')
+        cls.test_foobar = 'test foobar'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foobar')
+        del cls.test_foobar
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+        self.assertFalse(hasattr(self.layer, 'layer_bar'))
+        self.assertFalse(hasattr(self.layer, 'test_bar'))
+
+
+class BarTest(unittest.TestCase):
+
+    layer = BarLayer
+
+    def test_dummy(self):
+        self.assertFalse(hasattr(self.layer, 'layer_foo'))
+        self.assertFalse(hasattr(self.layer, 'test_foo'))
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)
+
+
+class FooBarTest(unittest.TestCase):
+
+    layer = FooBarLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)
+        self.assertEqual('layer foobar', self.layer.layer_foobar)
+        self.assertEqual('test foobar', self.layer.test_foobar)
+
+
+class Bar2Test(unittest.TestCase):
+
+    layer = BarLayer
+
+    def test_dummy(self):
+        self.assertFalse(hasattr(self.layer, 'layer_foo'))
+        self.assertFalse(hasattr(self.layer, 'test_foo'))
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)

zope/pytestlayer/tests/fixture/order_with_layered_suite/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/order_with_layered_suite/foo.txt

@@ -0,0 +1,14 @@
+Test layered suite
+------------------
+
+    >>> layer
+    <class 'order_with_layered_suite.test_core.FooLayer'>
+
+    >>> layer.layer_foo
+    'layer foo'
+    >>> layer.test_foo
+    'test foo'
+    >>> hasattr(layer, 'layer_bar')
+    False
+    >>> hasattr(layer, 'test_bar')
+    False

zope/pytestlayer/tests/fixture/order_with_layered_suite/foobar.txt

@@ -0,0 +1,14 @@
+Test layered suite
+------------------
+
+    >>> layer
+    <class 'order_with_layered_suite.test_core.FooBarLayer'>
+
+    >>> layer.layer_foo
+    'layer foo'
+    >>> layer.test_foo
+    'test foo'
+    >>> layer.layer_bar
+    'layer bar'
+    >>> layer.test_bar
+    'test bar'

zope/pytestlayer/tests/fixture/order_with_layered_suite/test_core.py

@@ -0,0 +1,139 @@
+import doctest
+import unittest
+
+from plone.testing import layered
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+class BarLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_bar = 'layer bar'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_bar
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp bar')
+        cls.test_bar = 'test bar'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown bar')
+        del cls.test_bar
+
+
+class FooBarLayer(FooLayer, BarLayer):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foobar = 'layer foobar'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foobar
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foobar')
+        cls.test_foobar = 'test foobar'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foobar')
+        del cls.test_foobar
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+        self.assertFalse(hasattr(self.layer, 'layer_bar'))
+        self.assertFalse(hasattr(self.layer, 'test_bar'))
+
+
+class BarTest(unittest.TestCase):
+
+    layer = BarLayer
+
+    def test_dummy(self):
+        self.assertFalse(hasattr(self.layer, 'layer_foo'))
+        self.assertFalse(hasattr(self.layer, 'test_foo'))
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)
+
+
+class FooBarTest(unittest.TestCase):
+
+    layer = FooBarLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)
+        self.assertEqual('layer foobar', self.layer.layer_foobar)
+        self.assertEqual('test foobar', self.layer.test_foobar)
+
+
+class Bar2Test(unittest.TestCase):
+
+    layer = BarLayer
+
+    def test_dummy(self):
+        self.assertFalse(hasattr(self.layer, 'layer_foo'))
+        self.assertFalse(hasattr(self.layer, 'test_foo'))
+        self.assertEqual('layer bar', self.layer.layer_bar)
+        self.assertEqual('test bar', self.layer.test_bar)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+
+    OPTIONFLAGS = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
+
+    suite.addTests([
+        layered(
+            doctest.DocFileSuite(
+                'foo.txt',
+                optionflags=OPTIONFLAGS,
+            ),
+            layer=FooLayer,
+        ),
+        layered(
+            doctest.DocFileSuite(
+                'foobar.txt',
+                optionflags=OPTIONFLAGS,
+            ),
+            layer=FooBarLayer,
+        ),
+    ])
+    return suite

zope/pytestlayer/tests/fixture/session_fixture/conftest.py

@@ -0,0 +1,13 @@
+from session_fixture.test_core import FooLayer
+
+import zope.pytestlayer.fixture
+
+
+pytest_plugins = ('zopelayer', )
+
+
+globals().update(zope.pytestlayer.fixture.create(
+    FooLayer,
+    session_fixture_name='foo_layer_session',
+    class_fixture_name='foo_layer_class',
+    function_fixture_name='foo_layer'))

zope/pytestlayer/tests/fixture/session_fixture/test_core.py

@@ -0,0 +1,37 @@
+import unittest
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+def test_can_access_layer_via_fixture(foo_layer_session):
+    assert 'layer foo' == foo_layer_session.layer_foo
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_accesses_fixture_with_generated_name_for_layer(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)

zope/pytestlayer/tests/fixture/shared_with_layered_suite/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer',)

zope/pytestlayer/tests/fixture/shared_with_layered_suite/mydoctest.txt

@@ -0,0 +1,10 @@
+Test layered suite
+------------------
+
+    >>> layer
+    <class 'shared_with_layered_suite.test_core.FooLayer'>
+
+    >>> layer.layer_foo
+    'layer foo'
+    >>> layer.test_foo
+    'test foo'

zope/pytestlayer/tests/fixture/shared_with_layered_suite/test_core.py

@@ -0,0 +1,53 @@
+import doctest
+import unittest
+
+from plone.testing import layered
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)
+
+
+def test_suite():
+    suite = unittest.TestSuite()
+
+    OPTIONFLAGS = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
+
+    suite.addTests([
+        layered(
+            doctest.DocFileSuite(
+                'mydoctest.txt',
+                optionflags=OPTIONFLAGS,
+            ),
+            layer=FooLayer,
+        ),
+    ])
+    return suite

zope/pytestlayer/tests/fixture/single_layer/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/single_layer/test_core.py

@@ -0,0 +1,33 @@
+import unittest
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)

zope/pytestlayer/tests/fixture/single_layer_in_two_modules/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )

zope/pytestlayer/tests/fixture/single_layer_in_two_modules/test_core.py

@@ -0,0 +1,33 @@
+import unittest
+
+from zope.pytestlayer.testing import log_to_terminal
+
+
+class FooLayer(object):
+
+    @classmethod
+    def setUp(cls):
+        cls.layer_foo = 'layer foo'
+
+    @classmethod
+    def tearDown(cls):
+        del cls.layer_foo
+
+    @classmethod
+    def testSetUp(cls):
+        log_to_terminal(cls.pytest_request, 'testSetUp foo')
+        cls.test_foo = 'test foo'
+
+    @classmethod
+    def testTearDown(cls):
+        log_to_terminal(cls.pytest_request, 'testTearDown foo')
+        del cls.test_foo
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)

zope/pytestlayer/tests/fixture/single_layer_in_two_modules/test_second_module.py

@@ -0,0 +1,12 @@
+import unittest
+
+from .test_core import FooLayer
+
+
+class FooTest(unittest.TestCase):
+
+    layer = FooLayer
+
+    def test_dummy(self):
+        self.assertEqual('layer foo', self.layer.layer_foo)
+        self.assertEqual('test foo', self.layer.test_foo)

zope/pytestlayer/tests/fixture/single_layer_with_unattached_base_layer/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ('zopelayer', )