Add support for callable *required* argument to assertDataColumns()

and add relevant tests.

datatest/case.py

@@ -142,14 +142,23 @@ def test_columns(self):
             def test_columns(self):
                 self.assertDataColumns()
         """
+        # TODO: Explore the idea of implementing CompareList to assert
+        # column order.
         subject_set = CompareSet(self.subjectData.columns())
-        required_list = self._normalize_required(required, 'columns')
-        if subject_set != required_list:
+
+        if callable(required):
+            differences = subject_set.compare(required)
+        else:
+            required_list = self._normalize_required(required, 'columns')
+            if subject_set != required_list:
+                differences = subject_set.compare(required_list)
+            else:
+                differences = None
+
+        if differences:
             if msg is None:
                 msg = 'different column names'
-            self.fail(msg, subject_set.compare(required_list))
-        # TODO: Implement callable *required* argument.
-        # TODO: Explore the idea of implementing DataList to assert column order.
+            self.fail(msg, differences)
 
     def assertDataSet(self, columns, required=None, msg=None, **kwds_filter):
         """Test that the column or *columns* in subjectData contain the

tests/test_case.py

@@ -7,6 +7,7 @@
 # Import compatiblity layers.
 from . import _io as io
 from . import _unittest as unittest
+from .common import MinimalSource
 
 # Import code to test.
 from datatest.case import DataTestCase
@@ -324,73 +325,81 @@ def test_method(_self):
 
 
 class TestAssertDataColumns(TestHelperCase):
-    def setUp(self):
-        _fh = io.StringIO('label1,value\n'
-                          'a,65\n'
-                          'b,70\n')
-        self.reference = CsvSource(_fh, in_memory=True)
+    def test_required_set(self):
+        class _TestClass(DataTestCase):
+            def setUp(_self):
+                data = [('label1', 'value'),
+                        ('a', '6'),
+                        ('b', '7')]
+                _self.subjectData = MinimalSource(data)
 
-    def test_pass(self):
+            def test_method(_self):
+                required_set = set(['label1', 'value'])
+                _self.assertDataColumns(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):
-                _self.referenceData = self.reference  # <- referenceData!
-                same_as_reference = io.StringIO('label1,value\n'
-                                                'a,6\n'
-                                                'b,7\n')
-                _self.subjectData = CsvSource(same_as_reference, in_memory=True)
+                data = [('label1', 'value'),
+                        ('a', '6'),
+                        ('b', '7')]
+                _self.subjectData = MinimalSource(data)
 
             def test_method(_self):
-                _self.assertDataColumns()  # <- test assert
+                data = [('label1', 'value'),
+                        ('a', '6'),
+                        ('b', '7')]
+                required_source = MinimalSource(data)
+                _self.assertDataColumns(required=required_source)  # <- test assert
 
         failure = self._run_one_test(_TestClass, 'test_method')
         self.assertIsNone(failure)
 
-    def test_pass_using_set_arg_reference(self):
+    def test_required_function(self):
         class _TestClass(DataTestCase):
             def setUp(_self):
-                #_self.referenceData =   <- intentionally omitted
-                subject = io.StringIO('label1,value\n'
-                                      'a,6\n'
-                                      'b,7\n')
-                _self.subjectData = CsvSource(subject, in_memory=True)
+                data = [('label1', 'value'),
+                        ('a', '6'),
+                        ('b', '7')]
+                _self.subjectData = MinimalSource(data)
 
             def test_method(_self):
-                reference_set = set(['label1', 'value'])
-                _self.assertDataColumns(required=reference_set)  # <- test assert
+                def lowercase(x):  # <- Helper function!!!
+                    return x == x.lower()
+                _self.assertDataColumns(required=lowercase)  # <- test assert
 
         failure = self._run_one_test(_TestClass, 'test_method')
         self.assertIsNone(failure)
 
-    def test_pass_using_source_arg_reference(self):
+    def test_using_reference(self):
         class _TestClass(DataTestCase):
             def setUp(_self):
-                #_self.referenceData =   <- intentionally omitted
-                subject = io.StringIO('label1,value\n'
-                                      'a,6\n'
-                                      'b,7\n')
-                _self.subjectData = CsvSource(subject, in_memory=True)
+                data = [('label1', 'value'),
+                        ('a', '6'),
+                        ('b', '7')]
+                _self.subjectData = MinimalSource(data)
+                _self.referenceData = MinimalSource(data)  # <- Same as subject!
 
             def test_method(_self):
-                reference = io.StringIO('label1,value\n'
-                                        'a,6\n'
-                                        'b,7\n')
-                ref_source = CsvSource(reference, in_memory=True)
-                _self.assertDataColumns(required=ref_source)  # <- test assert
+                _self.assertDataColumns()  # <- test assert
 
         failure = self._run_one_test(_TestClass, 'test_method')
         self.assertIsNone(failure)
 
     def test_extra(self):
         class _TestClass(DataTestCase):
             def setUp(_self):
-                _self.referenceData = self.reference
-                too_many = io.StringIO('label1,label2,value\n'
-                                       'a,x,6\n'
-                                       'b,y,7\n')
-                _self.subjectData = CsvSource(too_many, in_memory=True)
+                data = [('label1', 'label2', 'value'),
+                        ('a', 'x', '6'),
+                        ('b', 'y', '7')]
+                _self.subjectData = MinimalSource(data)
 
             def test_method(_self):
-                _self.assertDataColumns()  # <- test assert
+                required_set = set(['label1', 'value'])
+                _self.assertDataColumns(required=required_set)  # <- test assert
 
         failure = self._run_one_test(_TestClass, 'test_method')
         pattern = "different column names:\n Extra\(u?'label2'\)"
@@ -399,19 +408,36 @@ def test_method(_self):
     def test_missing(self):
         class _TestClass(DataTestCase):
             def setUp(_self):
-                _self.referenceData = self.reference
-                too_few = io.StringIO('label1\n'
-                                      'a\n'
-                                      'b\n')
-                _self.subjectData = CsvSource(too_few, in_memory=True)
+                data = [('label1',),
+                        ('a',),
+                        ('b',)]
+                _self.subjectData = MinimalSource(data)
 
             def test_method(_self):
-                _self.assertDataColumns()  # <- test assert
+                required_set = set(['label1', 'value'])
+                _self.assertDataColumns(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.subjectData = MinimalSource(data)
+
+            def test_method(_self):
+                def lowercase(x):  # <- Helper function!!!
+                    return x == x.lower()
+                _self.assertDataColumns(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 TestAssertDataSet(TestHelperCase):
     def setUp(self):