Question

我来自Java世界，您可以在其中隐藏变量和函数，然后使用反射对它们运行单元测试。我使用嵌套函数来隐藏类的实现细节，以便只显示公共API。我正在尝试针对这些嵌套函数编写单元测试，以确保在开发时不会破坏它们。我试过调用一个嵌套函数，如：

def outer():
    def inner():
        pass

outer.inner()

导致错误消息：

AttributeError：'function'对象没有属性'inner'

我有办法针对这些嵌套函数编写单元测试吗？如果没有，是否有办法触发名称，为类变量添加函数名称，方法是为它们添加__？

Answer 1

内在不存在，直到外在它。您应该将内部向上移动到顶层函数以实现可测试性，或者让外部测试测试其自身和内部的所有可能的执行路径。

请注意，内部函数不是一个简单的函数，它是一个闭包。考虑这种情况：

def outer(a):
    b = compute_something_from(a)
    def inner():
        do_something_with(a, b)

这是标准的可测试性权衡。如果cyclomatic complexity过高，则测试会太多。

Answer 2

Python惯例是使用前导下划线命名“私有”函数和方法。当您看到前导下划线时，您知道不要尝试使用它。

请记住，Python is not Java。

Answer 3

我认为没有机会从extern名称空间访问inner（）。

但是，在我看来，你保持inner（）嵌套这一事实意味着真正重要的唯一“契约”是outer（）的一个。 inner（）是实现的一部分，您不应该测试实现。如果你真的想测试inner（），那么对outer（）进行大量测试，其中包含涉及inner（）所有功能的数据。

Answer 4

无法从外部函数对象获取内部函数（请参阅其他回复！）。然而，单元测试和闭包都使（至少对我来说）开发人员的性能有了惊人的提升。我们可以同时拥有吗？我们可以单独测试嵌套函数吗？

不容易。

然而，这似乎可以通过使用python模块解析器，ast或tokenizer来实现代码本身，提取内部函数（通过嵌套的某些路径），并允许测试以封闭状态运行它们来实现函数（封闭名称的值）和更多嵌套函数的存根/模拟（在测试目标中定义）。

有人知道这样的事吗？谷歌搜索没有找到任何东西。

Answer 5

我有同样的疑问，并找到了一种方法来测试内部函数。

def outer():
    def inner():
        pass

    if __debug__:
        test_inner(inner)
        # return

def test_inner(f):
     f() # this calls the inner function

outer()

基本上你可以将内部函数作为参数发送到外部并根据需要进行测试。当调用 outer（）时，您的测试将运行，并且因为它是一个闭包，它将保留外部函数的任何额外属性（如变量）。使用列表，您可以发送任意数量的功能。要忽略 if ，可以选择运行以下代码：

python -O code.py

Answer 6

我写了一个小帮手模块，它允许这个：

嵌套函数的示例：

def f(v1):
  v2 = 1
  def g(v3=2):
    return v1 + v2 + v3 + 4
  def h():
    return 16
  return g() + h() + 32

class C(object):
  def foo(self):
    def k(x):
      return [ self, x ]
    return k(3)

def m():
  vm = 1
  def n(an=2):
    vn = 4
    def o(ao=8):
      vo = 16
      return vm + an + vn + ao + vo
    return o()
  return n()

这些可以使用这种代码进行单元测试：

import unittest
from nested import nested

class TestNested(unittest.TestCase):
  def runTest(self):
    nestedG = nested(f, 'g', v1=8, v2=1)
    self.assertEqual(nestedG(2), 15)
    nestedH = nested(f, 'h')
    self.assertEqual(nestedH(), 16)
    nestedK = nested(C.foo, 'k', self='mock')
    self.assertEqual(nestedK(5), [ 'mock', 5 ])
    nestedN = nested(m, 'n', vm=1)
    nestedO = nested(nestedN, 'o', vm=1, an=2, vn=4)
    self.assertEqual(nestedO(8), 31)

def main(argv):
  unittest.main()

if __name__ == '__main__':
  import sys
  sys.exit(main(sys.argv))

小助手模块nested如下所示：

import types

def freeVar(val):
  def nested():
    return val
  return nested.__closure__[0]

def nested(outer, innerName, **freeVars):
  if isinstance(outer, (types.FunctionType, types.MethodType)):
    outer = outer.func_code
  for const in outer.co_consts:
    if isinstance(const, types.CodeType) and const.co_name == innerName:
      return types.FunctionType(const, globals(), None, None, tuple(
          freeVar(freeVars[name]) for name in const.co_freevars))

Answer 7

我遇到了一个有趣的案例，我能够使用 MagicMock 对嵌套函数运行单元测试。关键是嵌套函数作为参数发送给我可以访问的另一个函数。与 OP 的示例保持一致：

# my_app.py

def util(func):
    # run some logic using func

def outer():
    def inner():
        pass

    util(inner)

能够模拟 util 函数允许访问调用参数，在本例中恰好是 inner 函数：

def test_inner
    # Arrange
    mock_util = MagicMock()

    with patch.object(my_app, 'util', mock_util):
        outer() # run the outer function to capture the util call with MagicMock

    inner_function = mock_util.call_args[0][0]

    # Act
    inner_function() # run the inner function for testing

    # Assert
    # make whatever assertions you would like

这次我很幸运，因为我不需要更改我被要求测试的代码。 @Victor-Barroso's answer 为那些正在寻找选择的人提供了一种有意的方式来做类似的事情。不过，如果您要更改代码，您也可以按照 @Dustin's advice 或有关此问题的任何其他好的答案进行操作。

对嵌套函数运行单元测试

7 个答案: