Remove assertSubjectColumns() from public API and add it to the backward

compatibility sub-package (api_dev2) along with related tests.

datatest/__past__/api_dev0.py

@@ -2,6 +2,7 @@
 """Backwards compatibility for version 0.6.0.dev0 API."""
 from __future__ import absolute_import
 import datatest
+from datatest.__past__ import api_dev2
 from datatest.__past__ import api_dev1
 from datatest import DataTestCase
 

datatest/__past__/api_dev1.py

@@ -3,6 +3,7 @@
 from __future__ import absolute_import
 import inspect
 import datatest
+from datatest.__past__ import api_dev2
 from datatest.utils import itertools
 from datatest import DataTestCase
 

datatest/__past__/api_dev2.py

@@ -3,4 +3,26 @@
 from __future__ import absolute_import
 from datatest import DataTestCase
 
-#DataTestCase.assertEqual = DataTestCase.assertValid
+from datatest import CompareSet
+
+
+def assertSubjectColumns(self, required=None, msg=None):
+    """Test that the column names of subject match the *required*
+    values.  The *required* argument can be a collection, callable,
+    data source, or None:
+
+        def test_columns(self):
+            required_names = {'col1', 'col2'}
+            self.assertSubjectColumns(required_names)
+
+    If *required* is omitted, the column names from reference are used
+    in its place:
+
+        def test_columns(self):
+            self.assertSubjectColumns()
+    """
+    subject_set = CompareSet(self.subject.columns())
+    required = self._normalize_required(required, 'columns')
+    msg = msg or 'different column names'
+    self.assertEqual(subject_set, required, msg)
+DataTestCase.assertSubjectColumns = assertSubjectColumns

datatest/case.py

@@ -218,28 +218,6 @@ def uppercase(x):  # <- Helper function.
             differences = first.compare(second)
             self.fail(msg or default_msg, differences)
 
-    def assertSubjectColumns(self, required=None, msg=None):
-        """Test that the column names of :attr:`subject` match the
-        *required* values.  The *required* argument can be a collection,
-        callable, data source, or None::
-
-            def test_columns(self):
-                required_names = {'col1', 'col2'}
-                self.assertSubjectColumns(required_names)
-
-        If *required* is omitted, the column names from
-        :attr:`reference` are used in its place::
-
-            def test_columns(self):
-                self.assertSubjectColumns()
-        """
-        # TODO: Explore the idea of implementing CompareList to assert
-        # column order.
-        subject_set = CompareSet(self.subject.columns())
-        required = self._normalize_required(required, 'columns')
-        msg = msg or 'different column names'
-        self.assertEqual(subject_set, required, msg)
-
     def assertSubjectSet(self, columns, required=None, msg=None, **kwds_filter):
         """Test that the column or *columns* in :attr:`subject` contain
         the *required* values::

tests/past_api_dev2.py

@@ -8,9 +8,15 @@
 """
 from . import _io as io
 from . import _unittest as unittest
+from .common import MinimalSource
 import datatest
 from datatest.__past__ import api_dev2  # <- MONKEY PATCH!!!
 
+from datatest import DataError
+from datatest import Missing
+from datatest import Extra
+from datatest import Invalid
+
 
 class TestNamesAndAttributes(unittest.TestCase):
     def _run_wrapped_test(self, case, method):
@@ -55,6 +61,78 @@ def test_method(_self):
         self.assertIsNone(failure)
 
 
+class TestAssertSubjectColumns(datatest.DataTestCase):
+    def setUp(self):
+        data = [('label1', 'value'),
+                ('a', '6'),
+                ('b', '7')]
+        self.subject = MinimalSource(data)
+
+    def test_required_set(self):
+        required_set = set(['label1', 'value'])
+        self.assertSubjectColumns(required=required_set)  # <- test assert
+
+    def test_required_source(self):
+        data = [('label1', 'value'),
+                ('a', '6'),
+                ('b', '7')]
+        required_source = MinimalSource(data)
+        self.assertSubjectColumns(required=required_source)  # <- test assert
+
+    def test_required_function(self):
+        def lowercase(x):  # <- Helper function!!!
+            return x == x.lower()
+        self.assertSubjectColumns(required=lowercase)  # <- test assert
+
+    def test_using_reference(self):
+        data = [('label1', 'value'),
+                ('a', '6'),
+                ('b', '7')]
+        self.subject = MinimalSource(data)
+        self.reference = MinimalSource(data)
+        self.assertSubjectColumns()  # <- test assert
+
+    def test_extra(self):
+        data = [('label1', 'label2', 'value'),
+                ('a', 'x', '6'),
+                ('b', 'y', '7')]
+        self.subject = MinimalSource(data)
+
+        with self.assertRaises(DataError) as cm:
+            required_set = set(['label1', 'value'])
+            self.assertSubjectColumns(required=required_set)  # <- test assert
+
+        differences = cm.exception.differences
+        self.assertEqual(set(differences), set([Extra('label2')]))
+
+    def test_missing(self):
+        data = [('label1',),
+                ('a',),
+                ('b',)]
+        self.subject = MinimalSource(data)
+
+        with self.assertRaises(DataError) as cm:
+            required_set = set(['label1', 'value'])
+            self.assertSubjectColumns(required=required_set)  # <- test assert
+
+        differences = cm.exception.differences
+        self.assertEqual(set(differences), set([Missing('value')]))
+
+    def test_invalid(self):
+        data = [('LABEL1', 'value'),
+                ('a', '6'),
+                ('b', '7')]
+        self.subject = MinimalSource(data)
+
+        with self.assertRaises(DataError) as cm:
+            def lowercase(x):  # <- Helper function!!!
+                return x == x.lower()
+            self.assertSubjectColumns(required=lowercase)  # <- test assert
+
+        differences = cm.exception.differences
+        self.assertEqual(set(differences), set([Invalid('LABEL1')]))
+
+
 if __name__ == '__main__':
     unittest.main()
 else:

tests/test_case.py

@@ -478,121 +478,6 @@ def test_method(_self):
         self.assertRegex(failure, pattern)
 
 
-class TestAssertSubjectColumns(TestHelperCase):
-    def test_required_set(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('label1', 'value'),
-                        ('a', '6'),
-                        ('b', '7')]
-                _self.subject = MinimalSource(data)
-
-            def test_method(_self):
-                required_set = set(['label1', 'value'])
-                _self.assertSubjectColumns(required=required_set)  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        self.assertIsNone(failure)
-
-    def test_required_source(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('label1', 'value'),
-                        ('a', '6'),
-                        ('b', '7')]
-                _self.subject = MinimalSource(data)
-
-            def test_method(_self):
-                data = [('label1', 'value'),
-                        ('a', '6'),
-                        ('b', '7')]
-                required_source = MinimalSource(data)
-                _self.assertSubjectColumns(required=required_source)  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        self.assertIsNone(failure)
-
-    def test_required_function(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('label1', 'value'),
-                        ('a', '6'),
-                        ('b', '7')]
-                _self.subject = MinimalSource(data)
-
-            def test_method(_self):
-                def lowercase(x):  # <- Helper function!!!
-                    return x == x.lower()
-                _self.assertSubjectColumns(required=lowercase)  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        self.assertIsNone(failure)
-
-    def test_using_reference(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('label1', 'value'),
-                        ('a', '6'),
-                        ('b', '7')]
-                _self.subject = MinimalSource(data)
-                _self.reference = MinimalSource(data)  # <- Same as subject!
-
-            def test_method(_self):
-                _self.assertSubjectColumns()  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        self.assertIsNone(failure)
-
-    def test_extra(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('label1', 'label2', 'value'),
-                        ('a', 'x', '6'),
-                        ('b', 'y', '7')]
-                _self.subject = MinimalSource(data)
-
-            def test_method(_self):
-                required_set = set(['label1', 'value'])
-                _self.assertSubjectColumns(required=required_set)  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        pattern = "different column names:\n Extra\(u?'label2'\)"
-        self.assertRegex(failure, pattern)
-
-    def test_missing(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('label1',),
-                        ('a',),
-                        ('b',)]
-                _self.subject = MinimalSource(data)
-
-            def test_method(_self):
-                required_set = set(['label1', 'value'])
-                _self.assertSubjectColumns(required=required_set)  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        pattern = "different column names:\n Missing\(u?'value'\)"
-        self.assertRegex(failure, pattern)
-
-    def test_invalid(self):
-        class _TestClass(DataTestCase):
-            def setUp(_self):
-                data = [('LABEL1', 'value'),
-                        ('a', '6'),
-                        ('b', '7')]
-                _self.subject = MinimalSource(data)
-
-            def test_method(_self):
-                def lowercase(x):  # <- Helper function!!!
-                    return x == x.lower()
-                _self.assertSubjectColumns(required=lowercase)  # <- test assert
-
-        failure = self._run_one_test(_TestClass, 'test_method')
-        pattern = "different column names:\n Invalid\(u?'LABEL1'\)"
-        self.assertRegex(failure, pattern)
-
-
 class TestAssertSubjectSet(TestHelperCase):
     def setUp(self):
         _fh = io.StringIO('label,label2\n'