tests.py

Question

要创建给定函数的单元测试，我需要修补''.join(...)。

我尝试了很多方法（使用mock库），但即使我有一些使用该库创建单元测试的经验，我也无法让它工作。

出现的第一个问题是str是一个内置类，因此无法模拟。 post by William John Bert显示了如何处理此问题（在他的案例中为datetime.date）。图书馆官方文档的"Partial mocking" section中也有可能的解决方案。

第二个问题是str并未真正直接使用。相反，调用文字join的方法''。那么，补丁的路径应该是什么？

这些选项都不起作用：

patch('__builtin__.str', 'join')
patch('string.join')
patch('__builtin__.str', FakeStr)（其中FakeStr是str的子类）

非常感谢任何帮助。

Answer 1

你不能，因为无法在内置类中设置属性：

>>> str.join = lambda x: None
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't set attributes of built-in/extension type 'str'

并且您无法修补str，因为''.join使用了文字，因此无论您如何尝试，{strong>总是创建str替换str中的__builtin__。

如果您读取生成的字节码，则可以看到这一点：

>>> import dis
>>> def test():
...     ''.join([1,2,3])
... 
>>> dis.dis(test)
  2           0 LOAD_CONST               1 ('')
              3 LOAD_ATTR                0 (join)
              6 LOAD_CONST               2 (1)
              9 LOAD_CONST               3 (2)
             12 LOAD_CONST               4 (3)
             15 BUILD_LIST               3
             18 CALL_FUNCTION            1
             21 POP_TOP             
             22 LOAD_CONST               0 (None)
             25 RETURN_VALUE

字节码是在编译时生成的，正如您所看到的那样，第一个LOAD_CONST加载''即str，无论如何您在运行时更改str的值。

你可以做什么，是使用可以模拟的包装函数，或者避免使用文字。例如，使用str()代替''，可以mock str类join类，其子类实现{{1}}方法的方式（即使这可能）影响太多代码，可能不可行，具体取决于您使用的模块。）

Answer 2

如果您感到非常幸运，可以检查并修补代码对象中的字符串consts：

def patch_strings(fun, cls):
    new_consts = tuple(
                  cls(c) if type(c) is str else c
                  for c in fun.func_code.co_consts)

    code = type(fun.func_code)

    fun.func_code = code(
           fun.func_code.co_argcount,
           fun.func_code.co_nlocals, 
           fun.func_code.co_stacksize,
           fun.func_code.co_flags,
           fun.func_code.co_code,
           new_consts,
           fun.func_code.co_names,
           fun.func_code.co_varnames,
           fun.func_code.co_filename,
           fun.func_code.co_name,
           fun.func_code.co_firstlineno,
           fun.func_code.co_lnotab,
           fun.func_code.co_freevars,
           fun.func_code.co_cellvars)

def a():
    return ''.join(['a', 'b'])

class mystr(str):
    def join(self, s):
        print 'join called!'
        return super(mystr, self).join(s)

patch_strings(a, mystr)
print a()      # prints "join called!\nab"

Python3版本：

def patch_strings(fun, cls):
    new_consts = tuple(
                   cls(c) if type(c) is str else c
                   for c in fun.__code__.co_consts)

    code = type(fun.__code__)

    fun.__code__ = code(
           fun.__code__.co_argcount,
           fun.__code__.co_kwonlyargcount,
           fun.__code__.co_nlocals, 
           fun.__code__.co_stacksize,
           fun.__code__.co_flags,
           fun.__code__.co_code,
           new_consts,
           fun.__code__.co_names,
           fun.__code__.co_varnames,
           fun.__code__.co_filename,
           fun.__code__.co_name,
           fun.__code__.co_firstlineno,
           fun.__code__.co_lnotab,
           fun.__code__.co_freevars,
           fun.__code__.co_cellvars)

Answer 3

实际上没有办法可以使用字符串文字，因为它们总是使用内置的str类，正如您所发现的那样，它不能以这种方式进行修补。

当然，您可以编写一个代替join(seq, sep='')使用的函数''.join()并修补该函数，或者您经常使用的str子类Separator显式构造将用于join操作的字符串（例如Separator('').join(....)）。这些变通办法有点难看，但你不能修补这个方法。

Answer 4

我在这里修改模块中的变量进行测试。我不喜欢这个想法，因为我改变了我的代码以适应测试，但它确实有效。

tests.py

import mock

from main import func


@mock.patch('main.patched_str')
def test(patched_str):
    patched_str.join.return_value = "hello"

    result = func('1', '2')

    assert patched_str.join.called_with('1', '2')
    assert result == "hello" 


if __name__ == '__main__':
    test()

main.py

patched_str = ''

def func(*args):
    return patched_str.join(args)

Answer 5

我的解决方案有点棘手，但适用于大多数情况。它不使用模拟库BTW。我的解决方案的优势在于您可以继续使用''.join而不会进行任何丑陋的修改。

当我必须在Python3.2中运行为Python3.3编写的代码时，我找到了这种方法（它将str(...).casefold替换为str(...).lower）

假设你有这个模块：

# my_module.py

def my_func():
    """Print some joined text"""
    print('_'.join(str(n) for n in range(5)))

有一个测试它的单元测试示例。请注意，它是为Python 2.7编写的，但可以很容易地为Python 3修改（参见注释）：

import re
from imp import reload  # for Python 3

import my_module


class CustomJoinTets(unittest.TestCase):
    """Test case using custom str(...).join method"""
    def setUp(self):
        """Replace the join method with a custom function"""
        with open(my_module.__file__.replace('.pyc', '.py')) as f:
            # Replace `separator.join(` with `custom_join(separator)(`
            contents = re.sub(r"""(?P<q>["'])(?P<sep>.*?)(?P=q)[.]join\(""",
                              r"custom_join(\g<q>\g<sep>\g<q>)(",
                              f.read())

        # Replace the code in the module
        # For Python 3 do `exec(contents, my_module.__dict__)`
        exec contents in my_module.__dict__

        # Create `custom_join` object in the module
        my_module.custom_join = self._custom_join

    def tearDown(self):
        """Reload the module"""
        reload(my_module)

    def _custom_join(self, separator):
        """A factory for a custom join"""
        separator = '+{}+'.format(separator)
        return separator.join

    def test_smoke(self):
        """Do something"""
        my_module.my_func()

if __name__ == '__main__':
    unittest.main()

如果你真的想要mock库，你可以让_custom_join方法返回MagicMock对象：

    def _custom_join(self, separator):
        """A factory for a custom join"""
        import mock

        return mock.MagicMock(name="{!r}.join".format(separator))

如何使用模拟库修补方法''.join

5 个答案:

tests.py

main.py