Все подряд

.venv2/Lib/site-packages/alembic/testing/suite/test_autogen_computed.py

@@ -0,0 +1,203 @@
+import sqlalchemy as sa
+from sqlalchemy import Column
+from sqlalchemy import Integer
+from sqlalchemy import MetaData
+from sqlalchemy import Table
+
+from ._autogen_fixtures import AutogenFixtureTest
+from ... import testing
+from ...testing import config
+from ...testing import eq_
+from ...testing import exclusions
+from ...testing import is_
+from ...testing import is_true
+from ...testing import mock
+from ...testing import TestBase
+
+
+class AutogenerateComputedTest(AutogenFixtureTest, TestBase):
+    __requires__ = ("computed_columns",)
+    __backend__ = True
+
+    def test_add_computed_column(self):
+        m1 = MetaData()
+        m2 = MetaData()
+
+        Table("user", m1, Column("id", Integer, primary_key=True))
+
+        Table(
+            "user",
+            m2,
+            Column("id", Integer, primary_key=True),
+            Column("foo", Integer, sa.Computed("5")),
+        )
+
+        diffs = self._fixture(m1, m2)
+
+        eq_(diffs[0][0], "add_column")
+        eq_(diffs[0][2], "user")
+        eq_(diffs[0][3].name, "foo")
+        c = diffs[0][3].computed
+
+        is_true(isinstance(c, sa.Computed))
+        is_(c.persisted, None)
+        eq_(str(c.sqltext), "5")
+
+    def test_remove_computed_column(self):
+        m1 = MetaData()
+        m2 = MetaData()
+
+        Table(
+            "user",
+            m1,
+            Column("id", Integer, primary_key=True),
+            Column("foo", Integer, sa.Computed("5")),
+        )
+
+        Table("user", m2, Column("id", Integer, primary_key=True))
+
+        diffs = self._fixture(m1, m2)
+
+        eq_(diffs[0][0], "remove_column")
+        eq_(diffs[0][2], "user")
+        c = diffs[0][3]
+        eq_(c.name, "foo")
+
+        if config.requirements.computed_reflects_normally.enabled:
+            is_true(isinstance(c.computed, sa.Computed))
+        else:
+            is_(c.computed, None)
+
+        if config.requirements.computed_reflects_as_server_default.enabled:
+            is_true(isinstance(c.server_default, sa.DefaultClause))
+            eq_(str(c.server_default.arg.text), "5")
+        elif config.requirements.computed_reflects_normally.enabled:
+            is_true(isinstance(c.computed, sa.Computed))
+        else:
+            is_(c.computed, None)
+
+    @testing.combinations(
+        lambda: (None, sa.Computed("bar*5")),
+        (lambda: (sa.Computed("bar*5"), None)),
+        lambda: (
+            sa.Computed("bar*5"),
+            sa.Computed("bar * 42", persisted=True),
+        ),
+        lambda: (sa.Computed("bar*5"), sa.Computed("bar * 42")),
+    )
+    @config.requirements.computed_reflects_normally
+    def test_cant_change_computed_warning(self, test_case):
+        arg_before, arg_after = testing.resolve_lambda(test_case, **locals())
+        m1 = MetaData()
+        m2 = MetaData()
+
+        arg_before = [] if arg_before is None else [arg_before]
+        arg_after = [] if arg_after is None else [arg_after]
+
+        Table(
+            "user",
+            m1,
+            Column("id", Integer, primary_key=True),
+            Column("bar", Integer),
+            Column("foo", Integer, *arg_before),
+        )
+
+        Table(
+            "user",
+            m2,
+            Column("id", Integer, primary_key=True),
+            Column("bar", Integer),
+            Column("foo", Integer, *arg_after),
+        )
+
+        with mock.patch("alembic.util.warn") as mock_warn:
+            diffs = self._fixture(m1, m2)
+
+        eq_(
+            mock_warn.mock_calls,
+            [mock.call("Computed default on user.foo cannot be modified")],
+        )
+
+        eq_(list(diffs), [])
+
+    @testing.combinations(
+        lambda: (None, None),
+        lambda: (sa.Computed("5"), sa.Computed("5")),
+        lambda: (sa.Computed("bar*5"), sa.Computed("bar*5")),
+        (
+            lambda: (sa.Computed("bar*5"), None),
+            config.requirements.computed_doesnt_reflect_as_server_default,
+        ),
+    )
+    def test_computed_unchanged(self, test_case):
+        arg_before, arg_after = testing.resolve_lambda(test_case, **locals())
+        m1 = MetaData()
+        m2 = MetaData()
+
+        arg_before = [] if arg_before is None else [arg_before]
+        arg_after = [] if arg_after is None else [arg_after]
+
+        Table(
+            "user",
+            m1,
+            Column("id", Integer, primary_key=True),
+            Column("bar", Integer),
+            Column("foo", Integer, *arg_before),
+        )
+
+        Table(
+            "user",
+            m2,
+            Column("id", Integer, primary_key=True),
+            Column("bar", Integer),
+            Column("foo", Integer, *arg_after),
+        )
+
+        with mock.patch("alembic.util.warn") as mock_warn:
+            diffs = self._fixture(m1, m2)
+        eq_(mock_warn.mock_calls, [])
+
+        eq_(list(diffs), [])
+
+    @config.requirements.computed_reflects_as_server_default
+    def test_remove_computed_default_on_computed(self):
+        """Asserts the current behavior which is that on PG and Oracle,
+        the GENERATED ALWAYS AS is reflected as a server default which we can't
+        tell is actually "computed", so these come out as a modification to
+        the server default.
+
+        """
+        m1 = MetaData()
+        m2 = MetaData()
+
+        Table(
+            "user",
+            m1,
+            Column("id", Integer, primary_key=True),
+            Column("bar", Integer),
+            Column("foo", Integer, sa.Computed("bar + 42")),
+        )
+
+        Table(
+            "user",
+            m2,
+            Column("id", Integer, primary_key=True),
+            Column("bar", Integer),
+            Column("foo", Integer),
+        )
+
+        diffs = self._fixture(m1, m2)
+
+        eq_(diffs[0][0][0], "modify_default")
+        eq_(diffs[0][0][2], "user")
+        eq_(diffs[0][0][3], "foo")
+        old = diffs[0][0][-2]
+        new = diffs[0][0][-1]
+
+        is_(new, None)
+        is_true(isinstance(old, sa.DefaultClause))
+
+        if exclusions.against(config, "postgresql"):
+            eq_(str(old.arg.text), "(bar + 42)")
+        elif exclusions.against(config, "oracle"):
+            eq_(str(old.arg.text), '"BAR"+42')