MNT: Use pytest-catchlog to handle testing log messages.

Pytest 3.1.0 broke our current use of capfd, but that doesn't seem to be
a good way to handle capturing of log messages. (pytest-dev/pytest#2079)
So instead use pytest-catchlog, which was recommended in that issue and
seems to be maintained.

Author: dopplershift

setup.py

@@ -45,7 +45,8 @@
     extras_require={
         'netcdf': 'netCDF4>=1.1.0',
         'dev': 'ipython[all]>=3.1',
-        'test': ['pytest', 'pytest-flake8', 'pytest-runner', 'netCDF4>=1.1.0',
+        'test': ['pytest', 'pytest-catchlog', 'pytest-flake8', 'pytest-runner',
+                 'netCDF4>=1.1.0',
                  'flake8>3.2.0', 'flake8-builtins', 'flake8-comprehensions',
                  'flake8-copyright', 'flake8-import-order', 'flake8-mutable',
                  'flake8-pep3101', 'flake8-print', 'flake8-quotes',

siphon/cdmr/tests/test_ncstream.py

@@ -62,28 +62,10 @@ def test_local_data():
     assert messages[0][0] == '2014-10-28T21:00:00Z'
 
 
-def test_bad_magic():
+def test_bad_magic(caplog):
     """Test that we get notified of bad magic bytes in stream."""
-    import logging
-    import sys
-
-    # Only StringIO's version supports writing str
-    if sys.version_info.major == 2:
-        from StringIO import StringIO
-    else:
-        from io import StringIO
-
-    # Set up capturing of logging
-    log = logging.getLogger('siphon.cdmr.ncstream')
-    err_out = StringIO()
-    log.addHandler(logging.StreamHandler(err_out))
-
     # Try reading a bad message
     f = BytesIO(b'\x00\x01\x02\x03')
     read_ncstream_messages(f)
 
-    log.handlers.pop()
-
-    # Make sure we got some error output
-    err_out.seek(0)
-    assert 'Unknown magic' in err_out.read()
+    assert 'Unknown magic' in caplog.text

siphon/tests/test_metadata.py

@@ -545,13 +545,12 @@ def test_data_format(self):
         assert 'dataFormat' in md
         assert md['dataFormat'] == 'GRIB-1'
 
-    def test_data_malformed_format(self, capfd):
+    def test_data_malformed_format(self, caplog):
         """Test getting a warning for a malformed dataFormat tag."""
         xml = '<dataFormat>netCDF-4</dataFormat>'
         element = self._make_element(xml)
         TDSCatalogMetadata(element)
-        out, err = capfd.readouterr()
-        assert 'Value netCDF-4 not valid for type dataFormat' in ''.join(err)
+        assert 'Value netCDF-4 not valid for type dataFormat' in caplog.text
 
     def test_data_type(self):
         """Test parsing dataType tags."""

siphon/tests/test_ncss_dataset.py

@@ -55,14 +55,13 @@ def test_attribute_byte(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_invalid_byte(self, capfd):
+    def test_attribute_invalid_byte(self, caplog):
         """Test parsing an invalid byte attribute."""
         xml = '<attribute name="missing_value" type="byte" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert [\'a\'] to int. Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert [\'a\'] to int. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_attribute_short(self):
@@ -73,14 +72,13 @@ def test_attribute_short(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_invalid_short(self, capfd):
+    def test_attribute_invalid_short(self, caplog):
         """Test parsing an invalid short attribute."""
         xml = '<attribute name="missing_value" type="short" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert [\'a\'] to int. Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert [\'a\'] to int. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_attribute_int(self):
@@ -91,14 +89,13 @@ def test_attribute_int(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_invalid_int(self, capfd):
+    def test_attribute_invalid_int(self, caplog):
         """Test parsing an invalid int attribute."""
         xml = '<attribute name="missing_value" type="int" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert [\'a\'] to int. Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert [\'a\'] to int. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_attribute_long(self):
@@ -109,14 +106,13 @@ def test_attribute_long(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_invalid_long(self, capfd):
+    def test_attribute_invalid_long(self, caplog):
         """Test parsing a invalid long attribute."""
         xml = '<attribute name="missing_value" type="long" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert [\'a\'] to int. Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert [\'a\'] to int. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_attribute_float(self):
@@ -127,14 +123,13 @@ def test_attribute_float(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_invalid_float(self, capfd):
+    def test_attribute_invalid_float(self, caplog):
         """Test parsing an invalid float value attribute."""
         xml = '<attribute name="missing_value" type="float" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert [\'a\'] to float. Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert [\'a\'] to float. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_attribute_float_nan(self):
@@ -156,14 +151,13 @@ def test_attribute_double(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_invalid_double(self, capfd):
+    def test_attribute_invalid_double(self, caplog):
         """Test parsing an invalid double attribute."""
         xml = '<attribute name="missing_value" type="double" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert [\'a\'] to float. Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert [\'a\'] to float. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_attribute_double_nan(self):
@@ -210,15 +204,13 @@ def test_attribute_boolean_false(self):
         actual = self.types.handle_attribute(element)
         assert expected == actual
 
-    def test_attribute_boolean_invalid(self, capfd):
+    def test_attribute_boolean_invalid(self, caplog):
         """Test parsing an invalid boolean attribute."""
         xml = '<attribute name="missing_value" type="boolean" value="a"/>'
         element = ET.fromstring(xml)
         expected = {'missing_value': ['a']}
         actual = self.types.handle_attribute(element)
-        expected_message = 'Cannot convert values [\'a\'] to boolean.'
-        expected_message += ' Keeping type as str.'
-        assert expected_message in ''.join(capfd.readouterr())
+        assert 'Cannot convert values [\'a\'] to boolean. Keeping type as str.' in caplog.text
         assert expected == actual
 
     def test_value_1(self):