Instead of importing this from_pytest, instantiating it, and getting a context manager, you can just use it as afixture (no import required).

def test_main(monkeypatch):    monkeypatch.setattr(...)

Apparently, in order for me to use this, my methodhas to be a fixture. In this case, it isn't, so I guess I'll use the context manager way then.

Did it not work? I'm using it in FuzzManager in tests (eg.here).

That SO is about using it in a setup method, which is not a test, so it has to be a fixture to use other fixtures. That doesn't apply to you.

It works if the test_* function is not in a class:

def test_main(monkeypatch):

However, it doesn't if it is in a custom class:

class RunCcoverageTests(unittest.TestCase):    """"TestCase class for functions in run_ccoverage.py"""    @staticmethod    /snip    def test_main(monkeypatch):

It fails with the following error:

TypeError: test_main() missing 1 required positional argument: 'monkeypatch'

Question: IsRunCcoverageTests supposed to inherit fromunittest.TestCase for things to work?

I tried:

import _pytest/snipclass RunCcoverageTests(_pytest.monkeypatch.MonkeyPatch):    """"TestCase class for functions in run_ccoverage.py"""    @staticmethod    /snip    def test_main(monkeypatch):

and this seems to work. Is this the right intended fix?SO also mentions thatunittest.TestCase cannot be monkeypatched in the form I mentioned in the previous comment, so I think this is related.

I know this can be solved if I remove the class entirely, but I (may) have some other tests that use their own class in more elaborate ways.

Another question: bynot using awith statement, wouldn't the function continue to be monkeypatch'ed for the remaining of the runs of tests by pytest?

Oh no, calling_pytest.monkeypatch.MonkeyPatch as the parameter forRunCcoverageTests results in pytest not being able to discover this test automatically.

Hmm, you're right. Thepytest unittest section explains why in the notes at the end. Any new tests I write are not inheriting fromunittest. The only point of it is to run existing test suites while transitioning topytest.

About the monkeypatch lifetime without using a context (with): Fixtures are cleaned up automatically. They are thepytest equivalent ofunittest.TestCase.setUp() andunittest.TestCase.tearDown(). Another useful one istmp_path which gives you apathlib.Path object to a unique temporary directory.

So here's theunittest way to use a fixture likemonkeypatch without using the internal classes in_pytest:

import timeimport unittestimport pytest@pytest.fixturedef cls_monkeypatch(request, monkeypatch):    request.cls.monkeypatch = monkeypatch@pytest.mark.usefixtures('cls_monkeypatch')class ThingTest(unittest.TestCase):    def test_something(self):        self.monkeypatch.setattr(time, 'sleep', lambda x: None)        start = time.time()        time.sleep(1)        end = time.time()        self.assertLess(end - start, 1)

... and here's thepytest way:

import timedef test_something(monkeypatch):        monkeypatch.setattr(time, 'sleep', lambda x: None)        start = time.time()        time.sleep(1)        end = time.time()        assert (end - start) < 1

I'll move entirely to pytest in another PR. Thanks!

You could also ensure thatreport_coverage anddisable_pool are called as you expect, instead of just logging. I usually do this by declaring adict() in the method and then setting keys to assert later. Eg.

calls = {"disable_pool": 0}monkeypatch.setattr("disable_pool", lambda: calls["disable_pool"] += 1)run_ccoverage.main()assert calls["disable_pool"] == 1

We can't do an increment assignment in a lambda, can we?lambda: calls["disable_pool"] += 1 seems to throw at+=.

You're right, my bad. I am doing this somewhere, but I must have been using a non-lambda function, and I can't find it.