pattern: ported to pytest (#4015)

lib/spack/spack/test/pattern.py

@@ -23,85 +23,88 @@
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 ##############################################################################
 
-import unittest
+import pytest
-
 import spack.util.pattern as pattern
 
 
-class CompositeTest(unittest.TestCase):
+@pytest.fixture()
+def interface():
+    """Returns the interface class for the composite."""
+    class Base:
+        counter = 0
 
-    def setUp(self):
+        def add(self):
-        class Base:
+            raise NotImplemented('add not implemented')
-            counter = 0
+
+        def subtract(self):
+            raise NotImplemented('subtract not implemented')
+
+    return Base
+
+
+@pytest.fixture()
+def implementation(interface):
+    """Returns an implementation of the interface"""
+    class Implementation(interface):
+
+            def __init__(self, value):
+                self.value = value
 
             def add(self):
-                raise NotImplemented('add not implemented')
+                interface.counter += self.value
 
             def subtract(self):
-                raise NotImplemented('subtract not implemented')
+                interface.counter -= self.value
 
-        class One(Base):
+    return Implementation
 
-            def add(self):
-                Base.counter += 1
 
-            def subtract(self):
+@pytest.fixture(params=[
-                Base.counter -= 1
+    'interface',
-
+    'method_list'
-        class Two(Base):
+])
-
+def composite(interface, implementation, request):
-            def add(self):
+    """Returns a composite that contains an instance of `implementation(1)`
-                Base.counter += 2
+    and one of `implementation(2)`.
-
+    """
-            def subtract(self):
+    if request.param == 'interface':
-                Base.counter -= 2
+        @pattern.composite(interface=interface)
-
+        class Composite:
-        self.Base = Base
-        self.One = One
-        self.Two = Two
-
-    def test_composite_from_method_list(self):
-
-        @pattern.composite(method_list=['add', 'subtract'])
-        class CompositeFromMethodList:
             pass
 
-        composite = CompositeFromMethodList()
+    else:
-        composite.append(self.One())
+        @pattern.composite(method_list=['add', 'subtract'])
-        composite.append(self.Two())
+        class Composite:
-        composite.add()
+            pass
-        self.assertEqual(self.Base.counter, 3)
-        composite.pop()
-        composite.subtract()
-        self.assertEqual(self.Base.counter, 2)
 
-    def test_composite_from_interface(self):
+    c = Composite()
+    c.append(implementation(1))
+    c.append(implementation(2))
 
-        @pattern.composite(interface=self.Base)
+    return c
+
+
+def test_composite_interface_calls(interface, composite):
+
+    composite.add()
+    assert interface.counter == 3
+
+    composite.pop()
+    composite.subtract()
+    assert interface.counter == 2
+
+
+def test_composite_wrong_container(interface):
+
+    with pytest.raises(TypeError):
+        @pattern.composite(interface=interface, container=2)
         class CompositeFromInterface:
             pass
 
-        composite = CompositeFromInterface()
-        composite.append(self.One())
-        composite.append(self.Two())
-        composite.add()
-        self.assertEqual(self.Base.counter, 3)
 
-        composite.pop()
+def test_composite_no_methods():
-        composite.subtract()
-        self.assertEqual(self.Base.counter, 2)
 
-    def test_error_conditions(self):
+    with pytest.raises(TypeError):
-
+        @pattern.composite()
-        def wrong_container():
+        class CompositeFromInterface:
-            @pattern.composite(interface=self.Base, container=2)
+            pass
-            class CompositeFromInterface:
-                pass
-
-        def no_methods():
-            @pattern.composite()
-            class CompositeFromInterface:
-                pass
-
-        self.assertRaises(TypeError, wrong_container)
-        self.assertRaises(TypeError, no_methods)