fix pytest-dev#3

Author: Orenef11

src/_pytest/mark/structures.py

@@ -1,5 +1,6 @@
 import collections.abc
 import inspect
+import operator
 import warnings
 from typing import Any
 from typing import Callable
@@ -369,28 +370,30 @@ def get_unpacked_marks(obj: object) -> Iterable[Mark]:
     return mark_list
 
 
-def get_unpacked_marks(obj) -> List[Mark]:
-    """Obtain the unpacked marks that are stored on an object."""
-    return normalize_mark_list(get_unpacked_marks(obj))
+def marks_to_dict(marks: Iterable[Mark]) -> Dict[str, Mark]:
+    return {mark.name if mark.name != "parametrize" else mark.args[0]: mark for mark in marks}
 
 
-def extract_mro_markers(cls):
-    if cls is None or getattr(cls, "mro_markers", []) or cls is object:
-        return
+def get_mro_marks(cls: type) -> Dict[str, Mark]:
+    if cls is object or cls is None:
+        return {}
+    if hasattr(cls, "mro_markers"):
+        return getattr(cls, "mro_markers")
 
-    markers = {str(mark): mark for mark in get_unpacked_marks(cls) if mark.name != "parametrize"}
-    for parent_obj in cls.__mro__[::-1][:-1]:
-        if parent_obj is object:
-            continue
-        if not getattr(parent_obj, "mro_markers", []):
-            extract_mro_markers(parent_obj)
+    markers_dict = marks_to_dict(get_unpacked_marks(cls))
+    for parent_obj in cls.__mro__[1:]:
+        if parent_obj is not object:
+            for mark_name, mark in get_mro_marks(parent_obj).items():
+                if mark_name not in markers_dict:
+                    markers_dict[mark_name] = mark
 
-        [
-            markers.__setitem__(str(mark), mark)
-            for mark in parent_obj.mro_markers
-            if mark.name != "parametrize"
-        ]
-    setattr(cls, "mro_markers", list(markers.values()))
+    # The method is recursive, and it's called for each class.
+    # To not extract the marks for each item's classes, I store the variable in "cls" as variable cached.
+    setattr(cls, "mro_markers", markers_dict)
+    # marks = dict(markers_dict, **{mark.name: mark for mark in getattr(cls, "pytestmark", [])})
+    # setattr(cls, "pytestmark", list(marks.values()))
+    # return marks
+    return markers_dict
 
 
 def normalize_mark_list(

src/_pytest/nodes.py

@@ -378,14 +378,10 @@ def iter_markers_with_node(
         :param name: If given, filter the results by the name attribute.
         :returns: An iterator of (node, mark) tuples.
         """
-        duplicate_markers = set()
         for node in reversed(self.listchain()):
             for mark in node.own_markers:
-                if (name is None or getattr(mark, "name", None) == name) and str(
-                    mark
-                ) not in duplicate_markers:
+                if name is None or getattr(mark, "name", None) == name:
                     yield node, mark
-                    duplicate_markers.add(str(mark))
 
     @overload
     def get_closest_marker(self, name: str) -> Optional[Mark]:

src/_pytest/python.py

@@ -63,8 +63,7 @@
 from _pytest.main import Session
 from _pytest.mark import MARK_GEN
 from _pytest.mark import ParameterSet
-from _pytest.mark.structures import extract_mro_markers
-from _pytest.mark.structures import get_marks_as_list
+from _pytest.mark.structures import get_mro_marks, marks_to_dict
 from _pytest.mark.structures import get_unpacked_marks
 from _pytest.mark.structures import Mark
 from _pytest.mark.structures import MarkDecorator
@@ -1619,10 +1618,9 @@ def __init__(
         # to a readonly property that returns FunctionDefinition.name.
 
         self.keywords.update(self.obj.__dict__)
-        self.own_markers.extend(get_marks_as_list(self.obj))
+        self.own_markers.extend(get_unpacked_marks(self.obj))
         if self.cls:
-            extract_mro_markers(self.cls)
-            self.own_markers.extend(getattr(self.cls, "mro_markers"))
+            self.own_markers[:] = list(dict(get_mro_marks(self.cls), **marks_to_dict(self.own_markers)).values())
         if callspec:
             self.callspec = callspec
             # this is total hostile and a mess

testing/test_mark.py

@@ -600,7 +600,7 @@ def test_func():
         )
         values = reprec.getfailedcollections()
         assert len(values) == 1
-        assert "TypeError" in str(values[0].longrepr)
+        assert "AttributeError: type object 'pytestmark' has no attribute 'name'" in str(values[0].longrepr)
 
     def test_mark_dynamically_in_funcarg(self, pytester: Pytester) -> None:
         pytester.makeconftest(
@@ -1129,16 +1129,7 @@ def test_foo():
     assert result.ret == ExitCode.USAGE_ERROR
 
 
-@pytest.mark.parametrize(
-    "markers",
-    (
-        "mark1",
-        "mark1 and mark2",
-        "mark1 and mark2 and mark3",
-        "mark1 and mark2 and mark3 and mark4",
-    ),
-)
-def test_markers_from_multiple_inheritances(pytester: Pytester, markers) -> None:
+def test_markers_from_multiple_inheritances(pytester: Pytester, request) -> None:
     py_file = pytester.makepyfile(
         """
         import pytest
@@ -1153,9 +1144,9 @@ class Base2:
         @pytest.mark.mark3
         class TestMultipleInheritances(Base1, Base2):
             @pytest.mark.mark4
-            def test_multiple_inheritances(self):
-                pass
+            def test_multiple_inheritances(self, request):
+                assert {mark.name for mark in request.node.iter_markers()} == {"mark1","mark2","mark3","mark4",}
         """
     )
-    result = pytester.inline_run(py_file, "-m", markers)
+    result = pytester.inline_run()
     result.assertoutcome(passed=1)