Unittest: ignore test cases that are also ABC

MegaIng · June 17, 2024, 5:52pm

The isabstract check proposed above would fix this, right? Since “TestCase cls can be properly created” if and only if “isabstract(cls)”, so it shouldn’t break any code that didn’t previously fail on test collection.

(I guess unless people start doing really weird stuff with custom AbstractMeta meta-sub-classes ^[1]. I think breaking those is ok)

sub-meta-classes? Both sound weird… ↩︎

zuo · June 18, 2024, 12:54am

I often had to use mixins to group test methods that can run on different implementations of the same interface, for example:
[…]

Did you try:

class BackendTestsMixin:
    backend: BackendInterface
    def test_read(self):
        assert isinstance(self, TestCase)
        self.assertEqual(self.backend.read(), "42")

blhsing · June 18, 2024, 4:16am

Ned Batchelder:

I’m curious if anyone has a reason why we shouldn’t change unittest to understand abc classes? Currently this example fails:
import abc
import unittest

class Mixin(unittest.TestCase, abc.ABC):
    @abc.abstractmethod
    def make_backend(self):
        ...

    def test_it(self):
        assert 1 == 2
unittest tries to instantiate the TestCase class, which it cannot do

That’s a very good point, and one that should classify the current behavior as a bug.

I’ve created a PR for this issue then.

blhsing · June 18, 2024, 4:34am

The only thing that object.__new__ looks at in determining whether a class is abstract and unable to be instantiated is with the Py_TPFLAGS_IS_ABSTRACT flag:

github.com

python/cpython/blob/ac37a806018cc40fafebcd0fa90250c3e0261e0c/Objects/typeobject.c#L6324


      
                                  "object.__new__() takes exactly one argument (the type to instantiate)");
                  return NULL;
              }
              if (type->tp_init == object_init) {
                  PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments",
                               type->tp_name);
                  return NULL;
              }
          }
          
          if (type->tp_flags & Py_TPFLAGS_IS_ABSTRACT) {
              PyObject *abstract_methods;
              PyObject *sorted_methods;
              PyObject *joined;
              PyObject* comma_w_quotes_sep;
              Py_ssize_t method_count;
          
              /* Compute "', '".join(sorted(type.__abstractmethods__))
                 into joined. */
              abstract_methods = type_abstractmethods(type, NULL);
              if (abstract_methods == NULL)

So it really doesn’t matter if a user makes a class abstract with a custom base class/metaclass as long as the flag is properly set.

blhsing · June 18, 2024, 9:05am

Ah, I see that it was previously discussed to add a new class decorator that would explicitly mark a test case as a base class so the loader would skip it. That certainly would work too, and would allow for other forms of base classes not limited to just abstract base classes with non-overridden abstract methods.

The only minor downside is that the “this is a base class” decorator feels redundant when the base class is clearly abstract already. Perhaps we can do both? That is, the loader would skip a test case if it’s abstract or marked as a base class by the decorator.

If we implement only the decorator we would then have to document that abstract classes must be marked by this decorator, or the resulting TypeError from running the module loader would still be considered a bug.

JonathonReinhart · June 17, 2026, 2:06pm

I’m pleased to see that, on the 2-year anniversary of this thread, this bug has been resolved:

github.com/python/cpython

gh-120665: make unittest loaders avoid loading test cases that are abstract base classes (#120666)

main ← blhsing:fix-unittest-loader-abc-testcase

opened 04:05AM - 18 Jun 24 UTC

blhsing

+61 -2

# Make unittest loaders avoid loading test cases that are abstract base classes … Currently, loading a `TestCase`-derived subclass that is also an abstract base class like the following: ```python import unittest from abc import ABC, abstractmethod class FooBase(unittest.TestCase, ABC): @abstractmethod def test(self): ... class Foo(FooBase): def test(self): pass unittest.main() ``` would currently result in: ``` TypeError: Can't instantiate abstract class FooBase without an implementation for abstract method 'test' ``` This PR fixes the error by making the unittest loaders avoid loading such test cases and methods from them. * Issue: gh-120665

nedbat · June 17, 2026, 3:40pm

I missed that it was the exact date!