Asserting execution order in python unittest
Question: I have a function that creates a temporary directory, switches to that
temporary directory, performs some work, and then switches back to the
original directory. I am trying to write a unit test that tests this. I don't
have a problem verifying that the current directory was changed to the temp
dir and changed back again, but I'm having a problem verifying that the
important stuff took place in between those calls.

My original idea was to abstract the function into three sub functions so that
I could test the call order. I can replace each of the three sub functions
with mocks to verify that they are called -- however, I am still presented
with the issue of verifying the order. On a mock I can use assert_has_calls,
but upon what object do I call that function?

Here is the class I'm trying to test:

    
    
    import shutil
    import os
    import subprocess
    import tempfile
    import pkg_resources
    
    
    class Converter:
        def __init__(self, encoded_file_path):
            self.encoded_file_path = encoded_file_path
            self.unencoded_file_path = None
            self.original_path = None
            self.temp_dir = None
    
        def change_to_temp_dir(self):
            self.original_path = os.getcwd()
            self.temp_dir = tempfile.mkdtemp()
            os.chdir(self.temp_dir)
    
        def change_to_original_dir(self):
            os.chdir(self.original_path)
            shutil.rmtree(self.temp_dir)
    
        def do_stuff(self):
            pass
    
        def run(self):
            self.change_to_temp_dir()
            self.do_stuff()
            self.change_to_original_dir()
    

This is as far as I got writing the test case:

    
    
    def test_converter(self, pkg_resources, tempfile, subprocess, os, shutil):
        encoded_file_path = Mock()
    
        converter = Converter(encoded_file_path)
        converter.change_to_temp_dir = Mock()
        converter.do_stuff= Mock()
        converter.change_to_original_dir = Mock()
    
        assert converter.encoded_file_path == encoded_file_path
        assert converter.unencoded_file_path is None
    
        converter.run()
    

Now that I have each function mocked, I can verify THAT they were called, but
not in what ORDER. How do I go about doing this?


Answer: One workaround would to be to create a separate mock object, attach methods to
it and use
[`assert_has_calls()`](http://www.voidspace.org.uk/python/mock/mock.html#mock.Mock.assert_has_calls)
to check the call order:

    
    
    converter = Converter(encoded_file_path)
    converter.change_to_temp_dir = Mock()
    converter.do_stuff = Mock()
    converter.change_to_original_dir = Mock()
    
    m = Mock()
    m.configure_mock(first=converter.change_to_temp_dir,
                     second=converter.do_stuff,
                     third=converter.change_to_original_dir)
    
    converter.run()
    m.assert_has_calls([call.first(), call.second(), call.third()])
    

