Implemented rouch support for class based tests

Author: boxed

README.rst

@@ -84,12 +84,6 @@ Some plugins work, but you have to specify to load them in setup.cfg:
         pytest_django
 
 
-Notable missing features
-------------------------
-
-* no support for class based tests
-
-
 Usage
 ------
 

hammett/__init__.py

@@ -496,35 +496,46 @@ def main(verbose=False, fail_fast=False, quiet=False, filenames=None, drop_into_
         if not isinstance(module_markers, list):
             module_markers = [module_markers]
 
-        from hammett.impl import execute_test_function
+        from hammett.impl import execute_test_function, execute_test_class
+        from unittest import TestCase
         for name, f in list(module.__dict__.items()):
             if g.results['abort']:
                 break
-            if name.startswith('test_') and callable(f):
-                for m in module_markers:
-                    f = m(f)
-
-                if match is not None:
-                    if match not in name:
-                        continue
-
-                if markers is not None:
-                    keep = False
-                    for f_marker in getattr(f, 'hammett_markers', []):
-                        if f_marker.name in markers:
-                            arg = markers[f_marker.name]
-                            if arg is not None:
-                                assert len(f_marker.args) == 1, 'hammett only supports filtering on single arguments to markers right now'
-                                if str(f_marker.args[0]) == arg:
-                                    keep = True
-                                    break
-                            else:
+
+            if match is not None:
+                if match not in name:
+                    continue
+
+            for m in module_markers:
+                f = m(f)
+
+            is_test_function = name.startswith('test_') and callable(f)
+            is_test_class = isinstance(f, type) and issubclass(f, TestCase)
+
+            if not is_test_function and not is_test_class:
+                continue
+
+            if markers is not None:
+                keep = False
+                for f_marker in getattr(f, 'hammett_markers', []):
+                    if f_marker.name in markers:
+                        arg = markers[f_marker.name]
+                        if arg is not None:
+                            assert len(f_marker.args) == 1, 'hammett only supports filtering on single arguments to markers right now'
+                            if str(f_marker.args[0]) == arg:
                                 keep = True
                                 break
-                    if not keep:
-                        continue
+                        else:
+                            keep = True
+                            break
+                if not keep:
+                    continue
+
+            if is_test_function:
+                execute_test_function(f'{module_name}.{name}', f, module_request)
+            elif is_test_class:
+                execute_test_class(f'{module_name}.{name}', f, module_request)
 
-                execute_test_function(module_name + '.' + name, f, module_request)
             if should_stop():
                 break
 

hammett/impl.py

@@ -390,7 +390,6 @@ def inc_test_result(status, _name, _f, duration, stdout, stderr):
         hammett.g.should_stop = True
 
     filename = _f.__module__.replace('.', os.sep) + '.py'
-    assert _name.startswith(_f.__module__)
     _name = _name[len(_f.__module__) + 1:]
     hammett.g.result_db['test_results'][filename][_name] = dict(stdout=stdout, stderr=stderr, status=status)
 
@@ -530,6 +529,19 @@ def execute_test_function(_name, _f, module_request):
         return run_test(_name, _f, module_request)
 
 
+def execute_test_class(_name, _c, module_request):
+    test_case = _c()
+    test_case.setUp()
+
+    for member_name in dir(test_case):
+        if member_name.startswith('test_'):
+            execute_test_function(f'{_name}.{member_name}', getattr(test_case, member_name), module_request)
+
+    test_case.tearDown()
+
+    # return run_test(_name, _f, module_request)
+
+
 class FakePytestParser:
     def parse_known_args(self, *args):
         class Fake: