forked from a2aproject/a2a-python
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathtest_errors.py
More file actions
201 lines (160 loc) · 7.04 KB
/
Copy pathtest_errors.py
File metadata and controls
201 lines (160 loc) · 7.04 KB
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
import pytest
from a2a.client import A2AClientError, A2AClientHTTPError, A2AClientJSONError
class TestA2AClientError:
"""Test cases for the base A2AClientError class."""
def test_instantiation(self):
"""Test that A2AClientError can be instantiated."""
error = A2AClientError('Test error message')
assert isinstance(error, Exception)
assert str(error) == 'Test error message'
def test_inheritance(self):
"""Test that A2AClientError inherits from Exception."""
error = A2AClientError()
assert isinstance(error, Exception)
class TestA2AClientHTTPError:
"""Test cases for A2AClientHTTPError class."""
def test_instantiation(self):
"""Test that A2AClientHTTPError can be instantiated with status_code and message."""
error = A2AClientHTTPError(404, 'Not Found')
assert isinstance(error, A2AClientError)
assert error.status_code == 404
assert error.message == 'Not Found'
def test_message_formatting(self):
"""Test that the error message is formatted correctly."""
error = A2AClientHTTPError(500, 'Internal Server Error')
assert str(error) == 'HTTP Error 500: Internal Server Error'
def test_inheritance(self):
"""Test that A2AClientHTTPError inherits from A2AClientError."""
error = A2AClientHTTPError(400, 'Bad Request')
assert isinstance(error, A2AClientError)
def test_with_empty_message(self):
"""Test behavior with an empty message."""
error = A2AClientHTTPError(403, '')
assert error.status_code == 403
assert error.message == ''
assert str(error) == 'HTTP Error 403: '
def test_with_various_status_codes(self):
"""Test with different HTTP status codes."""
test_cases = [
(200, 'OK'),
(201, 'Created'),
(400, 'Bad Request'),
(401, 'Unauthorized'),
(403, 'Forbidden'),
(404, 'Not Found'),
(500, 'Internal Server Error'),
(503, 'Service Unavailable'),
]
for status_code, message in test_cases:
error = A2AClientHTTPError(status_code, message)
assert error.status_code == status_code
assert error.message == message
assert str(error) == f'HTTP Error {status_code}: {message}'
class TestA2AClientJSONError:
"""Test cases for A2AClientJSONError class."""
def test_instantiation(self):
"""Test that A2AClientJSONError can be instantiated with a message."""
error = A2AClientJSONError('Invalid JSON format')
assert isinstance(error, A2AClientError)
assert error.message == 'Invalid JSON format'
def test_message_formatting(self):
"""Test that the error message is formatted correctly."""
error = A2AClientJSONError('Missing required field')
assert str(error) == 'JSON Error: Missing required field'
def test_inheritance(self):
"""Test that A2AClientJSONError inherits from A2AClientError."""
error = A2AClientJSONError('Parsing error')
assert isinstance(error, A2AClientError)
def test_with_empty_message(self):
"""Test behavior with an empty message."""
error = A2AClientJSONError('')
assert error.message == ''
assert str(error) == 'JSON Error: '
def test_with_various_messages(self):
"""Test with different error messages."""
test_messages = [
'Malformed JSON',
'Missing required fields',
'Invalid data type',
'Unexpected JSON structure',
'Empty JSON object',
]
for message in test_messages:
error = A2AClientJSONError(message)
assert error.message == message
assert str(error) == f'JSON Error: {message}'
class TestExceptionHierarchy:
"""Test the exception hierarchy and relationships."""
def test_exception_hierarchy(self):
"""Test that the exception hierarchy is correct."""
assert issubclass(A2AClientError, Exception)
assert issubclass(A2AClientHTTPError, A2AClientError)
assert issubclass(A2AClientJSONError, A2AClientError)
def test_catch_specific_exception(self):
"""Test that specific exceptions can be caught."""
try:
raise A2AClientHTTPError(404, 'Not Found')
except A2AClientHTTPError as e:
assert e.status_code == 404
assert e.message == 'Not Found'
def test_catch_base_exception(self):
"""Test that derived exceptions can be caught as base exception."""
exceptions = [
A2AClientHTTPError(404, 'Not Found'),
A2AClientJSONError('Invalid JSON'),
]
for raised_error in exceptions:
try:
raise raised_error
except A2AClientError as e:
assert isinstance(e, A2AClientError)
class TestExceptionRaising:
"""Test cases for raising and handling the exceptions."""
def test_raising_http_error(self):
"""Test raising an HTTP error and checking its properties."""
with pytest.raises(A2AClientHTTPError) as excinfo:
raise A2AClientHTTPError(429, 'Too Many Requests')
error = excinfo.value
assert error.status_code == 429
assert error.message == 'Too Many Requests'
assert str(error) == 'HTTP Error 429: Too Many Requests'
def test_raising_json_error(self):
"""Test raising a JSON error and checking its properties."""
with pytest.raises(A2AClientJSONError) as excinfo:
raise A2AClientJSONError('Invalid format')
error = excinfo.value
assert error.message == 'Invalid format'
assert str(error) == 'JSON Error: Invalid format'
def test_raising_base_error(self):
"""Test raising the base error."""
with pytest.raises(A2AClientError) as excinfo:
raise A2AClientError('Generic client error')
assert str(excinfo.value) == 'Generic client error'
# Additional parametrized tests for more comprehensive coverage
@pytest.mark.parametrize(
'status_code,message,expected',
[
(400, 'Bad Request', 'HTTP Error 400: Bad Request'),
(404, 'Not Found', 'HTTP Error 404: Not Found'),
(500, 'Server Error', 'HTTP Error 500: Server Error'),
],
)
def test_http_error_parametrized(status_code, message, expected):
"""Parametrized test for HTTP errors with different status codes."""
error = A2AClientHTTPError(status_code, message)
assert error.status_code == status_code
assert error.message == message
assert str(error) == expected
@pytest.mark.parametrize(
'message,expected',
[
('Missing field', 'JSON Error: Missing field'),
('Invalid type', 'JSON Error: Invalid type'),
('Parsing failed', 'JSON Error: Parsing failed'),
],
)
def test_json_error_parametrized(message, expected):
"""Parametrized test for JSON errors with different messages."""
error = A2AClientJSONError(message)
assert error.message == message
assert str(error) == expected