def test_execute_raises_if_shlex_wold_block(): """ Check if execute raises ValueError when None is passed instead of the command. That would cause ``shlex.split`` to read from stdin. """ with pytest.raises(ValueError): execute(None, [])
def test_execute_pre_checks_fail(popen_mock, invalid_check, checks_count): """Test if ``execute`` raises ``PreChecksFailed`` if pre-execute checks fail.""" failing_pre_checks = [lambda: False] * checks_count with pytest.raises(PreChecksFailed): # Exception coming from the pre-checks - we don't get to the point of running post-checks. execute(FAKE_COMMAND, [invalid_check], pre_checks=failing_pre_checks, interval=0.1, timeout=0.1) assert not popen_mock.called, 'After pre-checks failed, the command should not be executed.'
def test_execute_raises_if_shlex_wold_block(): """ Check if execute raises ValueError when None is passed instead of the command. That would cause ``shlex.split`` to read from stdin. """ with pytest.raises(ValueError): execute(None, [])
def test_execute_raises_when_process_exits(): """Check if ``SubprocessExited`` is thrown if the process exits.""" process_mock = Mock() process_mock.poll.return_value = 12 exiting_popen_mock = Mock(return_value=process_mock) with pytest.raises(SubprocessExited): execute(FAKE_COMMAND, [lambda: exiting_popen_mock.called], popen=exiting_popen_mock) assert exiting_popen_mock.popen_called
def test_execute_accepts_strings(popen_mock): """Check that if the command is a string, it is split in the shell way.""" string_command = 'command --arg "quoted_val" --arg2 not_quoted_val --flag -d=\'sth_else\'' list_command = ['command', '--arg', 'quoted_val', '--arg2', 'not_quoted_val', '--flag', '-d=sth_else'] execute(string_command, [], popen=popen_mock) assert popen_mock.called_with(list_command) execute(list_command, [], popen=popen_mock) assert popen_mock.call_args_list[0] == popen_mock.call_args_list[1]
def test_execute_waits_for_the_post_checks_to_turn_ok(popen_mock): """Check if ``execute`` will poll the checks until they resolve OK or timeout occurs.""" check = MagicMock(side_effect=[False, False, False, True]) sleep_mock = Mock() execute(FAKE_COMMAND, [check], pre_checks=[lambda: True], sleep_fn=sleep_mock, popen=popen_mock) assert popen_mock.called assert (check.call_count == 4, 'The check function should return False 3 times as a post-check and once - and the last time - True.') assert sleep_mock.call_count == 3, 'Sleeping should take place after each failed check.'
def test_execute_raises_when_process_exits(): """Check if ``SubprocessExited`` is thrown if the process exits.""" process_mock = Mock() process_mock.poll.return_value = 12 exiting_popen_mock = Mock(return_value=process_mock) with pytest.raises(SubprocessExited): execute(FAKE_COMMAND, [lambda: exiting_popen_mock.called], popen=exiting_popen_mock) assert exiting_popen_mock.popen_called
def test_execute_pre_checks_fail(popen_mock, invalid_check, checks_count): """Test if ``execute`` raises ``PreChecksFailed`` if pre-execute checks fail.""" failing_pre_checks = [lambda: False] * checks_count with pytest.raises(PreChecksFailed): # Exception coming from the pre-checks - we don't get to the point of running post-checks. execute(FAKE_COMMAND, [invalid_check], pre_checks=failing_pre_checks, interval=0.1, timeout=0.1) assert not popen_mock.called, 'After pre-checks failed, the command should not be executed.'
def test_execute_pre_checks_defaults(popen_mock): """Test if negated post-checks are used as pre-checks by default.""" with pytest.raises(PreChecksFailed): # We expect the failure to come from pre-checks. # A negated version of the passed check will be used as a pre-check. execute(FAKE_COMMAND, [lambda: True], timeout=0.1, popen=popen_mock) assert not popen_mock.called, 'We shouldn\'t be able to run the command after pre-checks failed.' # Positive case - the check fn returns False before Popen and True after - just as in the ideal world: execute(FAKE_COMMAND, [lambda: popen_mock.called], timeout=0.1, popen=popen_mock) assert popen_mock.called
def test_execute_pre_checks_pass(popen_mock, checks_count, initial_failures_count): """ Check if succeeding pre-checks cause the command to be executed. Check if initially failing pre-checks are polled until they pass. """ pre_checks = [ chain([lambda: False] * initial_failures_count, cycle([lambda: True])).next for _ in range(checks_count) ] execute(FAKE_COMMAND, [lambda: True], pre_checks=pre_checks, popen=popen_mock) assert popen_mock.called, 'The command should be executed.'
def test_execute_accepts_strings(popen_mock): """Check that if the command is a string, it is split in the shell way.""" string_command = 'command --arg "quoted_val" --arg2 not_quoted_val --flag -d=\'sth_else\'' list_command = [ 'command', '--arg', 'quoted_val', '--arg2', 'not_quoted_val', '--flag', '-d=sth_else' ] execute(string_command, [], popen=popen_mock) assert popen_mock.called_with(list_command) execute(list_command, [], popen=popen_mock) assert popen_mock.call_args_list[0] == popen_mock.call_args_list[1]
def test_execute_pre_checks_defaults(popen_mock): """Test if negated post-checks are used as pre-checks by default.""" with pytest.raises(PreChecksFailed): # We expect the failure to come from pre-checks. # A negated version of the passed check will be used as a pre-check. execute(FAKE_COMMAND, [lambda: True], timeout=0.1, popen=popen_mock) assert not popen_mock.called, 'We shouldn\'t be able to run the command after pre-checks failed.' # Positive case - the check fn returns False before Popen and True after - just as in the ideal world: execute(FAKE_COMMAND, [lambda: popen_mock.called], timeout=0.1, popen=popen_mock) assert popen_mock.called
def test_execute_post_checks_fail(popen_mock, process_mock): """Check if ``PostChecksFailed`` is raised when post checks fail.""" with pytest.raises(PostChecksFailed): # One check that will fail as a post-check and pass as a negated pre-check. killer_mock = Mock() execute(FAKE_COMMAND, [lambda: False], kill_fn=killer_mock, timeout=0.1, popen=popen_mock) killer_mock.assert_called_once_with(process_mock) with pytest.raises(PostChecksFailed): # Separate failing post-check and passing pre-check. execute(FAKE_COMMAND, [lambda: not popen_mock.called], pre_checks=[lambda: True], kill_fn=killer_mock, timeout=0.1, popen=popen_mock) assert killer_mock.call_count == 2
def test_execute_pre_checks_pass(popen_mock, checks_count, initial_failures_count): """ Check if succeeding pre-checks cause the command to be executed. Check if initially failing pre-checks are polled until they pass. """ pre_checks = [ chain([lambda: False] * initial_failures_count, cycle([lambda: True])).next for _ in range(checks_count) ] execute(FAKE_COMMAND, [lambda: True], pre_checks=pre_checks, popen=popen_mock) assert popen_mock.called, 'The command should be executed.'
def test_execute_waits_for_the_post_checks_to_turn_ok(popen_mock): """Check if ``execute`` will poll the checks until they resolve OK or timeout occurs.""" check = MagicMock(side_effect=[False, False, False, True]) sleep_mock = Mock() execute(FAKE_COMMAND, [check], pre_checks=[lambda: True], sleep_fn=sleep_mock, popen=popen_mock) assert popen_mock.called assert ( check.call_count == 4, 'The check function should return False 3 times as a post-check and once - and the last time - True.' ) assert sleep_mock.call_count == 3, 'Sleeping should take place after each failed check.'
def test_execute_popen_called(popen_mock): """Check if the ``execute`` function calls ``Popen`` when checks are OK.""" process = execute(FAKE_COMMAND, [lambda: popen_mock.called], popen=popen_mock) assert popen_mock.popen_called # This actually checks if the mocked Popen object was returned. assert process.poll() is None
def test_execute_same_service_sequentially(): """Check if the pre-checks detect remains of the previous process.""" port = port_for.select_random() command = [SERVICE, 'tcp', '--port', str(port)] process = execute(command, [check_tcp(port)]) with pytest.raises(PreChecksFailed): # The previous process still in place. execute(command, [check_tcp(port)], timeout=1) process.terminate() # The process will take >2 seconds to tear down. # Now, as the previous process is dead, the `execute` should succeed. another_process = execute(command, [check_tcp(port)], timeout=5) another_process.kill()
def test_execute_same_service_sequentially(): """Check if the pre-checks detect remains of the previous process.""" port = port_for.select_random() command = [SERVICE, 'tcp', '--port', str(port)] process = execute(command, [check_tcp(port)]) with pytest.raises(PreChecksFailed): # The previous process still in place. execute(command, [check_tcp(port)], timeout=1) process.terminate() # The process will take >2 seconds to tear down. # Now, as the previous process is dead, the `execute` should succeed. another_process = execute(command, [check_tcp(port)], timeout=5) another_process.kill()
def test_execute_process_killed(): """ Check if the process gets killed after post checks fail. We spawn a process that listens TCP on some port and supply a failing check so that the process should get killed. We check if the process got killed by checking if nothing listens on TCP after PostChecksFailed is raised. """ port = port_for.select_random() passing_check = check_tcp(port) def failing_check_for_testing_purposes(): return False with pytest.raises(PostChecksFailed) as checks_failed: execute([SERVICE, 'tcp', '--port', str(port)], [passing_check, failing_check_for_testing_purposes], timeout=1) assert 'function failing_check_for_testing_purposes' in str(checks_failed.value) # The process will be killed and nothing will be listening on that port. wait_until(lambda: passing_check() is False)
def test_execute_post_checks_fail(popen_mock, process_mock): """Check if ``PostChecksFailed`` is raised when post checks fail.""" with pytest.raises(PostChecksFailed): # One check that will fail as a post-check and pass as a negated pre-check. killer_mock = Mock() execute(FAKE_COMMAND, [lambda: False], kill_fn=killer_mock, timeout=0.1, popen=popen_mock) killer_mock.assert_called_once_with(process_mock) with pytest.raises(PostChecksFailed): # Separate failing post-check and passing pre-check. execute(FAKE_COMMAND, [lambda: not popen_mock.called], pre_checks=[lambda: True], kill_fn=killer_mock, timeout=0.1, popen=popen_mock) assert killer_mock.call_count == 2
def test_execute_check_unix(tmpdir, delay): """Check the executor with the unix socket check.""" socket_file = str(tmpdir / 'temp_unix_socket') check = check_unix(socket_file) assert check() is False process = execute( [SERVICE, '--delay', str(delay), 'unix', '--socket-file', socket_file], [check_unix(socket_file)], timeout=1 + delay) assert check() is True assert process.poll() is None process.kill()
def test_execute_check_tcp(delay): """Check the executor with the TCP check.""" port = port_for.select_random() check = check_tcp(port) assert check() is False process = execute( [SERVICE, '--delay', str(delay), 'tcp', '--port', str(port)], [check_tcp(port)], timeout=1 + delay) assert check() is True assert process.poll() is None # Still running. process.kill()
def test_execute_process_killed(): """ Check if the process gets killed after post checks fail. We spawn a process that listens TCP on some port and supply a failing check so that the process should get killed. We check if the process got killed by checking if nothing listens on TCP after PostChecksFailed is raised. """ port = port_for.select_random() passing_check = check_tcp(port) def failing_check_for_testing_purposes(): return False with pytest.raises(PostChecksFailed) as checks_failed: execute([SERVICE, 'tcp', '--port', str(port)], [passing_check, failing_check_for_testing_purposes], timeout=1) assert 'function failing_check_for_testing_purposes' in str( checks_failed.value) # The process will be killed and nothing will be listening on that port. wait_until(lambda: passing_check() is False)
def test_execute_check_unix(tmpdir, delay): """Check the executor with the unix socket check.""" socket_file = str(tmpdir / 'temp_unix_socket') check = check_unix(socket_file) assert check() is False process = execute( [SERVICE, '--delay', str(delay), 'unix', '--socket-file', socket_file], [check_unix(socket_file)], timeout=1 + delay) assert check() is True assert process.poll() is None process.kill()
def test_execute_check_tcp(delay): """Check the executor with the TCP check.""" port = port_for.select_random() check = check_tcp(port) assert check() is False process = execute( [SERVICE, '--delay', str(delay), 'tcp', '--port', str(port)], [check_tcp(port)], timeout=1 + delay) assert check() is True assert process.poll() is None # Still running. process.kill()
def test_execute_failing_checks(): """Test if failing checks result in ``PostChecksFailed`` being thrown.""" port = check_tcp(port_for.select_random()) tcp_check = check_tcp(port) unix_check = check_unix('no_such_sock') http_check = check_http('http://127.0.0.1:%s' % port) with pytest.raises(PostChecksFailed): execute('sleep 10', [tcp_check], timeout=1) with pytest.raises(PostChecksFailed): execute('sleep 10', [unix_check], timeout=1) with pytest.raises(PostChecksFailed): execute('sleep 10', [http_check], timeout=1) with pytest.raises(PostChecksFailed): # 3 failing checks at once. execute('sleep 10', [http_check, unix_check, tcp_check], timeout=1)
def test_execute_failing_checks(): """Test if failing checks result in ``PostChecksFailed`` being thrown.""" port = check_tcp(port_for.select_random()) tcp_check = check_tcp(port) unix_check = check_unix('no_such_sock') http_check = check_http('http://127.0.0.1:%s' % port) with pytest.raises(PostChecksFailed): execute('sleep 10', [tcp_check], timeout=1) with pytest.raises(PostChecksFailed): execute('sleep 10', [unix_check], timeout=1) with pytest.raises(PostChecksFailed): execute('sleep 10', [http_check], timeout=1) with pytest.raises(PostChecksFailed): # 3 failing checks at once. execute('sleep 10', [http_check, unix_check, tcp_check], timeout=1)
def test_execute_check_http(delay): """Check the executor with the HTTP HEAD request check.""" port = port_for.select_random() good_path = '/good_path' check = check_http('http://127.0.0.1:%s%s' % (port, good_path)) check_bad_path = check_http('http://127.0.0.1:%s/bad_path' % port) # This request will not return 200. assert check() is False assert check_bad_path() is False process = execute( [SERVICE, '--delay', str(delay), 'http', '--port', str(port), '--path', good_path], [check], timeout=1 + delay) assert check() is True assert check_bad_path() is False assert process.poll() is None process.kill()
def test_execute_check_http(delay): """Check the executor with the HTTP HEAD request check.""" port = port_for.select_random() good_path = '/good_path' check = check_http('http://127.0.0.1:%s%s' % (port, good_path)) check_bad_path = check_http('http://127.0.0.1:%s/bad_path' % port) # This request will not return 200. assert check() is False assert check_bad_path() is False process = execute([ SERVICE, '--delay', str(delay), 'http', '--port', str(port), '--path', good_path ], [check], timeout=1 + delay) assert check() is True assert check_bad_path() is False assert process.poll() is None process.kill()
def test_execute_popen_called(popen_mock): """Check if the ``execute`` function calls ``Popen`` when checks are OK.""" process = execute(FAKE_COMMAND, [lambda: popen_mock.called], popen=popen_mock) assert popen_mock.popen_called # This actually checks if the mocked Popen object was returned. assert process.poll() is None