gibson-cli 0.1.0__py3-none-any.whl

services/code/customization/tests/test_code_customization_BaseCustomization.py

@@ -0,0 +1,14 @@
+import pytest
+
+from core.Configuration import Configuration
+from services.code.customization.BaseCustomization import BaseCustomization
+
+
+def test_preserve_exception():
+    with pytest.raises(NotImplementedError):
+        BaseCustomization(Configuration()).preserve()
+
+
+def test_restore_exception():
+    with pytest.raises(NotImplementedError):
+        BaseCustomization(Configuration()).restore()

structure/Entity.py

@@ -0,0 +1,115 @@
+from structure.keys.ForeignKey import ForeignKey
+from structure.keys.Index import Index
+
+
+class Entity:
+    def __init__(self):
+        self.attributes = None
+        self.constraints = None
+        self.keys = None
+        self.name = None
+        self.parameters = None
+
+    def add_attribute(self, name, data_type, after=None, before=None):
+        was_added = False
+
+        json = {
+            "as": None,
+            "bytes": None,
+            "check": None,
+            "comment": None,
+            "data_type": {
+                "formatted": data_type,
+                "raw": data_type,
+            },
+            "default": None,
+            "extra": {"increment": {"auto": None}},
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": name,
+            "nullable": None,
+            "numeric": {
+                "precision": None,
+                "scale": None,
+            },
+            "on": None,
+            "reference": None,
+            "sql": f"{name} {data_type}",
+            "unsigned": None,
+            "values": None,
+        }
+
+        attributes = []
+        for attribute in self.attributes:
+            if was_added is False and attribute["name"] == after:
+                was_added = True
+                attributes.append(attribute)
+                attributes.append(json)
+            elif was_added is False and attribute["name"] == before:
+                was_added = True
+                attributes.append(json)
+                attributes.append(attribute)
+            else:
+                attributes.append(attribute)
+
+        if was_added is False:
+            attributes.append(json)
+
+        self.attributes = attributes
+        return self
+
+    def add_foreign_key(self, foreign_key: ForeignKey):
+        self.keys["foreign"].append(foreign_key.json())
+        return self
+
+    def add_index(self, index: Index):
+        self.keys["index"].append(index.json())
+        return self
+
+    def create_statement(self):
+        parts = []
+        for attribute in self.attributes:
+            parts.append("    " + attribute["sql"])
+
+        if self.keys["primary"] is not None:
+            parts.append("    " + self.keys["primary"]["sql"])
+
+        for unique_key in self.keys["unique"]:
+            parts.append("    " + unique_key["sql"])
+
+        for index in self.keys["index"]:
+            parts.append("    " + index["sql"])
+
+        for fk in self.keys["foreign"]:
+            parts.append("    " + fk["sql"])
+
+        for check in self.constraints["check"]:
+            parts.append("    " + check["sql"])
+
+        parameters = self.parameters["sql"]
+        if parameters not in [None, ""]:
+            parameters = " " + parameters
+        else:
+            parameters = ""
+
+        return (
+            f"create table if not exists {self.name}(\n"
+            + ",\n".join(parts)
+            + f"\n){parameters}"
+        )
+
+    def import_from_struct(self, data: dict):
+        if "name" in data and "struct" in data:
+            self.name = data["name"]
+
+            for key in data["struct"].keys():
+                setattr(self, key, data["struct"][key])
+        elif "entity" in data and "struct" in data["entity"]:
+            self.name = data["entity"]["name"]
+
+            for key in data["entity"]["struct"].keys():
+                setattr(self, key, data["entity"]["struct"][key])
+        else:
+            raise RuntimeError("cannot import from struct, incorrect data format")
+
+        return self

structure/constraints/ReferenceConstraint.py

@@ -0,0 +1,36 @@
+class ReferenceConstraint:
+    def __init__(self):
+        self.attributes = None
+        self.match = None
+        self.on_delete = None
+        self.on_update = None
+        self.references = None
+
+    def json(self):
+        return {
+            "attributes": self.attributes,
+            "match": self.match,
+            "on": {"delete": self.on_delete, "update": self.on_update},
+            "references": self.references,
+            "sql": self.sql(),
+        }
+
+    def sql(self):
+        if self.attributes is None or self.attributes == []:
+            raise RuntimeError("reference constraint is missing attributes")
+
+        if self.references is None:
+            raise RuntimeError("reference constraint is missing referenced entity")
+
+        parts = ["references", self.references, "(" + ", ".join(self.attributes) + ")"]
+
+        if self.match is not None:
+            parts.append(f"match {self.match}")
+
+        if self.on_delete is not None:
+            parts.append(f"on delete {self.on_delete}")
+
+        if self.on_update is not None:
+            parts.append(f"on update {self.on_update}")
+
+        return " ".join(parts)

structure/keys/ForeignKey.py

@@ -0,0 +1,41 @@
+from structure.constraints.ReferenceConstraint import ReferenceConstraint
+
+
+class ForeignKey:
+    def __init__(self):
+        self.attributes = None
+        self.name = None
+        self.reference = None
+        self.relationship = None
+        self.symbol = None
+
+    def json(self):
+        return {
+            "attributes": self.attributes,
+            "name": self.name,
+            "reference": self.reference.json(),
+            "relationship": {"type": None},
+            "sql": self.sql(),
+            "symbol": self.symbol,
+        }
+
+    def sql(self):
+        if self.attributes is None or self.attributes == []:
+            raise RuntimeError("foreign key is missing attributes")
+
+        if self.reference is None or not isinstance(
+            self.reference, ReferenceConstraint
+        ):
+            raise RuntimeError("reference must be instance of ReferenceConstraint")
+
+        parts = []
+        if self.symbol is not None:
+            parts.append(f"constraint {self.symbol}")
+
+        parts.append("foreign key")
+        if self.name is not None:
+            parts.append(self.name)
+
+        parts.append("(" + ", ".join(self.attributes) + ")")
+
+        return " ".join(parts) + " " + self.reference.sql()

structure/keys/Index.py

@@ -0,0 +1,64 @@
+from structure.keys.IndexAttribute import IndexAttribute
+
+
+class Index:
+    def __init__(self):
+        self.__attribute_name_list = []
+        self.attributes = None
+        self.name = None
+        self.using = None
+
+    def add_attribute(self, name, asc=False, desc=False):
+        if asc is True and desc is True:
+            raise RuntimeError("an index attribute cannot be both asc and desc")
+
+        if self.attributes is None:
+            self.attributes = []
+
+        attribute = IndexAttribute()
+        attribute.name = name
+
+        if asc is True:
+            attribute.asc = True
+        elif desc is True:
+            attribute.desc = True
+
+        self.attributes.append(attribute)
+        self.__attribute_name_list.append(name)
+
+        return self
+
+    def attribute_name_list(self):
+        return self.__attribute_name_list
+
+    def json(self):
+        return {
+            "attributes": self.__attribute_name_list,
+            "name": self.name,
+            "sql": self.sql(),
+            "using": self.using,
+        }
+
+    def reset_attributes(self):
+        self.__attribute_name_list = []
+        self.attributes = None
+        return self
+
+    def sql(self):
+        if self.attributes is None or self.attributes == []:
+            raise RuntimeError("index is missing attributes")
+
+        parts = ["index"]
+        if self.name is not None:
+            parts.append(self.name)
+
+        if self.using is not None:
+            parts.append(f"using {self.using}")
+
+        attributes = []
+        for attribute in self.attributes:
+            attributes.append(attribute.sql())
+
+        parts.append("(" + ", ".join(attributes) + ")")
+
+        return " ".join(parts)

structure/keys/IndexAttribute.py

@@ -0,0 +1,14 @@
+class IndexAttribute:
+    def __init__(self):
+        self.asc = None
+        self.desc = None
+        self.name = None
+
+    def sql(self):
+        sql = self.name
+        if self.asc is True:
+            sql += " asc"
+        elif self.desc is True:
+            sql += " desc"
+
+        return sql

structure/keys/tests/test_ForeignKey.py

@@ -0,0 +1,80 @@
+import pytest
+
+from structure.constraints.ReferenceConstraint import ReferenceConstraint
+from structure.keys.ForeignKey import ForeignKey
+
+
+def test_sql_exceptions():
+    with pytest.raises(RuntimeError) as e:
+        ForeignKey().sql()
+
+    assert str(e.value) == "foreign key is missing attributes"
+
+    foreign_key = ForeignKey()
+    foreign_key.attributes = ["a"]
+
+    with pytest.raises(RuntimeError) as e:
+        foreign_key.sql()
+
+    assert str(e.value) == "reference must be instance of ReferenceConstraint"
+
+    foreign_key.reference = "abc"
+
+    with pytest.raises(RuntimeError) as e:
+        foreign_key.sql()
+
+    assert str(e.value) == "reference must be instance of ReferenceConstraint"
+
+
+def test_sql():
+    reference = ReferenceConstraint()
+    reference.attributes = ["a", "b"]
+    reference.references = "other_table"
+
+    foreign_key = ForeignKey()
+    foreign_key.reference = reference
+
+    foreign_key.attributes = ["a", "b"]
+
+    assert foreign_key.sql() == "foreign key (a, b) references other_table (a, b)"
+
+    foreign_key.name = "abc_def_fk"
+
+    assert foreign_key.sql() == (
+        "foreign key abc_def_fk (a, b) references other_table (a, b)"
+    )
+
+    foreign_key.symbol = "foreign_key_symbol"
+
+    assert foreign_key.sql() == (
+        "constraint foreign_key_symbol foreign key abc_def_fk (a, b) "
+        + "references other_table (a, b)"
+    )
+
+
+def test_json():
+    reference = ReferenceConstraint()
+    reference.attributes = ["a", "b"]
+    reference.references = "other_table"
+
+    foreign_key = ForeignKey()
+    foreign_key.attributes = ["c", "d"]
+    foreign_key.name = "abc_def_fk"
+    foreign_key.reference = reference
+    foreign_key.symbol = "foreign_key_symbol"
+
+    assert foreign_key.json() == {
+        "attributes": ["c", "d"],
+        "name": "abc_def_fk",
+        "reference": {
+            "attributes": ["a", "b"],
+            "match": None,
+            "on": {"delete": None, "update": None},
+            "references": "other_table",
+            "sql": "references other_table (a, b)",
+        },
+        "relationship": {"type": None},
+        "sql": "constraint foreign_key_symbol foreign key abc_def_fk (c, d) "
+        + "references other_table (a, b)",
+        "symbol": "foreign_key_symbol",
+    }

structure/keys/tests/test_Index.py

@@ -0,0 +1,98 @@
+import pytest
+
+from structure.keys.Index import Index
+
+
+def test_sql_exceptions():
+    with pytest.raises(RuntimeError) as e:
+        Index().sql()
+
+    assert str(e.value) == "index is missing attributes"
+
+
+def test_sql_1():
+    index = Index()
+    index.add_attribute("a").add_attribute("b")
+
+    assert index.sql() == "index (a, b)"
+
+    index.name = "abc_def_idx"
+
+    assert index.sql() == "index abc_def_idx (a, b)"
+
+    index.using = "btree"
+
+    assert index.sql() == "index abc_def_idx using btree (a, b)"
+
+
+def test_sql_2():
+    index = Index()
+    index.add_attribute("a").add_attribute("b")
+    index.using = "hash"
+
+    assert index.sql() == "index using hash (a, b)"
+
+
+def test_add_attribute_asc_and_desc_exception():
+    with pytest.raises(RuntimeError) as e:
+        Index().add_attribute("abc", True, True)
+
+    assert str(e.value) == "an index attribute cannot be both asc and desc"
+
+
+def test_add_attribute_asc():
+    index = Index()
+    index.add_attribute("a", True)
+
+    assert index.sql() == "index (a asc)"
+
+    index = Index()
+    index.add_attribute("a", asc=True)
+
+    assert index.sql() == "index (a asc)"
+
+
+def test_add_attribute_desc():
+    index = Index()
+    index.add_attribute("a", False, True)
+
+    assert index.sql() == "index (a desc)"
+
+    index = Index()
+    index.add_attribute("a", desc=True)
+
+    assert index.sql() == "index (a desc)"
+
+
+def test_attribute_name_list():
+    index = Index()
+    index.add_attribute("a").add_attribute("b")
+
+    assert index.attribute_name_list() == ["a", "b"]
+
+
+def test_reset_attributes():
+    index = Index()
+    index.add_attribute("a").add_attribute("b")
+
+    assert len(index.attributes) == 2
+    assert index.attribute_name_list() == ["a", "b"]
+
+    index.reset_attributes()
+
+    assert index.attributes is None
+    assert index.attribute_name_list() == []
+
+
+def test_json():
+    index = Index()
+    index.add_attribute("a").add_attribute("b")
+    index.name = "abc_def_idx"
+    index.using = "btree"
+
+    assert index.json() == {
+        "attributes": ["a", "b"],
+        "name": "abc_def_idx",
+        "sql": "index abc_def_idx using btree (a, b)",
+        "using": "btree",
+    }

structure/keys/tests/test_IndexAttribute.py

@@ -0,0 +1,17 @@
+from structure.keys.IndexAttribute import IndexAttribute
+
+
+def test_sql():
+    index_attribute = IndexAttribute()
+    index_attribute.name = "abc"
+
+    assert index_attribute.sql() == "abc"
+
+    index_attribute.asc = True
+
+    assert index_attribute.sql() == "abc asc"
+
+    index_attribute.asc = None
+    index_attribute.desc = True
+
+    assert index_attribute.sql() == "abc desc"

structure/testing.py

@@ -0,0 +1,194 @@
+from structure.Entity import Entity
+
+
+def structure_testing_get_entity():
+    entity = Entity()
+    entity.attributes = [
+        {
+            "as_": None,
+            "bytes_": None,
+            "check": None,
+            "comment": None,
+            "data_type": {"formatted": "bigint", "raw": "bigint"},
+            "default": None,
+            "extra": {"increment": {"auto": True}},
+            "key": {"index": None, "primary": True, "unique": None},
+            "length": None,
+            "name": "id",
+            "nullable": False,
+            "numeric": {"precision": None, "scale": None},
+            "on": None,
+            "reference": None,
+            "sql": "id bigint not null auto_increment primary key",
+            "unsigned": None,
+            "values": None,
+        },
+        {
+            "as_": None,
+            "bytes_": None,
+            "check": None,
+            "comment": None,
+            "data_type": {"formatted": "varchar(36)", "raw": "varchar"},
+            "default": None,
+            "extra": {"increment": {"auto": None}},
+            "key": {"index": None, "primary": None, "unique": True},
+            "length": 36,
+            "name": "uuid",
+            "nullable": False,
+            "numeric": {"precision": None, "scale": None},
+            "on": None,
+            "reference": None,
+            "sql": "uuid varchar(36) not null unique key",
+            "unsigned": None,
+            "values": None,
+        },
+        {
+            "as_": None,
+            "bytes_": None,
+            "check": None,
+            "comment": None,
+            "data_type": {"formatted": "datetime", "raw": "datetime"},
+            "default": "current_timestamp",
+            "extra": {"increment": {"auto": None}},
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": "date_created",
+            "nullable": False,
+            "numeric": {"precision": None, "scale": None},
+            "on": None,
+            "reference": None,
+            "sql": "date_created datetime not null default current_timestamp",
+            "unsigned": None,
+            "values": None,
+        },
+        {
+            "as_": None,
+            "bytes_": None,
+            "check": None,
+            "comment": None,
+            "data_type": {"formatted": "datetime", "raw": "datetime"},
+            "default": "null",
+            "extra": {"increment": {"auto": None}},
+            "key": {"index": None, "primary": None, "unique": None},
+            "length": None,
+            "name": "date_updated",
+            "nullable": None,
+            "numeric": {"precision": None, "scale": None},
+            "on": "update current_timestamp",
+            "reference": None,
+            "sql": "date_updated datetime default null on update current_timestamp",
+            "unsigned": None,
+            "values": None,
+        },
+    ]
+    entity.constraints = {"check": []}
+    entity.keys = {"foreign": [], "index": [], "primary": None, "unique": []}
+    entity.name = "abc_def"
+    entity.parameters = {
+        "auto": None,
+        "charset": None,
+        "collate": None,
+        "default": None,
+        "engine": None,
+        "sql": None,
+    }
+
+    return entity
+
+
+def structure_testing_get_struct_data():
+    return {
+        "entity": {
+            "name": "abc_def",
+            "struct": {
+                "attributes": [
+                    {
+                        "as_": None,
+                        "bytes_": None,
+                        "check": None,
+                        "comment": None,
+                        "data_type": {"formatted": "bigint", "raw": "bigint"},
+                        "default": None,
+                        "extra": {"increment": {"auto": True}},
+                        "key": {"index": None, "primary": True, "unique": None},
+                        "length": None,
+                        "name": "id",
+                        "nullable": False,
+                        "numeric": {"precision": None, "scale": None},
+                        "on": None,
+                        "reference": None,
+                        "sql": "id bigint not null auto_increment primary key",
+                        "unsigned": None,
+                        "values": None,
+                    },
+                    {
+                        "as_": None,
+                        "bytes_": None,
+                        "check": None,
+                        "comment": None,
+                        "data_type": {"formatted": "varchar(36)", "raw": "varchar"},
+                        "default": None,
+                        "extra": {"increment": {"auto": None}},
+                        "key": {"index": None, "primary": None, "unique": True},
+                        "length": 36,
+                        "name": "uuid",
+                        "nullable": False,
+                        "numeric": {"precision": None, "scale": None},
+                        "on": None,
+                        "reference": None,
+                        "sql": "uuid varchar(36) not null unique key",
+                        "unsigned": None,
+                        "values": None,
+                    },
+                    {
+                        "as_": None,
+                        "bytes_": None,
+                        "check": None,
+                        "comment": None,
+                        "data_type": {"formatted": "datetime", "raw": "datetime"},
+                        "default": "current_timestamp",
+                        "extra": {"increment": {"auto": None}},
+                        "key": {"index": None, "primary": None, "unique": None},
+                        "length": None,
+                        "name": "date_created",
+                        "nullable": False,
+                        "numeric": {"precision": None, "scale": None},
+                        "on": None,
+                        "reference": None,
+                        "sql": "date_created datetime not null default current_timestamp",
+                        "unsigned": None,
+                        "values": None,
+                    },
+                    {
+                        "as_": None,
+                        "bytes_": None,
+                        "check": None,
+                        "comment": None,
+                        "data_type": {"formatted": "datetime", "raw": "datetime"},
+                        "default": "null",
+                        "extra": {"increment": {"auto": None}},
+                        "key": {"index": None, "primary": None, "unique": None},
+                        "length": None,
+                        "name": "date_updated",
+                        "nullable": None,
+                        "numeric": {"precision": None, "scale": None},
+                        "on": "update current_timestamp",
+                        "reference": None,
+                        "sql": "date_updated datetime default null on update current_timestamp",
+                        "unsigned": None,
+                        "values": None,
+                    },
+                ],
+                "constraints": {"check": []},
+                "keys": {"foreign": [], "index": [], "primary": None, "unique": []},
+                "parameters": {
+                    "auto": None,
+                    "charset": None,
+                    "collate": None,
+                    "default": None,
+                    "engine": None,
+                    "sql": None,
+                },
+            },
+        }
+    }