53

我正在寻找抽象基类中定义的测试方法的方法/最佳实践。我能直接想到的一件事是对基类的所有具体子类执行测试，但有时这似乎过分了。

考虑这个例子：

import abc

class Abstract(object):

    __metaclass__ = abc.ABCMeta

    @abc.abstractproperty
    def id(self):
        return   

    @abc.abstractmethod
    def foo(self):
        print "foo"

    def bar(self):
        print "bar"

是否可以在bar不进行任何子类化的情况下进行测试？

4

6 回答 6

66

在较新版本的 Python 中，您可以使用unittest.mock.patch()

class MyAbcClassTest(unittest.TestCase):

    @patch.multiple(MyAbcClass, __abstractmethods__=set())
    def test(self):
         self.instance = MyAbcClass() # Ha!
于 2015-02-26T08:58:21.080 回答
28

这是我发现的：如果您将__abstractmethods__属性设置为空集，您将能够实例化抽象类。此行为在PEP 3119中指定：

如果结果__abstractmethods__集非空，则该类被认为是抽象的，并且尝试实例化它会引发 TypeError。

所以你只需要在测试期间清除这个属性。

>>> import abc
>>> class A(metaclass = abc.ABCMeta):
...     @abc.abstractmethod
...     def foo(self): pass

你不能实例化A：

>>> A()
Traceback (most recent call last):
TypeError: Can't instantiate abstract class A with abstract methods foo

如果您覆盖__abstractmethods__，您可以：

>>> A.__abstractmethods__=set()
>>> A() #doctest: +ELLIPSIS
<....A object at 0x...>

它适用于两种方式：

>>> class B(object): pass
>>> B() #doctest: +ELLIPSIS
<....B object at 0x...>

>>> B.__abstractmethods__={"foo"}
>>> B()
Traceback (most recent call last):
TypeError: Can't instantiate abstract class B with abstract methods foo

您还可以使用unittest.mock（从 3.3 开始）临时覆盖 ABC 行为。

>>> class A(metaclass = abc.ABCMeta):
...     @abc.abstractmethod
...     def foo(self): pass
>>> from unittest.mock import patch
>>> p = patch.multiple(A, __abstractmethods__=set())
>>> p.start()
{}
>>> A() #doctest: +ELLIPSIS
<....A object at 0x...>
>>> p.stop()
>>> A()
Traceback (most recent call last):
TypeError: Can't instantiate abstract class A with abstract methods foo
于 2013-06-27T14:16:13.300 回答
25

正如lunaryon所说，这是不可能的。包含抽象方法的 ABC 的真正目的是它们不能像声明的那样实例化。

但是，可以创建一个自省 ABC 的实用函数，并动态创建一个虚拟的非抽象类。这个函数可以直接在你的测试方法/函数中调用，这样你就不必为了测试一些方法而在测试文件上写样板代码。

def concreter(abclass):
    """
    >>> import abc
    >>> class Abstract(metaclass=abc.ABCMeta):
    ...     @abc.abstractmethod
    ...     def bar(self):
    ...        return None

    >>> c = concreter(Abstract)
    >>> c.__name__
    'dummy_concrete_Abstract'
    >>> c().bar() # doctest: +ELLIPSIS
    (<abc_utils.Abstract object at 0x...>, (), {})
    """
    if not "__abstractmethods__" in abclass.__dict__:
        return abclass
    new_dict = abclass.__dict__.copy()
    for abstractmethod in abclass.__abstractmethods__:
        #replace each abc method or property with an identity function:
        new_dict[abstractmethod] = lambda x, *args, **kw: (x, args, kw)
    #creates a new class, with the overriden ABCs:
    return type("dummy_concrete_%s" % abclass.__name__, (abclass,), new_dict)
于 2012-03-18T14:57:34.830 回答
4

不，这不对。的真正目的abc是创建无法实例化的类，除非所有抽象属性都被具体实现覆盖。因此，您需要从抽象基类派生并覆盖所有抽象方法和属性。

于 2012-03-18T09:45:03.960 回答
4

@jsbueno 提出的concreter的更紧凑版本可能是：

def concreter(abclass):
    class concreteCls(abclass):
        pass
    concreteCls.__abstractmethods__ = frozenset()
    return type('DummyConcrete' + abclass.__name__, (concreteCls,), {})

结果类仍然具有所有原始抽象方法（现在可以调用它们，即使这不太可能有用......）并且可以根据需要进行模拟。

于 2016-06-01T16:47:45.723 回答
4

您可以使用多重继承实践来访问抽象类的已实现方法。显然，遵循这样的设计决策取决于抽象类的结构，因为您需要在测试用例中实现抽象方法（至少带上签名）。

这是您的案例的示例：

class Abstract(object):

    __metaclass__ = abc.ABCMeta

    @abc.abstractproperty
    def id(self):
        return

    @abc.abstractmethod
    def foo(self):
        print("foo")

    def bar(self):
        print("bar")

class AbstractTest(unittest.TestCase, Abstract):

    def foo(self):
        pass
    def test_bar(self):
        self.bar()
        self.assertTrue(1==1)
于 2018-09-04T19:28:27.837 回答