diff --git a/lib/iris/tests/unit/common/metadata/test_AncillaryVariableMetadata.py b/lib/iris/tests/unit/common/metadata/test_AncillaryVariableMetadata.py index b7304f4301..a12af28242 100644 --- a/lib/iris/tests/unit/common/metadata/test_AncillaryVariableMetadata.py +++ b/lib/iris/tests/unit/common/metadata/test_AncillaryVariableMetadata.py @@ -4,25 +4,22 @@ # See LICENSE in the root of the repository for full licensing details. """Unit tests for the :class:`iris.common.metadata.AncillaryVariableMetadata`.""" -# Import iris.tests first so that some things can be initialised before -# importing anything else. -import iris.tests as tests # isort:skip - from copy import deepcopy -import unittest.mock as mock -from unittest.mock import sentinel + +import pytest from iris.common.lenient import _LENIENT, _qualname from iris.common.metadata import AncillaryVariableMetadata, BaseMetadata -class Test(tests.IrisTest): - def setUp(self): - self.standard_name = mock.sentinel.standard_name - self.long_name = mock.sentinel.long_name - self.var_name = mock.sentinel.var_name - self.units = mock.sentinel.units - self.attributes = mock.sentinel.attributes +class Test: + @pytest.fixture(autouse=True) + def _setup(self, mocker): + self.standard_name = mocker.sentinel.standard_name + self.long_name = mocker.sentinel.long_name + self.var_name = mocker.sentinel.var_name + self.units = mocker.sentinel.units + self.attributes = mocker.sentinel.attributes self.cls = AncillaryVariableMetadata def test_repr(self): @@ -44,7 +41,7 @@ def test_repr(self): self.units, self.attributes, ) - self.assertEqual(expected, repr(metadata)) + assert repr(metadata) == expected def test__fields(self): expected = ( @@ -54,107 +51,108 @@ def test__fields(self): "units", "attributes", ) - self.assertEqual(self.cls._fields, expected) + assert self.cls._fields == expected def test_bases(self): - self.assertTrue(issubclass(self.cls, BaseMetadata)) + assert issubclass(self.cls, BaseMetadata) -class Test___eq__(tests.IrisTest): - def setUp(self): +class Test___eq__: + @pytest.fixture(autouse=True) + def _setup(self, mocker): self.values = dict( - standard_name=sentinel.standard_name, - long_name=sentinel.long_name, - var_name=sentinel.var_name, - units=sentinel.units, - attributes=sentinel.attributes, + standard_name=mocker.sentinel.standard_name, + long_name=mocker.sentinel.long_name, + var_name=mocker.sentinel.var_name, + units=mocker.sentinel.units, + attributes=mocker.sentinel.attributes, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = AncillaryVariableMetadata def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.__eq__.__doc__, self.cls.__eq__.__doc__) + assert self.cls.__eq__.__doc__ == BaseMetadata.__eq__.__doc__ def test_lenient_service(self): qualname___eq__ = _qualname(self.cls.__eq__) - self.assertIn(qualname___eq__, _LENIENT) - self.assertTrue(_LENIENT[qualname___eq__]) - self.assertTrue(_LENIENT[self.cls.__eq__]) + assert qualname___eq__ in _LENIENT + assert _LENIENT[qualname___eq__] + assert _LENIENT[self.cls.__eq__] - def test_call(self): - other = sentinel.other - return_value = sentinel.return_value + def test_call(self, mocker): + other = mocker.sentinel.other + return_value = mocker.sentinel.return_value metadata = self.cls(*(None,) * len(self.cls._fields)) - with mock.patch.object( - BaseMetadata, "__eq__", return_value=return_value - ) as mocker: - result = metadata.__eq__(other) - - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(), kwargs) - - def test_op_lenient_same(self): + + patcher = mocker.patch.object(BaseMetadata, "__eq__", return_value=return_value) + result = metadata.__eq__(other) + + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == {} + + def test_op_lenient_same(self, mocker): lmetadata = self.cls(**self.values) rmetadata = self.cls(**self.values) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertTrue(lmetadata.__eq__(rmetadata)) - self.assertTrue(rmetadata.__eq__(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.__eq__(rmetadata) + assert rmetadata.__eq__(lmetadata) - def test_op_lenient_same_none(self): + def test_op_lenient_same_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["var_name"] = None rmetadata = self.cls(**right) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertTrue(lmetadata.__eq__(rmetadata)) - self.assertTrue(rmetadata.__eq__(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.__eq__(rmetadata) + assert rmetadata.__eq__(lmetadata) - def test_op_lenient_different(self): + def test_op_lenient_different(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["units"] = self.dummy rmetadata = self.cls(**right) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertFalse(lmetadata.__eq__(rmetadata)) - self.assertFalse(rmetadata.__eq__(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert not lmetadata.__eq__(rmetadata) + assert not rmetadata.__eq__(lmetadata) - def test_op_strict_same(self): + def test_op_strict_same(self, mocker): lmetadata = self.cls(**self.values) rmetadata = self.cls(**self.values) - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertTrue(lmetadata.__eq__(rmetadata)) - self.assertTrue(rmetadata.__eq__(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.__eq__(rmetadata) + assert rmetadata.__eq__(lmetadata) - def test_op_strict_different(self): + def test_op_strict_different(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["long_name"] = self.dummy rmetadata = self.cls(**right) - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertFalse(lmetadata.__eq__(rmetadata)) - self.assertFalse(rmetadata.__eq__(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert not lmetadata.__eq__(rmetadata) + assert not rmetadata.__eq__(lmetadata) - def test_op_strict_different_none(self): + def test_op_strict_different_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["long_name"] = None rmetadata = self.cls(**right) - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertFalse(lmetadata.__eq__(rmetadata)) - self.assertFalse(rmetadata.__eq__(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert not lmetadata.__eq__(rmetadata) + assert not rmetadata.__eq__(lmetadata) -class Test___lt__(tests.IrisTest): - def setUp(self): +class Test___lt__: + @pytest.fixture(autouse=True) + def _setup(self): self.cls = AncillaryVariableMetadata self.one = self.cls(1, 1, 1, 1, 1) self.two = self.cls(1, 1, 1, 2, 1) @@ -163,99 +161,100 @@ def setUp(self): def test__ascending_lt(self): result = self.one < self.two - self.assertTrue(result) + assert result def test__descending_lt(self): result = self.two < self.one - self.assertFalse(result) + assert not result def test__none_rhs_operand(self): result = self.one < self.none - self.assertFalse(result) + assert not result def test__none_lhs_operand(self): result = self.none < self.one - self.assertTrue(result) + assert result def test__ignore_attributes(self): result = self.one < self.attributes - self.assertFalse(result) + assert not result result = self.attributes < self.one - self.assertFalse(result) + assert not result -class Test_combine(tests.IrisTest): - def setUp(self): +class Test_combine: + @pytest.fixture(autouse=True) + def _setup(self, mocker): self.values = dict( - standard_name=sentinel.standard_name, - long_name=sentinel.long_name, - var_name=sentinel.var_name, - units=sentinel.units, - attributes=sentinel.attributes, + standard_name=mocker.sentinel.standard_name, + long_name=mocker.sentinel.long_name, + var_name=mocker.sentinel.var_name, + units=mocker.sentinel.units, + attributes=mocker.sentinel.attributes, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = AncillaryVariableMetadata self.none = self.cls(*(None,) * len(self.cls._fields)) def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.combine.__doc__, self.cls.combine.__doc__) + assert self.cls.combine.__doc__ == BaseMetadata.combine.__doc__ def test_lenient_service(self): qualname_combine = _qualname(self.cls.combine) - self.assertIn(qualname_combine, _LENIENT) - self.assertTrue(_LENIENT[qualname_combine]) - self.assertTrue(_LENIENT[self.cls.combine]) - - def test_lenient_default(self): - other = sentinel.other - return_value = sentinel.return_value - with mock.patch.object( + assert qualname_combine in _LENIENT + assert _LENIENT[qualname_combine] + assert _LENIENT[self.cls.combine] + + def test_lenient_default(self, mocker): + other = mocker.sentinel.other + return_value = mocker.sentinel.return_value + patcher = mocker.patch.object( BaseMetadata, "combine", return_value=return_value - ) as mocker: - result = self.none.combine(other) - - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(lenient=None), kwargs) - - def test_lenient(self): - other = sentinel.other - lenient = sentinel.lenient - return_value = sentinel.return_value - with mock.patch.object( + ) + result = self.none.combine(other) + + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == dict(lenient=None) + + def test_lenient(self, mocker): + other = mocker.sentinel.other + lenient = mocker.sentinel.lenient + return_value = mocker.sentinel.return_value + patcher = mocker.patch.object( BaseMetadata, "combine", return_value=return_value - ) as mocker: - result = self.none.combine(other, lenient=lenient) + ) + result = self.none.combine(other, lenient=lenient) - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(lenient=lenient), kwargs) + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == dict(lenient=lenient) - def test_op_lenient_same(self): + def test_op_lenient_same(self, mocker): lmetadata = self.cls(**self.values) rmetadata = self.cls(**self.values) expected = self.values - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - def test_op_lenient_same_none(self): + def test_op_lenient_same_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["var_name"] = None rmetadata = self.cls(**right) expected = self.values - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - def test_op_lenient_different(self): + def test_op_lenient_different(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["units"] = self.dummy @@ -263,20 +262,20 @@ def test_op_lenient_different(self): expected = self.values.copy() expected["units"] = None - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - def test_op_strict_same(self): + def test_op_strict_same(self, mocker): lmetadata = self.cls(**self.values) rmetadata = self.cls(**self.values) expected = self.values.copy() - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - def test_op_strict_different(self): + def test_op_strict_different(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["long_name"] = self.dummy @@ -284,11 +283,11 @@ def test_op_strict_different(self): expected = self.values.copy() expected["long_name"] = None - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - def test_op_strict_different_none(self): + def test_op_strict_different_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["long_name"] = None @@ -296,81 +295,82 @@ def test_op_strict_different_none(self): expected = self.values.copy() expected["long_name"] = None - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected -class Test_difference(tests.IrisTest): - def setUp(self): +class Test_difference: + @pytest.fixture(autouse=True) + def _setup(self, mocker): self.values = dict( - standard_name=sentinel.standard_name, - long_name=sentinel.long_name, - var_name=sentinel.var_name, - units=sentinel.units, - attributes=sentinel.attributes, + standard_name=mocker.sentinel.standard_name, + long_name=mocker.sentinel.long_name, + var_name=mocker.sentinel.var_name, + units=mocker.sentinel.units, + attributes=mocker.sentinel.attributes, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = AncillaryVariableMetadata self.none = self.cls(*(None,) * len(self.cls._fields)) def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.difference.__doc__, self.cls.difference.__doc__) + assert self.cls.difference.__doc__ == BaseMetadata.difference.__doc__ def test_lenient_service(self): qualname_difference = _qualname(self.cls.difference) - self.assertIn(qualname_difference, _LENIENT) - self.assertTrue(_LENIENT[qualname_difference]) - self.assertTrue(_LENIENT[self.cls.difference]) - - def test_lenient_default(self): - other = sentinel.other - return_value = sentinel.return_value - with mock.patch.object( + assert qualname_difference in _LENIENT + assert _LENIENT[qualname_difference] + assert _LENIENT[self.cls.difference] + + def test_lenient_default(self, mocker): + other = mocker.sentinel.other + return_value = mocker.sentinel.return_value + patcher = mocker.patch.object( BaseMetadata, "difference", return_value=return_value - ) as mocker: - result = self.none.difference(other) - - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(lenient=None), kwargs) - - def test_lenient(self): - other = sentinel.other - lenient = sentinel.lenient - return_value = sentinel.return_value - with mock.patch.object( + ) + result = self.none.difference(other) + + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == dict(lenient=None) + + def test_lenient(self, mocker): + other = mocker.sentinel.other + lenient = mocker.sentinel.lenient + return_value = mocker.sentinel.return_value + patcher = mocker.patch.object( BaseMetadata, "difference", return_value=return_value - ) as mocker: - result = self.none.difference(other, lenient=lenient) + ) + result = self.none.difference(other, lenient=lenient) - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(lenient=lenient), kwargs) + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == dict(lenient=lenient) - def test_op_lenient_same(self): + def test_op_lenient_same(self, mocker): lmetadata = self.cls(**self.values) rmetadata = self.cls(**self.values) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertIsNone(lmetadata.difference(rmetadata)) - self.assertIsNone(rmetadata.difference(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.difference(rmetadata) is None + assert rmetadata.difference(lmetadata) is None - def test_op_lenient_same_none(self): + def test_op_lenient_same_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["var_name"] = None rmetadata = self.cls(**right) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertIsNone(lmetadata.difference(rmetadata)) - self.assertIsNone(rmetadata.difference(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.difference(rmetadata) is None + assert rmetadata.difference(lmetadata) is None - def test_op_lenient_different(self): + def test_op_lenient_different(self, mocker): left = self.values.copy() lmetadata = self.cls(**left) right = self.values.copy() @@ -381,19 +381,19 @@ def test_op_lenient_different(self): rexpected = deepcopy(self.none)._asdict() rexpected["units"] = lexpected["units"][::-1] - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(lexpected, lmetadata.difference(rmetadata)._asdict()) - self.assertEqual(rexpected, rmetadata.difference(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=True) + assert lmetadata.difference(rmetadata)._asdict() == lexpected + assert rmetadata.difference(lmetadata)._asdict() == rexpected - def test_op_strict_same(self): + def test_op_strict_same(self, mocker): lmetadata = self.cls(**self.values) rmetadata = self.cls(**self.values) - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertIsNone(lmetadata.difference(rmetadata)) - self.assertIsNone(rmetadata.difference(lmetadata)) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.difference(rmetadata) is None + assert rmetadata.difference(lmetadata) is None - def test_op_strict_different(self): + def test_op_strict_different(self, mocker): left = self.values.copy() lmetadata = self.cls(**left) right = self.values.copy() @@ -404,11 +404,11 @@ def test_op_strict_different(self): rexpected = deepcopy(self.none)._asdict() rexpected["long_name"] = lexpected["long_name"][::-1] - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(lexpected, lmetadata.difference(rmetadata)._asdict()) - self.assertEqual(rexpected, rmetadata.difference(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.difference(rmetadata)._asdict() == lexpected + assert rmetadata.difference(lmetadata)._asdict() == rexpected - def test_op_strict_different_none(self): + def test_op_strict_different_none(self, mocker): left = self.values.copy() lmetadata = self.cls(**left) right = self.values.copy() @@ -419,54 +419,47 @@ def test_op_strict_different_none(self): rexpected = deepcopy(self.none)._asdict() rexpected["long_name"] = lexpected["long_name"][::-1] - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(lexpected, lmetadata.difference(rmetadata)._asdict()) - self.assertEqual(rexpected, rmetadata.difference(lmetadata)._asdict()) + mocker.patch("iris.common.metadata._LENIENT", return_value=False) + assert lmetadata.difference(rmetadata)._asdict() == lexpected + assert rmetadata.difference(lmetadata)._asdict() == rexpected -class Test_equal(tests.IrisTest): - def setUp(self): +class Test_equal: + @pytest.fixture(autouse=True) + def _setup(self): self.cls = AncillaryVariableMetadata self.none = self.cls(*(None,) * len(self.cls._fields)) def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.equal.__doc__, self.cls.equal.__doc__) + assert self.cls.equal.__doc__ == BaseMetadata.equal.__doc__ def test_lenient_service(self): qualname_equal = _qualname(self.cls.equal) - self.assertIn(qualname_equal, _LENIENT) - self.assertTrue(_LENIENT[qualname_equal]) - self.assertTrue(_LENIENT[self.cls.equal]) - - def test_lenient_default(self): - other = sentinel.other - return_value = sentinel.return_value - with mock.patch.object( - BaseMetadata, "equal", return_value=return_value - ) as mocker: - result = self.none.equal(other) - - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(lenient=None), kwargs) - - def test_lenient(self): - other = sentinel.other - lenient = sentinel.lenient - return_value = sentinel.return_value - with mock.patch.object( - BaseMetadata, "equal", return_value=return_value - ) as mocker: - result = self.none.equal(other, lenient=lenient) - - self.assertEqual(return_value, result) - self.assertEqual(1, mocker.call_count) - (arg,), kwargs = mocker.call_args - self.assertEqual(other, arg) - self.assertEqual(dict(lenient=lenient), kwargs) - - -if __name__ == "__main__": - tests.main() + assert qualname_equal in _LENIENT + assert _LENIENT[qualname_equal] + assert _LENIENT[self.cls.equal] + + def test_lenient_default(self, mocker): + other = mocker.sentinel.other + return_value = mocker.sentinel.return_value + patcher = mocker.patch.object(BaseMetadata, "equal", return_value=return_value) + result = self.none.equal(other) + + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == dict(lenient=None) + + def test_lenient(self, mocker): + other = mocker.sentinel.other + lenient = mocker.sentinel.lenient + return_value = mocker.sentinel.return_value + patcher = mocker.patch.object(BaseMetadata, "equal", return_value=return_value) + result = self.none.equal(other, lenient=lenient) + + assert result == return_value + assert patcher.call_count == 1 + (arg,), kwargs = patcher.call_args + assert arg == other + assert kwargs == dict(lenient=lenient)