如何测试python模块私有化？

在Python2.7中，是否可以测试模块私有

运行后：

import unittest

__private_stuff = 1 # if it would have single underscore, it would not be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        self.assertEqual(__private_stuff, 1)

unittest.main(__name__)

结果是：

E
======================================================================
ERROR: test_internal_symbol (__main__.ComplexTestCase)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "C:\files\y.py", line 7, in test_internal_symbol
    self.assertEqual(__private_stuff, 1)
NameError: global name '_ComplexTestCase__private_stuff' is not defined

----------------------------------------------------------------------

有什么办法可以绕过它吗？
（不修改要添加测试的代码）

备选方案（我希望避免） 一种方法是重命名这些方法。
另一种方法是添加额外的重命名符号

private\u stuff=\uu private\u stuff

。

但这很快就会变得非常乏味。
代码库使用这些“_xyz”作为公共符号（从其他模块中使用），并且有很多这样的符号。
此外，始终存在“xyz”和“xyz”符号。

（试图找到“为什么”的答案，找到了唯一合理的解释
在数学公式中，使用了前导下划线来标记“修改”，如使用“素数”。

---

e、 g.

x

和

x'

相似，但不相同）

实际上在哪里定义了

\u private\u stuff

？因为我怀疑它是否在您的测试用例模块中定义。如果确实如此，那么这将起作用：

import unittest

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = globals()['__private_stuff']
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

否则，如果它在其他模块中，这应该可以工作，尽管我没有测试它：

import unittest
import other_module

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = getattr(other_module, '__private_stuff')
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

---

\uu private\u stuff

的实际定义在哪里？因为我怀疑它是否在您的测试用例模块中定义。如果确实如此，那么这将起作用：

import unittest

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = globals()['__private_stuff']
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

否则，如果它在其他模块中，这应该可以工作，尽管我没有测试它：

import unittest
import other_module

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = getattr(other_module, '__private_stuff')
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

---

\uu private\u stuff

的实际定义在哪里？因为我怀疑它是否在您的测试用例模块中定义。如果确实如此，那么这将起作用：

import unittest

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = globals()['__private_stuff']
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

否则，如果它在其他模块中，这应该可以工作，尽管我没有测试它：

import unittest
import other_module

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = getattr(other_module, '__private_stuff')
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

---

\uu private\u stuff

的实际定义在哪里？因为我怀疑它是否在您的测试用例模块中定义。如果确实如此，那么这将起作用：

import unittest

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = globals()['__private_stuff']
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

否则，如果它在其他模块中，这应该可以工作，尽管我没有测试它：

import unittest
import other_module

__private_stuff = 1 # if it would have single underscore, it would bot be a problem.

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        private_stuff = getattr(other_module, '__private_stuff')
        self.assertEqual(private_stuff, 1)

unittest.main(__name__)

---

有几种方法可以防止python在类中调用名称混乱算法

使用

getattr

检索被测属性的值（根据1.618的答案）：

在类外编写测试方法：

def test_internal_symbol(self):
    self.assertEqual(module_under_test.__private_stuff, 1)

class ComplexTestCase(unittest.TestCase):
    test_internal_symbol = test_internal_symbol

重构私有属性名称，以3个下划线结尾：

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        self.assertEqual(module_under_test.__private_stuff___, 1)

---

有几种方法可以防止python在类中调用名称混乱算法

使用

getattr

检索被测属性的值（根据1.618的答案）：

在类外编写测试方法：

def test_internal_symbol(self):
    self.assertEqual(module_under_test.__private_stuff, 1)

class ComplexTestCase(unittest.TestCase):
    test_internal_symbol = test_internal_symbol

重构私有属性名称，以3个下划线结尾：

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        self.assertEqual(module_under_test.__private_stuff___, 1)

---

有几种方法可以防止python在类中调用名称混乱算法

使用

getattr

检索被测属性的值（根据1.618的答案）：

在类外编写测试方法：

def test_internal_symbol(self):
    self.assertEqual(module_under_test.__private_stuff, 1)

class ComplexTestCase(unittest.TestCase):
    test_internal_symbol = test_internal_symbol

重构私有属性名称，以3个下划线结尾：

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        self.assertEqual(module_under_test.__private_stuff___, 1)

---

有几种方法可以防止python在类中调用名称混乱算法

使用

getattr

检索被测属性的值（根据1.618的答案）：

在类外编写测试方法：

def test_internal_symbol(self):
    self.assertEqual(module_under_test.__private_stuff, 1)

class ComplexTestCase(unittest.TestCase):
    test_internal_symbol = test_internal_symbol

重构私有属性名称，以3个下划线结尾：

class ComplexTestCase(unittest.TestCase):
    def test_internal_symbol(self):
        self.assertEqual(module_under_test.__private_stuff___, 1)

---

是的，testcase将与

\uuuu private\u stuff

在单独的文件中。（只是尽量使文章尽可能简短，因为两个案例都会引发相同的错误）是的，testcase将与

\uuuu private\u stuff

放在不同的文件中。（只是尽量使文章尽可能简短，因为两个案例都会引发相同的错误）是的，testcase将与

\uuuu private\u stuff

放在不同的文件中。（只是尽量使文章尽可能简短，因为两个案例都会引发相同的错误）是的，testcase将与

\uuuu private\u stuff

放在不同的文件中。（只是尽量缩短帖子，因为两种情况都会产生相同的错误）