def test_simple(self):
@dataclass
class Foo:
some_field: str
assert get_type_tree(Foo, locals()) == Object(
"Foo", Foo, {"some_field": Primitive(str)})
def match(cls, pytype: type, localns=None):
if is_dataclass(pytype):
field_hints = get_dataclass_type_hints(pytype, localns=localns)
fields = {
field_name: get_type_tree(subtype, localns)
for field_name, subtype in field_hints.items()
}
return Object(pytype.__name__, constructor=pytype, fields=fields)
def match(cls,
pytype: type,
localns=None) -> typing.Optional[AbstractNode]:
if (hasattr(pytype, "__origin__"
) # isinstance(Union[...], GenericAlias) returns False
and pytype.__origin__ == typing.Union
and len(pytype.__args__) == 2
and type(None) in pytype.__args__):
other = [arg for arg in pytype.__args__
if arg is not type(None)][0]
return Nullable(get_type_tree(other))
def test_nested(self):
@dataclass
class Bar:
other_field: str
@dataclass
class Foo:
some_field: Bar
list_field: list[Bar]
expected_bar_node = Object("Bar", Bar, {"other_field": Primitive(str)})
assert get_type_tree(Foo, locals()) == Object(
"Foo", Foo, {
"some_field": expected_bar_node,
"list_field": List(expected_bar_node)
})
def test_api_gen():
foo_type_tree = get_type_tree(Foo)
ctx = CodeSnippetContext()
func_code = build_ts_func("getFoo", foo_type_tree, None,
"/api/foo/<my_id>", ["my_id"], "GET", ctx)
expected_func_code = """
export const getFoo = async (myId: string): Promise<Foo> => {
const response = await fetch(`/api/foo/${myId}`, {
method: 'GET'
});
if (!response.ok) {
throw new ApiError("HTTP status code: " + response.status, response);
}
return await response.json();
}"""
assert func_code == expected_func_code
assert ctx.natural_order() == ["ApiError", "Foo"]
def match(cls, pytype: type, localns=None):
if isinstance(pytype, GenericAlias) and pytype.__origin__ == list:
subtype = pytype.__args__[0]
return List(element_node=get_type_tree(subtype, localns=localns))
def match(cls, pytype: type, localns=None) -> Optional[AbstractNode]:
if isinstance(pytype, GenericAlias) and pytype.__origin__ == tuple:
return Tuple([get_type_tree(f) for f in pytype.__args__])
def test_date():
assert get_type_tree(datetime.date) == Date()
source = datetime.date(2020, 10, 1)
assert Date().create_dto(source) == "2020-10-01"
assert Date().parse_dto("2020-10-01") == source
def test_datetime():
assert get_type_tree(datetime.datetime) == DateTime()
source = datetime.datetime(2020, 10, 1, 3, 2, 1)
assert DateTime().create_dto(source) == "2020-10-01T03:02:01Z"
assert DateTime().parse_dto("2020-10-01T03:02:01Z") == source
def test_primitives():
assert get_type_tree(int) == Primitive(int)
assert get_type_tree(float) == Primitive(float)
assert get_type_tree(str) == Primitive(str)
assert get_type_tree(bool) == Primitive(bool)
def test_tree_parsing(self):
assert get_type_tree(dict[str, int]) == Dict(Primitive(int))
t = get_type_tree(dict[int, str])
assert t == UnsupportedTypeNode(dict[int, str])
with pytest.raises(UnsupportedTypeError):
t.ts_repr(CodeSnippetContext())
def test_tree_parsing(self):
assert get_type_tree(list[str]) == List(Primitive(str))
assert get_type_tree(list[list[bool]]) == List(List(Primitive(bool)))
def match(cls, pytype: type, localns=None) -> Optional[AbstractNode]:
if isinstance(pytype, GenericAlias) and pytype.__origin__ == dict:
if pytype.__args__[0] != str:
# js "objects" only properly support string keys
return UnsupportedTypeNode(pytype)
return Dict(get_type_tree(pytype.__args__[1], localns=localns))
