28
votes

I have a method (run_script) would like to test. Specifically I want to test that a call to subprocess.Popenoccurs. It would be even better to test that subprocess.Popen is called with certain parameters. When I run the test however I get TypeError: 'tuple' object is not callable.

How can I test my method to ensure that subprocess is actually being called using mocks?

@mock.patch('subprocess.Popen')
def run_script(file_path):
  process = subprocess.Popen(['myscript', -M, file_path], stdout=subprocess.PIPE)
  output,err = process.communicate()
  return process.returncode

def test_run_script(self, mock_subproc_popen):
  mock_subproc_popen.return_value = mock.Mock(communicate=('ouput','error'), returncode=0)
  am.account_manager("path")
  self.assertTrue(mock_subproc_popen.called)
3

3 Answers

44
votes

It seems unusual to me that you use the patch decorator over the run_script function, since you don't pass a mock argument there.

How about this:

def run_script(file_path):
  process = subprocess.Popen(['myscript', -M, file_path], stdout=subprocess.PIPE)
  output,err = process.communicate()
  return process.returncode

@mock.patch('subprocess.Popen')
def test_run_script(self, mock_subproc_popen):
  process_mock = mock.Mock()
  attrs = {'communicate.return_value': ('output', 'error')}
  process_mock.configure_mock(**attrs)
  mock_subproc_popen.return_value = process_mock 
  am.account_manager("path") # this calls run_script somewhere, is that right?
  self.assertTrue(mock_subproc_popen.called)

Right now, your mocked subprocess.Popen seems to return a tuple, causeing process.communicate() to raise TypeError: 'tuple' object is not callable.. Therefore it's most important to get the return_value on mock_subproc_popen just right.

1
votes

There is no need for anything complex. You can simply move the call to subprocess to a function and pass a mock function in your test.

import subprocess
import unittest
import logging

from unittest.mock import Mock


def _exec(cmd):
    p = subprocess.Popen(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE
    )
    stdout, stderr = p.communicate()
    return p, stdout, stderr


def uses_exec(execute=_exec):
    cmd = ['ls']
    p, stdout, stderr = execute(cmd)
    if p.returncode != 0:
        logging.error(
            '%s returned Error Code: %s',
            cmd,
            p.returncode
        )
        logging.error(stderr)
    else:
        logging.info(stdout)


class TestUsesExecute(unittest.TestCase):

    def test_get_aws_creds_from_namespace(self):
        p = lambda:None
        p.returncode = 0
        stdout = 'file1  file2'
        mock_execute = Mock(return_value=(p, stdout, ''))
        uses_exec(execute=mock_execute)
        mock_execute.assert_called_with(['ls'])


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

This pattern works in all programming languages that allow functions to be passed as parameters. It can be used with other python system calls for file and network reads just as easily.

0
votes

There exists the testfixtures package that you can make use of.

Here's an example on using the mock Popen:

from unittest import TestCase

from testfixtures.mock import call
from testfixtures import Replacer, ShouldRaise, compare
from testfixtures.popen import MockPopen, PopenBehaviour


class TestMyFunc(TestCase):

    def setUp(self):
        self.Popen = MockPopen()
        self.r = Replacer()
        self.r.replace(dotted_path, self.Popen)
        self.addCleanup(self.r.restore)

    def test_example(self):
        # set up
        self.Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e')

        # testing of results
        compare(my_func(), b'o')

        # testing calls were in the right order and with the correct parameters:
        process = call.Popen(['svn', 'ls', '-R', 'foo'], stderr=PIPE, stdout=PIPE)
        compare(Popen.all_calls, expected=[
            process,
            process.communicate()
        ])

    def test_example_bad_returncode(self):
        # set up
        Popen.set_command('svn ls -R foo', stdout=b'o', stderr=b'e',
                          returncode=1)

        # testing of error
        with ShouldRaise(RuntimeError('something bad happened')):
            my_func()