From ae03f142396c222c32c615e4c4341cc40d72e428 Mon Sep 17 00:00:00 2001 From: Bill Little Date: Thu, 21 Mar 2024 13:38:19 +0000 Subject: [PATCH] pytest migration of unit.common.metadata.test_CellMeasureMetadata --- .../metadata/test_CellMeasureMetadata.py | 574 +++++++++--------- 1 file changed, 283 insertions(+), 291 deletions(-) diff --git a/lib/iris/tests/unit/common/metadata/test_CellMeasureMetadata.py b/lib/iris/tests/unit/common/metadata/test_CellMeasureMetadata.py index 3618d2ace5..4a83c32268 100644 --- a/lib/iris/tests/unit/common/metadata/test_CellMeasureMetadata.py +++ b/lib/iris/tests/unit/common/metadata/test_CellMeasureMetadata.py @@ -4,26 +4,23 @@ # See LICENSE in the root of the repository for full licensing details. """Unit tests for the :class:`iris.common.metadata.CellMeasureMetadata`.""" -# 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, CellMeasureMetadata -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.measure = mock.sentinel.measure +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.measure = mocker.sentinel.measure self.cls = CellMeasureMetadata def test_repr(self): @@ -47,7 +44,7 @@ def test_repr(self): self.attributes, self.measure, ) - self.assertEqual(expected, repr(metadata)) + assert repr(metadata) == expected def test__fields(self): expected = ( @@ -58,148 +55,148 @@ def test__fields(self): "attributes", "measure", ) - 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, - measure=sentinel.measure, + 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, + measure=mocker.sentinel.measure, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = CellMeasureMetadata def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.__eq__.__doc__, self.cls.__eq__.__doc__) + assert BaseMetadata.__eq__.__doc__ == self.cls.__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_measure_none(self): + def test_op_lenient_same_measure_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = None 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(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_measure(self): + def test_op_lenient_different_measure(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = 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_measure(self): + def test_op_strict_different_measure(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = 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) - def test_op_strict_different_measure_none(self): + def test_op_strict_different_measure_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = 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 = CellMeasureMetadata self.one = self.cls(1, 1, 1, 1, 1, 1) self.two = self.cls(1, 1, 1, 2, 1, 1) @@ -208,111 +205,112 @@ 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, - measure=sentinel.measure, + 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, + measure=mocker.sentinel.measure, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = CellMeasureMetadata self.none = self.cls(*(None,) * len(self.cls._fields)) def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.combine.__doc__, self.cls.combine.__doc__) + assert BaseMetadata.combine.__doc__ == self.cls.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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() - 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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() - def test_op_lenient_same_measure_none(self): + def test_op_lenient_same_measure_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = None rmetadata = self.cls(**right) expected = right.copy() - 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 expected == lmetadata.combine(rmetadata)._asdict() + assert 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 @@ -320,11 +318,11 @@ 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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() - def test_op_lenient_different_measure(self): + def test_op_lenient_different_measure(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = self.dummy @@ -332,20 +330,20 @@ def test_op_lenient_different_measure(self): expected = self.values.copy() expected["measure"] = 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 expected == lmetadata.combine(rmetadata)._asdict() + assert 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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() - 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 @@ -353,11 +351,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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() - def test_op_strict_different_measure(self): + def test_op_strict_different_measure(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = self.dummy @@ -365,11 +363,11 @@ def test_op_strict_different_measure(self): expected = self.values.copy() expected["measure"] = 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 expected == lmetadata.combine(rmetadata)._asdict() + assert 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 @@ -377,11 +375,11 @@ 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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() - def test_op_strict_different_measure_none(self): + def test_op_strict_different_measure_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = None @@ -389,96 +387,97 @@ def test_op_strict_different_measure_none(self): expected = self.values.copy() expected["measure"] = 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 expected == lmetadata.combine(rmetadata)._asdict() + assert expected == rmetadata.combine(lmetadata)._asdict() -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, - measure=sentinel.measure, + 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, + measure=mocker.sentinel.measure, ) - self.dummy = sentinel.dummy + self.dummy = mocker.sentinel.dummy self.cls = CellMeasureMetadata self.none = self.cls(*(None,) * len(self.cls._fields)) def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.difference.__doc__, self.cls.difference.__doc__) + assert BaseMetadata.difference.__doc__ == self.cls.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_measure_none(self): + def test_op_lenient_same_measure_none(self, mocker): lmetadata = self.cls(**self.values) right = self.values.copy() right["measure"] = None rmetadata = self.cls(**right) lexpected = deepcopy(self.none)._asdict() - lexpected["measure"] = (sentinel.measure, None) + lexpected["measure"] = (mocker.sentinel.measure, None) rexpected = deepcopy(self.none)._asdict() - rexpected["measure"] = (None, sentinel.measure) + rexpected["measure"] = (None, mocker.sentinel.measure) - 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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert 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() @@ -489,11 +488,11 @@ 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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert rexpected == rmetadata.difference(lmetadata)._asdict() - def test_op_lenient_different_measure(self): + def test_op_lenient_different_measure(self, mocker): left = self.values.copy() lmetadata = self.cls(**left) right = self.values.copy() @@ -504,19 +503,19 @@ def test_op_lenient_different_measure(self): rexpected = deepcopy(self.none)._asdict() rexpected["measure"] = lexpected["measure"][::-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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert 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() @@ -527,11 +526,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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert rexpected == rmetadata.difference(lmetadata)._asdict() - def test_op_strict_different_measure(self): + def test_op_strict_different_measure(self, mocker): left = self.values.copy() lmetadata = self.cls(**left) right = self.values.copy() @@ -542,11 +541,11 @@ def test_op_strict_different_measure(self): rexpected = deepcopy(self.none)._asdict() rexpected["measure"] = lexpected["measure"][::-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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert 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() @@ -557,11 +556,11 @@ 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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert rexpected == rmetadata.difference(lmetadata)._asdict() - def test_op_strict_different_measure_none(self): + def test_op_strict_different_measure_none(self, mocker): left = self.values.copy() lmetadata = self.cls(**left) right = self.values.copy() @@ -572,54 +571,47 @@ def test_op_strict_different_measure_none(self): rexpected = deepcopy(self.none)._asdict() rexpected["measure"] = lexpected["measure"][::-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 lexpected == lmetadata.difference(rmetadata)._asdict() + assert rexpected == rmetadata.difference(lmetadata)._asdict() -class Test_equal(tests.IrisTest): - def setUp(self): +class Test_equal: + @pytest.fixture(autouse=True) + def _setup(self): self.cls = CellMeasureMetadata self.none = self.cls(*(None,) * len(self.cls._fields)) def test_wraps_docstring(self): - self.assertEqual(BaseMetadata.equal.__doc__, self.cls.equal.__doc__) + assert BaseMetadata.equal.__doc__ == self.cls.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)