blocks|key|4668271|text|我不能弄清楚它；所以最终用多个非test_前缀函数解决了它：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4668272|def+test_password_credentials_grant(self):
++++for+user+in+self.user_mocks:
++++++++self.register(user)
++++++++self.login(user)
++++++++self.access_token(user,+self.assertEqual)++#+Ensures+access_token+is+generated%2Bvalid
++++++++self.logout(user)
++++++++self.access_token(user,+self.assertNotEqual)++#+Ensures+access_token+is+now+invalid
++++++++self.unregister(user)|code-block|syntax|javascript|4668273|entityMap^0|G|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Couldn't figure it out; so ended up hacking it out with multiple non <code>test_</code> prefixed functions:

<pre><code>def test_password_credentials_grant(self):
 for user in self.user_mocks:
 self.register(user)
 self.login(user)
 self.access_token(user, self.assertEqual) # Ensures access_token is generated+valid
 self.logout(user)
 self.access_token(user, self.assertNotEqual) # Ensures access_token is now invalid
 self.unregister(user)
</code></pre>

blocks|key|4668297|text|我喜欢你自己的简单答案，但是如果你想保持不同的单元测试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4668298|显然，unittest使用新的TestCase实例运行单独的测试。那么，只需要将对象绑定到除self之外的其他对象。例如：|4668299|from+unittest+import+TestCase,+main+as+unittest_main


class+TestSimpleFoo(TestCase):

++++def+setUp(self):
++++++++pass

++++def+test_a(self):
++++++++TestSimpleFoo.foo+=+'can'

++++def+test_f(self):
++++++++self.assertEqual(TestSimpleFoo.foo,+'can')


if+__name__+==+'__main__':
++++unittest_main()|code-block|syntax|javascript|4668300|您可能对setUpClass和tearDownClass也很感兴趣：https://docs.python.org/3/library/unittest.html#setupclass-and-teardownclass|offset|length|4668301|还要注意单元测试的执行顺序：https://docs.python.org/2/library/unittest.html#unittest.TestLoader.sortTestMethodsUsing|4668302|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/unittest.html#setupclass-and-teardownclass|1|https://docs.python.org/2/library/unittest.html#unittest.TestLoader.sortTestMethodsUsing^0|0|0|0|Y|24|0|0|E|2G|1|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@$K|12|L|13|1|14]]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$K|16|L|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]]]

I like your own answer for the simplicity of it, but if you want to keep distinct unit tests:

Apparently unittest runs separate tests with fresh instances of the TestCase. Well, just bind the objects to be persisted to something else but self. For example:

<pre><code>from unittest import TestCase, main as unittest_main


class TestSimpleFoo(TestCase):

 def setUp(self):
 pass

 def test_a(self):
 TestSimpleFoo.foo = 'can'

 def test_f(self):
 self.assertEqual(TestSimpleFoo.foo, 'can')


if __name__ == '__main__':
 unittest_main()
</code></pre>

You might be interesed in setUpClass and tearDownClass too:
<a href="https://docs.python.org/3/library/unittest.html#setupclass-and-teardownclass">https://docs.python.org/3/library/unittest.html#setupclass-and-teardownclass</a>

Also take care about the execution order of your unit tests:
<a href="https://docs.python.org/2/library/unittest.html#unittest.TestLoader.sortTestMethodsUsing">https://docs.python.org/2/library/unittest.html#unittest.TestLoader.sortTestMethodsUsing</a>

blocks|key|4668383|text|正如一些评论所回应的那样，以这种方式构建测试可能是测试本身的一个设计缺陷，您应该考虑重组它们。然而，如果你想这样做，并依赖于你正在使用的测试运行器按字母(似乎)顺序执行它们的事实，那么我建议如下。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4668384|与@Matthias所说的类似，但对于以后可能决定继承类的情况，我会做一件不同的事情。|4668385|from+unittest+import+TestCase,+main+as+unittest_main


class+TestSimpleFoo(TestCase):
++++foo+=+'bar'

++++def+setUp(self):
++++++++pass

++++def+test_a(self):
++++++++self.assertEqual(self.__class__.foo,+'bar')
++++++++self.__class__.foo+=+'can'

++++def+test_f(self):
++++++++self.assertEqual(self.__class__.foo,+'can')


if+__name__+==+'__main__':
++++unittest_main()|code-block|syntax|javascript|4668386|此答案与您接受的@Matthias的答案之间的区别在于显式声明了类，而不是查找所述类引用。|4668387|TestSimpleFoo+vs+self.__class__|4668388|我更喜欢动态性，这样我就可以在以后继承测试，并背靠背地运行两个测试类，而不会在两者之间有任何交叉。因为如果选择从该类继承，显式命名类引用将导致两个测试类都针对该引用运行，而不是针对各自的类运行。|4668389|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

As some comments have echoed, structuring your tests in this manner is probably a design flaw in the tests themselves and you should consider restructuring them. However, if you want to do this and rely on the fact that the test runner you are using executes them in an alphabetical (seemingly) order then I suggest the following.

Similar to what @Matthias was saying but I would do one thing differently for the cases where you may decide to inherit from the class at a later date.

<pre><code>from unittest import TestCase, main as unittest_main


class TestSimpleFoo(TestCase):
 foo = 'bar'

 def setUp(self):
 pass

 def test_a(self):
 self.assertEqual(self.__class__.foo, 'bar')
 self.__class__.foo = 'can'

 def test_f(self):
 self.assertEqual(self.__class__.foo, 'can')


if __name__ == '__main__':
 unittest_main()
</code></pre>

The difference between this answer and @Matthias's answer you accepted is the explicit declaration of the class versus the lookup of said class reference. 

<pre><code>TestSimpleFoo vs self.__class__
</code></pre>

I prefer the dynamicness so I can inherit the tests later and run both test classes back to back and not have any cross over between the two. Because if you would choose to inherit from this class, explicitly naming the class reference would cause both test classes to run against that reference rather than their own respective classes.

How do I persist changes made within the same object inheriting from <code>TestCase</code> in unitttest?

<pre><code>from unittest import TestCase, main as unittest_main


class TestSimpleFoo(TestCase):
 foo = 'bar'

 def setUp(self):
 pass

 def test_a(self):
 self.assertEqual(self.foo, 'bar')
 self.foo = 'can'

 def test_f(self):
 self.assertEqual(self.foo, 'can')


if __name__ == '__main__':
 unittest_main()
</code></pre>

I.e.: I want those two tests above to pass

Persist variable changes between tests in unittest?

单元测试

如何在unitttest中持久化继承自TestCase的同一对象中所做的更改？from unittest import TestCase, main as unittest_mainclass TestSimpleFoo(TestCase):    foo = 'bar'    def setUp(self):    ...

问在unittest中保留测试之间的变量更改？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在unittest中保留测试之间的变量更改？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在unittest中保留测试之间的变量更改？
EN