def test_final_class_with_predicate_field(opts, input, renderer):
input.classes = [
schema.Class("Object", properties=[
schema.PredicateProperty("foo"),
]),
]
assert generate(opts, renderer) == dbscheme.Scheme(
src=schema_file,
includes=[],
declarations=[
dbscheme.Table(
name="objects",
columns=[
dbscheme.Column('id', '@object', binding=True),
]
),
dbscheme.Table(
name="object_foo",
keyset=dbscheme.KeySet(["id"]),
columns=[
dbscheme.Column('id', '@object'),
]
),
],
)
def test_class_with_derived_and_repeated_property(opts, input, renderer):
input.classes = [
schema.Class(
name="Base",
derived={"Left", "Right"},
properties=[
schema.RepeatedProperty("rep", "Prop"),
]),
]
assert generate(opts, renderer) == dbscheme.Scheme(
src=schema_file,
includes=[],
declarations=[
dbscheme.Union(
lhs="@base",
rhs=["@left", "@right"],
),
dbscheme.Table(
name="base_reps",
keyset=dbscheme.KeySet(["id", "index"]),
columns=[
dbscheme.Column('id', '@base'),
dbscheme.Column('index', 'int'),
dbscheme.Column('rep', '@prop'),
]
)
],
)
def test_final_class_with_repeated_field(opts, input, renderer, property_cls):
input.classes = [
schema.Class("Object", properties=[
property_cls("foo", "bar"),
]),
]
assert generate(opts, renderer) == dbscheme.Scheme(
src=schema_file,
includes=[],
declarations=[
dbscheme.Table(
name="objects",
columns=[
dbscheme.Column('id', '@object', binding=True),
]
),
dbscheme.Table(
name="object_foos",
keyset=dbscheme.KeySet(["id", "index"]),
columns=[
dbscheme.Column('id', '@object'),
dbscheme.Column('index', 'int'),
dbscheme.Column('foo', 'bar'),
]
),
],
)
def test_one_table_with_two_binding_first_is_id(generate_traps):
assert generate_traps([
dbscheme.Table(name="foos", columns=[
dbscheme.Column("x", "a", binding=True),
dbscheme.Column("y", "b", binding=True),
]),
]) == [
cpp.Trap("foos", name="Foos", fields=[
cpp.Field("x", "a"),
cpp.Field("y", "b"),
], id=cpp.Field("x", "a")),
]
def test_one_table_overridden_underscore_named_field(generate_traps):
assert generate_traps([
dbscheme.Table(name="foos",
columns=[dbscheme.Column("whatever_", "bar")]),
]) == [
cpp.Trap("foos", name="Foos", fields=[cpp.Field("whatever", "bar")]),
]
def test_one_table_with_id(generate_traps):
assert generate_traps([
dbscheme.Table(name="foos", columns=[
dbscheme.Column("bla", "int", binding=True)]),
]) == [
cpp.Trap("foos", name="Foos", fields=[cpp.Field(
"bla", "int")], id=cpp.Field("bla", "int")),
]
def test_final_class_with_single_class_field(opts, input, renderer):
input.classes = [
schema.Class("Object",
properties=[
schema.SingleProperty("foo", "Bar"),
]),
]
assert generate(opts, renderer) == dbscheme.Scheme(
src=schema_file,
includes=[],
declarations=[
dbscheme.Table(name="objects",
columns=[
dbscheme.Column('id', '@object', binding=True),
dbscheme.Column('foo', '@bar'),
])
],
)
def test_comments_ignored(load):
assert load("""
// fake_table();
foos(/* x */unique /*y*/int/*
z
*/ id/* */: /* * */ @bar/*,
int ignored: int ref*/);
@foo = @bar | @baz | @bla; // | @xxx""") == [
dbscheme.Table(name="foos", columns=[dbscheme.Column(schema_name="id", type="@bar", binding=True)]),
dbscheme.Union(lhs="@foo", rhs=["@bar", "@baz", "@bla"]),
]
def test_empty_final_class(opts, input, renderer):
input.classes = [
schema.Class("Object"),
]
assert generate(opts, renderer) == dbscheme.Scheme(
src=schema_file,
includes=[],
declarations=[
dbscheme.Table(name="objects",
columns=[
dbscheme.Column('id', '@object', binding=True),
])
],
)
def test_final_class_with_more_fields(opts, input, renderer):
input.classes = [
schema.Class("Object", properties=[
schema.SingleProperty("one", "x"),
schema.SingleProperty("two", "y"),
schema.OptionalProperty("three", "z"),
schema.RepeatedProperty("four", "u"),
schema.RepeatedOptionalProperty("five", "v"),
schema.PredicateProperty("six"),
]),
]
assert generate(opts, renderer) == dbscheme.Scheme(
src=schema_file,
includes=[],
declarations=[
dbscheme.Table(
name="objects",
columns=[
dbscheme.Column('id', '@object', binding=True),
dbscheme.Column('one', 'x'),
dbscheme.Column('two', 'y'),
]
),
dbscheme.Table(
name="object_threes",
keyset=dbscheme.KeySet(["id"]),
columns=[
dbscheme.Column('id', '@object'),
dbscheme.Column('three', 'z'),
]
),
dbscheme.Table(
name="object_fours",
keyset=dbscheme.KeySet(["id", "index"]),
columns=[
dbscheme.Column('id', '@object'),
dbscheme.Column('index', 'int'),
dbscheme.Column('four', 'u'),
]
),
dbscheme.Table(
name="object_fives",
keyset=dbscheme.KeySet(["id", "index"]),
columns=[
dbscheme.Column('id', '@object'),
dbscheme.Column('index', 'int'),
dbscheme.Column('five', 'v'),
]
),
dbscheme.Table(
name="object_six",
keyset=dbscheme.KeySet(["id"]),
columns=[
dbscheme.Column('id', '@object'),
]
),
],
)
def test_one_table_no_tags(generate_tags):
assert generate_tags([
dbscheme.Table(name="foos", columns=[dbscheme.Column("bla", "int")]),
]) == []
def test_one_table(generate_traps):
assert generate_traps([
dbscheme.Table(name="foos", columns=[dbscheme.Column("bla", "int")]),
]) == [
cpp.Trap("foos", name="Foos", fields=[cpp.Field("bla", "int")]),
]
def test_one_table_with_two_binding_first_is_id(generate_traps):
assert generate_traps([
dbscheme.Table(name="foos", columns=[
dbscheme.Column("x", "a", binding=True),
dbscheme.Column("y", "b", binding=True),
]),
]) == [
cpp.Trap("foos", name="Foos", fields=[
cpp.Field("x", "a"),
cpp.Field("y", "b"),
], id=cpp.Field("x", "a")),
]
@pytest.mark.parametrize("column,field", [
(dbscheme.Column("x", "string"), cpp.Field("x", "std::string")),
(dbscheme.Column("y", "boolean"), cpp.Field("y", "bool")),
(dbscheme.Column("z", "@db_type"), cpp.Field("z", "TrapAffixLabel<DbTypeTag>")),
])
def test_one_table_special_types(generate_traps, column, field):
assert generate_traps([
dbscheme.Table(name="foos", columns=[column]),
]) == [
cpp.Trap("foos", name="Foos", fields=[field]),
]
@pytest.mark.parametrize("name", ["start_line", "start_column", "end_line", "end_column", "index", "num_whatever"])
def test_one_table_overridden_unsigned_field(generate_traps, name):
assert generate_traps([
dbscheme.Table(name="foos", columns=[dbscheme.Column(name, "bar")]),
def test_one_table_overridden_unsigned_field(generate_traps, name):
assert generate_traps([
dbscheme.Table(name="foos", columns=[dbscheme.Column(name, "bar")]),
]) == [
cpp.Trap("foos", name="Foos", fields=[cpp.Field(name, "unsigned")]),
]
def test_dbcolumn_name():
assert dbscheme.Column("foo", "some_type").name == "foo"
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_dbcolumn_types(type, binding, lhstype, rhstype):
col = dbscheme.Column("foo", type, binding)
assert col.lhstype == lhstype
assert col.rhstype == rhstype
""") == [
dbscheme.Table(name="test_foos", columns=[])
]
def test_load_table_with_keyset(load):
assert load("""
#keyset[x, y,z]
test_foos();
""") == [
dbscheme.Table(name="test_foos", columns=[], keyset=dbscheme.KeySet(["x", "y", "z"]))
]
expected_columns = [
("int foo: int ref", dbscheme.Column(schema_name="foo", type="int", binding=False)),
(" int bar : int ref", dbscheme.Column(schema_name="bar", type="int", binding=False)),
("str baz_: str ref", dbscheme.Column(schema_name="baz", type="str", binding=False)),
("int x: @foo ref", dbscheme.Column(schema_name="x", type="@foo", binding=False)),
("int y: @foo", dbscheme.Column(schema_name="y", type="@foo", binding=True)),
("unique int z: @foo", dbscheme.Column(schema_name="z", type="@foo", binding=True)),
]
@pytest.mark.parametrize("column,expected", expected_columns)
def test_load_table_with_column(load, column, expected):
assert load(f"""
foos(
{column}
);
""") == [
def test_dbcolumn_keyword_name(keyword):
assert dbscheme.Column(keyword, "some_type").name == keyword + "_"
