def test_resolve_nonexisting_instance_attribute():
class User:
pass
user = User()
with raises(th.AttributeError):
get(user, _.name)
def test_resolve_private_instance_attribute():
class User:
def __init__(self, name):
self.__name = name
user = User("Bob")
with raises(th.AttributeError):
get(user, _.__name)
def test_attribute_error():
exception = "th.AttributeError: _.body['items'][0]\n" \
" ^^^^ does not exist"
with raises(th.AttributeError) as exc:
get(None, _.body["items"][0])
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
assert repr(exc.value) == exception
def test_key_error_verbose():
exception = "th.KeyError: _['result']['items']\n" \
" ^^^^^^^ does not exist\n" \
"where _ is <class 'dict'>:\n" \
"{'result': {}}"
with raises(th.KeyError) as exc:
get({"result": {}}, _["result"]["items"], verbose=True)
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
def test_index_error_verbose():
exception = "th.IndexError: _['items'][10]\n" \
" ^^ out of range\n" \
"where _ is <class 'dict'>:\n" \
"{'items': [1, 2, 3]}"
with raises(th.IndexError) as exc:
get({"items": [1, 2, 3]}, _["items"][10], verbose=True)
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
def test_key_error():
exception = "th.KeyError: _['result']['items']\n" \
" ^^^^^^^ does not exist"
with raises(th.KeyError) as exc:
get({"result": {}}, _["result"]["items"])
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
assert repr(exc.value) == exception
def test_type_error_subscriptable():
exception = "th.TypeError: _['status'][0]\n" \
" ^^^^^^^^^^^ inappropriate type (int)"
with raises(th.TypeError) as exc:
get({"status": 200}, _["status"][0])
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
assert repr(exc.value) == exception
def test_type_error_subscriptable_verbose():
exception = "th.TypeError: _['status'][0]\n" \
" ^^^^^^^^^^^ inappropriate type (int)\n" \
"where _ is <class 'dict'>:\n" \
"{'status': 200}"
with raises(th.TypeError) as exc:
get({"status": 200}, _["status"][0], verbose=True)
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
def test_index_error():
exception = "th.IndexError: _['items'][10]\n" \
" ^^ out of range"
with raises(th.IndexError) as exc:
get({"items": [1, 2, 3]}, _["items"][10])
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
assert repr(exc.value) == exception
def test_type_error():
exception = "th.TypeError: _['status'][None]\n" \
" ^^^^ inappropriate type (NoneType)"
with raises(th.TypeError) as exc:
get({"status": "OK"}, _["status"][None])
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
assert repr(exc.value) == exception
def test_type_error_verbose():
exception = "th.TypeError: _['status'][None]\n" \
" ^^^^ inappropriate type (NoneType)\n" \
"where _ is <class 'dict'>:\n" \
"{'status': 'OK'}"
with raises(th.TypeError) as exc:
get({"status": "OK"}, _["status"][None], verbose=True)
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
def test_attribute_error_verbose():
exception = "th.AttributeError: _.body['items'][0]\n" \
" ^^^^ does not exist\n" \
"where _ is <class 'NoneType'>:\n" \
"None"
with raises(th.AttributeError) as exc:
get(None, _.body["items"][0], verbose=True)
tb = "".join(format_exception(exc.type, exc.value, exc.tb))
assert tb.endswith(exception + "\n")
def test_resolve_protected_instance_attribute():
class User:
def __init__(self, name):
self._name = name
user = User("Bob")
assert get(user, _._name) == user._name
def test_resolve_public_instance_attribute():
class User:
def __init__(self, name):
self.name = name
user = User("Bob")
assert get(user, _.name) == user.name
def test_resolve_sequence_inappropriate_type():
numbers = [1, 2, 3]
with raises(th.TypeError):
get(numbers, _["first"])
def test_resolve_sequence_slice():
numbers = [1, 2, 3]
assert get(numbers, _[0:1]) == numbers[0:1]
def test_resolve_nonexisting_class_attribute():
class User:
pass
with raises(th.AttributeError):
get(User, _.unknown)
def test_resolve_sequence_index():
numbers = [1, 2, 3]
assert get(numbers, _[0]) == numbers[0]
def test_resolve_nonexisting_instance_attribute_with_default():
class User:
pass
user = User()
assert get(user, _.name, default=s.default) == s.default
def test_resolve_mapping_int_key():
numbers = {
0: "zero",
}
assert get(numbers, _[0]) == numbers[0]
def test_resolve_mapping_nonexisting_key():
numbers = {}
with raises(th.KeyError):
get(numbers, _["key"])
def test_resolve_nonexisting_class_attribute_with_default():
class User:
pass
assert get(User, _.unknown, default=s.default) == s.default
def test_resolve_mapping_str_key():
numbers = {
"id": 1,
}
assert get(numbers, _["id"]) == numbers["id"]
def test_resolve_sequence_outside_index_with_default():
assert get([], _[0], default=s.default) == s.default
def test_resolve_class_attribute():
class User:
name = "Bob"
assert get(User, _.name) == User.name
def test_resolve_mapping_nonexisting_key_with_default():
assert get({}, _["key"], default=s.default) == s.default
def test_resolve_sequence_outside_index():
numbers = []
with raises(th.IndexError):
get(numbers, _[len(numbers) + 1])
def test_resolve_sequence_inappropriate_type_with_default():
assert get([], _["first"], default=s.default) == s.default