summaryrefslogtreecommitdiffstats
path: root/tests/error_handler_test.py
blob: 47e2afaa47cb0159e84b3428c5067962a07ae5c6 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
from __future__ import annotations

import os.path
import stat
import sys
from unittest import mock

import pytest
import re_assert

from pre_commit import error_handler
from pre_commit.errors import FatalError
from pre_commit.store import Store
from pre_commit.util import CalledProcessError
from testing.util import cmd_output_mocked_pre_commit_home
from testing.util import xfailif_windows


@pytest.fixture
def mocked_log_and_exit():
    with mock.patch.object(error_handler, '_log_and_exit') as log_and_exit:
        yield log_and_exit


def test_error_handler_no_exception(mocked_log_and_exit):
    with error_handler.error_handler():
        pass
    assert mocked_log_and_exit.call_count == 0


def test_error_handler_fatal_error(mocked_log_and_exit):
    exc = FatalError('just a test')
    with error_handler.error_handler():
        raise exc

    mocked_log_and_exit.assert_called_once_with(
        'An error has occurred',
        1,
        exc,
        # Tested below
        mock.ANY,
    )

    pattern = re_assert.Matches(
        r'Traceback \(most recent call last\):\n'
        r'  File ".+pre_commit.error_handler.py", line \d+, in error_handler\n'
        r'    yield\n'
        r'(    \^\^\^\^\^\n)?'
        r'  File ".+tests.error_handler_test.py", line \d+, '
        r'in test_error_handler_fatal_error\n'
        r'    raise exc\n'
        r'(    \^\^\^\^\^\^\^\^\^\n)?'
        r'(pre_commit\.errors\.)?FatalError: just a test\n',
    )
    pattern.assert_matches(mocked_log_and_exit.call_args[0][3])


def test_error_handler_uncaught_error(mocked_log_and_exit):
    exc = ValueError('another test')
    with error_handler.error_handler():
        raise exc

    mocked_log_and_exit.assert_called_once_with(
        'An unexpected error has occurred',
        3,
        exc,
        # Tested below
        mock.ANY,
    )
    pattern = re_assert.Matches(
        r'Traceback \(most recent call last\):\n'
        r'  File ".+pre_commit.error_handler.py", line \d+, in error_handler\n'
        r'    yield\n'
        r'(    \^\^\^\^\^\n)?'
        r'  File ".+tests.error_handler_test.py", line \d+, '
        r'in test_error_handler_uncaught_error\n'
        r'    raise exc\n'
        r'(    \^\^\^\^\^\^\^\^\^\n)?'
        r'ValueError: another test\n',
    )
    pattern.assert_matches(mocked_log_and_exit.call_args[0][3])


def test_error_handler_keyboardinterrupt(mocked_log_and_exit):
    exc = KeyboardInterrupt()
    with error_handler.error_handler():
        raise exc

    mocked_log_and_exit.assert_called_once_with(
        'Interrupted (^C)',
        130,
        exc,
        # Tested below
        mock.ANY,
    )
    pattern = re_assert.Matches(
        r'Traceback \(most recent call last\):\n'
        r'  File ".+pre_commit.error_handler.py", line \d+, in error_handler\n'
        r'    yield\n'
        r'(    \^\^\^\^\^\n)?'
        r'  File ".+tests.error_handler_test.py", line \d+, '
        r'in test_error_handler_keyboardinterrupt\n'
        r'    raise exc\n'
        r'(    \^\^\^\^\^\^\^\^\^\n)?'
        r'KeyboardInterrupt\n',
    )
    pattern.assert_matches(mocked_log_and_exit.call_args[0][3])


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)


def test_error_handler_non_ascii_exception(mock_store_dir):
    with pytest.raises(SystemExit):
        with error_handler.error_handler():
            raise ValueError('☃')


def test_error_handler_non_utf8_exception(mock_store_dir):
    with pytest.raises(SystemExit):
        with error_handler.error_handler():
            raise CalledProcessError(1, ('exe',), 0, b'error: \xa0\xe1', b'')


def test_error_handler_non_stringable_exception(mock_store_dir):
    class C(Exception):
        def __str__(self):
            raise RuntimeError('not today!')

    with pytest.raises(SystemExit):
        with error_handler.error_handler():
            raise C()


def test_error_handler_no_tty(tempdir_factory):
    pre_commit_home = tempdir_factory.get()
    ret, out, _ = cmd_output_mocked_pre_commit_home(
        sys.executable,
        '-c',
        'from pre_commit.error_handler import error_handler\n'
        'with error_handler():\n'
        '    raise ValueError("\\u2603")\n',
        retcode=3,
        tempdir_factory=tempdir_factory,
        pre_commit_home=pre_commit_home,
    )
    log_file = os.path.join(pre_commit_home, 'pre-commit.log')
    out_lines = out.splitlines()
    assert out_lines[-2] == 'An unexpected error has occurred: ValueError: ☃'
    assert out_lines[-1] == f'Check the log at {log_file}'


@xfailif_windows  # pragma: win32 no cover
def test_error_handler_read_only_filesystem(mock_store_dir, cap_out, capsys):
    # a better scenario would be if even the Store crash would be handled
    # but realistically we're only targetting systems where the Store has
    # already been set up
    Store()

    write = (stat.S_IWGRP | stat.S_IWOTH | stat.S_IWUSR)
    os.chmod(mock_store_dir, os.stat(mock_store_dir).st_mode & ~write)

    with pytest.raises(SystemExit):
        with error_handler.error_handler():
            raise ValueError('ohai')

    output = cap_out.get()
    assert output.startswith(
        'An unexpected error has occurred: ValueError: ohai\n'
        'Failed to write to log at ',
    )

    # our cap_out mock is imperfect so the rest of the output goes to capsys
    out, _ = capsys.readouterr()
    # the things that normally go to the log file will end up here
    assert '### version information' in out