def test_unit_path_does_exist_incorrectly(self, stdout, Popen): """ Test the case for when the unit path does exist, but its contents are incorrect. It should write it and then start it. """ pipe_output = ('some output', None) Popen.return_value = mock.MagicMock() Popen.return_value.returncode = 0 Popen.return_value.communicate.return_value = pipe_output with mock.patch('__builtin__.open', autospec=True) as mock_open: mock_file = mock.MagicMock(spec=file) mock_file.read.return_value = 'This file has the wrong contents.' mock_context = mock.MagicMock() mock_context.__enter__.return_value = mock_file mock_open.return_value = mock_context # Set up the unit file to have the incorrect contents manage_workers._start_workers() # Make sure open was called correctly. It should be called twice, once for reading, and # again for writing unit_filename = manage_workers._UNIT_FILENAME_TEMPLATE % 0 expected_path = os.path.join(manage_workers._SYSTEMD_UNIT_PATH, unit_filename) expected_file_contents = manage_workers._WORKER_TEMPLATE % { 'num': 0, 'environment_file': manage_workers._ENVIRONMENT_FILE, 'max_tasks_argument': '' } self.assertEqual(mock_open.call_count, 2) # Let's inspect the read call first_open = mock_open.mock_calls[0] self.assertEqual(first_open[1], (expected_path, )) file_context = first_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.read.assert_called_once_with() file_context.__exit__.assert_called_once_with(None, None, None) # Now, let's inspect the write call second_open = mock_open.mock_calls[4] self.assertEqual(second_open[1], (expected_path, 'w')) file_context = second_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.write.assert_called_once_with(expected_file_contents) file_context.__exit__.assert_called_once_with(None, None, None) # Make sure we started the worker correctly Popen.assert_called_once_with('systemctl start %s' % unit_filename, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) pipe = Popen() pipe.communicate.assert_called_once_with() # Make sure we printed the output of the pipe self.assertEqual(stdout.write.call_count, 2) self.assertEqual(stdout.write.mock_calls[0][1][0], pipe_output[0]) self.assertEqual(stdout.write.mock_calls[1][1][0], '\n')
def test_unit_path_does_exist_incorrectly(self, stdout, Popen): """ Test the case for when the unit path does exist, but its contents are incorrect. It should write it and then start it. """ pipe_output = ('some output', None) Popen.return_value = mock.MagicMock() Popen.return_value.returncode = 0 Popen.return_value.communicate.return_value = pipe_output with mock.patch('__builtin__.open', autospec=True) as mock_open: mock_file = mock.MagicMock(spec=file) mock_file.read.return_value = 'This file has the wrong contents.' mock_context = mock.MagicMock() mock_context.__enter__.return_value = mock_file mock_open.return_value = mock_context # Set up the unit file to have the incorrect contents manage_workers._start_workers() # Make sure open was called correctly. It should be called twice, once for reading, and # again for writing unit_filename = manage_workers._UNIT_FILENAME_TEMPLATE % 0 expected_path = os.path.join(manage_workers._SYSTEMD_UNIT_PATH, unit_filename) expected_file_contents = manage_workers._WORKER_TEMPLATE % { 'num': 0, 'environment_file': manage_workers._ENVIRONMENT_FILE} self.assertEqual(mock_open.call_count, 2) # Let's inspect the read call first_open = mock_open.mock_calls[0] self.assertEqual(first_open[1], (expected_path,)) file_context = first_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.read.assert_called_once_with() file_context.__exit__.assert_called_once_with(None, None, None) # Now, let's inspect the write call second_open = mock_open.mock_calls[4] self.assertEqual(second_open[1], (expected_path, 'w')) file_context = second_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.write.assert_called_once_with(expected_file_contents) file_context.__exit__.assert_called_once_with(None, None, None) # Make sure we started the worker correctly Popen.assert_called_once_with('systemctl start %s' % unit_filename, stdout=subprocess.PIPE, shell=True) pipe = Popen() pipe.communicate.assert_called_once_with() # Make sure we printed the output of the pipe self.assertEqual(stdout.write.call_count, 2) self.assertEqual(stdout.write.mock_calls[0][1][0], pipe_output[0]) self.assertEqual(stdout.write.mock_calls[1][1][0], '\n')
def test_unit_path_does_exist_correctly(self, stdout, Popen): """ Test the case for when the unit path does exist, and its contents are correct. It should start it, but should not write it again. """ pipe_output = ('some output', None) Popen.return_value = mock.MagicMock() Popen.return_value.returncode = 0 Popen.return_value.communicate.return_value = pipe_output expected_read_data = manage_workers._WORKER_TEMPLATE % { 'num': 0, 'environment_file': manage_workers._ENVIRONMENT_FILE, 'max_tasks_argument': '' } with mock.patch('__builtin__.open', autospec=True) as mock_open: mock_file = mock.MagicMock(spec=file) mock_file.read.return_value = expected_read_data mock_context = mock.MagicMock() mock_context.__enter__.return_value = mock_file mock_open.return_value = mock_context manage_workers._start_workers() # Make sure open was called correctly unit_filename = manage_workers._UNIT_FILENAME_TEMPLATE % 0 expected_path = os.path.join(manage_workers._SYSTEMD_UNIT_PATH, unit_filename) mock_open.assert_called_once_with(expected_path) file_context = mock_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.read.assert_called_once_with() file_context.__exit__.assert_called_once_with(None, None, None) # Make sure we started the worker correctly Popen.assert_called_once_with('systemctl start %s' % unit_filename, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True) pipe = Popen() pipe.communicate.assert_called_once_with() # Make sure we printed the output of the pipe self.assertEqual(stdout.write.call_count, 2) self.assertEqual(stdout.write.mock_calls[0][1][0], pipe_output[0]) self.assertEqual(stdout.write.mock_calls[1][1][0], '\n')
def test_unit_path_does_not_exist(self, stdout, Popen): """ Test the case for when the unit path does not exist. It should write it and start it. """ pipe_output = ('some output', None) Popen.return_value = mock.MagicMock() Popen.return_value.returncode = 0 Popen.return_value.communicate.return_value = pipe_output with mock.patch('__builtin__.open', autospec=True) as mock_open: mock_file = mock.MagicMock(spec=file) mock_context = mock.MagicMock() mock_context.__enter__.return_value = mock_file mock_open.return_value = mock_context manage_workers._start_workers() # Make sure open was called correctly. It should be called once for writing unit_filename = manage_workers._UNIT_FILENAME_TEMPLATE % 0 expected_path = os.path.join(manage_workers._SYSTEMD_UNIT_PATH, unit_filename) expected_file_contents = manage_workers._WORKER_TEMPLATE % { 'num': 0, 'environment_file': manage_workers._ENVIRONMENT_FILE } # Now, let's inspect the write call mock_open.assert_called_once_with(expected_path, 'w') file_context = mock_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.write.assert_called_once_with(expected_file_contents) file_context.__exit__.assert_called_once_with(None, None, None) # Make sure we started the worker correctly Popen.assert_called_once_with('systemctl start %s' % unit_filename, stdout=subprocess.PIPE, shell=True) pipe = Popen() pipe.communicate.assert_called_once_with() # Make sure we printed the output of the pipe self.assertEqual(stdout.write.call_count, 2) self.assertEqual(stdout.write.mock_calls[0][1][0], pipe_output[0]) self.assertEqual(stdout.write.mock_calls[1][1][0], '\n')
def test_unit_path_does_exist_correctly(self, stdout, Popen): """ Test the case for when the unit path does exist, and its contents are correct. It should start it, but should not write it again. """ pipe_output = ('some output', None) Popen.return_value = mock.MagicMock() Popen.return_value.returncode = 0 Popen.return_value.communicate.return_value = pipe_output expected_read_data = manage_workers._WORKER_TEMPLATE % { 'num': 0, 'environment_file': manage_workers._ENVIRONMENT_FILE} with mock.patch('__builtin__.open', autospec=True) as mock_open: mock_file = mock.MagicMock(spec=file) mock_file.read.return_value = expected_read_data mock_context = mock.MagicMock() mock_context.__enter__.return_value = mock_file mock_open.return_value = mock_context manage_workers._start_workers() # Make sure open was called correctly unit_filename = manage_workers._UNIT_FILENAME_TEMPLATE % 0 expected_path = os.path.join(manage_workers._SYSTEMD_UNIT_PATH, unit_filename) mock_open.assert_called_once_with(expected_path) file_context = mock_open() file_context.__enter__.assert_called_once_with() file_handle = file_context.__enter__() file_handle.read.assert_called_once_with() file_context.__exit__.assert_called_once_with(None, None, None) # Make sure we started the worker correctly Popen.assert_called_once_with('systemctl start %s' % unit_filename, stdout=subprocess.PIPE, shell=True) pipe = Popen() pipe.communicate.assert_called_once_with() # Make sure we printed the output of the pipe self.assertEqual(stdout.write.call_count, 2) self.assertEqual(stdout.write.mock_calls[0][1][0], pipe_output[0]) self.assertEqual(stdout.write.mock_calls[1][1][0], '\n')