def test_log_and_exit(mock_out_store_directory):
    mocked_write = mock.Mock()
    with pytest.raises(error_handler.PreCommitSystemExit):
        error_handler._log_and_exit("msg", FatalError("hai"), "I'm a stacktrace", write_fn=mocked_write)

    printed = "".join(call[0][0] for call in mocked_write.call_args_list)
    assert printed == ("msg: FatalError: hai\n" "Check the log at ~/.pre-commit/pre-commit.log\n")

    log_file = os.path.join(mock_out_store_directory, "pre-commit.log")
    assert os.path.exists(log_file)
    contents = io.open(log_file).read()
    assert contents == ("msg: FatalError: hai\n" "I'm a stacktrace\n")
Beispiel #2
0
def test_log_and_exit(cap_out, mock_store_dir):
    with pytest.raises(SystemExit):
        error_handler._log_and_exit(
            'msg',
            error_handler.FatalError('hai'),
            "I'm a stacktrace",
        )

    printed = cap_out.get()
    log_file = os.path.join(mock_store_dir, 'pre-commit.log')
    assert printed == ('msg: FatalError: hai\n'
                       'Check the log at {}\n'.format(log_file))

    assert os.path.exists(log_file)
    with io.open(log_file) as f:
        assert f.read() == ('msg: FatalError: hai\n' "I'm a stacktrace\n")
def test_log_and_exit(mock_out_store_directory):
    mocked_print = mock.Mock()
    with pytest.raises(error_handler.PreCommitSystemExit):
        error_handler._log_and_exit(
            'msg',
            FatalError('hai'),
            "I'm a stacktrace",
            print_fn=mocked_print,
        )

    printed = '\n'.join(call[0][0] for call in mocked_print.call_args_list)
    assert printed == ('msg: FatalError: hai\n'
                       'Check the log at ~/.pre-commit/pre-commit.log')

    log_file = os.path.join(mock_out_store_directory, 'pre-commit.log')
    assert os.path.exists(log_file)
    contents = io.open(log_file).read()
    assert contents == ('msg: FatalError: hai\n' "I'm a stacktrace\n")
Beispiel #4
0
def test_log_and_exit(cap_out, mock_store_dir):
    tb = (
        'Traceback (most recent call last):\n'
        '  File "<stdin>", line 2, in <module>\n'
        'pre_commit.errors.FatalError: hai\n'
    )

    with pytest.raises(SystemExit) as excinfo:
        error_handler._log_and_exit('msg', 1, FatalError('hai'), tb)
    assert excinfo.value.code == 1

    printed = cap_out.get()
    log_file = os.path.join(mock_store_dir, 'pre-commit.log')
    assert printed == f'msg: FatalError: hai\nCheck the log at {log_file}\n'

    assert os.path.exists(log_file)
    with open(log_file) as f:
        logged = f.read()
        pattern = re_assert.Matches(
            r'^### version information\n'
            r'\n'
            r'```\n'
            r'pre-commit version: \d+\.\d+\.\d+\n'
            r'git --version: git version .+\n'
            r'sys.version:\n'
            r'(    .*\n)*'
            r'sys.executable: .*\n'
            r'os.name: .*\n'
            r'sys.platform: .*\n'
            r'```\n'
            r'\n'
            r'### error information\n'
            r'\n'
            r'```\n'
            r'msg: FatalError: hai\n'
            r'```\n'
            r'\n'
            r'```\n'
            r'Traceback \(most recent call last\):\n'
            r'  File "<stdin>", line 2, in <module>\n'
            r'pre_commit\.errors\.FatalError: hai\n'
            r'```\n',
        )
        pattern.assert_matches(logged)
Beispiel #5
0
def test_log_and_exit(cap_out, mock_out_store_directory):
    with pytest.raises(error_handler.PreCommitSystemExit):
        error_handler._log_and_exit(
            'msg', FatalError('hai'), "I'm a stacktrace",
        )

    printed = cap_out.get()
    assert printed == (
        'msg: FatalError: hai\n'
        'Check the log at ~/.pre-commit/pre-commit.log\n'
    )

    log_file = os.path.join(mock_out_store_directory, 'pre-commit.log')
    assert os.path.exists(log_file)
    contents = io.open(log_file).read()
    assert contents == (
        'msg: FatalError: hai\n'
        "I'm a stacktrace\n"
    )
def test_log_and_exit(cap_out, mock_store_dir):
    with pytest.raises(SystemExit):
        error_handler._log_and_exit(
            'msg', error_handler.FatalError('hai'), "I'm a stacktrace",
        )

    printed = cap_out.get()
    log_file = os.path.join(mock_store_dir, 'pre-commit.log')
    assert printed == (
        'msg: FatalError: hai\n'
        'Check the log at {}\n'.format(log_file)
    )

    assert os.path.exists(log_file)
    with io.open(log_file) as f:
        assert f.read() == (
            'msg: FatalError: hai\n'
            "I'm a stacktrace\n"
        )
def test_log_and_exit(mock_out_store_directory):
    mocked_print = mock.Mock()
    with pytest.raises(error_handler.PreCommitSystemExit):
        error_handler._log_and_exit(
            'msg', FatalError('hai'), "I'm a stacktrace",
            print_fn=mocked_print,
        )

    printed = '\n'.join(call[0][0] for call in mocked_print.call_args_list)
    assert printed == (
        'msg: FatalError: hai\n'
        'Check the log at ~/.pre-commit/pre-commit.log'
    )

    log_file = os.path.join(mock_out_store_directory, 'pre-commit.log')
    assert os.path.exists(log_file)
    contents = io.open(log_file).read()
    assert contents == (
        'msg: FatalError: hai\n'
        "I'm a stacktrace\n"
    )
Beispiel #8
0
def test_log_and_exit(cap_out, mock_store_dir):
    with pytest.raises(SystemExit):
        error_handler._log_and_exit(
            'msg',
            error_handler.FatalError('hai'),
            "I'm a stacktrace",
        )

    printed = cap_out.get()
    log_file = os.path.join(mock_store_dir, 'pre-commit.log')
    assert printed == f'msg: FatalError: hai\nCheck the log at {log_file}\n'

    assert os.path.exists(log_file)
    with open(log_file) as f:
        logged = f.read()
        expected = (r'^### version information\n'
                    r'\n'
                    r'```\n'
                    r'pre-commit version: \d+\.\d+\.\d+\n'
                    r'sys.version:\n'
                    r'(    .*\n)*'
                    r'sys.executable: .*\n'
                    r'os.name: .*\n'
                    r'sys.platform: .*\n'
                    r'```\n'
                    r'\n'
                    r'### error information\n'
                    r'\n'
                    r'```\n'
                    r'msg: FatalError: hai\n'
                    r'```\n'
                    r'\n'
                    r'```\n'
                    r"I'm a stacktrace\n"
                    r'```\n')
        assert re.match(expected, logged)