def test_integration_array_ref_fk_def():
"""
GIVEN schema that references another object schema with a foreign key already
defined from an array and schemas
WHEN column_factory is called with the schema and schemas
THEN schemas is not modified and relationship is returned with the spec.
"""
spec = {
"type": "array",
"items": {
"$ref": "#/components/schemas/RefSchema"
}
}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "table 1",
"properties": {
"id": {
"type": "integer"
},
"schema_id": {
"type": "integer",
"x-foreign-key": "schema.id"
},
},
}
}
model_schema = {
"type": "object",
"x-tablename": "schema",
"properties": {
"id": {
"type": "integer"
}
},
}
logical_name = "ref_schema"
column_factory.column_factory(spec=spec,
schemas=schemas,
logical_name=logical_name,
model_schema=model_schema)
assert schemas == {
"RefSchema": {
"type": "object",
"x-tablename": "table 1",
"properties": {
"id": {
"type": "integer"
},
"schema_id": {
"type": "integer",
"x-foreign-key": "schema.id"
},
},
}
}
def test_integration_object_ref_uselist():
"""
GIVEN schema that references another object schema with a uselist and schemas
WHEN column_factory is called with the schema and schemas
THEN relationship with uselist is returned with the spec.
"""
spec = {"$ref": "#/components/schemas/RefSchema"}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "ref_schema",
"properties": {
"id": {
"type": "integer"
}
},
"x-backref": "ref_schemas",
"x-uselist": False,
}
}
([_, (_, relationship)], spec) = column_factory.column_factory(
spec=spec,
schemas=schemas,
logical_name="ref_schema",
model_schema={"properties": {}},
)
assert relationship.backref == ("ref_schemas", {"uselist": False})
def test_integration_object_all_of_ref():
"""
GIVEN schema with allOf that references another object schema and schemas
WHEN column_factory is called with the schema and schemas
THEN foreign key reference and relationship is returned.
"""
spec = {"allOf": [{"$ref": "#/components/schemas/RefSchema"}]}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "table 1",
"properties": {
"id": {
"type": "integer"
}
},
}
}
[ # pylint: disable=unbalanced-tuple-unpacking
(fk_logical_name, fk_column),
(tbl_logical_name, relationship),
] = column_factory.column_factory(spec=spec,
schemas=schemas,
logical_name="column_1")
assert fk_logical_name == "column_1_id"
assert isinstance(fk_column.type, sqlalchemy.Integer)
assert len(fk_column.foreign_keys) == 1
assert tbl_logical_name == "column_1"
assert relationship.argument == "RefSchema"
assert relationship.backref is None
def test_integration_relationship():
"""
GIVEN relationship property artifacts
WHEN column_factory is called with the artifacts
THEN a relationship is returned.
"""
artifacts = types.ManyToOneRelationshipPropertyArtifacts(
type=types.PropertyType.RELATIONSHIP,
sub_type=types.RelationshipType.MANY_TO_ONE,
parent="RefSchema",
backref_property=None,
kwargs=None,
write_only=None,
description=None,
required=False,
schema={"type": "object"},
foreign_key="foreign.key",
foreign_key_property="foreign_key",
nullable=None,
)
relationship = column_factory.column_factory(artifacts=artifacts)
assert relationship.argument == "RefSchema"
assert relationship.backref is None
assert relationship.uselist is None
def test_integration_json():
"""
GIVEN json column artifacts
WHEN column_factory is called with the artifacts
THEN a SQLAlchemy JSON column is returned.
"""
artifacts = types.JsonPropertyArtifacts(
type=types.PropertyType.JSON,
open_api=types.OpenApiJsonPropertyArtifacts(
nullable=None,
read_only=None,
write_only=None,
),
extension=types.ExtensionJsonPropertyArtifacts(
primary_key=False,
index=None,
unique=None,
foreign_key=None,
kwargs=None,
foreign_key_kwargs=None,
),
schema={"type": "boolean"},
required=False,
description=None,
)
column = column_factory.column_factory(artifacts=artifacts)
assert isinstance(column, sqlalchemy.types.Column)
assert isinstance(column.type, sqlalchemy.types.JSON)
def test_integration_array_ref_read_only():
"""
GIVEN schema that references another object schema from an array that is read only
and schemas
WHEN column_factory is called with the schema and schemas
THEN no columns and the schema is returned.
"""
schema = {
"type": "array",
"items": {
"$ref": "#/components/schemas/RefSchema"
},
"readOnly": True,
}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "table 1",
"properties": {
"id": {
"type": "integer"
}
},
}
}
model_schema = {
"type": "object",
"x-tablename": "schema",
"properties": {
"id": {
"type": "integer"
}
},
}
logical_name = "ref_schema"
([], returned_schema) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name=logical_name,
model_schema=model_schema,
model_name="model",
)
assert returned_schema == {
"type": "array",
"items": {
"type": "object",
"properties": {
"id": {
"type": "integer"
}
}
},
"readOnly": True,
}
def test_integration_all_of():
"""
GIVEN schema with allOf statement
WHEN column_factory is called with the schema and schemas
THEN SQLAlchemy boolean column is returned in a dictionary with logical name.
"""
spec = {"allOf": [{"type": "boolean"}]}
schemas = {}
[(logical_name, column)
] = column_factory.column_factory(spec=spec,
schemas=schemas,
logical_name="column_1")
assert logical_name == "column_1"
assert isinstance(column.type, sqlalchemy.Boolean)
def test_integration_ref():
"""
GIVEN schema that references another schema and schemas
WHEN column_factory is called with the schema and schemas
THEN SQLAlchemy boolean column is returned in a dictionary with logical name.
"""
spec = {"$ref": "#/components/schemas/RefSchema"}
schemas = {"RefSchema": {"type": "boolean"}}
[(logical_name, column)
] = column_factory.column_factory(spec=spec,
schemas=schemas,
logical_name="column_1")
assert logical_name == "column_1"
assert isinstance(column.type, sqlalchemy.Boolean)
def test_integration_kwargs():
"""
GIVEN schema with kwargs
WHEN column_factory is called with the schema
THEN SQLAlchemy column is constructed with the kwargs.
"""
schema = {"type": "boolean", "x-kwargs": {"doc": "doc 1"}}
schemas = {}
([(_, column)], _) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name="column_1",
model_schema={},
model_name="schema",
)
assert column.doc == "doc 1"
def test_integration():
"""
GIVEN schema
WHEN column_factory is called with the schema
THEN SQLAlchemy boolean column is returned in a dictionary with logical name and
spec.
"""
spec = {"type": "boolean"}
schemas = {}
([(logical_name, column)],
spec) = column_factory.column_factory(spec=spec,
schemas=schemas,
logical_name="column_1",
model_schema={})
assert logical_name == "column_1"
assert isinstance(column.type, sqlalchemy.Boolean)
assert spec == {"type": "boolean"}
def test_integration_backref():
"""
GIVEN backref property artifacts
WHEN column_factory is called with the artifacts
THEN None is returned.
"""
artifacts = types.BackrefPropertyArtifacts(
type=types.PropertyType.BACKREF,
sub_type=types.BackrefSubType.OBJECT,
properties=[],
schema={},
required=None,
description=None,
)
backref = column_factory.column_factory(artifacts=artifacts)
assert backref is None
def test_integration_simple_json(schema, expected_schema):
"""
GIVEN JSON schema and expected schema
WHEN column_factory is called with the schema
THEN a SQLALchemy JSON column and the expected schema are returned.
"""
schemas = {}
([(logical_name, column)],
returned_schema) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name="column_1",
model_schema={},
model_name="schema",
)
assert logical_name == "column_1"
assert isinstance(column.type, facades.sqlalchemy.column.JSON)
assert returned_schema == expected_schema
def test_integration_all_of():
"""
GIVEN schema with allOf statement
WHEN column_factory is called with the schema
THEN SQLAlchemy boolean column is returned in a dictionary with logical name and
spec.
"""
spec = {"allOf": [{"type": "boolean"}]}
schemas = {}
([(logical_name, column)], spec) = column_factory.column_factory(
spec=spec,
schemas=schemas,
logical_name="column_1",
model_schema={},
model_name="schema",
)
assert logical_name == "column_1"
assert isinstance(column.type, facades.sqlalchemy.column.Boolean)
assert spec == {"type": "boolean"}
def test_integration_simple(schema, expected_schema):
"""
GIVEN schema
WHEN column_factory is called with the schema
THEN a SQLAlchemy boolean column is returned in a tuple with logical name and
schema.
"""
schemas = {}
([(logical_name, column)],
returned_schema) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name="column_1",
model_schema={},
model_name="schema",
)
assert logical_name == "column_1"
assert isinstance(column.type, facades.sqlalchemy.column.Boolean)
assert returned_schema == expected_schema
def test_integration_ref():
"""
GIVEN schema that references another schema and schemas
WHEN column_factory is called with the schema and schemas
THEN SQLAlchemy boolean column is returned in a dictionary with logical name and
the schema.
"""
schema = {"$ref": "#/components/schemas/RefSchema"}
schemas = {"RefSchema": {"type": "boolean"}}
([(logical_name, column)],
returned_schema) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name="column_1",
model_schema={},
model_name="schema",
)
assert logical_name == "column_1"
assert isinstance(column.type, facades.sqlalchemy.column.Boolean)
assert returned_schema == {"type": "boolean"}
def test_integration_object_ref():
"""
GIVEN schema that references another object schema and schemas
WHEN column_factory is called with the schema and schemas
THEN foreign key reference and relationship is returned with the spec.
"""
schema = {"$ref": "#/components/schemas/RefSchema"}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "ref_schema",
"properties": {
"id": {
"type": "integer"
}
},
}
}
logical_name = "ref_schema"
(
[(fk_logical_name, fk_column), (tbl_logical_name, relationship)],
returned_schema,
) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name=logical_name,
model_schema={"properties": {}},
model_name="schema",
)
assert fk_logical_name == "ref_schema_id"
assert isinstance(fk_column.type, facades.sqlalchemy.column.Integer)
assert len(fk_column.foreign_keys) == 1
assert tbl_logical_name == logical_name
assert relationship.argument == "RefSchema"
assert relationship.backref is None
assert relationship.uselist is None
assert returned_schema == {"type": "object", "x-de-$ref": "RefSchema"}
def test_integration_object_ref_fk_def():
"""
GIVEN schema that references another object schema which already has the foreign
key defined and schemas
WHEN column_factory is called with the schema and schemas
THEN no foreign key column is returned.
"""
model_schema = {
"properties": {
"ref_schema_id": {
"type": "integer",
"x-foreign-key": "ref_schema.id"
}
}
}
spec = {"$ref": "#/components/schemas/RefSchema"}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "ref_schema",
"properties": {
"id": {
"type": "integer"
}
},
}
}
logical_name = "ref_schema"
([(tbl_logical_name, relationship)],
_) = column_factory.column_factory(spec=spec,
schemas=schemas,
logical_name=logical_name,
model_schema=model_schema)
assert tbl_logical_name == logical_name
assert relationship.argument == "RefSchema"
def test_integration_simple():
"""
GIVEN simple column artifacts
WHEN column_factory is called with the artifacts
THEN a SQLAlchemy boolean column is returned.
"""
artifacts = types.SimplePropertyArtifacts(
type=types.PropertyType.SIMPLE,
open_api=types.OpenApiSimplePropertyArtifacts(
type="boolean",
format=None,
max_length=None,
nullable=None,
default=None,
read_only=None,
write_only=None,
),
extension=types.ExtensionSimplePropertyArtifacts(
primary_key=False,
autoincrement=None,
index=None,
unique=None,
server_default=None,
foreign_key=None,
kwargs=None,
foreign_key_kwargs=None,
dict_ignore=False,
),
schema={"type": "boolean"},
required=False,
description=None,
)
column = column_factory.column_factory(artifacts=artifacts)
assert isinstance(column, sqlalchemy.types.Column)
assert isinstance(column.type, sqlalchemy.types.Boolean)
def test_integration_array_ref():
"""
GIVEN schema that references another object schema from an array and schemas
WHEN column_factory is called with the schema and schemas
THEN foreign key reference is added to the referenced schema and relationship is
returned with the schema.
"""
schema = {
"type": "array",
"items": {
"$ref": "#/components/schemas/RefSchema"
}
}
schemas = {
"RefSchema": {
"type": "object",
"x-tablename": "table 1",
"properties": {
"id": {
"type": "integer"
}
},
}
}
model_schema = {
"type": "object",
"x-tablename": "schema",
"properties": {
"id": {
"type": "integer"
}
},
}
logical_name = "ref_schema"
(
[(tbl_logical_name, relationship)],
returned_schema,
) = column_factory.column_factory(
schema=schema,
schemas=schemas,
logical_name=logical_name,
model_schema=model_schema,
model_name="model",
)
assert tbl_logical_name == logical_name
assert relationship.argument == "RefSchema"
assert returned_schema == {
"type": "array",
"items": {
"type": "object",
"x-de-$ref": "RefSchema"
},
}
assert schemas == {
"RefSchema": {
"allOf": [
{
"type": "object",
"x-tablename": "table 1",
"properties": {
"id": {
"type": "integer"
}
},
},
{
"type": "object",
"properties": {
"schema_ref_schema_id": {
"type": "integer",
"x-foreign-key": "schema.id",
"x-dict-ignore": True,
}
},
},
]
}
}
