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