是否可以对使用子进程的代码运行单元测试？

Question

My Django app has some management commands that start other management commands using subprocess.Popen(['manage.py', '<command>', ...) . They are kept like this mainly to run processes in parallel and prevent one command from interfering with another.

However, when writing unit tests these new processes don't use the test environment and database and therefore fail.

For now, I've added a setting that runs call_command() instead of Popen() (see below):

        if settings.TESTING:
            self.returncode = call_command(self.command, *params)
        else:
            self.process = subprocess.Popen(['python', 'manage.py', self.command] + params)

            # ... later on:
            self.process.wait()
            self.returncode = self.process.returncode

However the subprocess calls and the logic involved in waiting remains untested. Is it possible to test subprocess calls within the unit tests?

Note: the test database is not an in-memory SQLite - I know that wouldn't work. It's an actual database that is created and destroyed every run.

Answer 1

If you considered it as a unit-test, then you could mock your command calls to return mock data to make sure that command caller works just fine.

And for the coverage for the command code, you could also write another unit-test only for that command by using call_command method which provided by Django.

Like so:

class TestYourCommandCaller(TestCase):
    ...

    @mock.patch('subprocess.Popen')
    def test_your_business_which_call_the_command(self, mock_process):
        # Mock your process

        call_your_function_which_create_processes()

        # Assert your process have been called

and another test for your command to also coverage command code:

class TestYourCommand(TestCase):
    def test_command_call(self):
        call_command('command_name', *params)

        # Assert the result

Answer 2

Yes, you can do this. Currently I have code that runs several programs via subprocess. I am using unittest to make sure the functions that do this produce expected output. Maybe some purists would consider this is an improper use of unit tests, but it works for me for automating my tests. A fairly simple example follows:

call_ls.py:

import subprocess
def call_ls():
    subproc = subprocess.Popen(['ls', 'empty_dir'], 
                                stdout=subprocess.PIPE,
                                stderr=subprocess.STDOUT)
    result = subproc.communicate()
    return result

test_call_ls.py:

import unittest
import call_ls

class TestCallLs(unittest.TestCase):
    def test_call_ls(self):
        test_out = call_ls.call_ls()
        self.assertEqual((b'', None), test_out)

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

The tuple in the assert is for handling what subprocess.communicate() returns. As you'd expect, the directory 'empty_dir' has nothing in it. Running the test gives expected results:

$ python test_call_ls.py 
.  
---------------------------------------------------------------------- 
Ran 1 test in 0.006s 

OK