Fix assert 'str' in str(ex) for pytest 5

See pytest-dev/pytest#5579 for change

tests/controller/test_modelrun.py

@@ -131,7 +131,7 @@ def test_builder_scenario_sosmodelrun_not_in_sosmodel(self, config_data):
         with raises(SmifModelRunError) as ex:
             builder.finish()
         assert "ScenarioSets {'population'} are selected in the ModelRun " \
-               "configuration but not found in the SosModel configuration" in str(ex)
+               "configuration but not found in the SosModel configuration" in str(ex.value)
 
 
 class TestModelRun:
@@ -152,7 +152,7 @@ def test_run_timesteps(self, config_data):
         store = Mock()
         with raises(SmifModelRunError) as ex:
             model_run.run(store)
-        assert 'No timesteps specified' in str(ex)
+        assert 'No timesteps specified' in str(ex.value)
 
     def test_serialize(self, config_data):
         """Serialise back to config dict

tests/convert/test_interval.py

@@ -497,10 +497,10 @@ def test_equality(self):
 
     def test_invalid_set_interval(self):
         interval = Interval('test', ('PT0H', 'PT1H'))
-        with raises(ValueError) as excinfo:
+        with raises(ValueError) as ex:
             interval.interval = None
         msg = "A time interval must add either a single tuple or a list of tuples"
-        assert msg in str(excinfo)
+        assert msg in str(ex.value)
 
     def test_empty_interval_tuple(self):
         with raises(ValueError):
@@ -747,19 +747,19 @@ def test_validate_intervals_passes(self, remap_months):
     def test_validate_intervals_fails(self, remap_months):
         data = remap_months
         data.append({'name': '5', 'interval': [('PT0H', 'PT1H')]})
-        with raises(ValueError) as excinfo:
+        with raises(ValueError) as ex:
             IntervalSet('remap_months', data)
-        assert "Duplicate entry for hour 0 in interval set remap_months." in str(excinfo.value)
+        assert "Duplicate entry for hour 0 in interval set remap_months." in str(ex.value)
 
     def test_time_interval_start_before_end(self):
-        with raises(ValueError) as excinfo:
+        with raises(ValueError) as ex:
             Interval('backwards', ('P1Y', 'P3M'))
-        assert "A time interval must not end before it starts" in str(excinfo)
+        assert "A time interval must not end before it starts" in str(ex.value)
 
         interval = Interval('starts_ok', ('P0Y', 'P1M'))
-        with raises(ValueError) as excinfo:
+        with raises(ValueError) as ex:
             interval.interval = ('P2M', 'P1M')
-        assert "A time interval must not end before it starts" in str(excinfo)
+        assert "A time interval must not end before it starts" in str(ex.value)
 
 
 class TestIntersection:

tests/convert/test_region.py

@@ -235,7 +235,7 @@ def test_must_have_unique_names(self):
                 }
             ])
 
-        assert 'Region set must have uniquely named regions' in str(ex)
+        assert 'Region set must have uniquely named regions' in str(ex.value)
 
 
 class TestRegionRegister():
@@ -247,7 +247,7 @@ def test_create(self):
 
         with raises(ValueError) as ex:
             register.get_entry('nonexistent')
-        assert "ResolutionSet 'nonexistent' not registered" in str(ex)
+        assert "ResolutionSet 'nonexistent' not registered" in str(ex.value)
 
     def test_convert_equal(self, register):
         data = np.ones(1)

tests/data_layer/test_config_store_yaml.py

@@ -48,7 +48,7 @@ def test_model_run_write_twice(self, model_run, config_handler):
 
         with raises(SmifDataExistsError) as ex:
             config_handler.write_model_run(model_run1)
-        assert "Model_run 'unique' already exists" in str(ex)
+        assert "Model_run 'unique' already exists" in str(ex.value)
 
     def test_model_run_read_one(self, model_run, config_handler):
         """Test reading a single model_run.
@@ -70,7 +70,7 @@ def test_model_run_read_missing(self, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.read_model_run('missing_name')
-        assert "Model_run 'missing_name' not found" in str(ex)
+        assert "Model_run 'missing_name' not found" in str(ex.value)
 
     def test_model_run_update(self, model_run, config_handler):
         """Test updating a model_run description
@@ -95,7 +95,7 @@ def test_model_run_update_mismatch(self, model_run, config_handler):
         model_run['name'] = 'model_run'
         with raises(SmifDataMismatchError) as ex:
             config_handler.update_model_run('model_run2', model_run)
-        assert "name 'model_run2' must match 'model_run'" in str(ex)
+        assert "name 'model_run2' must match 'model_run'" in str(ex.value)
 
     def test_model_run_update_missing(self, model_run, config_handler):
         """Test that updating a nonexistent model_run should fail
@@ -105,7 +105,7 @@ def test_model_run_update_missing(self, model_run, config_handler):
 
         with raises(SmifDataNotFoundError) as ex:
             config_handler.update_model_run('missing_name', model_run)
-        assert "Model_run 'missing_name' not found" in str(ex)
+        assert "Model_run 'missing_name' not found" in str(ex.value)
 
     def test_model_run_delete(self, model_run, config_handler):
         """Test that updating a nonexistent model_run should fail
@@ -126,7 +126,7 @@ def test_model_run_delete_missing(self, model_run, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.delete_model_run('missing_name')
-        assert "Model_run 'missing_name' not found" in str(ex)
+        assert "Model_run 'missing_name' not found" in str(ex.value)
 
 
 class TestSosModel:
@@ -162,7 +162,7 @@ def test_sos_model_write_twice(self, get_sos_model, config_handler):
 
         with raises(SmifDataExistsError) as ex:
             config_handler.write_sos_model(sos_model1)
-        assert "Sos_model 'unique' already exists" in str(ex)
+        assert "Sos_model 'unique' already exists" in str(ex.value)
 
     def test_sos_model_read_one(self, get_sos_model, config_handler):
         """Test reading a single sos_model.
@@ -184,7 +184,7 @@ def test_sos_model_read_missing(self, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.read_sos_model('missing_name')
-        assert "Sos_model 'missing_name' not found" in str(ex)
+        assert "Sos_model 'missing_name' not found" in str(ex.value)
 
     def test_sos_model_update(self, get_sos_model, config_handler):
         """Test updating a sos_model description
@@ -209,7 +209,7 @@ def test_sos_model_update_mismatch(self, get_sos_model, config_handler):
         sos_model['name'] = 'sos_model'
         with raises(SmifDataMismatchError) as ex:
             config_handler.update_sos_model('sos_model2', sos_model)
-        assert "name 'sos_model2' must match 'sos_model'" in str(ex)
+        assert "name 'sos_model2' must match 'sos_model'" in str(ex.value)
 
     def test_sos_model_update_missing(self, get_sos_model, config_handler):
         """Test that updating a nonexistent sos_model should fail
@@ -219,7 +219,7 @@ def test_sos_model_update_missing(self, get_sos_model, config_handler):
 
         with raises(SmifDataNotFoundError) as ex:
             config_handler.update_sos_model('missing_name', sos_model)
-        assert "Sos_model 'missing_name' not found" in str(ex)
+        assert "Sos_model 'missing_name' not found" in str(ex.value)
 
     def test_sos_model_delete(self, get_sos_model, config_handler):
         """Test that updating a nonexistent sos_model should fail
@@ -240,7 +240,7 @@ def test_sos_model_delete_missing(self, get_sos_model, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.delete_sos_model('missing_name')
-        assert "Sos_model 'missing_name' not found" in str(ex)
+        assert "Sos_model 'missing_name' not found" in str(ex.value)
 
 
 class TestSectorModel:
@@ -278,7 +278,7 @@ def test_sector_model_write_twice(self, get_sector_model, config_handler):
 
         with raises(SmifDataExistsError) as ex:
             config_handler.write_model(sector_model1)
-        assert "Sector_model 'unique' already exists" in str(ex)
+        assert "Sector_model 'unique' already exists" in str(ex.value)
 
     def test_sector_model_read_one(self, get_sector_model, config_handler):
         """Test reading a single sector_model.
@@ -300,7 +300,7 @@ def test_sector_model_read_missing(self, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.read_model('missing_name')
-        assert "Sector_model 'missing_name' not found" in str(ex)
+        assert "Sector_model 'missing_name' not found" in str(ex.value)
 
     def test_sector_model_update(self, get_sector_model, config_handler):
         """Test updating a sector_model description
@@ -327,7 +327,7 @@ def test_sector_model_update_mismatch(self, get_sector_model, config_handler):
         sector_model['name'] = 'sector_model'
         with raises(SmifDataMismatchError) as ex:
             config_handler.update_model('sector_model2', sector_model)
-        assert "name 'sector_model2' must match 'sector_model'" in str(ex)
+        assert "name 'sector_model2' must match 'sector_model'" in str(ex.value)
 
     def test_sector_model_update_missing(self, get_sector_model, config_handler):
         """Test that updating a nonexistent sector_model should fail
@@ -337,7 +337,7 @@ def test_sector_model_update_missing(self, get_sector_model, config_handler):
 
         with raises(SmifDataNotFoundError) as ex:
             config_handler.update_model('missing_name', sector_model)
-        assert "Sector_model 'missing_name' not found" in str(ex)
+        assert "Sector_model 'missing_name' not found" in str(ex.value)
 
     def test_sector_model_delete(self, get_sector_model, config_handler):
         """Test that updating a nonexistent sector_model should fail
@@ -354,7 +354,7 @@ def test_sector_model_delete_missing(self, get_sector_model, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.delete_model('missing_name')
-        assert "Sector_model 'missing_name' not found" in str(ex)
+        assert "Sector_model 'missing_name' not found" in str(ex.value)
 
 
 class TestScenarios:
@@ -374,4 +374,4 @@ def test_read_scenario_missing(self, config_handler):
         """
         with raises(SmifDataNotFoundError) as ex:
             config_handler.read_scenario('missing')
-        assert "Scenario 'missing' not found" in str(ex)
+        assert "Scenario 'missing' not found" in str(ex.value)

tests/data_layer/test_data_array.py

@@ -7,7 +7,7 @@
 from numpy.testing import assert_array_equal
 from pytest import fixture, raises
 from smif.data_layer.data_array import DataArray, show_null
-from smif.exception import SmifDataNotFoundError, SmifDataMismatchError
+from smif.exception import SmifDataMismatchError
 from smif.metadata import Spec
 
 
@@ -226,7 +226,7 @@ def test_multi_dim_order(self):
             dtype='float'
         )
         data = numpy.array([
-            #4  2
+            # 4  2
             [1, 2],  # c
             [5, 6],  # a
             [9, 0]   # b
@@ -264,7 +264,7 @@ def test_match_metadata(self):
               "['region'], instead got data columns ['other'] and index names ['region']"
         with raises(SmifDataMismatchError) as ex:
             DataArray.from_df(spec, df)
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
         # may not be indexed, if columns are otherwise all okay
         df = pd.DataFrame([
@@ -280,7 +280,7 @@ def test_match_metadata(self):
               "['region'], instead got data columns ['test'] and index names [None]"
         with raises(SmifDataMismatchError) as ex:
             DataArray.from_df(spec, df)
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
         # must not have dimension labels outside of the spec dimension
         df = pd.DataFrame([
@@ -291,7 +291,7 @@ def test_match_metadata(self):
               "dimension 'region': ['extra']"
         with raises(SmifDataMismatchError) as ex:
             DataArray.from_df(spec, df)
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
     def test_scalar(self):
         # should handle zero-dimensional case (numpy array as scalar)
@@ -327,7 +327,7 @@ def test_error_duplicate_rows_single_index(self):
             DataArray.from_df(spec, df)
 
         msg = "Data for 'test' contains duplicate values at [{'a': 1}]"
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
     def test_error_duplicate_rows_multi_index(self):
         spec = Spec(
@@ -349,7 +349,7 @@ def test_error_duplicate_rows_multi_index(self):
 
         msg = "Data for 'test' contains duplicate values at [{'a': 2, 'b': 4}]"
         msg_alt = "Data for 'test' contains duplicate values at [{'b': 4, 'a': 2}]"
-        assert msg in str(ex) or msg_alt in str(ex)
+        assert msg in str(ex.value) or msg_alt in str(ex.value)
 
 
 class TestMissingData:
@@ -366,7 +366,7 @@ def test_missing_data_raises(self, small_da):
 
         msg = "Data for 'test_data' had missing values - read 20 but expected 24 in " + \
               "total, from dims of length {a: 2, b: 3, c: 4}"
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
     def test_missing_data_message(self, small_da):
         """Should check for NaNs and raise SmifDataError
@@ -380,7 +380,7 @@ def test_missing_data_message(self, small_da):
 
         expected = "Data for 'test_data' had missing values - read 22 but expected 24 in " + \
                    "total, from dims of length {a: 2, b: 3, c: 4}"
-        assert expected in str(ex)
+        assert expected in str(ex.value)
 
     def test_missing_data_message_non_numeric(self, small_da_non_numeric):
         """Should check for NaNs and raise SmifDataError
@@ -394,7 +394,7 @@ def test_missing_data_message_non_numeric(self, small_da_non_numeric):
 
         expected = "Data for 'test_data' had missing values - read 22 but expected 24 in " + \
                    "total, from dims of length {a: 2, b: 3, c: 4}"
-        assert expected in str(ex)
+        assert expected in str(ex.value)
 
     def test_no_missing_data(self, small_da):
 
@@ -439,7 +439,6 @@ def test_missing_data_non_numeric(self, small_da_non_numeric):
         except TypeError:
             index = pd.MultiIndex(levels=levels, labels=codes, names=names)
 
-
         expected = pd.DataFrame(data=numpy.array([[None]], dtype=numpy.object),
                                 index=index,
                                 columns=['test_data'])

tests/data_layer/test_data_handle.py

@@ -469,7 +469,7 @@ def test_set_data_wrong_shape(self, mock_store, mock_model_with_conversion):
 
         msg = "Data shape (1, 2) does not match spec " \
               "(2, 1)"
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
     def test_set_data_with_square_brackets(self, mock_store, mock_model):
         """should allow dict-like write access to output data
@@ -499,10 +499,10 @@ def test_set_data_with_square_brackets_raises(self, mock_store, mock_model):
         spec = mock_model.outputs['gas_demand']
         da = DataArray(spec, data)
 
-        with raises(TypeError) as err:
+        with raises(TypeError) as ex:
             data_handle["gas_demand"] = da
 
-        assert "Pass in a numpy array" in str(err)
+        assert "Pass in a numpy array" in str(ex.value)
 
 
 class TestDataHandleState():
@@ -624,7 +624,7 @@ def test_previous_timestep_error(self, mock_model, mock_store):
         data_handle = DataHandle(mock_store, 1, 2015, [2015, 2020], mock_model)
         with raises(SmifTimestepResolutionError) as ex:
             data_handle.previous_timestep
-        assert 'no previous timestep' in str(ex)
+        assert 'no previous timestep' in str(ex.value)
 
 
 class TestDataHandleGetResults:

tests/data_layer/test_data_store.py

@@ -119,7 +119,7 @@ def test_read_data_array_missing_timestep(self, handler, scenario):
         msg = "not found for timestep 2011"
         with raises(SmifDataNotFoundError) as ex:
             handler.read_scenario_variant_data('mortality.csv', spec, 2011)
-        assert msg in str(ex)
+        assert msg in str(ex.value)
 
     def test_string_data(self, handler):
         spec = Spec(