diff --git a/lib/iris/tests/unit/common/metadata/test_CoordMetadata.py b/lib/iris/tests/unit/common/metadata/test_CoordMetadata.py index 010838b7fc..bb6b2115d2 100644 --- a/lib/iris/tests/unit/common/metadata/test_CoordMetadata.py +++ b/lib/iris/tests/unit/common/metadata/test_CoordMetadata.py @@ -4,27 +4,24 @@ # See LICENSE in the root of the repository for full licensing details. """Unit tests for the :class:`iris.common.metadata.CoordMetadata`.""" -# 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 BaseMetadata, CoordMetadata -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 - self.coord_system = mock.sentinel.coord_system - self.climatological = mock.sentinel.climatological +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.coord_system = mocker.sentinel.coord_system + self.climatological = mocker.sentinel.climatological self.cls = CoordMetadata def test_repr(self): @@ -51,7 +48,7 @@ def test_repr(self): self.coord_system, self.climatological, ) - self.assertEqual(expected, repr(metadata)) + assert repr(metadata) == expected def test__fields(self): expected = ( @@ -63,153 +60,153 @@ def test__fields(self): "coord_system", "climatological", ) - 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, - coord_system=sentinel.coord_system, - climatological=sentinel.climatological, + 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, + coord_system=mocker.sentinel.coord_system, + climatological=mocker.sentinel.climatological, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = CoordMetadata 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_same_members_none(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=True) - def test_op_lenient_same_members_none(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() right[member] = None rmetadata = self.cls(**right) + assert not lmetadata.__eq__(rmetadata) + assert not rmetadata.__eq__(lmetadata) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertFalse(lmetadata.__eq__(rmetadata)) - self.assertFalse(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_lenient_different_members(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=True) - def test_op_lenient_different_members(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() right[member] = self.dummy rmetadata = self.cls(**right) + assert not lmetadata.__eq__(rmetadata) + assert not rmetadata.__eq__(lmetadata) - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertFalse(lmetadata.__eq__(rmetadata)) - self.assertFalse(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_members(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=False) - def test_op_strict_different_members(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() right[member] = self.dummy rmetadata = self.cls(**right) + assert not lmetadata.__eq__(rmetadata) + assert not rmetadata.__eq__(lmetadata) - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertFalse(lmetadata.__eq__(rmetadata)) - self.assertFalse(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) + + def test_op_strict_different_members_none(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=False) - def test_op_strict_different_members_none(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() right[member] = 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)) + 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 = CoordMetadata self.one = self.cls(1, 1, 1, 1, 1, 1, 1) self.two = self.cls(1, 1, 1, 2, 1, 1, 1) @@ -218,113 +215,114 @@ 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_coord_system(self): result = self.one < self.attributes_cs - self.assertFalse(result) + assert not result result = self.attributes_cs < 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, - coord_system=sentinel.coord_system, - climatological=sentinel.climatological, + 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, + coord_system=mocker.sentinel.coord_system, + climatological=mocker.sentinel.climatological, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = CoordMetadata 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_same_members_none(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=True) - def test_op_lenient_same_members_none(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() right[member] = None rmetadata = self.cls(**right) expected = right.copy() + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertTrue(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertTrue(expected, rmetadata.combine(lmetadata)._asdict()) - - 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 @@ -332,11 +330,13 @@ 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_lenient_different_members(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=True) - def test_op_lenient_different_members(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() @@ -344,21 +344,19 @@ def test_op_lenient_different_members(self): rmetadata = self.cls(**right) expected = self.values.copy() expected[member] = None + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) - - 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 @@ -366,11 +364,13 @@ 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_members(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=False) - def test_op_strict_different_members(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() @@ -378,12 +378,10 @@ def test_op_strict_different_members(self): rmetadata = self.cls(**right) expected = self.values.copy() expected[member] = None + assert lmetadata.combine(rmetadata)._asdict() == expected + assert rmetadata.combine(lmetadata)._asdict() == expected - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(expected, lmetadata.combine(rmetadata)._asdict()) - self.assertEqual(expected, rmetadata.combine(lmetadata)._asdict()) - - 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 @@ -391,11 +389,13 @@ 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 + + def test_op_strict_different_members_none(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=False) - def test_op_strict_different_members_none(self): for member in self.cls._members: lmetadata = self.cls(**self.values) right = self.values.copy() @@ -403,84 +403,85 @@ def test_op_strict_different_members_none(self): rmetadata = self.cls(**right) expected = self.values.copy() expected[member] = 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()) + 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, - coord_system=sentinel.coord_system, - climatological=sentinel.climatological, + 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, + coord_system=mocker.sentinel.coord_system, + climatological=mocker.sentinel.climatological, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = CoordMetadata 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_same_members_none(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=True) - def test_op_lenient_same_members_none(self): for member in self.cls._members: lmetadata = self.cls(**self.values) member_value = getattr(lmetadata, member) @@ -491,12 +492,10 @@ def test_op_lenient_same_members_none(self): lexpected[member] = (member_value, None) rexpected = deepcopy(self.none)._asdict() rexpected[member] = (None, member_value) + assert lmetadata.difference(rmetadata)._asdict() == lexpected + assert rmetadata.difference(lmetadata)._asdict() == rexpected - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(lexpected, lmetadata.difference(rmetadata)._asdict()) - self.assertEqual(rexpected, rmetadata.difference(lmetadata)._asdict()) - - 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() @@ -507,11 +506,13 @@ 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_lenient_different_members(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=True) - def test_op_lenient_different_members(self): for member in self.cls._members: left = self.values.copy() lmetadata = self.cls(**left) @@ -522,20 +523,18 @@ def test_op_lenient_different_members(self): lexpected[member] = (left[member], right[member]) rexpected = deepcopy(self.none)._asdict() rexpected[member] = lexpected[member][::-1] + assert lmetadata.difference(rmetadata)._asdict() == lexpected + assert rmetadata.difference(lmetadata)._asdict() == rexpected - with mock.patch("iris.common.metadata._LENIENT", return_value=True): - self.assertEqual(lexpected, lmetadata.difference(rmetadata)._asdict()) - self.assertEqual(rexpected, rmetadata.difference(lmetadata)._asdict()) - - 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() @@ -546,11 +545,13 @@ 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_members(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=False) - def test_op_strict_different_members(self): for member in self.cls._members: left = self.values.copy() lmetadata = self.cls(**left) @@ -561,12 +562,10 @@ def test_op_strict_different_members(self): lexpected[member] = (left[member], right[member]) rexpected = deepcopy(self.none)._asdict() rexpected[member] = lexpected[member][::-1] + assert lmetadata.difference(rmetadata)._asdict() == lexpected + assert rmetadata.difference(lmetadata)._asdict() == rexpected - with mock.patch("iris.common.metadata._LENIENT", return_value=False): - self.assertEqual(lexpected, lmetadata.difference(rmetadata)._asdict()) - self.assertEqual(rexpected, rmetadata.difference(lmetadata)._asdict()) - - 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() @@ -577,11 +576,13 @@ 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 + + def test_op_strict_different_members_none(self, mocker): + mocker.patch("iris.common.metadata._LENIENT", return_value=False) - def test_op_strict_different_members_none(self): for member in self.cls._members: left = self.values.copy() lmetadata = self.cls(**left) @@ -592,55 +593,46 @@ def test_op_strict_different_members_none(self): lexpected[member] = (left[member], right[member]) rexpected = deepcopy(self.none)._asdict() rexpected[member] = lexpected[member][::-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()) + 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 = CoordMetadata 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)