Swift: testing non-trivial dataclass properties

Author: redsun82

.gitignore

@@ -20,6 +20,9 @@
 # python virtual environment folder
 .venv/
 
+# binary files created by pytest-cov
+.coverage
+
 # It's useful (though not required) to be able to unpack codeql in the ql checkout itself
 /codeql/
 

swift/codegen/.coverage

@@ -19,42 +19,42 @@ def dbtype(typename):
 def cls_to_dbscheme(cls: schema.Class):
     """ Yield all dbscheme entities needed to model class `cls` """
     if cls.derived:
-        yield DbUnion(dbtype(cls.name), (dbtype(c) for c in cls.derived))
+        yield Union(dbtype(cls.name), (dbtype(c) for c in cls.derived))
     # output a table specific to a class only if it is a leaf class or it has 1-to-1 properties
     # Leaf classes need a table to bind the `@` ids
     # 1-to-1 properties are added to a class specific table
     # in other cases, separate tables are used for the properties, and a class specific table is unneeded
     if not cls.derived or any(f.is_single for f in cls.properties):
         binding = not cls.derived
-        keyset = DbKeySet(["id"]) if cls.derived else None
-        yield DbTable(
+        keyset = KeySet(["id"]) if cls.derived else None
+        yield Table(
             keyset=keyset,
             name=inflection.tableize(cls.name),
             columns=[
-                        DbColumn("id", type=dbtype(cls.name), binding=binding),
+                        Column("id", type=dbtype(cls.name), binding=binding),
                     ] + [
-                        DbColumn(f.name, dbtype(f.type)) for f in cls.properties if f.is_single
+                        Column(f.name, dbtype(f.type)) for f in cls.properties if f.is_single
                     ]
         )
     # use property-specific tables for 1-to-many and 1-to-at-most-1 properties
     for f in cls.properties:
         if f.is_optional:
-            yield DbTable(
-                keyset=DbKeySet(["id"]),
+            yield Table(
+                keyset=KeySet(["id"]),
                 name=inflection.tableize(f"{cls.name}_{f.name}"),
                 columns=[
-                    DbColumn("id", type=dbtype(cls.name)),
-                    DbColumn(f.name, dbtype(f.type)),
+                    Column("id", type=dbtype(cls.name)),
+                    Column(f.name, dbtype(f.type)),
                 ],
             )
         elif f.is_repeated:
-            yield DbTable(
-                keyset=DbKeySet(["id", "index"]),
+            yield Table(
+                keyset=KeySet(["id", "index"]),
                 name=inflection.tableize(f"{cls.name}_{f.name}"),
                 columns=[
-                    DbColumn("id", type=dbtype(cls.name)),
-                    DbColumn("index", type="int"),
-                    DbColumn(inflection.singularize(f.name), dbtype(f.type)),
+                    Column("id", type=dbtype(cls.name)),
+                    Column("index", type="int"),
+                    Column(inflection.singularize(f.name), dbtype(f.type)),
                 ]
             )
 
@@ -68,7 +68,7 @@ def get_includes(data: schema.Schema, include_dir: pathlib.Path):
     for inc in data.includes:
         inc = include_dir / inc
         with open(inc) as inclusion:
-            includes.append(DbSchemeInclude(src=inc.relative_to(paths.swift_dir), data=inclusion.read()))
+            includes.append(SchemeInclude(src=inc.relative_to(paths.swift_dir), data=inclusion.read()))
     return includes
 
 
@@ -78,7 +78,7 @@ def generate(opts, renderer):
 
     data = schema.load(input)
 
-    dbscheme = DbScheme(src=input.relative_to(paths.swift_dir),
+    dbscheme = Scheme(src=input.relative_to(paths.swift_dir),
                         includes=get_includes(data, include_dir=input.parent),
                         declarations=get_declarations(data))
 

swift/codegen/dbschemegen.py

@@ -10,7 +10,7 @@
 
 
 @dataclass
-class DbColumn:
+class Column:
     schema_name: str
     type: str
     binding: bool = False
@@ -36,69 +36,69 @@ def rhstype(self):
 
 
 @dataclass
-class DbKeySetId:
+class KeySetId:
     id: str
     first: bool = False
 
 
 @dataclass
-class DbKeySet:
-    ids: List[DbKeySetId]
+class KeySet:
+    ids: List[KeySetId]
 
     def __post_init__(self):
         assert self.ids
-        self.ids = [DbKeySetId(x) for x in self.ids]
+        self.ids = [KeySetId(x) for x in self.ids]
         self.ids[0].first = True
 
 
-class DbDecl:
+class Decl:
     is_table = False
     is_union = False
 
 
 @dataclass
-class DbTable(DbDecl):
+class Table(Decl):
     is_table: ClassVar = True
 
     name: str
-    columns: List[DbColumn]
-    keyset: DbKeySet = None
+    columns: List[Column]
+    keyset: KeySet = None
 
     def __post_init__(self):
         if self.columns:
             self.columns[0].first = True
 
 
 @dataclass
-class DbUnionCase:
+class UnionCase:
     type: str
     first: bool = False
 
 
 @dataclass
-class DbUnion(DbDecl):
+class Union(Decl):
     is_union: ClassVar = True
 
     lhs: str
-    rhs: List[DbUnionCase]
+    rhs: List[UnionCase]
 
     def __post_init__(self):
         assert self.rhs
-        self.rhs = [DbUnionCase(x) for x in self.rhs]
+        self.rhs = [UnionCase(x) for x in self.rhs]
         self.rhs.sort(key=lambda c: c.type)
         self.rhs[0].first = True
 
 
 @dataclass
-class DbSchemeInclude:
+class SchemeInclude:
     src: str
     data: str
 
 
 @dataclass
-class DbScheme:
+class Scheme:
     template: ClassVar = 'dbscheme'
 
     src: str
-    includes: List[DbSchemeInclude]
-    declarations: List[DbDecl]
+    includes: List[SchemeInclude]
+    declarations: List[Decl]

swift/codegen/lib/dbscheme.py

@@ -6,20 +6,20 @@
 
 
 @dataclass
-class QlParam:
+class Param:
     param: str
     type: str = None
     first: bool = False
 
 
 @dataclass
-class QlProperty:
+class Property:
     singular: str
     type: str
     tablename: str
-    tableparams: List[QlParam]
+    tableparams: List[Param]
     plural: str = None
-    params: List[QlParam] = field(default_factory=list)
+    params: List[Param] = field(default_factory=list)
     first: bool = False
     local_var: str = "x"
 
@@ -31,7 +31,7 @@ def __post_init__(self):
         assert self.tableparams
         if self.type_is_class:
             self.tableparams = [x if x != "result" else self.local_var for x in self.tableparams]
-        self.tableparams = [QlParam(x) for x in self.tableparams]
+        self.tableparams = [Param(x) for x in self.tableparams]
         self.tableparams[0].first = True
 
     @property
@@ -45,13 +45,13 @@ def type_is_class(self):
 
 
 @dataclass
-class QlClass:
+class Class:
     template: ClassVar = 'ql_class'
 
     name: str
     bases: List[str] = field(default_factory=list)
     final: bool = False
-    properties: List[QlProperty] = field(default_factory=list)
+    properties: List[Property] = field(default_factory=list)
     dir: pathlib.Path = pathlib.Path()
     imports: List[str] = field(default_factory=list)
 
@@ -74,15 +74,15 @@ def path(self):
 
 
 @dataclass
-class QlStub:
+class Stub:
     template: ClassVar = 'ql_stub'
 
     name: str
     base_import: str
 
 
 @dataclass
-class QlImportList:
+class ImportList:
     template: ClassVar = 'ql_imports'
 
     imports: List[str] = field(default_factory=list)

swift/codegen/lib/ql.py

@@ -12,32 +12,32 @@
 
 def get_ql_property(cls: schema.Class, prop: schema.Property):
     if prop.is_single:
-        return ql.QlProperty(
+        return ql.Property(
             singular=inflection.camelize(prop.name),
             type=prop.type,
             tablename=inflection.tableize(cls.name),
             tableparams=["this"] + ["result" if p is prop else "_" for p in cls.properties if p.is_single],
         )
     elif prop.is_optional:
-        return ql.QlProperty(
+        return ql.Property(
             singular=inflection.camelize(prop.name),
             type=prop.type,
             tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
             tableparams=["this", "result"],
         )
     elif prop.is_repeated:
-        return ql.QlProperty(
+        return ql.Property(
             singular=inflection.singularize(inflection.camelize(prop.name)),
             plural=inflection.pluralize(inflection.camelize(prop.name)),
             type=prop.type,
             tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
             tableparams=["this", "index", "result"],
-            params=[ql.QlParam("index", type="int")],
+            params=[ql.Param("index", type="int")],
         )
 
 
 def get_ql_class(cls: schema.Class):
-    return ql.QlClass(
+    return ql.Class(
         name=cls.name,
         bases=cls.bases,
         final=not cls.derived,
@@ -51,7 +51,7 @@ def get_import(file):
     return str(stem).replace("/", ".")
 
 
-def get_types_used_by(cls: ql.QlClass):
+def get_types_used_by(cls: ql.Class):
     for b in cls.bases:
         yield b
     for p in cls.properties:
@@ -60,7 +60,7 @@ def get_types_used_by(cls: ql.QlClass):
             yield param.type
 
 
-def get_classes_used_by(cls: ql.QlClass):
+def get_classes_used_by(cls: ql.Class):
     return sorted(set(t for t in get_types_used_by(cls) if t[0].isupper()))
 
 
@@ -98,12 +98,12 @@ def generate(opts, renderer):
         renderer.render(c, qll)
         stub_file = (stub_out / c.path).with_suffix(".qll")
         if not stub_file.is_file() or is_generated(stub_file):
-            stub = ql.QlStub(name=c.name, base_import=get_import(qll))
+            stub = ql.Stub(name=c.name, base_import=get_import(qll))
             renderer.render(stub, stub_file)
 
     # for example path/to/syntax/generated -> path/to/syntax.qll
     include_file = stub_out.with_suffix(".qll")
-    all_imports = ql.QlImportList([v for _, v in sorted(imports.items())])
+    all_imports = ql.ImportList([v for _, v in sorted(imports.items())])
     renderer.render(all_imports, include_file)
 
     renderer.cleanup(existing)

swift/codegen/qlgen.py

@@ -0,0 +1,52 @@
+import sys
+from copy import deepcopy
+
+from swift.codegen.lib import dbscheme
+from swift.codegen.test.utils import *
+
+
+def test_dbcolumn_name():
+    assert dbscheme.Column("foo", "some_type").name == "foo"
+
+
+@pytest.mark.parametrize("keyword", dbscheme.dbscheme_keywords)
+def test_dbcolumn_keyword_name(keyword):
+    assert dbscheme.Column(keyword, "some_type").name == keyword + "_"
+
+
+@pytest.mark.parametrize("type,binding,lhstype,rhstype", [
+    ("builtin_type", False, "builtin_type", "builtin_type ref"),
+    ("builtin_type", True, "builtin_type", "builtin_type ref"),
+    ("@at_type", False, "int", "@at_type ref"),
+    ("@at_type", True, "unique int", "@at_type"),
+])
+def test_dbcolumn_types(type, binding, lhstype, rhstype):
+    col = dbscheme.Column("foo", type, binding)
+    assert col.lhstype == lhstype
+    assert col.rhstype == rhstype
+
+
+def test_keyset_has_first_id_marked():
+    ids = ["a", "b", "c"]
+    ks = dbscheme.KeySet(ids)
+    assert ks.ids[0].first
+    assert [id.id for id in ks.ids] == ids
+
+
+def test_table_has_first_column_marked():
+    columns = [dbscheme.Column("a", "x"), dbscheme.Column("b", "y", binding=True), dbscheme.Column("c", "z")]
+    expected = deepcopy(columns)
+    table = dbscheme.Table("foo", columns)
+    expected[0].first = True
+    assert table.columns == expected
+
+
+def test_union_has_first_case_marked():
+    rhs = ["a", "b", "c"]
+    u = dbscheme.Union(lhs="x", rhs=rhs)
+    assert u.rhs[0].first
+    assert [c.type for c in u.rhs] == rhs
+
+
+if __name__ == '__main__':
+    sys.exit(pytest.main())