Generalise attributes tests to do both global+local.

Author: pp-mo

lib/iris/tests/unit/common/metadata/test_CubeMetadata.py

@@ -100,15 +100,23 @@ def test_bases(self):
 
 
 @pytest.fixture(params=CubeMetadata._fields)
+# Fixture to parametrise tests over all CubeMetadata fields.
 def fieldname(request):
     return request.param
 
 
 @pytest.fixture(params=["strict", "lenient"])
+# Fixture to parametrise tests over strict/lenient behaviour.
 def op_leniency(request):
     return request.param
 
 
+@pytest.fixture(params=["attributes", "global_attributes"])
+# Fixture to parametrise atrribute tests over global/local attributes fields.
+def attributes_fieldname(request):
+    return request.param
+
+
 class Test___eq__:
     @pytest.fixture(autouse=True)
     def setup(self):
@@ -226,13 +234,13 @@ def test_op_different__value(self, fieldname, op_leniency):
                 assert lmetadata.__eq__(rmetadata) == expect_success
                 assert rmetadata.__eq__(lmetadata) == expect_success
 
-    # TODO: generalise attribute testing to global_attributes
-
-    def test_op_different__attribute_extra(self, op_leniency):
+    def test_op_different__attribute_extra(
+        self, attributes_fieldname, op_leniency
+    ):
         # Check when one set of attributes has an extra entry.
         is_lenient = op_leniency == "lenient"
         lmetadata = self.cls(**self.lvalues)
-        self.rvalues["attributes"]["_extra_"] = 1
+        self.rvalues[attributes_fieldname]["_extra_"] = 1
         rmetadata = self.cls(**self.rvalues)
         # This counts as equal *only* in the lenient case.
         expect_success = is_lenient
@@ -243,11 +251,13 @@ def test_op_different__attribute_extra(self, op_leniency):
             assert lmetadata.__eq__(rmetadata) == expect_success
             assert rmetadata.__eq__(lmetadata) == expect_success
 
-    def test_op_different__attribute_value(self, op_leniency):
+    def test_op_different__attribute_value(
+        self, attributes_fieldname, op_leniency
+    ):
         # lhs and rhs have different values for an attribute, both strict + lenient.
         is_lenient = op_leniency == "lenient"
-        self.lvalues["attributes"]["_extra_"] = mock.sentinel.value1
-        self.rvalues["attributes"]["_extra_"] = mock.sentinel.value2
+        self.lvalues[attributes_fieldname]["_extra_"] = mock.sentinel.value1
+        self.rvalues[attributes_fieldname]["_extra_"] = mock.sentinel.value2
         lmetadata = self.cls(**self.lvalues)
         rmetadata = self.cls(**self.rvalues)
         with mock.patch(
@@ -422,15 +432,19 @@ def test_op_different__value(self, fieldname, op_leniency):
             assert lmetadata.combine(rmetadata)._asdict() == expected
             assert rmetadata.combine(lmetadata)._asdict() == expected
 
-    # TODO: generalise attribute testing to global_attributes
-
-    def test_op_different__attribute_extra(self, op_leniency):
+    def test_op_different__attribute_extra(
+        self, attributes_fieldname, op_leniency
+    ):
         # One field has an extra attribute, both strict + lenient.
         is_lenient = op_leniency == "lenient"
 
-        self.lvalues["attributes"] = {"_a_common_": mock.sentinel.dummy}
-        self.rvalues["attributes"] = self.lvalues["attributes"].copy()
-        self.rvalues["attributes"]["_extra_"] = mock.sentinel.testvalue
+        self.lvalues[attributes_fieldname] = {
+            "_a_common_": mock.sentinel.dummy
+        }
+        self.rvalues[attributes_fieldname] = self.lvalues[
+            attributes_fieldname
+        ].copy()
+        self.rvalues[attributes_fieldname]["_extra_"] = mock.sentinel.testvalue
         lmetadata = self.cls(**self.lvalues)
         rmetadata = self.cls(**self.rvalues)
 
@@ -448,15 +462,17 @@ def test_op_different__attribute_extra(self, op_leniency):
             assert lmetadata.combine(rmetadata)._asdict() == expected
             assert rmetadata.combine(lmetadata)._asdict() == expected
 
-    def test_op_different__attribute_value(self, op_leniency):
+    def test_op_different__attribute_value(
+        self, attributes_fieldname, op_leniency
+    ):
         # lhs and rhs have different values for an attribute, both strict + lenient.
         is_lenient = op_leniency == "lenient"
 
-        self.lvalues["attributes"] = {
+        self.lvalues[attributes_fieldname] = {
             "_a_common_": self.dummy,
             "_b_common_": mock.sentinel.value1,
         }
-        self.lvalues["attributes"] = {
+        self.lvalues[attributes_fieldname] = {
             "_a_common_": self.dummy,
             "_b_common_": mock.sentinel.value2,
         }
@@ -466,7 +482,7 @@ def test_op_different__attribute_value(self, op_leniency):
         # 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
+        expected[attributes_fieldname] = None
 
         with mock.patch(
             "iris.common.metadata._LENIENT", return_value=is_lenient
@@ -605,24 +621,24 @@ def test_op_different__value(self, fieldname, op_leniency):
         assert lmetadata.difference(rmetadata)._asdict() == ldiff_metadata
         assert rmetadata.difference(lmetadata)._asdict() == rdiff_metadata
 
-    # TODO: generalise attribute testing to global_attributes
-
-    def test_op_different__attribute_extra(self, op_leniency):
+    def test_op_different__attribute_extra(
+        self, attributes_fieldname, op_leniency
+    ):
         # One field has an extra attribute, both strict + lenient.
         is_lenient = op_leniency == "lenient"
-        self.lvalues["attributes"] = {"_a_common_": self.dummy}
+        self.lvalues[attributes_fieldname] = {"_a_common_": self.dummy}
         lmetadata = self.cls(**self.lvalues)
         rvalues = deepcopy(self.lvalues)
-        rvalues["attributes"]["_b_extra_"] = mock.sentinel.extra
+        rvalues[attributes_fieldname]["_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
+            lexpected[attributes_fieldname] = diffentry
             rexpected = lexpected.copy()
-            rexpected["attributes"] = diffentry[::-1]
+            rexpected[attributes_fieldname] = diffentry[::-1]
 
         with mock.patch(
             "iris.common.metadata._LENIENT", return_value=is_lenient
@@ -636,15 +652,17 @@ def test_op_different__attribute_extra(self, op_leniency):
                 assert lmetadata.difference(rmetadata)._asdict() == lexpected
                 assert rmetadata.difference(lmetadata)._asdict() == rexpected
 
-    def test_op_different__attribute_value(self, op_leniency):
+    def test_op_different__attribute_value(
+        self, attributes_fieldname, op_leniency
+    ):
         # lhs and rhs have different values for an attribute, both strict + lenient.
         is_lenient = op_leniency == "lenient"
-        self.lvalues["attributes"] = {
+        self.lvalues[attributes_fieldname] = {
             "_a_common_": self.dummy,
             "_b_extra_": mock.sentinel.value1,
         }
         lmetadata = self.cls(**self.lvalues)
-        self.rvalues["attributes"] = {
+        self.rvalues[attributes_fieldname] = {
             "_a_common_": self.dummy,
             "_b_extra_": mock.sentinel.value2,
         }
@@ -658,9 +676,9 @@ def test_op_different__attribute_value(self, op_leniency):
             ]
         )
         lexpected = self.none._asdict()
-        lexpected["attributes"] = diffentry
+        lexpected[attributes_fieldname] = diffentry
         rexpected = lexpected.copy()
-        rexpected["attributes"] = diffentry[::-1]
+        rexpected[attributes_fieldname] = diffentry[::-1]
 
         with mock.patch(
             "iris.common.metadata._LENIENT", return_value=is_lenient