Skip to content

Commit

Permalink
Convert Test_difference to pytest.
Browse files Browse the repository at this point in the history
  • Loading branch information
@pp-mo
pp-mo committed Sep 28, 2022
1 parent e0e669c commit c58ceb7
Showing 1 changed file with 119 additions and 175 deletions.
294 changes: 119 additions & 175 deletions lib/iris/tests/unit/common/metadata/test_CubeMetadata.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -444,7 +444,7 @@ def test_op_different__attribute_value(self, op_leniency):
lmetadata = self.cls(**self.lvalues)
rmetadata = self.cls(**self.rvalues)

# Result contains entirely EMPTY attributes (either strict or lenient).
# Result has entirely EMPTY attributes (whether strict or lenient).
# TODO: is this maybe a mistake of the existing implementation ?
expected = self.lvalues.copy()
expected["attributes"] = None
Expand All @@ -457,30 +457,31 @@ def test_op_different__attribute_value(self, op_leniency):
assert rmetadata.combine(lmetadata)._asdict() == expected


class Test_difference(tests.IrisTest):
def setUp(self):
self.values = dict(
class Test_difference:
@pytest.fixture(autouse=True)
def setup(self):
self.lvalues = dict(
standard_name=sentinel.standard_name,
long_name=sentinel.long_name,
var_name=sentinel.var_name,
units=sentinel.units,
attributes=sentinel.attributes,
attributes=dict(), # MUST be a dict
cell_methods=sentinel.cell_methods,
)
# Make a copy with all-different objects in it.
self.rvalues = deepcopy(self.lvalues)
self.dummy = sentinel.dummy
self.cls = CubeMetadata
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])
assert qualname_difference in _LENIENT
assert _LENIENT[qualname_difference]
assert _LENIENT[self.cls.difference]

def test_lenient_default(self):
other = sentinel.other
Expand All @@ -490,11 +491,8 @@ def test_lenient_default(self):
) 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)
assert return_value == result
assert mocker.call_args_list == [mock.call(other, lenient=None)]

def test_lenient(self):
other = sentinel.other
Expand All @@ -505,178 +503,124 @@ def test_lenient(self):
) as mocker:
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 return_value == result
assert mocker.call_args_list == [mock.call(other, lenient=lenient)]

def test_op_lenient_same(self):
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))

def test_op_lenient_same_none(self):
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))

def test_op_lenient_same_cell_methods_none(self):
lmetadata = self.cls(**self.values)
right = self.values.copy()
right["cell_methods"] = None
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["cell_methods"] = (sentinel.cell_methods, None)
rexpected = deepcopy(self.none)._asdict()
rexpected["cell_methods"] = (None, sentinel.cell_methods)

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_same(self, op_leniency):
is_lenient = op_leniency == "lenient"
lmetadata = self.cls(**self.lvalues)
rmetadata = self.cls(**self.rvalues)

def test_op_lenient_different(self):
left = self.values.copy()
lmetadata = self.cls(**left)
right = self.values.copy()
right["units"] = self.dummy
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["units"] = (left["units"], right["units"])
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()
)
with mock.patch(
"iris.common.metadata._LENIENT", return_value=is_lenient
):
assert lmetadata.difference(rmetadata) is None
assert rmetadata.difference(lmetadata) is None

def test_op_lenient_different_cell_methods(self):
left = self.values.copy()
lmetadata = self.cls(**left)
right = self.values.copy()
right["cell_methods"] = self.dummy
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["cell_methods"] = (
left["cell_methods"],
right["cell_methods"],
)
rexpected = deepcopy(self.none)._asdict()
rexpected["cell_methods"] = lexpected["cell_methods"][::-1]
def test_op_different__none(self, fieldname, op_leniency):
if fieldname in ("attributes",): # 'units'):
# These cannot properly be set to 'None'. Tested elsewhere.
pytest.skip()

with mock.patch("iris.common.metadata._LENIENT", return_value=True):
self.assertEqual(
lexpected, lmetadata.difference(rmetadata)._asdict()
)
self.assertEqual(
rexpected, rmetadata.difference(lmetadata)._asdict()
)
is_lenient = op_leniency == "lenient"

lmetadata = self.cls(**self.lvalues)
self.rvalues[fieldname] = None
rmetadata = self.cls(**self.rvalues)

def test_op_strict_same(self):
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))

def test_op_strict_different(self):
left = self.values.copy()
lmetadata = self.cls(**left)
right = self.values.copy()
right["long_name"] = self.dummy
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["long_name"] = (left["long_name"], right["long_name"])
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()
if fieldname in ("units", "cell_methods"):
# These ones are always "strict"
strict_result = True
elif fieldname in ("standard_name", "long_name", "var_name"):
strict_result = not is_lenient
else:
# Ensure we are handling all the different field cases
raise ValueError(
f"{self.__name__} unhandled fieldname : {fieldname}"
)
self.assertEqual(
rexpected, rmetadata.difference(lmetadata)._asdict()

if strict_result:
diffentry = tuple(
[getattr(mm, fieldname) for mm in (lmetadata, rmetadata)]
)
lexpected = self.none._asdict()
lexpected[fieldname] = diffentry
rexpected = lexpected.copy()
rexpected[fieldname] = diffentry[::-1]
# NOTE: in these cases, the difference metadata will fail an == operation,
# because of the 'None' entries.
# But we can use metadata._asdict() and test that.

def test_op_strict_different_cell_methods(self):
left = self.values.copy()
lmetadata = self.cls(**left)
right = self.values.copy()
right["cell_methods"] = self.dummy
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["cell_methods"] = (
left["cell_methods"],
right["cell_methods"],
)
rexpected = deepcopy(self.none)._asdict()
rexpected["cell_methods"] = lexpected["cell_methods"][::-1]
with mock.patch(
"iris.common.metadata._LENIENT", return_value=is_lenient
):
if strict_result:
assert lmetadata.difference(rmetadata)._asdict() == lexpected
assert rmetadata.difference(lmetadata)._asdict() == rexpected
else:
# Expect NO differences
assert lmetadata.difference(rmetadata) is None
assert rmetadata.difference(lmetadata) is None

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_different__attribute_extra(self, op_leniency):
is_lenient = op_leniency == "lenient"
self.lvalues["attributes"] = {"_a_common_": self.dummy}
lmetadata = self.cls(**self.lvalues)
rvalues = deepcopy(self.lvalues)
rvalues["attributes"]["_b_extra_"] = mock.sentinel.extra
rmetadata = self.cls(**rvalues)

if not is_lenient:
# In this case, attributes returns a "difference dictionary"
diffentry = tuple([{}, {"_b_extra_": mock.sentinel.extra}])
lexpected = self.none._asdict()
lexpected["attributes"] = diffentry
rexpected = lexpected.copy()
rexpected["attributes"] = diffentry[::-1]

def test_op_strict_different_none(self):
left = self.values.copy()
lmetadata = self.cls(**left)
right = self.values.copy()
right["long_name"] = None
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["long_name"] = (left["long_name"], right["long_name"])
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()
)
with mock.patch(
"iris.common.metadata._LENIENT", return_value=is_lenient
):
if is_lenient:
# It recognises no difference
assert lmetadata.difference(rmetadata) is None
assert rmetadata.difference(lmetadata) is None
else:
# As calculated above
assert lmetadata.difference(rmetadata)._asdict() == lexpected
assert rmetadata.difference(lmetadata)._asdict() == rexpected

def test_op_different__attribute_value(self, op_leniency):
is_lenient = op_leniency == "lenient"
self.lvalues["attributes"] = {
"_a_common_": self.dummy,
"_b_extra_": mock.sentinel.value1,
}
lmetadata = self.cls(**self.lvalues)
self.rvalues["attributes"] = {
"_a_common_": self.dummy,
"_b_extra_": mock.sentinel.value2,
}
rmetadata = self.cls(**self.rvalues)

def test_op_strict_different_measure_none(self):
left = self.values.copy()
lmetadata = self.cls(**left)
right = self.values.copy()
right["cell_methods"] = None
rmetadata = self.cls(**right)
lexpected = deepcopy(self.none)._asdict()
lexpected["cell_methods"] = (
left["cell_methods"],
right["cell_methods"],
# In this case, attributes returns a "difference dictionary"
diffentry = tuple(
[
{"_b_extra_": mock.sentinel.value1},
{"_b_extra_": mock.sentinel.value2},
]
)
rexpected = deepcopy(self.none)._asdict()
rexpected["cell_methods"] = lexpected["cell_methods"][::-1]
lexpected = self.none._asdict()
lexpected["attributes"] = diffentry
rexpected = lexpected.copy()
rexpected["attributes"] = diffentry[::-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()
)
with mock.patch(
"iris.common.metadata._LENIENT", return_value=is_lenient
):
# As calculated above -- same for both strict + lenient
assert lmetadata.difference(rmetadata)._asdict() == lexpected
assert rmetadata.difference(lmetadata)._asdict() == rexpected


class Test_equal(tests.IrisTest):
Expand Down

0 comments on commit c58ceb7

Please sign in to comment.