def test_class_dir(opts, input, renderer):
dir = pathlib.Path("another/rel/path")
input.classes = [
schema.Class("A", derived={"B"}, dir=dir),
schema.Class("B", bases={"A"}),
]
assert generate(opts, renderer) == {
import_file():
ql.ImportList([
stub_import_prefix + "another.rel.path.A",
stub_import_prefix + "B",
]),
stub_path() / dir / "A.qll":
ql.Stub(name="A",
base_import=gen_import_prefix + "another.rel.path.A"),
stub_path() / "B.qll":
ql.Stub(name="B", base_import=gen_import_prefix + "B"),
ql_output_path() / dir / "A.qll":
ql.Class(name="A", dir=dir),
ql_output_path() / "B.qll":
ql.Class(name="B",
final=True,
bases=["A"],
imports=[stub_import_prefix + "another.rel.path.A"])
}
def test_hierarchy(opts, input, renderer):
input.classes = [
schema.Class("D", bases={"B", "C"}),
schema.Class("C", bases={"A"}, derived={"D"}),
schema.Class("B", bases={"A"}, derived={"D"}),
schema.Class("A", derived={"B", "C"}),
]
assert generate(opts, renderer) == {
import_file():
ql.ImportList([stub_import_prefix + cls for cls in "ABCD"]),
stub_path() / "A.qll":
ql.Stub(name="A", base_import=gen_import_prefix + "A"),
stub_path() / "B.qll":
ql.Stub(name="B", base_import=gen_import_prefix + "B"),
stub_path() / "C.qll":
ql.Stub(name="C", base_import=gen_import_prefix + "C"),
stub_path() / "D.qll":
ql.Stub(name="D", base_import=gen_import_prefix + "D"),
ql_output_path() / "A.qll":
ql.Class(name="A"),
ql_output_path() / "B.qll":
ql.Class(name="B", bases=["A"], imports=[stub_import_prefix + "A"]),
ql_output_path() / "C.qll":
ql.Class(name="C", bases=["A"], imports=[stub_import_prefix + "A"]),
ql_output_path() / "D.qll":
ql.Class(name="D",
final=True,
bases=["B", "C"],
imports=[stub_import_prefix + cls for cls in "BC"]),
}
def test_single_class_property(opts, input, renderer):
input.classes = [
schema.Class("MyObject",
properties=[schema.SingleProperty("foo", "Bar")]),
schema.Class("Bar"),
]
assert generate(opts, renderer) == {
import_file():
ql.ImportList(
[stub_import_prefix + cls for cls in ("Bar", "MyObject")]),
stub_path() / "MyObject.qll":
ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
stub_path() / "Bar.qll":
ql.Stub(name="Bar", base_import=gen_import_prefix + "Bar"),
ql_output_path() / "MyObject.qll":
ql.Class(
name="MyObject",
final=True,
imports=[stub_import_prefix + "Bar"],
properties=[
ql.Property(singular="Foo",
type="Bar",
tablename="my_objects",
tableparams=["this", "result"]),
],
),
ql_output_path() / "Bar.qll":
ql.Class(name="Bar", final=True)
}
def test_single_class_property(generate_classes, is_child):
assert generate_classes([
schema.Class("MyObject",
properties=[
schema.SingleProperty("foo", "Bar", is_child=is_child)
]),
schema.Class("Bar"),
]) == {
"MyObject.qll": (ql.Stub(name="MyObject",
base_import=gen_import_prefix + "MyObject"),
ql.Class(
name="MyObject",
final=True,
imports=[stub_import_prefix + "Bar"],
properties=[
ql.Property(singular="Foo",
type="Bar",
tablename="my_objects",
tableparams=["this", "result"],
is_child=is_child),
],
)),
"Bar.qll": (ql.Stub(name="Bar", base_import=gen_import_prefix + "Bar"),
ql.Class(name="Bar", final=True)),
}
def test_hierarchy_children(generate_children_implementations):
assert generate_children_implementations([
schema.Class("D", bases={"B", "C"}),
schema.Class("C", bases={"A"}, derived={"D"}),
schema.Class("B", bases={"A"}, derived={"D"}),
schema.Class("A", derived={"B", "C"}),
]) == ql.GetParentImplementation(classes=[
ql.Class(name="A"),
ql.Class(name="B", bases=["A"], imports=[stub_import_prefix + "A"]),
ql.Class(name="C", bases=["A"], imports=[stub_import_prefix + "A"]),
ql.Class(name="D",
final=True,
bases=["B", "C"],
imports=[stub_import_prefix + cls for cls in "BC"]),
], )
def test_single_properties(generate_classes):
assert generate_classes([
schema.Class("MyObject",
properties=[
schema.SingleProperty("one", "x"),
schema.SingleProperty("two", "y"),
schema.SingleProperty("three", "z"),
]),
]) == {
"MyObject.qll":
(ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="One",
type="x",
tablename="my_objects",
tableparams=["this", "result", "_", "_"]),
ql.Property(singular="Two",
type="y",
tablename="my_objects",
tableparams=["this", "_", "result", "_"]),
ql.Property(singular="Three",
type="z",
tablename="my_objects",
tableparams=["this", "_", "_", "result"]),
])),
}
def test_single_properties(opts, input, renderer):
input.classes = [
schema.Class("MyObject",
properties=[
schema.SingleProperty("one", "x"),
schema.SingleProperty("two", "y"),
schema.SingleProperty("three", "z"),
]),
]
assert generate(opts, renderer) == {
import_file():
ql.ImportList([stub_import_prefix + "MyObject"]),
stub_path() / "MyObject.qll":
ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql_output_path() / "MyObject.qll":
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="One",
type="x",
tablename="my_objects",
tableparams=["this", "result", "_", "_"]),
ql.Property(singular="Two",
type="y",
tablename="my_objects",
tableparams=["this", "_", "result", "_"]),
ql.Property(singular="Three",
type="z",
tablename="my_objects",
tableparams=["this", "_", "_", "result"]),
])
}
def get_ql_class(cls: schema.Class):
return ql.Class(
name=cls.name,
bases=cls.bases,
final=not cls.derived,
properties=[get_ql_property(cls, p) for p in cls.properties],
dir=cls.dir,
)
def test_class_dir(generate_classes):
dir = pathlib.Path("another/rel/path")
assert generate_classes([
schema.Class("A", derived={"B"}, dir=dir),
schema.Class("B", bases={"A"}),
]) == {
f"{dir}/A.qll":
(ql.Stub(name="A",
base_import=gen_import_prefix + "another.rel.path.A"),
ql.Class(name="A", dir=dir)),
"B.qll":
(ql.Stub(name="B", base_import=gen_import_prefix + "B"),
ql.Class(name="B",
final=True,
bases=["A"],
imports=[stub_import_prefix + "another.rel.path.A"])),
}
def test_class_has_first_property_marked():
props = [
ql.Property(f"Prop{x}", f"Foo{x}", f"props{x}", [f"{x}"])
for x in range(4)
]
expected = deepcopy(props)
expected[0].first = True
cls = ql.Class("Class", properties=props)
assert cls.properties == expected
def test_one_empty_class(opts, input, renderer):
input.classes = [schema.Class("A")]
assert generate(opts, renderer) == {
import_file():
ql.ImportList([stub_import_prefix + "A"]),
stub_path() / "A.qll":
ql.Stub(name="A", base_import=gen_import_prefix + "A"),
ql_output_path() / "A.qll":
ql.Class(name="A", final=True),
}
def test_hierarchy(generate_classes):
assert generate_classes([
schema.Class("D", bases={"B", "C"}),
schema.Class("C", bases={"A"}, derived={"D"}),
schema.Class("B", bases={"A"}, derived={"D"}),
schema.Class("A", derived={"B", "C"}),
]) == {
"A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
ql.Class(name="A")),
"B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"),
ql.Class(name="B",
bases=["A"],
imports=[stub_import_prefix + "A"])),
"C.qll": (ql.Stub(name="C", base_import=gen_import_prefix + "C"),
ql.Class(name="C",
bases=["A"],
imports=[stub_import_prefix + "A"])),
"D.qll":
(ql.Stub(name="D", base_import=gen_import_prefix + "D"),
ql.Class(name="D",
final=True,
bases=["B", "C"],
imports=[stub_import_prefix + cls for cls in "BC"])),
}
def test_single_property(generate_classes):
assert generate_classes([
schema.Class("MyObject",
properties=[schema.SingleProperty("foo", "bar")]),
]) == {
"MyObject.qll":
(ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="Foo",
type="bar",
tablename="my_objects",
tableparams=["this", "result"]),
])),
}
def test_predicate_property(generate_classes):
assert generate_classes([
schema.Class("MyObject",
properties=[schema.PredicateProperty("is_foo")]),
]) == {
"MyObject.qll": (ql.Stub(name="MyObject",
base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="isFoo",
type="predicate",
tablename="my_object_is_foo",
tableparams=["this"],
is_predicate=True),
])),
}
def test_predicate_property(opts, input, renderer):
input.classes = [
schema.Class("MyObject",
properties=[schema.PredicateProperty("is_foo")]),
]
assert generate(opts, renderer) == {
import_file():
ql.ImportList([stub_import_prefix + "MyObject"]),
stub_path() / "MyObject.qll":
ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql_output_path() / "MyObject.qll":
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="isFoo",
type="predicate",
tablename="my_object_is_foo",
tableparams=["this"],
is_predicate=True),
])
}
def test_repeated_property(opts, input, renderer):
input.classes = [
schema.Class("MyObject",
properties=[schema.RepeatedProperty("foo", "bar")]),
]
assert generate(opts, renderer) == {
import_file():
ql.ImportList([stub_import_prefix + "MyObject"]),
stub_path() / "MyObject.qll":
ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql_output_path() / "MyObject.qll":
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="Foo",
plural="Foos",
type="bar",
tablename="my_object_foos",
tableparams=["this", "index", "result"]),
])
}
def test_repeated_property(generate_classes, is_child):
assert generate_classes([
schema.Class("MyObject",
properties=[
schema.RepeatedProperty("foo",
"bar",
is_child=is_child)
]),
]) == {
"MyObject.qll":
(ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
ql.Class(name="MyObject",
final=True,
properties=[
ql.Property(singular="Foo",
plural="Foos",
type="bar",
tablename="my_object_foos",
tableparams=["this", "index", "result"],
is_child=is_child),
])),
}
def test_root_class():
cls = ql.Class("Class")
assert cls.root
def test_class_sorts_bases():
bases = ["B", "Ab", "C", "Aa"]
expected = ["Aa", "Ab", "B", "C"]
cls = ql.Class("Foo", bases=bases)
assert cls.bases == expected
def test_one_empty_class(generate_classes):
assert generate_classes([schema.Class("A")]) == {
"A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
ql.Class(name="A", final=True)),
}
def test_non_root_class():
cls = ql.Class("Class", bases=["A"])
assert not cls.root
def test_class_db_id():
cls = ql.Class("ThisIsMyClass")
assert cls.db_id == "@this_is_my_class"
