From 8d7034bbc1431f385aef496a11b5ee09fc82634f Mon Sep 17 00:00:00 2001 From: Bedram Tamang Date: Fri, 10 Jul 2026 14:53:29 -0700 Subject: [PATCH] Remove legacy masoniteorm.backup directory Delete the unused masoniteorm.backup duplicate (59 tracked files) that no longer had any importers across the monorepo, and drop its now-stale entry from pytest norecursedirs in pyproject.toml. --- fastapi_startkit/pyproject.toml | 2 +- .../masoniteorm.backup/__init__.py | 2 - .../masoniteorm.backup/exceptions.py | 38 - .../masoniteorm.backup/scopes/BaseScope.py | 6 - .../scopes/SoftDeleteScope.py | 48 - .../scopes/SoftDeletesMixin.py | 13 - .../scopes/UUIDPrimaryKeyMixin.py | 8 - .../scopes/UUIDPrimaryKeyScope.py | 45 - .../masoniteorm.backup/scopes/__init__.py | 6 - .../masoniteorm.backup/scopes/scope.py | 15 - .../testing/BaseTestCaseSelectGrammar.py | 377 -------- .../masoniteorm.backup/testing/Database.py | 59 -- .../masoniteorm.backup/testing/TestCase.py | 11 - .../masoniteorm.backup/testing/__init__.py | 2 - .../masoniteorm.backup/tests/User.py | 17 - .../connections/test_base_connections.py | 27 - .../tests/eagers/test_eager.py | 59 -- .../tests/models/test_models.py | 296 ------ .../mssql/builder/test_mssql_query_builder.py | 425 --------- .../test_mssql_query_builder_relationships.py | 130 --- .../grammar/test_mssql_delete_grammar.py | 21 - .../grammar/test_mssql_insert_grammar.py | 35 - .../tests/mssql/grammar/test_mssql_qmark.py | 42 - .../grammar/test_mssql_select_grammar.py | 487 ---------- .../grammar/test_mssql_update_grammar.py | 28 - .../mssql/schema/test_mssql_schema_builder.py | 322 ------- .../schema/test_mssql_schema_builder_alter.py | 276 ------ .../builder/test_mysql_builder_transaction.py | 39 - .../tests/mysql/builder/test_query_builder.py | 861 ------------------ .../builder/test_query_builder_scopes.py | 62 -- .../tests/mysql/builder/test_transactions.py | 31 - .../test_mysql_connection_selects.py | 46 - .../grammar/test_mysql_delete_grammar.py | 65 -- .../grammar/test_mysql_insert_grammar.py | 91 -- .../tests/mysql/grammar/test_mysql_qmark.py | 177 ---- .../grammar/test_mysql_select_grammar.py | 482 ---------- .../grammar/test_mysql_update_grammar.py | 98 -- .../model/test_accessors_and_mutators.py | 35 - .../tests/mysql/model/test_model.py | 330 ------- .../relationships/test_belongs_to_many.py | 162 ---- .../relationships/test_has_many_through.py | 83 -- .../relationships/test_has_one_through.py | 91 -- .../mysql/relationships/test_relationships.py | 169 ---- .../mysql/schema/test_mysql_schema_builder.py | 380 -------- .../schema/test_mysql_schema_builder_alter.py | 309 ------- .../scopes/test_can_use_global_scopes.py | 38 - .../tests/mysql/scopes/test_can_use_scopes.py | 39 - .../tests/mysql/scopes/test_soft_delete.py | 84 -- .../builder/test_postgres_query_builder.py | 701 -------------- .../builder/test_postgres_transaction.py | 37 - .../postgres/grammar/test_delete_grammar.py | 65 -- .../postgres/grammar/test_insert_grammar.py | 72 -- .../postgres/grammar/test_select_grammar.py | 496 ---------- .../postgres/grammar/test_update_grammar.py | 107 --- .../test_postgres_relationships.py | 131 --- .../schema/test_postgres_schema_builder.py | 371 -------- .../test_postgres_schema_builder_alter.py | 319 ------- .../scopes/test_default_global_scopes.py | 145 --- .../tests/seeds/test_seeds.py | 12 - .../masoniteorm.backup/tests/utils.py | 57 -- 60 files changed, 1 insertion(+), 8981 deletions(-) delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/__init__.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/exceptions.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/BaseScope.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeleteScope.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeletesMixin.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyMixin.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyScope.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/__init__.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/scope.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/BaseTestCaseSelectGrammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/Database.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/TestCase.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/__init__.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/User.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/connections/test_base_connections.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/eagers/test_eager.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/models/test_models.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder_relationships.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_delete_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_insert_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_qmark.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_select_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_update_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder_alter.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_mysql_builder_transaction.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder_scopes.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_transactions.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/connections/test_mysql_connection_selects.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_delete_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_insert_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_qmark.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_select_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_update_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_accessors_and_mutators.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_model.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_belongs_to_many.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_many_through.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_one_through.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_relationships.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder_alter.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_global_scopes.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_scopes.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_soft_delete.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_query_builder.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_transaction.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_delete_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_insert_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_select_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_update_grammar.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/relationships/test_postgres_relationships.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder_alter.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/scopes/test_default_global_scopes.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/seeds/test_seeds.py delete mode 100644 fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/utils.py diff --git a/fastapi_startkit/pyproject.toml b/fastapi_startkit/pyproject.toml index dd882fcc..7710b22e 100644 --- a/fastapi_startkit/pyproject.toml +++ b/fastapi_startkit/pyproject.toml @@ -120,7 +120,7 @@ fixable = ["F401"] [tool.pytest.ini_options] asyncio_mode = "auto" -norecursedirs = ["masoniteorm.backup", ".venv", "dist", "build", "__pycache__"] +norecursedirs = [".venv", "dist", "build", "__pycache__"] [tool.coverage.run] source = ["src/fastapi_startkit"] diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/__init__.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/__init__.py deleted file mode 100644 index a18a46cf..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .models.model import Model -from .models.fields import Field diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/exceptions.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/exceptions.py deleted file mode 100644 index 9d4594db..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/exceptions.py +++ /dev/null @@ -1,38 +0,0 @@ -class DriverNotFound(Exception): - pass - - -class ModelNotFound(Exception): - pass - - -class HTTP404(Exception): - pass - - -class ConnectionNotRegistered(Exception): - pass - - -class QueryException(Exception): - pass - - -class MigrationNotFound(Exception): - pass - - -class ConfigurationNotFound(Exception): - pass - - -class InvalidUrlConfiguration(Exception): - pass - - -class MultipleRecordsFound(Exception): - pass - - -class InvalidArgument(Exception): - pass diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/BaseScope.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/BaseScope.py deleted file mode 100644 index 003907e3..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/BaseScope.py +++ /dev/null @@ -1,6 +0,0 @@ -class BaseScope: - def on_boot(self, builder): - raise NotImplementedError() - - def on_remove(self, builder): - raise NotImplementedError() diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeleteScope.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeleteScope.py deleted file mode 100644 index 2b6ea510..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeleteScope.py +++ /dev/null @@ -1,48 +0,0 @@ -from .BaseScope import BaseScope - - -class SoftDeleteScope(BaseScope): - """Global scope class to add soft deleting to models.""" - - def __init__(self, deleted_at_column="deleted_at"): - self.deleted_at_column = deleted_at_column - - def on_boot(self, builder): - builder.set_global_scope("_where_null", self._where_null, action="select") - builder.set_global_scope( - "_query_set_null_on_delete", - self._query_set_null_on_delete, - action="delete", - ) - builder.macro("with_trashed", self._with_trashed) - builder.macro("only_trashed", self._only_trashed) - builder.macro("force_delete", self._force_delete) - builder.macro("restore", self._restore) - - def on_remove(self, builder): - builder.remove_global_scope("_where_null", action="select") - builder.remove_global_scope("_query_set_null_on_delete", action="delete") - - def _where_null(self, builder): - return builder.where_null(f"{builder.get_table_name()}.{self.deleted_at_column}") - - def _with_trashed(self, model, builder): - builder.remove_global_scope("_where_null", action="select") - return builder - - def _only_trashed(self, model, builder): - builder.remove_global_scope("_where_null", action="select") - return builder.where_not_null(self.deleted_at_column) - - def _force_delete(self, model, builder, query=False): - if query: - return builder.remove_global_scope(self).set_action("delete") - return builder.remove_global_scope(self).delete() - - def _restore(self, model, builder): - return builder.remove_global_scope(self).update({self.deleted_at_column: None}) - - def _query_set_null_on_delete(self, builder): - return builder.set_action("update").set_updates( - {self.deleted_at_column: builder._model.get_new_datetime_string()} - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeletesMixin.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeletesMixin.py deleted file mode 100644 index dddf202e..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/SoftDeletesMixin.py +++ /dev/null @@ -1,13 +0,0 @@ -from .SoftDeleteScope import SoftDeleteScope - - -class SoftDeletesMixin: - """Global scope class to add soft deleting to models.""" - - __deleted_at__ = "deleted_at" - - def boot_SoftDeletesMixin(self, builder): - builder.set_global_scope(SoftDeleteScope(self.__deleted_at__)) - - def get_deleted_at_column(self): - return self.__deleted_at__ diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyMixin.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyMixin.py deleted file mode 100644 index e8bbfd35..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyMixin.py +++ /dev/null @@ -1,8 +0,0 @@ -from .UUIDPrimaryKeyScope import UUIDPrimaryKeyScope - - -class UUIDPrimaryKeyMixin: - """Global scope class to add UUID as primary key to models.""" - - def boot_UUIDPrimaryKeyMixin(self, builder): - builder.set_global_scope(UUIDPrimaryKeyScope()) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyScope.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyScope.py deleted file mode 100644 index 30b4bee4..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/UUIDPrimaryKeyScope.py +++ /dev/null @@ -1,45 +0,0 @@ -import uuid - -from .BaseScope import BaseScope - - -class UUIDPrimaryKeyScope(BaseScope): - """Global scope class to use UUID4 as primary key.""" - - def on_boot(self, builder): - builder.set_global_scope("_UUID_primary_key", self.set_uuid_create, action="insert") - builder.set_global_scope( - "_UUID_primary_key", - self.set_bulk_uuid_create, - action="bulk_create", - ) - - def on_remove(self, builder): - pass - - def generate_uuid(self, builder, uuid_version, bytes=False): - # UUID 3 and 5 requires parameters - uuid_func = getattr(uuid, f"uuid{uuid_version}") - args = [] - if uuid_version in [3, 5]: - args = [ - builder._model.__uuid_namespace__, - builder._model.__uuid_name__, - ] - - return uuid_func(*args).bytes if bytes else str(uuid_func(*args)) - - def build_uuid_pk(self, builder): - uuid_version = getattr(builder._model, "__uuid_version__", 4) - uuid_bytes = getattr(builder._model, "__uuid_bytes__", False) - return {builder._model.__primary_key__: self.generate_uuid(builder, uuid_version, uuid_bytes)} - - def set_uuid_create(self, builder): - # if there is already a primary key, no need to set a new one - if builder._model.__primary_key__ not in builder._creates: - builder._creates.update(self.build_uuid_pk(builder)) - - def set_bulk_uuid_create(self, builder): - for idx, create_atts in enumerate(builder._creates): - if builder._model.__primary_key__ not in create_atts: - builder._creates[idx].update(self.build_uuid_pk(builder)) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/__init__.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/__init__.py deleted file mode 100644 index e1a4f4e0..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/__init__.py +++ /dev/null @@ -1,6 +0,0 @@ -from .BaseScope import BaseScope -from .scope import scope -from .SoftDeleteScope import SoftDeleteScope -from .SoftDeletesMixin import SoftDeletesMixin -from .UUIDPrimaryKeyMixin import UUIDPrimaryKeyMixin -from .UUIDPrimaryKeyScope import UUIDPrimaryKeyScope diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/scope.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/scope.py deleted file mode 100644 index 79c2cb81..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/scopes/scope.py +++ /dev/null @@ -1,15 +0,0 @@ -class scope: - def __init__(self, callback, *params, **kwargs): - self.fn = callback - - def __set_name__(self, cls, name): - if cls not in cls._scopes: - cls._scopes[cls] = {name: self.fn} - else: - cls._scopes[cls].update({name: self.fn}) - self.cls = cls - - def __call__(self, *args, **kwargs): - instantiated = self.cls() - builder = instantiated.get_builder() - return self.fn(instantiated, builder, *args, **kwargs) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/BaseTestCaseSelectGrammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/BaseTestCaseSelectGrammar.py deleted file mode 100644 index b3035306..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/BaseTestCaseSelectGrammar.py +++ /dev/null @@ -1,377 +0,0 @@ -import inspect - -from ..expressions import JoinClause -from ..models_backup import Model -from ..query import QueryBuilder - - -class MockConnection: - connection_details = {} - - def make_connection(self): - return self - - -class BaseTestCaseSelectGrammar: - def setUp(self): - self.builder = QueryBuilder( - self.grammar, - table="users", - connection_class=MockConnection, - model=Model(), - dry=True, - ) - - def test_can_compile_select(self): - to_sql = self.builder.to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_order_by_and_first(self): - to_sql = self.builder.order_by("id", "asc").first(query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_columns(self): - to_sql = self.builder.select("username", "password").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_where(self): - to_sql = self.builder.select("username", "password").where("id", 1).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_or_where(self): - to_sql = self.builder.where("name", 2).or_where("name", 3).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_grouped_where(self): - to_sql = self.builder.where(lambda query: query.where("age", 2).where("name", "Joe")).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_several_where(self): - to_sql = self.builder.select("username", "password").where("id", 1).where("username", "joe").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_several_where_and_limit(self): - to_sql = self.builder.select("username", "password").where("id", 1).where("username", "joe").limit(10).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_sum(self): - to_sql = self.builder.sum("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_max(self): - to_sql = self.builder.max("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_max_and_columns(self): - to_sql = self.builder.select("username").max("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_max_and_columns_different_order(self): - to_sql = self.builder.max("age").select("username").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_order_by(self): - to_sql = self.builder.select("username").order_by("age", "desc").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_multiple_order_by(self): - to_sql = self.builder.select("username").order_by("age", "desc").order_by("name").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_with_group_by(self): - to_sql = self.builder.select("username").group_by("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_in(self): - to_sql = self.builder.select("username").where_in("age", [1, 2, 3]).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_in_empty(self): - to_sql = self.builder.where_in("age", []).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_not_in(self): - to_sql = self.builder.select("username").where_not_in("age", [1, 2, 3]).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_null(self): - to_sql = self.builder.select("username").where_null("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_not_null(self): - to_sql = self.builder.select("username").where_not_null("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_count(self): - to_sql = self.builder.count("*").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_count_column(self): - to_sql = self.builder.count("money").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_column(self): - to_sql = self.builder.where_column("name", "email").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_sub_select(self): - to_sql = self.builder.where_in("name", self.builder.new().select("age")).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_complex_sub_select(self): - to_sql = self.builder.where_in( - "name", - (self.builder.new().select("age").where_in("email", self.builder.new().select("email"))), - ).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_sub_select_where(self): - to_sql = self.builder.where_in( - "age", - self.builder.new().select("age").where("age", 2).where("name", "Joe"), - ).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_sub_select_from_lambda(self): - to_sql = ( - self.builder.new() - .where_in( - "age", - lambda q: q.select("age").where("age", 2).where("name", "Joe"), - ) - .to_sql() - ) - sql = getattr(self, "can_compile_sub_select_where")() - self.assertEqual(to_sql, sql) - - def test_can_compile_sub_select_value(self): - to_sql = self.builder.where("name", self.builder.new().sum("age")).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_exists(self): - to_sql = ( - self.builder.select("age").where_exists(self.builder.new().select("username").where("age", 12)).to_sql() - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_not_exists(self): - to_sql = ( - self.builder.select("age").where_not_exists(self.builder.new().select("username").where("age", 12)).to_sql() - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_having(self): - to_sql = self.builder.sum("age").group_by("age").having("age").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_having_with_expression(self): - to_sql = self.builder.sum("age").group_by("age").having("age", 10).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_having_with_greater_than_expression(self): - to_sql = self.builder.sum("age").group_by("age").having("age", ">", 10).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_join(self): - to_sql = self.builder.join("contacts", "users.id", "=", "contacts.user_id").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_join_clause(self): - clause = ( - JoinClause("report_groups as rg") - .on("bgt.fund", "=", "rg.fund") - .on("bgt.dept", "=", "rg.dept") - .on("bgt.acct", "=", "rg.acct") - .on("bgt.sub", "=", "rg.sub") - ) - to_sql = self.builder.join(clause).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_join_clause_with_value(self): - clause = JoinClause("report_groups as rg").on_value("bgt.active", "=", "1").or_on_value("bgt.acct", "=", "1234") - to_sql = self.builder.join(clause).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_join_clause_with_null(self): - clause = JoinClause("report_groups as rg").on_null("bgt.acct").or_on_null("bgt.dept").on_value("rg.abc", 10) - to_sql = self.builder.join(clause).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_join_clause_with_not_null(self): - clause = ( - JoinClause("report_groups as rg").on_not_null("bgt.acct").or_on_not_null("bgt.dept").on_value("rg.abc", 10) - ) - to_sql = self.builder.join(clause).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_join_clause_with_lambda(self): - to_sql = self.builder.join( - "report_groups as rg", - lambda clause: clause.on("bgt.fund", "=", "rg.fund").on_null("bgt"), - ).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_left_join_clause_with_lambda(self): - to_sql = self.builder.left_join( - "report_groups as rg", - lambda clause: clause.on("bgt.fund", "=", "rg.fund").or_on_null("bgt"), - ).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_right_join_clause_with_lambda(self): - to_sql = self.builder.right_join( - "report_groups as rg", - lambda clause: clause.on("bgt.fund", "=", "rg.fund").or_on_null("bgt"), - ).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_left_join(self): - to_sql = self.builder.left_join("contacts", "users.id", "=", "contacts.user_id").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_multiple_join(self): - to_sql = ( - self.builder.join("contacts", "users.id", "=", "contacts.user_id") - .join("posts", "comments.post_id", "=", "posts.id") - .to_sql() - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_limit_and_offset(self): - to_sql = self.builder.limit(10).offset(10).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_between(self): - to_sql = self.builder.between("age", 18, 21).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_not_between(self): - to_sql = self.builder.not_between("age", 18, 21).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_user_where_raw_and_where(self): - to_sql = self.builder.where_raw("age = '18'").where("name", "=", "James").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_where_raw_and_where_with_multiple_bindings(self): - query = self.builder.where_raw("`age` = ? AND `is_admin` = ?", [18, True]).where("email", "test@example.com") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(query.to_qmark(), sql) - self.assertEqual(query._bindings, [18, True, "test@example.com"]) - - def test_can_compile_first_or_fail(self): - to_sql = self.builder.where("is_admin", "=", True).first_or_fail(query=True).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_where_like(self): - to_sql = self.builder.where("age", "like", "%name%").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_where_regexp(self): - to_sql = self.builder.where("age", "regexp", "Joe").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_where_exists_with_lambda(self): - to_sql = self.builder.where_exists(lambda q: q.where("age", 1)).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - print(to_sql) - self.assertEqual(to_sql, sql) - - def test_where_not_exists_with_lambda(self): - to_sql = self.builder.where_not_exists(lambda q: q.where("age", 1)).to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - print(to_sql) - self.assertEqual(to_sql, sql) - - def test_where_not_regexp(self): - to_sql = self.builder.where("age", "not regexp", "Joe").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_where_not_like(self): - to_sql = self.builder.where("age", "not like", "%name%").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_shared_lock(self): - to_sql = self.builder.where("votes", ">=", 100).shared_lock().to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_update_lock(self): - to_sql = self.builder.where("votes", ">=", 100).lock_for_update().to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_where_date(self): - to_sql = self.builder.where_date("created_at", "2022-06-01").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_or_where_null(self): - to_sql = self.builder.where_null("column1").or_where_null("column2").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_select_distinct(self): - to_sql = self.builder.select("group").distinct().to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/Database.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/Database.py deleted file mode 100644 index 250368d8..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/Database.py +++ /dev/null @@ -1,59 +0,0 @@ -from ..config import load_config -from ..migrations import Migration -from ..seeds import Seeder - - -class Database: - _migrated = False - migration_directory = "databases/migrations" - seed_path = "databases/seeds" - - async def setUpDatabase(self): - """ - Run migrations once per test suite. - """ - if not Database._migrated: - migration = Migration(migration_directory=self.migration_directory) - await migration.create_table_if_not_exists() - await migration.migrate() - Database._migrated = True - - async def beginTransaction(self): - """ - Start a transaction for the current test and make it sticky in the resolver. - """ - resolver = load_config().DB - # We handle the session and transaction manually to ensure we can FORCE a rollback - self._session = resolver.get_session_factory()() - await self._session.__aenter__() - self._transaction = await self._session.begin() - - # Make this session "sticky" so QueryBuilder uses it - resolver.set_sticky_session(self._session) - - async def rollbackTransaction(self): - """ - Rollback the transaction after the test and clear the sticky session. - """ - resolver = load_config().DB - resolver.remove_sticky_session() - - if hasattr(self, "_transaction"): - try: - await self._transaction.rollback() - except Exception: - # Transaction might already be closed or inactive - pass - - if hasattr(self, "_session"): - await self._session.__aexit__(None, None, None) - - async def seed(self, *seeder_classes): - """ - Run seeders. - """ - seeder = Seeder(seed_path=self.seed_path) - if seeder_classes: - await seeder.call(*seeder_classes) - else: - await seeder.run_database_seed() diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/TestCase.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/TestCase.py deleted file mode 100644 index e94956e2..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/TestCase.py +++ /dev/null @@ -1,11 +0,0 @@ -from unittest import IsolatedAsyncioTestCase -from .Database import Database - - -class TestCase(IsolatedAsyncioTestCase, Database): - async def asyncSetUp(self): - await self.setUpDatabase() - await self.beginTransaction() - - async def asyncTearDown(self): - await self.rollbackTransaction() diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/__init__.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/__init__.py deleted file mode 100644 index bca81271..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/testing/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .TestCase import TestCase -from .Database import Database diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/User.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/User.py deleted file mode 100644 index 8ed65118..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/User.py +++ /dev/null @@ -1,17 +0,0 @@ -"""User Model""" - -from fastapi_startkit.masoniteorm.models import Model - - -class User(Model): - """User Model""" - - __fillable__ = ["name", "email", "password"] - - __connection__ = "t" - - __auth__ = "email" - - @property - def meta(self): - return 1 diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/connections/test_base_connections.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/connections/test_base_connections.py deleted file mode 100644 index 9c1f14e8..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/connections/test_base_connections.py +++ /dev/null @@ -1,27 +0,0 @@ -import unittest - -from tests.integrations.config.database import DB - - -class TestDefaultBehaviorConnections(unittest.TestCase): - def test_should_return_connection_with_enabled_logs(self): - connection = DB.begin_transaction("dev") - should_log_queries = connection.full_details.get("log_queries") - DB.commit("dev") - - self.assertTrue(should_log_queries) - - def test_should_disable_log_queries_in_connection(self): - connection = DB.begin_transaction("dev") - connection.disable_query_log() - - should_log_queries = connection.full_details.get("log_queries") - - self.assertFalse(should_log_queries) - - connection.enable_query_log() - should_log_queries = connection.full_details.get("log_queries") - - DB.commit("dev") - - self.assertTrue(should_log_queries) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/eagers/test_eager.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/eagers/test_eager.py deleted file mode 100644 index 759f64bb..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/eagers/test_eager.py +++ /dev/null @@ -1,59 +0,0 @@ -import unittest - -from src.masoniteorm.query.EagerRelation import EagerRelations - - -class TestEagerRelation(unittest.TestCase): - def test_can_register_string_eager_load(self): - self.assertEqual(EagerRelations().register("profile").get_eagers(), [["profile"]]) - self.assertEqual(EagerRelations().register("profile").is_nested, False) - self.assertEqual( - EagerRelations().register("profile.user").get_eagers(), - [{"profile": ["user"]}], - ) - self.assertEqual( - EagerRelations().register("profile.user", "profile.logo").get_eagers(), - [{"profile": ["user", "logo"]}], - ) - self.assertEqual( - EagerRelations().register("profile.user", "profile.logo", "profile.bio").get_eagers(), - [{"profile": ["user", "logo", "bio"]}], - ) - self.assertEqual( - EagerRelations().register("user", "logo", "bio").get_eagers(), - [["user", "logo", "bio"]], - ) - - def test_can_register_tuple_eager_load(self): - self.assertEqual(EagerRelations().register(("profile",)).get_eagers(), [["profile"]]) - self.assertEqual( - EagerRelations().register(("profile", "user")).get_eagers(), - [["profile", "user"]], - ) - self.assertEqual( - EagerRelations().register(("profile.name", "profile.user")).get_eagers(), - [{"profile": ["name", "user"]}], - ) - - def test_can_register_list_eager_load(self): - self.assertEqual(EagerRelations().register(["profile"]).get_eagers(), [["profile"]]) - self.assertEqual( - EagerRelations().register(["profile", "user"]).get_eagers(), - [["profile", "user"]], - ) - self.assertEqual( - EagerRelations().register(["profile.name", "profile.user"]).get_eagers(), - [{"profile": ["name", "user"]}], - ) - self.assertEqual( - EagerRelations().register(["profile.name"]).get_eagers(), - [{"profile": ["name"]}], - ) - self.assertEqual( - EagerRelations().register(["profile.name", "logo"]).get_eagers(), - [["logo"], {"profile": ["name"]}], - ) - self.assertEqual( - EagerRelations().register(["profile.name", "logo", "profile.user"]).get_eagers(), - [["logo"], {"profile": ["name", "user"]}], - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/models/test_models.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/models/test_models.py deleted file mode 100644 index a1e518f7..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/models/test_models.py +++ /dev/null @@ -1,296 +0,0 @@ -import datetime -import unittest -from decimal import Decimal - -import pendulum - -from fastapi_startkit.masoniteorm.models import Model - - -class ModelTest(Model): - __dates__ = ["due_date"] - __casts__ = { - "is_vip": "bool", - "payload": "json", - "x": "int", - "f": "float", - "d": "decimal", - } - - -class FillableModelTest(Model): - __fillable__ = ["due_date", "is_vip"] - - -class InvalidFillableGuardedModelTest(Model): - __fillable__ = ["due_date"] - __guarded__ = ["is_vip", "payload"] - - -class InvalidFillableGuardedChildModelTest(ModelTest): - __fillable__ = ["due_date"] - __guarded__ = ["is_vip", "payload"] - - -class ModelTestForced(Model): - __table__ = "users" - __force_update__ = True - - -class BaseModel(Model): - __dry__ = True - - def get_selects(self): - return [f"{self.get_table_name()}.*"] - - -class ModelWithBaseModel(BaseModel): - __table__ = "users" - - -class TestModels(unittest.TestCase): - def test_model_can_access_str_dates_as_pendulum(self): - model = ModelTest.hydrate({"user": "joe", "due_date": "2020-11-28 11:42:07"}) - - self.assertTrue(model.user) - self.assertTrue(model.due_date) - self.assertIsInstance(model.due_date, pendulum.now().__class__) - - def test_model_can_access_str_dates_as_pendulum_from_correct_datetimes( - self, - ): - model = ModelTest() - - self.assertEqual(model.get_new_date(datetime.datetime(2021, 1, 1, 7, 10)).hour, 7) - self.assertEqual(model.get_new_date(datetime.date(2021, 1, 1)).hour, 0) - self.assertEqual(model.get_new_date(datetime.time(1, 1, 1)).hour, 1) - self.assertEqual(model.get_new_date("2020-11-28 11:42:07").hour, 11) - - def test_model_can_access_str_dates_on_relationships(self): - model = ModelTest.hydrate({"user": "joe", "due_date": "2020-11-28 11:42:07"}) - model.add_relation({"profile": ModelTest.hydrate({"name": "bob", "due_date": "2020-11-28 11:42:07"})}) - - self.assertEqual(model.profile.name, "bob") - self.assertTrue(model.profile.due_date.is_past()) - - def test_model_original_and_dirty_attributes(self): - model = ModelTest.hydrate({"username": "joe", "admin": True}) - - self.assertEqual(model.username, "joe") - self.assertEqual(model.__original_attributes__, {"username": "joe", "admin": True}) - - model.username = "bob" - - self.assertEqual(model.username, "bob") - self.assertEqual(model.get_original("username"), "joe") - self.assertEqual(model.get_dirty("username"), "bob") - self.assertEqual(model.__dirty_attributes__["username"], "bob") - self.assertEqual(model.get_dirty_keys(), ["username"]) - self.assertTrue(model.is_dirty() is True) - self.assertEqual(model.__original_attributes__, {"username": "joe", "admin": True}) - - def test_model_creates_when_new(self): - model = ModelTest.hydrate({"id": 1, "username": "joe", "admin": True}) - - model.name = "Bill" - sql = model.save(query=True).to_sql() - self.assertTrue(sql.startswith("UPDATE")) - - model = ModelTest() - - model.name = "Bill" - sql = model.save(query=True).to_sql() - self.assertTrue(sql.startswith("INSERT")) - - def test_model_can_cast_attributes(self): - model = ModelTest.hydrate( - { - "is_vip": 1, - "payload": '["item1", "item2"]', - "x": True, - "f": "10.5", - "d": 3.14, - } - ) - - self.assertEqual(type(model.payload), list) - self.assertEqual(type(model.x), int) - self.assertEqual(type(model.f), float) - self.assertEqual(type(model.is_vip), bool) - self.assertEqual(type(model.serialize()["is_vip"]), bool) - - def test_model_can_cast_values(self): - model = ModelTest.hydrate({}) - - transformed = model.cast_values( - { - "is_vip": 1, - "payload": ["item1", "item2"], - "x": True, - "due_date": pendulum.now(), - "f": "10.5", - "d": 3.14, - } - ) - - self.assertEqual(type(transformed.get("x")), int) - self.assertEqual(type(transformed.get("is_vip")), bool) - self.assertEqual(type(transformed.get("f")), float) - self.assertEqual(type(transformed.get("d")), str) - self.assertEqual(type(transformed.get("d")), str) - self.assertEqual(type(transformed.get("payload")), str) - self.assertEqual(type(transformed.get("due_date")), str) - - def test_model_can_cast_dict_attributes(self): - """test cast with dict object to json field""" - json_str = '{"key": "value"}' - model = ModelTest.hydrate( - { - "is_vip": "1", - "payload": json_str, - "x": "1", - "f": "10.5", - "d": 3.14, - } - ) - - self.assertEqual(type(model.payload), dict) - self.assertEqual(type(model.x), int) - self.assertEqual(type(model.f), float) - self.assertEqual(type(model.is_vip), bool) - self.assertEqual(type(model.d), Decimal) - - def test_valid_json_cast(self): - model = ModelTest.hydrate({"payload": {"this": "dict", "is": "usable", "as": "json"}}) - - self.assertEqual(type(model.payload), dict) - - model = ModelTest.hydrate({"payload": {"this": "dict", "is": "invalid", "as": "json"}}) - - self.assertEqual(type(model.payload), dict) - - model = ModelTest.hydrate({"payload": '{"this": "dict", "is": "usable", "as": "json"}'}) - - self.assertEqual(type(model.payload), dict) - - model = ModelTest.hydrate({"payload": '{"valid": "json", "int": 1}'}) - - self.assertEqual(type(model.payload), dict) - - model = ModelTest.hydrate({"payload": "{'this': 'should', 'throw': 'error'}"}) - - self.assertEqual(model.payload, None) - - with self.assertRaises(ValueError): - model.payload = "{'this': 'should', 'throw': 'error'}" - model.save() - - def test_model_update_without_changes(self): - model = ModelTest.hydrate({"id": 1, "username": "joe", "name": "Joe", "admin": True}) - - model.username = "joe" - model.name = "Bill" - sql = model.save(query=True).to_sql() - self.assertTrue(sql.startswith("UPDATE")) - self.assertNotIn("username", sql) - - def test_force_update_on_model_class(self): - model = ModelTestForced.hydrate({"id": 1, "username": "joe", "name": "Joe", "admin": True}) - - model.username = "joe" - model.name = "Bill" - sql = model.save(query=True).to_sql() - self.assertTrue(sql.startswith("UPDATE")) - self.assertIn("username", sql) - self.assertIn("name", sql) - - def test_only_method(self): - model = ModelTestForced.hydrate({"id": 1, "username": "joe", "name": "Joe", "admin": True}) - - self.assertEqual({"username": "joe"}, model.only("username")) - self.assertEqual({"username": "joe"}, model.only(["username"])) - - def test_model_update_without_changes_at_all(self): - model = ModelTest.hydrate({"id": 1, "username": "joe", "name": "Joe", "admin": True}) - - model.username = "joe" - model.name = "Joe" - sql = model.save(query=True).to_sql() - self.assertFalse(sql.startswith("UPDATE")) - - def test_model_using_or_where(self): - model = ModelTest() - sql = model.where("name", "=", "joe").or_where("is_vip", True).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `model_tests` WHERE `model_tests`.`name` = 'joe' OR `model_tests`.`is_vip` = '1'""", - ) - - def test_model_using_or_where_and_chaining_wheres(self): - model = ModelTest() - - sql = ( - model.where("name", "=", "joe") - .or_where(lambda query: query.where("username", "Joseph").or_where("age", ">=", 18)) - .to_sql() - ) - - self.assertTrue( - sql, - """SELECT * FROM `model_tests` WHERE `model_tests`.`name` = 'joe' OR (`model_tests`.`username` = 'Joseph' OR `model_tests`.`age` >= '18'))""", - ) - - def test_both_fillable_and_guarded_attributes_raise(self): - # Both fillable and guarded props are populated on this class - with self.assertRaises(AttributeError): - InvalidFillableGuardedModelTest() - # Child that inherits from an intermediary class also fails - with self.assertRaises(AttributeError): - InvalidFillableGuardedChildModelTest() - # Still shouldn't be allowed to define even if empty - InvalidFillableGuardedModelTest.__fillable__ = [] - with self.assertRaises(AttributeError): - InvalidFillableGuardedModelTest() - # Or wildcard - InvalidFillableGuardedModelTest.__fillable__ = ["*"] - with self.assertRaises(AttributeError): - InvalidFillableGuardedModelTest() - # Empty guarded attr still raises - InvalidFillableGuardedModelTest.__guarded__ = [] - with self.assertRaises(AttributeError): - InvalidFillableGuardedModelTest() - # Removing one of the props allows us to instantiate - delattr(InvalidFillableGuardedModelTest, "__guarded__") - InvalidFillableGuardedModelTest() - - def test_model_can_provide_default_select(self): - sql = ModelWithBaseModel.to_sql() - self.assertEqual( - sql, - """SELECT `users`.* FROM `users`""", - ) - - def test_model_can_override_to_default_select(self): - sql = ModelWithBaseModel.select(["products.name", "products.id", "store.name"]).to_sql() - self.assertEqual( - sql, - """SELECT `products`.`name`, `products`.`id`, `store`.`name` FROM `users`""", - ) - - def test_model_can_use_aggregate_funcs_with_default_selects(self): - sql = ModelWithBaseModel.count().to_sql() - self.assertEqual( - sql, - """SELECT COUNT(*) AS m_count_reserved FROM `users`""", - ) - sql = ModelWithBaseModel.max("id").to_sql() - self.assertEqual( - sql, - """SELECT MAX(`users`.`id`) AS id FROM `users`""", - ) - sql = ModelWithBaseModel.min("id").to_sql() - self.assertEqual( - sql, - """SELECT MIN(`users`.`id`) AS id FROM `users`""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder.py deleted file mode 100644 index bdc51648..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder.py +++ /dev/null @@ -1,425 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from tests.utils import MockConnectionFactory - - -class MockConnection: - connection_details = {} - - def make_connection(self): - return self - - @classmethod - def get_default_query_grammar(cls): - return - - -class ModelTest(Model): - __timestamps__ = False - - -class TestMSSQLQueryBuilder(unittest.TestCase): - maxDiff = None - - def get_builder(self, table="users", dry=True): - connection = MockConnectionFactory().make("mssql") - return QueryBuilder( - # self.grammar, - connection_class=connection, - connection="mssql", - table=table, - model=ModelTest(), - dry=dry, - ) - - def test_sum(self): - builder = self.get_builder() - builder.sum("age") - - self.assertEqual(builder.to_sql(), "SELECT SUM([users].[age]) AS age FROM [users]") - - def test_where_like(self): - builder = self.get_builder() - builder.where("age", "like", "%name%") - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] LIKE '%name%'", - ) - - def test_where_not_like(self): - builder = self.get_builder() - builder.where("age", "not like", "%name%") - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] NOT LIKE '%name%'", - ) - - def test_max(self): - builder = self.get_builder() - builder.max("age") - - self.assertEqual(builder.to_sql(), "SELECT MAX([users].[age]) AS age FROM [users]") - - def test_min(self): - builder = self.get_builder() - builder.min("age") - - self.assertEqual(builder.to_sql(), "SELECT MIN([users].[age]) AS age FROM [users]") - - def test_avg(self): - builder = self.get_builder() - builder.avg("age") - - self.assertEqual(builder.to_sql(), "SELECT AVG([users].[age]) AS age FROM [users]") - - def test_all(self): - builder = self.get_builder() - builder.all() - - self.assertEqual(builder.to_sql(), "SELECT * FROM [users]") - - def test_get(self): - builder = self.get_builder() - builder.get() - - self.assertEqual(builder.to_sql(), "SELECT * FROM [users]") - - def test_first(self): - builder = self.get_builder().first(query=True) - - self.assertEqual(builder.to_sql(), "SELECT TOP 1 * FROM [users]") - - def test_select(self): - builder = self.get_builder() - builder.select("name", "email") - - self.assertEqual( - builder.to_sql(), - "SELECT [users].[name], [users].[email] FROM [users]", - ) - - def test_add_select_no_table(self): - builder = self.get_builder(table=None) - builder.add_select( - "other_test", - lambda q: q.max("updated_at").table("different_table"), - ).add_select("some_alias", lambda q: q.max("updated_at").table("another_table")) - - self.assertEqual( - builder.to_sql(), - ( - "SELECT " - "(SELECT MAX([different_table].[updated_at]) AS updated_at FROM [different_table]) AS other_test, " - "(SELECT MAX([another_table].[updated_at]) AS updated_at FROM [another_table]) AS some_alias" - ), - ) - - def test_select_raw(self): - builder = self.get_builder() - builder.select_raw("count(email) as email_count") - - self.assertEqual(builder.to_sql(), "SELECT count(email) as email_count FROM [users]") - - def test_create(self): - builder = self.get_builder().without_global_scopes() - builder.create( - {"name": "Corentin All", "email": "corentin@yopmail.com"}, - query=True, - ) - - self.assertEqual( - builder.to_sql(), - "INSERT INTO [users] ([users].[name], [users].[email]) VALUES ('Corentin All', 'corentin@yopmail.com')", - ) - - def test_delete(self): - builder = self.get_builder() - builder.delete("name", "Joe", query=True) - self.assertEqual( - builder.to_sql(), - "DELETE FROM [users] WHERE [users].[name] = 'Joe'", - ) - - def test_where(self): - builder = self.get_builder() - builder.where("name", "Joe") - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[name] = 'Joe'", - ) - - def test_where_exists(self): - builder = self.get_builder() - builder.where_exists("name") - self.assertEqual(builder.to_sql(), "SELECT * FROM [users] WHERE EXISTS 'name'") - - def test_limit(self): - builder = self.get_builder() - builder.limit(5) - - self.assertEqual(builder.to_sql(), "SELECT TOP 5 * FROM [users]") - - def test_offset(self): - builder = self.get_builder() - builder.offset(5) - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] OFFSET 5 ROWS FETCH NEXT 1 ROWS ONLY", - ) - - def test_join(self): - builder = self.get_builder() - builder.join("profiles", "users.id", "=", "profiles.user_id") - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] INNER JOIN [profiles] ON [users].[id] = [profiles].[user_id]", - ) - - def test_left_join(self): - builder = self.get_builder() - builder.left_join("profiles", "users.id", "=", "profiles.user_id") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] LEFT JOIN [profiles] ON [users].[id] = [profiles].[user_id]", - ) - - def test_right_join(self): - builder = self.get_builder() - builder.right_join("profiles", "users.id", "=", "profiles.user_id") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] RIGHT JOIN [profiles] ON [users].[id] = [profiles].[user_id]", - ) - - def test_update(self): - builder = self.get_builder().update({"name": "Joe", "email": "joe@yopmail.com"}, dry=True) - self.assertEqual( - builder.to_sql(), - "UPDATE [users] SET [users].[name] = 'Joe', [users].[email] = 'joe@yopmail.com'", - ) - - # def test_increment(self): - # builder = self.get_builder() - # builder.increment("age", 1) - # self.assertEqual( - # builder.to_sql(), "UPDATE [users] SET [users].[age] = [users].[age] + '1'" - # ) - - # def test_decrement(self): - # builder = self.get_builder() - # builder.decrement("age", 1) - # self.assertEqual( - # builder.to_sql(), "UPDATE [users] SET [users].[age] = [users].[age] - '1'" - # ) - - def test_count(self): - builder = self.get_builder() - builder.count("id") - self.assertEqual(builder.to_sql(), "SELECT COUNT([users].[id]) AS id FROM [users]") - - def test_order_by_asc(self): - builder = self.get_builder() - builder.order_by("email", "asc") - self.assertEqual(builder.to_sql(), "SELECT * FROM [users] ORDER BY [email] ASC") - - def test_order_by_desc(self): - builder = self.get_builder() - builder.order_by("email", "desc") - self.assertEqual(builder.to_sql(), "SELECT * FROM [users] ORDER BY [email] DESC") - - def test_where_column(self): - builder = self.get_builder() - builder.where_column("name", "username") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[name] = [users].[username]", - ) - - def test_where_not_in(self): - builder = self.get_builder() - builder.where_not_in("id", [1, 2, 3]) - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[id] NOT IN ('1','2','3')", - ) - - def test_between(self): - builder = self.get_builder() - builder.between("id", 2, 5) - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[id] BETWEEN '2' AND '5'", - ) - - def test_not_between(self): - builder = self.get_builder() - builder.not_between("id", 2, 5) - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[id] NOT BETWEEN '2' AND '5'", - ) - - def test_where_in(self): - builder = self.get_builder() - builder.where_in("id", [1, 2, 3]) - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[id] IN ('1','2','3')", - ) - - def test_where_null(self): - builder = self.get_builder() - builder.where_null("name") - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[name] IS NULL", - ) - - def test_where_not_null(self): - builder = self.get_builder() - builder.where_not_null("name") - - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[name] IS NOT NULL", - ) - - def test_having(self): - builder = self.get_builder(table="payments") - builder.select("user_id").avg("salary").group_by("user_id").having("salary", ">=", "1000") - - self.assertEqual( - builder.to_sql(), - "SELECT [payments].[user_id], AVG([payments].[salary]) AS salary FROM [payments] GROUP BY [payments].[user_id] HAVING [payments].[salary] >= '1000'", - ) - - def test_group_by(self): - builder = self.get_builder(table="payments") - builder.select("user_id").min("salary").group_by("user_id") - - self.assertEqual( - builder.to_sql(), - "SELECT [payments].[user_id], MIN([payments].[salary]) AS salary FROM [payments] GROUP BY [payments].[user_id]", - ) - - def test_builder_alone(self): - self.assertTrue( - QueryBuilder( - connection_class=MockConnection, - connection="mssql", - connection_details={ - "default": "mssql", - "mssql": { - "driver": "mssql", - "host": "localhost", - "user": "root", - "password": "root", - "database": "orm", - "port": "5432", - "prefix": "", - "grammar": "mssql", - }, - }, - ).table("users") - ) - - def test_where_lt(self): - builder = self.get_builder() - builder.where("age", "<", "20") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] < '20'", - ) - - def test_where_lte(self): - builder = self.get_builder() - builder.where("age", "<=", "20") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] <= '20'", - ) - - def test_where_gt(self): - builder = self.get_builder() - builder.where("age", ">", "20") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] > '20'", - ) - - def test_where_gte(self): - builder = self.get_builder() - builder.where("age", ">=", "20") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] >= '20'", - ) - - def test_where_ne(self): - builder = self.get_builder() - builder.where("age", "!=", "20") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] != '20'", - ) - - def test_or_where(self): - builder = self.get_builder() - builder.where("age", "20").or_where("age", "<", 20) - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] WHERE [users].[age] = '20' OR [users].[age] < '20'", - ) - - def test_can_call_with_schema(self): - builder = self.get_builder() - sql = builder.table("information_schema.columns").select("table_name").where("table_name", "users").to_sql() - self.assertEqual( - sql, - """SELECT [information_schema].[columns].[table_name] FROM [information_schema].[columns] WHERE [information_schema].[columns].[table_name] = 'users'""", - ) - - def test_truncate(self): - builder = self.get_builder(dry=True) - sql = builder.truncate() - self.assertEqual(sql, "TRUNCATE TABLE [users]") - - def test_truncate_without_foreign_keys(self): - builder = self.get_builder(dry=True) - sql = builder.truncate(foreign_keys=True) - self.assertEqual(sql, "TRUNCATE TABLE [users]") - - def test_latest(self): - builder = self.get_builder() - builder.latest("email") - self.assertEqual(builder.to_sql(), "SELECT * FROM [users] ORDER BY [email] DESC") - - def test_latest_multiple(self): - builder = self.get_builder() - builder.latest("email", "created_at") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] ORDER BY [email] DESC, [created_at] DESC", - ) - - def test_oldest(self): - builder = self.get_builder() - builder.oldest("email") - self.assertEqual(builder.to_sql(), "SELECT * FROM [users] ORDER BY [email] ASC") - - def test_oldest_multiple(self): - builder = self.get_builder() - builder.oldest("email", "created_at") - self.assertEqual( - builder.to_sql(), - "SELECT * FROM [users] ORDER BY [email] ASC, [created_at] ASC", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder_relationships.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder_relationships.py deleted file mode 100644 index 82350dc4..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/builder/test_mssql_query_builder_relationships.py +++ /dev/null @@ -1,130 +0,0 @@ -import unittest - -from dotenv import load_dotenv - -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MSSQLGrammar -from src.masoniteorm.relationships import belongs_to -from tests.utils import MockConnectionFactory - -load_dotenv(".env") - - -class Logo(Model): - __connection__ = "mssql" - - -class Article(Model): - __connection__ = "mssql" - - @belongs_to("id", "article_id") - def logo(self): - return Logo - - -class Profile(Model): - __connection__ = "mssql" - - -class User(Model): - __connection__ = "mssql" - - @belongs_to("id", "user_id") - def articles(self): - return Article - - @belongs_to("id", "user_id") - def profile(self): - return Profile - - @belongs_to("id", "parent_dynamic_id") - def parent_dynamic(self): - return self.__class__ - - @belongs_to("id", "parent_specified_id") - def parent_specified(self): - return User - - -class BaseTestQueryRelationships(unittest.TestCase): - maxDiff = None - - def get_builder(self, table="users"): - connection = MockConnectionFactory().make("mssql") - return QueryBuilder( - grammar=MSSQLGrammar, - connection_class=connection, - connection="mssql", - table=table, - model=User(), - ) - - def test_has(self): - builder = self.get_builder() - sql = builder.has("articles").to_sql() - self.assertEqual( - sql, - """SELECT * FROM [users] WHERE EXISTS (""" - """SELECT * FROM [articles] WHERE [articles].[user_id] = [users].[id]""" - """)""", - ) - - def test_has_reference_to_self(self): - builder = self.get_builder() - sql = builder.has("parent_dynamic").to_sql() - self.assertEqual( - sql, - """SELECT * FROM [users] WHERE EXISTS (""" - """SELECT * FROM [users] WHERE [users].[parent_dynamic_id] = [users].[id]""" - """)""", - ) - - def test_has_reference_to_self_using_class(self): - builder = self.get_builder() - sql = builder.has("parent_specified").to_sql() - self.assertEqual( - sql, - """SELECT * FROM [users] WHERE EXISTS (""" - """SELECT * FROM [users] WHERE [users].[parent_specified_id] = [users].[id]""" - """)""", - ) - - def test_where_has_query(self): - builder = self.get_builder() - sql = builder.where_has("articles", lambda q: q.where("active", 1)).to_sql() - self.assertEqual( - sql, - """SELECT * FROM [users] WHERE EXISTS (""" - """SELECT * FROM [articles] WHERE [articles].[user_id] = [users].[id] AND [articles].[active] = '1'""" - """)""", - ) - - def test_relationship_multiple_has(self): - to_sql = User.has("articles", "profile").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM [users] WHERE EXISTS (""" - """SELECT * FROM [articles] WHERE [articles].[user_id] = [users].[id]""" - """) AND EXISTS (""" - """SELECT * FROM [profiles] WHERE [profiles].[user_id] = [users].[id]""" - """)""", - ) - - def test_relationship_multiple_has_calls(self): - to_sql = User.has("articles").has("profile").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM [users] WHERE EXISTS (""" - """SELECT * FROM [articles] WHERE [articles].[user_id] = [users].[id]""" - """) AND EXISTS (""" - """SELECT * FROM [profiles] WHERE [profiles].[user_id] = [users].[id]""" - """)""", - ) - - def test_nested_has(self): - to_sql = User.has("articles.logo").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM [users] WHERE EXISTS (SELECT * FROM [articles] WHERE [articles].[user_id] = [users].[id] AND EXISTS (SELECT * FROM [logos] WHERE [logos].[article_id] = [articles].[id]))""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_delete_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_delete_grammar.py deleted file mode 100644 index 07a44114..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_delete_grammar.py +++ /dev/null @@ -1,21 +0,0 @@ -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MSSQLGrammar - - -class TestMySQLDeleteGrammar(unittest.TestCase): - def setUp(self): - self.builder = QueryBuilder(MSSQLGrammar, table="users") - - def test_can_compile_delete(self): - to_sql = self.builder.delete("id", 1, query=True).to_sql() - - sql = "DELETE FROM [users] WHERE [users].[id] = '1'" - self.assertEqual(to_sql, sql) - - def test_can_compile_delete_with_where(self): - to_sql = self.builder.where("age", 20).where("profile", 1).set_action("delete").delete(query=True).to_sql() - - sql = "DELETE FROM [users] WHERE [users].[age] = '20' AND [users].[profile] = '1'" - self.assertEqual(to_sql, sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_insert_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_insert_grammar.py deleted file mode 100644 index ca69af6c..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_insert_grammar.py +++ /dev/null @@ -1,35 +0,0 @@ -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MSSQLGrammar - - -class TestMySQLInsertGrammar(unittest.TestCase): - def setUp(self): - self.builder = QueryBuilder(MSSQLGrammar, table="users") - - def test_can_compile_insert(self): - to_sql = self.builder.create({"name": "Joe"}, query=True).to_sql() - - sql = "INSERT INTO [users] ([users].[name]) VALUES ('Joe')" - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create(self): - to_sql = self.builder.bulk_create( - # These keys are intentionally out of order to show column to value alignment works - [ - {"name": "Joe", "age": 5}, - {"age": 35, "name": "Bill"}, - {"name": "John", "age": 10}, - ], - query=True, - ).to_sql() - - sql = "INSERT INTO [users] ([age], [name]) VALUES ('5', 'Joe'), ('35', 'Bill'), ('10', 'John')" - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create_qmark(self): - to_sql = self.builder.bulk_create([{"name": "Joe"}, {"name": "Bill"}, {"name": "John"}], query=True).to_qmark() - - sql = "INSERT INTO [users] ([name]) VALUES (?), (?), (?)" - self.assertEqual(to_sql, sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_qmark.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_qmark.py deleted file mode 100644 index c28a8b11..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_qmark.py +++ /dev/null @@ -1,42 +0,0 @@ -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MSSQLGrammar - - -class TestMSSQLQmark(unittest.TestCase): - def setUp(self): - self.builder = QueryBuilder(MSSQLGrammar, table="users") - - def test_can_compile_select(self): - mark = self.builder.select("username").where("name", "Joe") - - sql = "SELECT [users].[username] FROM [users] WHERE [users].[name] = ?" - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, ["Joe"]) - - def test_can_compile_update(self): - mark = self.builder.update({"name": "Bob"}, dry=True).where("name", "Joe") - - sql = "UPDATE [users] SET [users].[name] = ? WHERE [users].[name] = ?" - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, ["Bob", "Joe"]) - - def test_can_compile_insert(self): - mark = self.builder.create({"name": "Bob"}, query=True) - - sql = "INSERT INTO [users] ([users].[name]) VALUES (?)" - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, ["Bob"]) - - def test_can_compile_where_in(self): - mark = self.builder.where_in("id", [1, 2, 3]) - - qmark_sql = "SELECT * FROM [users] WHERE [users].[id] IN (?, ?, ?)" - sql = "SELECT * FROM [users] WHERE [users].[id] IN ('1','2','3')" - self.assertEqual(mark.to_qmark(), qmark_sql) - self.assertEqual(mark._bindings, [1, 2, 3]) - self.assertEqual(self.builder.where_in("id", [1, 2, 3]).to_sql(), sql) - self.builder.reset() - # Assert that when passed string values it generates synonymous sql - self.assertEqual(self.builder.where_in("id", ["1", "2", "3"]).to_sql(), sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_select_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_select_grammar.py deleted file mode 100644 index 7860c318..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_select_grammar.py +++ /dev/null @@ -1,487 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query.grammars import MSSQLGrammar -from src.masoniteorm.testing import BaseTestCaseSelectGrammar - - -class TestMSSQLGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): - grammar = MSSQLGrammar - - def can_compile_select(self): - """ - self.builder.to_sql() - """ - return "SELECT * FROM [users]" - - def can_compile_with_columns(self): - """ - self.builder.select('username', 'password').to_sql() - """ - return "SELECT [users].[username], [users].[password] FROM [users]" - - def can_compile_with_where(self): - """ - self.builder.select('username', 'password').where('id', 1).to_sql() - """ - return "SELECT [users].[username], [users].[password] FROM [users] WHERE [users].[id] = '1'" - - def can_compile_with_several_where(self): - """ - self.builder.select('username', 'password').where('id', 1).where('username', 'joe').to_sql() - """ - return "SELECT [users].[username], [users].[password] FROM [users] WHERE [users].[id] = '1' AND [users].[username] = 'joe'" - - def can_compile_with_several_where_and_limit(self): - """ - self.builder.select('username', 'password').where('id', 1).where('username', 'joe').limit(10).to_sql() - """ - return "SELECT TOP 10 [users].[username], [users].[password] FROM [users] WHERE [users].[id] = '1' AND [users].[username] = 'joe'" - - def can_compile_with_sum(self): - """ - self.builder.sum('age').to_sql() - """ - return "SELECT SUM([users].[age]) AS age FROM [users]" - - def can_compile_order_by_and_first(self): - """ - self.builder.order_by('id', 'asc').first() - """ - return """SELECT TOP 1 * FROM [users] ORDER BY [id] ASC""" - - def can_compile_with_max(self): - """ - self.builder.max('age').to_sql() - """ - return "SELECT MAX([users].[age]) AS age FROM [users]" - - def can_compile_with_max_and_columns(self): - """ - self.builder.select('username').max('age').to_sql() - """ - return "SELECT [users].[username], MAX([users].[age]) AS age FROM [users]" - - def can_compile_with_max_and_columns_different_order(self): - """ - self.builder.max('age').select('username').to_sql() - """ - return "SELECT [users].[username], MAX([users].[age]) AS age FROM [users]" - - def can_compile_with_order_by(self): - """ - self.builder.select('username').order_by('age', 'desc').to_sql() - """ - return "SELECT [users].[username] FROM [users] ORDER BY [age] DESC" - - def can_compile_with_multiple_order_by(self): - """ - self.builder.select('username').order_by('age', 'desc').order_by('name').to_sql() - """ - return "SELECT [users].[username] FROM [users] ORDER BY [age] DESC, [name] ASC" - - def can_compile_with_group_by(self): - """ - self.builder.select('username').group_by('age').to_sql() - """ - return "SELECT [users].[username] FROM [users] GROUP BY [users].[age]" - - def can_compile_where_in(self): - """ - self.builder.select('username').where_in('age', [1,2,3]).to_sql() - """ - return "SELECT [users].[username] FROM [users] WHERE [users].[age] IN ('1','2','3')" - - def can_compile_where_in_empty(self): - """ - self.builder.where_in('age', []).to_sql() - """ - return """SELECT * FROM [users] WHERE 0 = 1""" - - def can_compile_where_null(self): - """ - self.builder.select('username').where_null('age').to_sql() - """ - return "SELECT [users].[username] FROM [users] WHERE [users].[age] IS NULL" - - def can_compile_where_not_null(self): - """ - self.builder.select('username').where_not_null('age').to_sql() - """ - return "SELECT [users].[username] FROM [users] WHERE [users].[age] IS NOT NULL" - - def can_compile_where_raw(self): - """ - self.builder.where_raw("`age` = '18'").to_sql() - """ - return "SELECT * FROM [users] WHERE [users].[age] = '18'" - - def test_can_compile_where_raw_and_where_with_multiple_bindings(self): - query = self.builder.where_raw("[age] = ? AND [is_admin] = ?", [18, True]).where("email", "test@example.com") - self.assertEqual( - query.to_qmark(), - "SELECT * FROM [users] WHERE [age] = ? AND [is_admin] = ? AND [users].[email] = ?", - ) - self.assertEqual(query._bindings, [18, True, "test@example.com"]) - - def can_compile_select_raw(self): - """ - self.builder.select_raw("COUNT(*)").to_sql() - """ - return "SELECT COUNT(*) FROM [users]" - - def can_compile_limit_and_offset(self): - """ - self.builder.limit(10).offset(10).to_sql() - """ - return "SELECT * FROM [users] OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY" - - def can_compile_select_raw_with_select(self): - """ - self.builder.select('id').select_raw("COUNT(*)").to_sql() - """ - return "SELECT [users].[id], COUNT(*) FROM [users]" - - def can_compile_having_raw(self): - """ - self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 18").to_sql() - """ - return "SELECT COUNT(*) as counts FROM [users] HAVING counts > 18" - - def can_compile_count(self): - """ - self.builder.count().to_sql() - """ - - return "SELECT COUNT(*) AS m_count_reserved FROM [users]" - - def can_compile_count_column(self): - """ - self.builder.count().to_sql() - """ - - return "SELECT COUNT([users].[money]) AS money FROM [users]" - - def can_compile_where_column(self): - """ - self.builder.where_column('name', 'email').to_sql() - """ - - return "SELECT * FROM [users] WHERE [users].[name] = [users].[email]" - - def can_compile_or_where(self): - """ - self.builder.where('name', 2).or_where('name', 3).to_sql() - """ - return "SELECT * FROM [users] WHERE [users].[name] = '2' OR [users].[name] = '3'" - - def can_grouped_where(self): - """ - self.builder.where(lambda query: query.where('age', 2).where('name', 'Joe')).to_sql() - """ - return "SELECT * FROM [users] WHERE ([users].[age] = '2' AND [users].[name] = 'Joe')" - - def can_compile_sub_select(self): - """ - self.builder.where_in('name', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age') - ).to_sql() - """ - - return "SELECT * FROM [users] WHERE [users].[name] IN (SELECT [users].[age] FROM [users])" - - def can_compile_sub_select_where(self): - """ - self.builder.where_in('age', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age').where('age', 2).where('name', 'Joe') - ).to_sql() - """ - - return "SELECT * FROM [users] WHERE [users].[age] IN (SELECT [users].[age] FROM [users] WHERE [users].[age] = '2' AND [users].[name] = 'Joe')" - - def can_compile_sub_select_value(self): - """ - self.builder.where('name', - self.builder.new().sum('age') - ).to_sql() - """ - - return "SELECT * FROM [users] WHERE [users].[name] = (SELECT SUM([users].[age]) AS age FROM [users])" - - def can_compile_complex_sub_select(self): - """ - self.builder.where_in('name', - (QueryBuilder(GrammarFactory.make(self.grammar), table='users') - .select('age').where_in('email', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('email') - )) - ).to_sql() - """ - return "SELECT * FROM [users] WHERE [users].[name] IN (SELECT [users].[age] FROM [users] WHERE [users].[email] IN (SELECT [users].[email] FROM [users]))" - - def can_compile_exists(self): - """ - self.builder.select('age').where_exists( - self.builder.new().select('username').where('age', 12) - ).to_sql() - """ - return "SELECT [users].[age] FROM [users] WHERE EXISTS (SELECT [users].[username] FROM [users] WHERE [users].[age] = '12')" - - def can_compile_not_exists(self): - """ - self.builder.select('age').where_not_exists( - self.builder.new().select('username').where('age', 12) - ).to_sql() - """ - return "SELECT [users].[age] FROM [users] WHERE NOT EXISTS (SELECT [users].[username] FROM [users] WHERE [users].[age] = '12')" - - def can_compile_having(self): - """ - builder.sum('age').group_by('age').having('age').to_sql() - """ - return "SELECT SUM([users].[age]) AS age FROM [users] GROUP BY [users].[age] HAVING [users].[age]" - - def can_compile_having_order(self): - """ - builder.sum('age').group_by('age').having('age').order_by('age', 'desc').to_sql() - """ - return "SELECT SUM([users].[age]) AS age FROM [users] GROUP BY [users].[age] HAVING [users].[age] ORDER [users].[age] DESC" - - def can_compile_between(self): - """ - builder.between('age', 18, 21).to_sql() - """ - return "SELECT * FROM [users] WHERE [users].[age] BETWEEN '18' AND '21'" - - def can_compile_not_between(self): - """ - builder.not_between('age', 18, 21).to_sql() - """ - return "SELECT * FROM [users] WHERE [users].[age] NOT BETWEEN '18' AND '21'" - - def can_compile_where_not_in(self): - """ - self.builder.select('username').where_not_in('age', [1,2,3]).to_sql() - """ - return "SELECT [users].[username] FROM [users] WHERE [users].[age] NOT IN ('1','2','3')" - - def can_compile_having_with_expression(self): - """ - builder.sum('age').group_by('age').having('age', 10).to_sql() - """ - return "SELECT SUM([users].[age]) AS age FROM [users] GROUP BY [users].[age] HAVING [users].[age] = '10'" - - def can_compile_having_with_greater_than_expression(self): - """ - builder.sum('age').group_by('age').having('age', '>', 10).to_sql() - """ - return "SELECT SUM([users].[age]) AS age FROM [users] GROUP BY [users].[age] HAVING [users].[age] > '10'" - - def can_compile_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return "SELECT * FROM [users] INNER JOIN [contacts] ON [users].[id] = [contacts].[user_id]" - - def can_compile_left_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return "SELECT * FROM [users] LEFT JOIN [contacts] ON [users].[id] = [contacts].[user_id]" - - def can_compile_multiple_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return "SELECT * FROM [users] INNER JOIN [contacts] ON [users].[id] = [contacts].[user_id] INNER JOIN [posts] ON [comments].[post_id] = [posts].[id]" - - def test_can_compile_where_raw(self): - to_sql = self.builder.where_raw("[age] = '18'").to_sql() - self.assertEqual(to_sql, "SELECT * FROM [users] WHERE [age] = '18'") - - def test_can_compile_having_raw(self): - to_sql = self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 10").to_sql() - self.assertEqual(to_sql, "SELECT COUNT(*) as counts FROM [users] HAVING counts > 10") - - def test_can_compile_having_raw_order(self): - to_sql = ( - self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 10").order_by_raw("counts DESC").to_sql() - ) - self.assertEqual( - to_sql, - "SELECT COUNT(*) as counts FROM [users] HAVING counts > 10 ORDER BY counts DESC", - ) - - def test_can_compile_select_raw(self): - to_sql = self.builder.select_raw("COUNT(*)").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_select_raw_with_select(self): - to_sql = self.builder.select("id").select_raw("COUNT(*)").to_sql() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def can_compile_first_or_fail(self): - """ - builder = self.get_builder() - builder.where("is_admin", "=", True).first_or_fail() - """ - return """SELECT TOP 1 * FROM [users] WHERE [users].[is_admin] = '1'""" - - def where_like(self): - """ - builder = self.get_builder() - builder.where("age", "like", "%name%") - """ - return """SELECT * FROM [users] WHERE [users].[age] LIKE '%name%'""" - - def where_not_like(self): - """ - builder = self.get_builder() - builder.where("age", "like", "%name%") - """ - return """SELECT * FROM [users] WHERE [users].[age] NOT LIKE '%name%'""" - - def where_regexp(self): - """ - builder = self.get_builder() - builder.where("age", "regexp", "Joe") - """ - return """SELECT * FROM [users] WHERE [users].[age] LIKE 'Joe'""" - - def where_not_regexp(self): - """ - builder = self.get_builder() - builder.where("age", "not regexp", "Joe") - """ - return """SELECT * FROM [users] WHERE [users].[age] NOT LIKE 'Joe'""" - - def can_compile_join_clause(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on("bgt.fund", "=", "rg.fund") - .on_value("bgt.active", "=", "1") - .or_on_value("bgt.acct", "=", "1234") - ) - builder.join(clause).to_sql() - """ - return "SELECT * FROM [users] INNER JOIN [report_groups] AS [rg] ON [bgt].[fund] = [rg].[fund] AND [bgt].[dept] = [rg].[dept] AND [bgt].[acct] = [rg].[acct] AND [bgt].[sub] = [rg].[sub]" - - def can_compile_join_clause_with_value(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_value("bgt.active", "=", "1") - .or_on_value("bgt.acct", "=", "1234") - ) - builder.join(clause).to_sql() - """ - return ( - "SELECT * FROM [users] INNER JOIN [report_groups] AS [rg] ON [bgt].[active] = '1' OR [bgt].[acct] = '1234'" - ) - - def can_compile_join_clause_with_null(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_null("bgt.acct") - .or_on_null("bgt.dept") - .on_value("rg.abc", 10) - ) - builder.join(clause).to_sql() - """ - return "SELECT * FROM [users] INNER JOIN [report_groups] AS [rg] ON [acct] IS NULL OR [dept] IS NULL AND [rg].[abc] = '10'" - - def can_compile_join_clause_with_not_null(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_not_null("bgt.acct") - .or_on_not_null("bgt.dept") - .on_value("rg.abc", 10) - ) - builder.join(clause).to_sql() - """ - return "SELECT * FROM [users] INNER JOIN [report_groups] AS [rg] ON [acct] IS NOT NULL OR [dept] IS NOT NULL AND [rg].[abc] = '10'" - - def can_compile_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .on_null("bgt") - ), - ).to_sql() - """ - return ( - "SELECT * FROM [users] INNER JOIN [report_groups] AS [rg] ON [bgt].[fund] = [rg].[fund] AND [bgt] IS NULL" - ) - - def can_compile_left_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.left_join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .or_on_null("bgt") - ), - ).to_sql() - """ - return "SELECT * FROM [users] LEFT JOIN [report_groups] AS [rg] ON [bgt].[fund] = [rg].[fund] OR [bgt] IS NULL" - - def can_compile_right_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.right_join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .or_on_null("bgt") - ), - ).to_sql() - """ - return "SELECT * FROM [users] RIGHT JOIN [report_groups] AS [rg] ON [bgt].[fund] = [rg].[fund] OR [bgt] IS NULL" - - def shared_lock(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return "SELECT * FROM [users] WITH(ROWLOCK) WHERE [users].[votes] >= '100'" - - def update_lock(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return "SELECT * FROM [users] WITH(ROWLOCK) WHERE [users].[votes] >= '100'" - - def can_user_where_raw_and_where(self): - """ - builder.where_raw("`age` = '18'").where("name", "=", "James").to_sql() - """ - return "SELECT * FROM [users] WHERE age = '18' AND [users].[name] = 'James'" - - def where_exists_with_lambda(self): - return """SELECT * FROM [users] WHERE EXISTS (SELECT * FROM [users] WHERE [users].[age] = '1')""" - - def where_not_exists_with_lambda(self): - return """SELECT * FROM [users] WHERE NOT EXISTS (SELECT * FROM [users] WHERE [users].[age] = '1')""" - - def where_date(self): - return """SELECT * FROM [users] WHERE DATE([users].[created_at]) = '2022-06-01'""" - - def or_where_null(self): - return """SELECT * FROM [users] WHERE [users].[column1] IS NULL OR [users].[column2] IS NULL""" - - def select_distinct(self): - return """SELECT DISTINCT [users].[group] FROM [users]""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_update_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_update_grammar.py deleted file mode 100644 index d9e3bbe6..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/grammar/test_mssql_update_grammar.py +++ /dev/null @@ -1,28 +0,0 @@ -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MSSQLGrammar -from src.masoniteorm.expressions import Raw - - -class TestMSSQLUpdateGrammar(unittest.TestCase): - def setUp(self): - self.builder = QueryBuilder(MSSQLGrammar, table="users") - - def test_can_compile_update(self): - to_sql = self.builder.where("name", "bob").update({"name": "Joe"}, dry=True).to_sql() - - sql = "UPDATE [users] SET [users].[name] = 'Joe' WHERE [users].[name] = 'bob'" - self.assertEqual(to_sql, sql) - - def test_can_compile_update_with_multiple_where(self): - to_sql = self.builder.where("name", "bob").where("age", 20).update({"name": "Joe"}, dry=True).to_sql() - - sql = "UPDATE [users] SET [users].[name] = 'Joe' WHERE [users].[name] = 'bob' AND [users].[age] = '20'" - self.assertEqual(to_sql, sql) - - def test_raw_expression(self): - to_sql = self.builder.update({"name": Raw("[username]")}, dry=True).to_sql() - - sql = "UPDATE [users] SET [users].[name] = [username]" - self.assertEqual(to_sql, sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder.py deleted file mode 100644 index 78a1c0c1..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder.py +++ /dev/null @@ -1,322 +0,0 @@ -import unittest - -from tests.integrations.config.database import DATABASES -from src.masoniteorm.connections import MSSQLConnection -from src.masoniteorm.schema import Schema -from src.masoniteorm.schema.platforms import MSSQLPlatform - - -class TestMSSQLSchemaBuilder(unittest.TestCase): - maxDiff = None - - def setUp(self): - self.schema = Schema( - connection_class=MSSQLConnection, - connection="mssql", - connection_details=DATABASES, - platform=MSSQLPlatform, - dry=True, - ).on("mssql") - - def test_can_add_columns(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE [users] ([name] VARCHAR(255) NOT NULL, [age] INT NOT NULL)"], - ) - - def test_can_add_tiny_text(self): - with self.schema.create("users") as blueprint: - blueprint.tiny_text("description") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE [users] ([description] TINYTEXT NOT NULL)"], - ) - - def test_can_add_unsigned_decimal(self): - with self.schema.create("users") as blueprint: - blueprint.unsigned_decimal("amount", 19, 4) - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE [users] ([amount] DECIMAL(19, 4) NOT NULL)"], - ) - - def test_can_add_columns_with_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - blueprint.unique("name") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] ([name] VARCHAR(255) NOT NULL, [age] INT NOT NULL, CONSTRAINT users_name_unique UNIQUE (name))" - ], - ) - - def test_can_have_float_type(self): - with self.schema.create("users") as blueprint: - blueprint.float("amount") - - self.assertEqual( - blueprint.to_sql(), - ["""CREATE TABLE [users] (""" """[amount] FLOAT(19, 4) NOT NULL)"""], - ) - - def test_can_have_unsigned_columns(self): - with self.schema.create("users") as blueprint: - blueprint.integer("profile_id").unsigned() - blueprint.big_integer("big_profile_id").unsigned() - blueprint.tiny_integer("tiny_profile_id").unsigned() - blueprint.small_integer("small_profile_id").unsigned() - blueprint.medium_integer("medium_profile_id").unsigned() - - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] (" - "[profile_id] INT NOT NULL, " - "[big_profile_id] BIGINT NOT NULL, " - "[tiny_profile_id] TINYINT NOT NULL, " - "[small_profile_id] SMALLINT NOT NULL, " - "[medium_profile_id] MEDIUMINT NOT NULL)" - ], - ) - - def test_can_add_columns_with_foreign_key_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.foreign("profile_id").references("id").on("profiles") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] " - "([name] VARCHAR(255) NOT NULL, " - "[age] INT NOT NULL, " - "[profile_id] INT NOT NULL, " - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_profile_id_foreign FOREIGN KEY ([profile_id]) REFERENCES [profiles]([id]))" - ], - ) - - def test_can_add_columns_with_add_foreign_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.add_foreign("profile_id.id.profiles") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] " - "([name] VARCHAR(255) NOT NULL, " - "[age] INT NOT NULL, " - "[profile_id] INT NOT NULL, " - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_profile_id_foreign FOREIGN KEY ([profile_id]) REFERENCES [profiles]([id]))" - ], - ) - - def test_can_advanced_table_creation(self): - with self.schema.create("users") as blueprint: - blueprint.increments("id") - blueprint.string("name") - blueprint.string("email").unique() - blueprint.string("password") - blueprint.integer("admin").default(0) - blueprint.string("remember_token").nullable() - blueprint.timestamp("verified_at").nullable() - blueprint.timestamp("registered_at").default_raw("CURRENT_TIMESTAMP") - blueprint.timestamps() - - self.assertEqual(len(blueprint.table.added_columns), 10) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] ([id] INT IDENTITY NOT NULL, [name] VARCHAR(255) NOT NULL, [email] VARCHAR(255) NOT NULL, " - "[password] VARCHAR(255) NOT NULL, [admin] INT NOT NULL DEFAULT 0, [remember_token] VARCHAR(255) NULL, " - "[verified_at] DATETIME NULL, [registered_at] DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP, [created_at] DATETIME NULL DEFAULT CURRENT_TIMESTAMP, " - "[updated_at] DATETIME NULL DEFAULT CURRENT_TIMESTAMP, CONSTRAINT users_id_primary PRIMARY KEY (id), CONSTRAINT users_email_unique UNIQUE (email))" - ], - ) - - def test_can_advanced_table_creation2(self): - with self.schema.create("users") as blueprint: - blueprint.increments("id") - blueprint.enum("gender", ["male", "female"]) - blueprint.string("name") - blueprint.string("duration") - blueprint.string("url") - blueprint.inet("last_address").nullable() - blueprint.cidr("route_origin").nullable() - blueprint.macaddr("mac_address").nullable() - blueprint.datetime("published_at") - blueprint.string("thumbnail").nullable() - blueprint.integer("premium") - blueprint.integer("author_id").unsigned().nullable() - blueprint.foreign("author_id").references("id").on("users").on_delete("CASCADE") - blueprint.text("description") - blueprint.timestamps() - - self.assertEqual(len(blueprint.table.added_columns), 15) - self.assertEqual( - blueprint.to_sql(), - ( - [ - "CREATE TABLE [users] ([id] INT IDENTITY NOT NULL, [gender] VARCHAR(255) NOT NULL CHECK([gender] IN ('male', 'female')), [name] VARCHAR(255) NOT NULL, [duration] VARCHAR(255) NOT NULL, " - "[url] VARCHAR(255) NOT NULL, [last_address] VARCHAR(255) NULL, [route_origin] VARCHAR(255) NULL, [mac_address] VARCHAR(255) NULL, [published_at] DATETIME NOT NULL, [thumbnail] VARCHAR(255) NULL, [premium] INT NOT NULL, " - "[author_id] INT NULL, [description] TEXT NOT NULL, [created_at] DATETIME NULL DEFAULT CURRENT_TIMESTAMP, " - "[updated_at] DATETIME NULL DEFAULT CURRENT_TIMESTAMP, " - "CONSTRAINT users_id_primary PRIMARY KEY (id), CONSTRAINT users_author_id_foreign FOREIGN KEY ([author_id]) REFERENCES [users]([id]) ON DELETE CASCADE)" - ] - ), - ) - - def test_can_add_columns_with_foreign_key_constraint_name(self): - with self.schema.create("users") as blueprint: - blueprint.integer("profile_id") - blueprint.foreign("profile_id", name="profile_foreign").references("id").on("profiles") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] (" - "[profile_id] INT NOT NULL, " - "CONSTRAINT profile_foreign FOREIGN KEY ([profile_id]) REFERENCES [profiles]([id]))" - ], - ) - - def test_can_have_composite_keys(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.primary(["name", "age"]) - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] " - "([name] VARCHAR(255) NOT NULL, " - "[age] INT NOT NULL, " - "[profile_id] INT NOT NULL, " - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_name_age_primary PRIMARY KEY (name, age))" - ], - ) - - def test_can_have_column_primary_key(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").primary() - blueprint.integer("age") - blueprint.integer("profile_id") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] " - "([name] VARCHAR(255) NOT NULL, " - "[age] INT NOT NULL, " - "[profile_id] INT NOT NULL, " - "CONSTRAINT users_name_primary PRIMARY KEY (name))" - ], - ) - - def test_has_table(self): - schema_sql = self.schema.has_table("users") - - sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'users'" - - self.assertEqual(schema_sql, sql) - - def test_can_truncate(self): - sql = self.schema.truncate("users") - - self.assertEqual(sql, "TRUNCATE TABLE [users]") - - def test_can_rename_table(self): - sql = self.schema.rename("users", "clients") - - self.assertEqual(sql, "EXEC sp_rename [users], [clients]") - - def test_can_drop_table_if_exists(self): - sql = self.schema.drop_table_if_exists("users", "clients") - - self.assertEqual(sql, "DROP TABLE IF EXISTS [users]") - - def test_can_drop_table(self): - sql = self.schema.drop_table("users", "clients") - - self.assertEqual(sql, "DROP TABLE [users]") - - def test_has_column(self): - sql = self.schema.has_column("users", "name") - - self.assertEqual( - sql, - "SELECT 1 FROM sys.columns WHERE Name = N'name' AND Object_ID = Object_ID(N'users')", - ) - - def test_can_enable_foreign_keys(self): - sql = self.schema.enable_foreign_key_constraints() - - self.assertEqual(sql, "") - - def test_can_disable_foreign_keys(self): - sql = self.schema.disable_foreign_key_constraints() - - self.assertEqual(sql, "") - - def test_can_truncate_without_foreign_keys(self): - sql = self.schema.truncate("users", foreign_keys=True) - - self.assertEqual( - sql, - [ - "ALTER TABLE [users] NOCHECK CONSTRAINT ALL", - "TRUNCATE TABLE [users]", - "ALTER TABLE [users] WITH CHECK CHECK CONSTRAINT ALL", - ], - ) - - def test_can_add_enum(self): - with self.schema.create("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE [users] ([status] VARCHAR(255) NOT NULL DEFAULT 'active' CHECK([status] IN ('active', 'inactive')))" - ], - ) - - def test_can_change_column_enum(self): - with self.schema.table("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active").change() - - self.assertEqual(len(blueprint.table.changed_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - "ALTER TABLE [users] ALTER COLUMN [status] VARCHAR(255) NOT NULL DEFAULT 'active' CHECK([status] IN ('active', 'inactive'))" - ], - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder_alter.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder_alter.py deleted file mode 100644 index e98d1766..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mssql/schema/test_mssql_schema_builder_alter.py +++ /dev/null @@ -1,276 +0,0 @@ -import unittest - -from tests.integrations.config.database import DATABASES -from src.masoniteorm.connections import MSSQLConnection -from src.masoniteorm.schema import Schema -from src.masoniteorm.schema.platforms import MSSQLPlatform -from src.masoniteorm.schema.Table import Table - - -class TestMySQLSchemaBuilderAlter(unittest.TestCase): - maxDiff = None - - def setUp(self): - self.schema = Schema( - connection_class=MSSQLConnection, - connection="mssql", - connection_details=DATABASES, - platform=MSSQLPlatform, - dry=True, - ) - - def test_can_add_columns(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - - sql = ["ALTER TABLE [users] ADD [name] VARCHAR(255) NOT NULL, [age] INT NOT NULL"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_adds_column_with_default(self): - with self.schema.table("users") as blueprint: - blueprint.string("name").default(0) - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = ["ALTER TABLE [users] ADD [name] VARCHAR(255) NOT NULL DEFAULT 0"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_rename(self): - with self.schema.table("users") as blueprint: - blueprint.rename("post", "comment", "integer") - - table = Table("users") - table.add_column("post", "integer") - blueprint.table.from_table = table - - sql = ["EXEC sp_rename 'users.post', 'comment', 'COLUMN'"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_and_rename(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.rename("post", "comment", "integer") - - table = Table("users") - table.add_column("post", "integer") - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE [users] ADD [name] VARCHAR(255) NOT NULL", - "EXEC sp_rename 'users.post', 'comment', 'COLUMN'", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop1(self): - with self.schema.table("users") as blueprint: - blueprint.drop_column("post") - - sql = ["ALTER TABLE [users] DROP COLUMN post"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_column_and_foreign_key(self): - with self.schema.table("users") as blueprint: - blueprint.unsigned_integer("playlist_id").nullable() - blueprint.foreign("playlist_id").references("id").on("playlists").on_delete("cascade") - - sql = [ - "ALTER TABLE [users] ADD [playlist_id] INT NULL", - "ALTER TABLE [users] ADD CONSTRAINT users_playlist_id_foreign FOREIGN KEY ([playlist_id]) REFERENCES [playlists]([id]) ON DELETE CASCADE", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_column_and_add_foreign(self): - with self.schema.table("users") as blueprint: - blueprint.unsigned_integer("playlist_id").nullable() - blueprint.add_foreign("playlist_id.id.playlists").on_delete("cascade") - - sql = [ - "ALTER TABLE [users] ADD [playlist_id] INT NULL", - "ALTER TABLE [users] ADD CONSTRAINT users_playlist_id_foreign FOREIGN KEY ([playlist_id]) REFERENCES [playlists]([id]) ON DELETE CASCADE", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_foreign_key(self): - with self.schema.table("users") as blueprint: - blueprint.drop_foreign("users_playlist_id_foreign") - - sql = ["ALTER TABLE [users] DROP CONSTRAINT users_playlist_id_foreign"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_foreign_key_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_foreign(["playlist_id"]) - - sql = ["ALTER TABLE [users] DROP CONSTRAINT users_playlist_id_foreign"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_unique_constraint(self): - with self.schema.table("users") as blueprint: - blueprint.drop_unique("users_playlist_id_unique") - - sql = ["DROP INDEX [users].[users_playlist_id_unique]"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_primary(self): - with self.schema.table("users") as blueprint: - blueprint.primary("playlist_id") - - sql = ["ALTER TABLE [users] ADD CONSTRAINT users_playlist_id_primary PRIMARY KEY (playlist_id)"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_index(self): - with self.schema.table("users") as blueprint: - blueprint.index("playlist_id") - - sql = ["CREATE INDEX users_playlist_id_index ON [users](playlist_id)"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_index(self): - with self.schema.table("users") as blueprint: - blueprint.drop_index("users_playlist_id_index") - - sql = ["DROP INDEX [users].[users_playlist_id_index]"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_index_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_index(["playlist_id"]) - - sql = ["DROP INDEX [users].[users_playlist_id_index]"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_unique_constraint_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_unique(["playlist_id"]) - - sql = ["DROP INDEX [users].[users_playlist_id_unique]"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_primary(self): - with self.schema.table("users") as blueprint: - blueprint.drop_primary(["id"]) - - sql = ["DROP INDEX [users].[users_id_primary]"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_has_table(self): - schema_sql = self.schema.has_table("users") - - sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'users'" - - self.assertEqual(schema_sql, sql) - - def test_drop_table(self): - schema_sql = self.schema.has_table("users") - - sql = "SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'users'" - - self.assertEqual(schema_sql, sql) - - def test_change(self): - with self.schema.table("users") as blueprint: - blueprint.integer("age").change() - blueprint.string("name") - blueprint.string("external_type").default("external") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual(len(blueprint.table.changed_columns), 1) - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE [users] ADD [name] VARCHAR(255) NOT NULL, [external_type] VARCHAR(255) NOT NULL DEFAULT 'external'", - "ALTER TABLE [users] ALTER COLUMN [age] INT NOT NULL", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_drop_add_and_change(self): - with self.schema.table("users") as blueprint: - blueprint.integer("age").default(0).change() - blueprint.string("name") - blueprint.drop_column("email") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual(len(blueprint.table.changed_columns), 1) - table = Table("users") - table.add_column("age", "string") - table.add_column("email", "string") - - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE [users] ADD [name] VARCHAR(255) NOT NULL", - "ALTER TABLE [users] ALTER COLUMN [age] INT NOT NULL DEFAULT 0", - "ALTER TABLE [users] DROP COLUMN email", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_create_indexes(self): - with self.schema.table("users") as blueprint: - blueprint.index("name") - blueprint.index(["name", "email"]) - blueprint.unique("name") - blueprint.unique(["name", "email"]) - blueprint.fulltext("description") - - self.assertEqual(len(blueprint.table.added_columns), 0) - print(blueprint.to_sql()) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE INDEX users_name_index ON [users](name)", - "CREATE INDEX users_name_email_index ON [users](name,email)", - "ALTER TABLE [users] ADD CONSTRAINT users_name_unique UNIQUE(name)", - "ALTER TABLE [users] ADD CONSTRAINT users_name_email_unique UNIQUE(name,email)", - ], - ) - - def test_timestamp_alter_add_nullable_column(self): - with self.schema.table("users") as blueprint: - blueprint.timestamp("due_date").nullable() - - self.assertEqual(len(blueprint.table.added_columns), 1) - - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = ["ALTER TABLE [users] ADD [due_date] DATETIME NULL"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_add_column_enum(self): - with self.schema.table("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = [ - "ALTER TABLE [users] ADD [status] VARCHAR(255) NOT NULL DEFAULT 'active' CHECK([status] IN ('active', 'inactive'))" - ] - - self.assertEqual(blueprint.to_sql(), sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_mysql_builder_transaction.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_mysql_builder_transaction.py deleted file mode 100644 index 67f3de9a..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_mysql_builder_transaction.py +++ /dev/null @@ -1,39 +0,0 @@ -import os -import unittest - -from src.masoniteorm.connections import ConnectionFactory -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar -from tests.integrations.config.database import DB - -if os.getenv("RUN_MYSQL_DATABASE") == "True": - - class User(Model): - __connection__ = "mysql" - __timestamps__ = False - - class BaseTestQueryRelationships(unittest.TestCase): - maxDiff = None - - def get_builder(self, table="users"): - connection = ConnectionFactory().make("mysql") - return QueryBuilder(grammar=MySQLGrammar, connection=connection, table=table).on("mysql") - - def test_transaction(self): - builder = self.get_builder() - builder.begin() - builder.create({"name": "phillip2", "email": "phillip2"}) - # builder.commit() - user = builder.where("name", "phillip2").first() - self.assertEqual(user["name"], "phillip2") - builder.rollback() - user = builder.where("name", "phillip2").first() - self.assertEqual(user, None) - - def test_transaction_default_globally(self): - connection = DB.begin_transaction() - self.assertEqual(connection, self.get_builder().new_connection()) - DB.commit() - DB.begin_transaction() - DB.rollback() diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder.py deleted file mode 100644 index b274311b..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder.py +++ /dev/null @@ -1,861 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.exceptions import InvalidArgument -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar -from src.masoniteorm.relationships import has_many -from tests.integrations.config.database import DATABASES -from tests.utils import MockConnectionFactory - - -class Articles(Model): - pass - - -class User(Model): - __timestamps__ = False - - @has_many("id", "user_id") - def articles(self): - return Articles - - -class BaseTestQueryBuilder: - maxDiff = None - - def get_builder(self, table="users", dry=True): - connection = MockConnectionFactory().make("default") - return QueryBuilder( - grammar=self.grammar, - connection_class=connection, - connection="t", - table=table, - model=User(), - dry=dry, - connection_details=DATABASES, - ) - - def test_sum(self): - builder = self.get_builder() - builder.sum("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_sum_chained(self): - builder = self.get_builder() - builder.sum("age").max("salary") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_with_(self): - builder = self.get_builder() - builder.with_("articles").sum("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_like(self): - builder = self.get_builder() - builder.where("age", "like", "%name%") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_like(self): - builder = self.get_builder() - builder.where("age", "not like", "%name%") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_max(self): - builder = self.get_builder() - builder.max("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_min(self): - builder = self.get_builder() - builder.min("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_avg(self): - builder = self.get_builder() - builder.avg("age") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_all(self): - builder = self.get_builder() - builder.all() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_get(self): - builder = self.get_builder() - builder.get() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_first(self): - builder = self.get_builder().first(query=True) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_find_with_model(self): - builder = self.get_builder() - builder.find(1000, query=True) - sql = """SELECT * FROM `users` WHERE `users`.`id` = '1000\'""" - self.assertEqual(builder.to_sql(), sql) - - def test_find_with_model_and_list(self): - builder = self.get_builder() - builder.find([1000, 2000, 3000], query=True) - sql = """SELECT * FROM `users` WHERE `users`.`id` IN ('1000','2000','3000')""" - self.assertEqual(builder.to_sql(), sql) - - def test_find_with_model_custom_column(self): - builder = self.get_builder() - builder.find(10, column="age", query=True) - sql = """SELECT * FROM `users` WHERE `users`.`age` = '10\'""" - self.assertEqual(builder.to_sql(), sql) - - def test_find_with_builder(self): - builder = self.get_builder() - builder._model = None - builder.find(10, column="age", query=True) - sql = """SELECT * FROM `users` WHERE `users`.`age` = '10\'""" - self.assertEqual(builder.to_sql(), sql) - - def test_find_with_builder_and_list(self): - builder = self.get_builder() - builder._model = None - builder.find([10, 20, 30], column="age", query=True) - sql = """SELECT * FROM `users` WHERE `users`.`age` IN ('10','20','30')""" - self.assertEqual(builder.to_sql(), sql) - - def test_find_with_builder_without_column(self): - builder = self.get_builder() - builder._model = None - with self.assertRaises(InvalidArgument): - builder.find(10, query=True) - - def test_select(self): - builder = self.get_builder() - builder.select("name", "email") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_select_with_table(self): - builder = self.get_builder() - builder.select("users.*") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_select_with_table_raw(self): - builder = self.get_builder() - builder.select("users.*").from_raw("orders, customers") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_select_with_alias(self): - builder = self.get_builder() - builder.select("users.username as name") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_select_raw(self): - builder = self.get_builder() - builder.select_raw("count(email) as email_count") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_add_select(self): - builder = self.get_builder() - sql = ( - builder.select("name") - .add_select("phone_count", lambda q: q.count("*").table("phones")) - .add_select("salary", lambda q: q.count("*").table("salary")) - .to_sql() - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_add_select_no_table(self): - builder = self.get_builder(table=None) - sql = ( - builder.add_select( - "other_test", - lambda q: q.max("updated_at").table("different_table"), - ) - .add_select( - "some_alias", - lambda q: q.max("updated_at").table("another_table"), - ) - .to_sql() - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_create(self): - builder = self.get_builder().without_global_scopes() - builder.create( - {"name": "Corentin All", "email": "corentin@yopmail.com"}, - query=True, - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_delete(self): - builder = self.get_builder() - builder.delete("name", "Joe", query=True) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where(self): - builder = self.get_builder() - builder.where("name", "Joe") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_exists(self): - builder = self.get_builder() - builder.where_exists("name") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_limit(self): - builder = self.get_builder() - builder.limit(5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_offset(self): - builder = self.get_builder() - builder.offset(5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_join(self): - builder = self.get_builder() - builder.join("profiles", "users.id", "=", "profiles.user_id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_left_join(self): - builder = self.get_builder() - builder.left_join("profiles", "users.id", "=", "profiles.user_id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_right_join(self): - builder = self.get_builder() - builder.right_join("profiles", "users.id", "=", "profiles.user_id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_update(self): - builder = self.get_builder().update({"name": "Joe", "email": "joe@yopmail.com"}, dry=True) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - # def test_increment(self): - # builder = self.get_builder() - # builder.increment("age", 1) - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(builder.to_sql(), sql) - - # def test_decrement(self): - # builder = self.get_builder() - # builder.decrement("age", 1) - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(builder.to_sql(), sql) - - def test_count(self): - builder = self.get_builder() - builder.count("id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_order_by_asc(self): - builder = self.get_builder() - builder.order_by("email", "asc") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_order_by_desc(self): - builder = self.get_builder() - builder.order_by("email", "desc") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_column(self): - builder = self.get_builder() - builder.where_column("name", "username") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_in(self): - builder = self.get_builder() - builder.where_not_in("id", [1, 2, 3]) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_between(self): - builder = self.get_builder() - builder.between("id", 2, 5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_not_between(self): - builder = self.get_builder() - builder.not_between("id", 2, 5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_in(self): - builder = self.get_builder() - builder.where_in("id", [1, 2, 3]) - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_null(self): - builder = self.get_builder() - builder.where_null("name") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_null(self): - builder = self.get_builder() - builder.where_not_null("name") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_having(self): - builder = self.get_builder(table="payments") - builder.select("user_id").avg("salary").group_by("user_id").having("salary", ">=", "1000") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_group_by(self): - builder = self.get_builder(table="payments") - builder.select("user_id").min("salary").group_by("user_id") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_builder_alone(self): - self.assertTrue( - QueryBuilder( - dry=True, - connection_details={ - "default": "mysql", - "mysql": { - "driver": "mysql", - "host": "localhost", - "username": "root", - "password": "", - "database": "orm", - "port": "3306", - "prefix": "", - "grammar": "mysql", - "options": {"charset": "utf8mb4"}, - }, - }, - ).table("users") - ) - - def test_where_lt(self): - builder = self.get_builder() - builder.where("age", "<", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_lte(self): - builder = self.get_builder() - builder.where("age", "<=", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_gt(self): - builder = self.get_builder() - builder.where("age", ">", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_gte(self): - builder = self.get_builder() - builder.where("age", ">=", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_ne(self): - builder = self.get_builder() - builder.where("age", "!=", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_or_where(self): - builder = self.get_builder() - builder.where("age", "20").or_where("age", "<", 20) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_or_where(self): - builder = self.get_builder() - builder.where("age", "20").or_where("age", "<", 20) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_like_as_operator(self): - builder = self.get_builder() - builder.where("age", "like", "%name%") - sql = getattr(self, "where_like")() - self.assertEqual(builder.to_sql(), sql) - - def test_where_like(self): - builder = self.get_builder() - builder.where_like("age", "%name%") - sql = getattr(self, "where_like")() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_like_as_operator(self): - builder = self.get_builder() - builder.where("age", "not like", "%name%") - sql = getattr(self, "where_not_like")() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_like(self): - builder = self.get_builder() - builder.where_not_like("age", "%name%") - sql = getattr(self, "where_not_like")() - self.assertEqual(builder.to_sql(), sql) - - def test_can_call_with_multi_tables(self): - builder = self.get_builder() - sql = builder.table("information_schema.columns").select("table_name").where("table_name", "users").to_sql() - self.assertEqual( - sql, - """SELECT `information_schema`.`columns`.`table_name` FROM `information_schema`.`columns` WHERE `information_schema`.`columns`.`table_name` = 'users'""", - ) - - def test_truncate(self): - builder = self.get_builder(dry=True) - sql = builder.truncate() - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - def test_truncate_without_foreign_keys(self): - builder = self.get_builder(dry=True) - sql = builder.truncate(foreign_keys=True) - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - def test_shared_lock(self): - builder = self.get_builder(dry=True) - sql = builder.where("votes", ">=", 100).shared_lock().to_sql() - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - def test_update_lock(self): - builder = self.get_builder(dry=True) - sql = builder.where("votes", ">=", 100).lock_for_update().to_sql() - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - -class MySQLQueryBuilderTest(BaseTestQueryBuilder, unittest.TestCase): - grammar = MySQLGrammar - - def sum(self): - """ - builder = self.get_builder() - builder.sum('age') - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users`" - - def sum_chained(self): - """ - builder = self.get_builder() - builder.sum('age') - """ - return "SELECT SUM(`users`.`age`) AS age, MAX(`users`.`salary`) AS salary FROM `users`" - - def with_(self): - """ - builder = self.get_builder() - builder.with_('articles').sum('age') - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users`" - - def max(self): - """ - builder = self.get_builder() - builder.max('age') - """ - return "SELECT MAX(`users`.`age`) AS age FROM `users`" - - def min(self): - """ - builder = self.get_builder() - builder.min('age') - """ - return "SELECT MIN(`users`.`age`) AS age FROM `users`" - - def avg(self): - """ - builder = self.get_builder() - builder.avg('age') - """ - return "SELECT AVG(`users`.`age`) AS age FROM `users`" - - def first(self): - """ - builder = self.get_builder() - builder.first() - """ - return "SELECT * FROM `users` LIMIT 1" - - def all(self): - """ - builder = self.get_builder() - builder.all() - """ - return "SELECT * FROM `users`" - - def get(self): - """ - builder = self.get_builder() - builder.get() - """ - return "SELECT * FROM `users`" - - def select(self): - """ - builder = self.get_builder() - builder.select('name', 'email') - """ - return "SELECT `users`.`name`, `users`.`email` FROM `users`" - - def select_with_table(self): - """ - builder = self.get_builder() - builder.select('users.*') - """ - return "SELECT `users`.* FROM `users`" - - def select_with_table_raw(self): - """ - builder = self.get_builder() - builder.select('users.*') - """ - return "SELECT `users`.* FROM orders, customers" - - def select_with_alias(self): - """ - builder = self.get_builder() - builder.select('users.name as name') - """ - return "SELECT `users`.`username` AS name FROM `users`" - - def select_raw(self): - """ - builder = self.get_builder() - builder.select_raw('count(email) as email_count') - """ - return "SELECT count(email) as email_count FROM `users`" - - def add_select(self): - """ - builder = self.get_builder() - builder.select('name', 'email') - """ - return "SELECT `users`.`name`, (SELECT COUNT(*) AS m_count_reserved FROM `phones`) AS phone_count, (SELECT COUNT(*) AS m_count_reserved FROM `salary`) AS salary FROM `users`" - - def add_select_no_table(self): - """ - builder = self.get_builder() - builder.select('name', 'email') - """ - return ( - "SELECT " - "(SELECT MAX(`different_table`.`updated_at`) AS updated_at FROM `different_table`) AS other_test, " - "(SELECT MAX(`another_table`.`updated_at`) AS updated_at FROM `another_table`) AS some_alias" - ) - - def create(self): - """ - builder = get_builder() - builder.create({"name": "Corentin All", 'email': 'corentin@yopmail.com'}) - """ - return "INSERT INTO `users` (`users`.`name`, `users`.`email`) VALUES ('Corentin All', 'corentin@yopmail.com')" - - def delete(self): - """ - builder = get_builder() - builder.delete("name', 'Joe') - """ - return "DELETE FROM `users` WHERE `users`.`name` = 'Joe'" - - def where(self): - """ - builder = get_builder() - builder.where('name', 'Joe') - """ - return "SELECT * FROM `users` WHERE `users`.`name` = 'Joe'" - - def where_exists(self): - """ - builder = get_builder() - builder.where_exists('name') - """ - return "SELECT * FROM `users` WHERE EXISTS 'name'" - - def limit(self): - """ - builder = get_builder() - builder.limit(5) - """ - return "SELECT * FROM `users` LIMIT 5" - - def offset(self): - """ - builder = get_builder() - builder.offset(5) - """ - return "SELECT * FROM `users` OFFSET 5" - - def join(self): - """ - builder.join("profiles", "users.id", "=", "profiles.user_id") - """ - return "SELECT * FROM `users` INNER JOIN `profiles` ON `users`.`id` = `profiles`.`user_id`" - - def left_join(self): - """ - builder.left_join("profiles", "users.id", "=", "profiles.user_id") - """ - return "SELECT * FROM `users` LEFT JOIN `profiles` ON `users`.`id` = `profiles`.`user_id`" - - def right_join(self): - """ - builder.right_join("profiles", "users.id", "=", "profiles.user_id") - """ - return "SELECT * FROM `users` RIGHT JOIN `profiles` ON `users`.`id` = `profiles`.`user_id`" - - def update(self): - """ - builder.update({"name": "Joe", "email": "joe@yopmail.com"}) - """ - return "UPDATE `users` SET `users`.`name` = 'Joe', `users`.`email` = 'joe@yopmail.com'" - - def increment(self): - """ - builder.increment('age', 1) - """ - return "UPDATE `users` SET `users`.`age` = `users`.`age` + '1'" - - def decrement(self): - """ - builder.decrement('age', 1) - """ - return "UPDATE `users` SET `users`.`age` = `users`.`age` - '1'" - - def count(self): - """ - builder.count(id) - """ - return "SELECT COUNT(`users`.`id`) AS id FROM `users`" - - def order_by_asc(self): - """ - builder.order_by('email', 'asc') - """ - return "SELECT * FROM `users` ORDER BY `email` ASC" - - def order_by_desc(self): - """ - builder.order_by('email', 'des') - """ - return "SELECT * FROM `users` ORDER BY `email` DESC" - - def where_column(self): - """ - builder.where_column('name', 'username') - """ - return "SELECT * FROM `users` WHERE `users`.`name` = `users`.`username`" - - def where_null(self): - """ - builder.where_null('name') - """ - return "SELECT * FROM `users` WHERE `users`.`name` IS NULL" - - def where_not_null(self): - """ - builder.where_null('name') - """ - return "SELECT * FROM `users` WHERE `users`.`name` IS NOT NULL" - - def where_not_in(self): - """ - builder.where_not_in('id', [1, 2, 3]) - """ - return "SELECT * FROM `users` WHERE `users`.`id` NOT IN ('1','2','3')" - - def where_in(self): - """ - builder.where_in('id', [1, 2, 3]) - """ - return "SELECT * FROM `users` WHERE `users`.`id` IN ('1','2','3')" - - def between(self): - """ - builder.between('id', 2, 5) - """ - return "SELECT * FROM `users` WHERE `users`.`id` BETWEEN '2' AND '5'" - - def not_between(self): - """ - builder.not_between('id', 2, 5) - """ - return "SELECT * FROM `users` WHERE `users`.`id` NOT BETWEEN '2' AND '5'" - - def having(self): - """ - builder.select('user_id').avg('salary').group_by('user_id').having('salary', '>=', '1000') - """ - return "SELECT `payments`.`user_id`, AVG(`payments`.`salary`) AS salary FROM `payments` GROUP BY `payments`.`user_id` HAVING `payments`.`salary` >= '1000'" - - def group_by(self): - """ - builder.select('user_id').min('salary').group_by('user_id') - """ - return "SELECT `payments`.`user_id`, MIN(`payments`.`salary`) AS salary FROM `payments` GROUP BY `payments`.`user_id`" - - def where_lt(self): - """ - builder = self.get_builder() - builder.where('age', '<', '20') - """ - return "SELECT * FROM `users` WHERE `users`.`age` < '20'" - - def where_lte(self): - """ - builder = self.get_builder() - builder.where('age', '<=', '20') - """ - return "SELECT * FROM `users` WHERE `users`.`age` <= '20'" - - def where_gt(self): - """ - builder = self.get_builder() - builder.where('age', '>', '20') - """ - return "SELECT * FROM `users` WHERE `users`.`age` > '20'" - - def where_gte(self): - """ - builder = self.get_builder() - builder.where('age', '>=', '20') - """ - return "SELECT * FROM `users` WHERE `users`.`age` >= '20'" - - def where_ne(self): - """ - builder = self.get_builder() - builder.where('age', '!=', '20') - """ - return "SELECT * FROM `users` WHERE `users`.`age` != '20'" - - def or_where(self): - """ - builder = self.get_builder() - builder.where('age', '20').or_where('age','<', 20) - """ - return "SELECT * FROM `users` WHERE `users`.`age` = '20' OR `users`.`age` < '20'" - - def where_like(self): - """ - builder = self.get_builder() - builder.where("age", "like", "%name%") - """ - return "SELECT * FROM `users` WHERE `users`.`age` LIKE '%name%'" - - def where_not_like(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%") - """ - return "SELECT * FROM `users` WHERE `users`.`age` NOT LIKE '%name%'" - - def truncate(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return """TRUNCATE TABLE `users`""" - - def truncate_without_foreign_keys(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return [ - "SET FOREIGN_KEY_CHECKS=0", - "TRUNCATE TABLE `users`", - "SET FOREIGN_KEY_CHECKS=1", - ] - - def shared_lock(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return "SELECT * FROM `users` WHERE `users`.`votes` >= '100' LOCK IN SHARE MODE" - - def update_lock(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return "SELECT * FROM `users` WHERE `users`.`votes` >= '100' FOR UPDATE" - - def test_latest(self): - builder = self.get_builder() - builder.latest("email") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_oldest(self): - builder = self.get_builder() - builder.oldest("email") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def latest(self): - """ - builder.order_by('email', 'des') - """ - return "SELECT * FROM `users` ORDER BY `email` DESC" - - def oldest(self): - """ - builder.order_by('email', 'asc') - """ - return "SELECT * FROM `users` ORDER BY `email` ASC" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder_scopes.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder_scopes.py deleted file mode 100644 index bba513a3..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_query_builder_scopes.py +++ /dev/null @@ -1,62 +0,0 @@ -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar -from src.masoniteorm.scopes import SoftDeleteScope -from tests.integrations.config.database import DATABASES -from tests.utils import MockConnectionFactory - - -class BaseTestQueryBuilderScopes(unittest.TestCase): - grammar = "mysql" - - def get_builder(self, table="users"): - connection = MockConnectionFactory().make("default") - return QueryBuilder( - grammar=MySQLGrammar, - connection_class=connection, - connection="mysql", - table=table, - connection_details=DATABASES, - ) - - def test_scopes(self): - builder = self.get_builder().set_scope("gender", lambda model, q: q.where("gender", "w")) - - self.assertEqual( - builder.gender().where("id", 1).to_sql(), - "SELECT * FROM `users` WHERE `users`.`gender` = 'w' AND `users`.`id` = '1'", - ) - - def test_global_scopes(self): - builder = self.get_builder().set_global_scope( - "where_not_null", - lambda q: q.where_not_null("deleted_at"), - action="select", - ) - - self.assertEqual( - builder.where("id", 1).to_sql(), - "SELECT * FROM `users` WHERE `users`.`id` = '1' AND `users`.`deleted_at` IS NOT NULL", - ) - - def test_global_scope_from_class(self): - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - - self.assertEqual( - builder.where("id", 1).to_sql(), - "SELECT * FROM `users` WHERE `users`.`id` = '1' AND `users`.`deleted_at` IS NULL", - ) - - def test_global_scope_remove_from_class(self): - builder = self.get_builder().set_global_scope(SoftDeleteScope()).remove_global_scope(SoftDeleteScope()) - - self.assertEqual( - builder.where("id", 1).to_sql(), - "SELECT * FROM `users` WHERE `users`.`id` = '1'", - ) - - def test_global_scope_adds_method(self): - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - - self.assertEqual(builder.with_trashed().to_sql(), "SELECT * FROM `users`") diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_transactions.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_transactions.py deleted file mode 100644 index 294448cc..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/builder/test_transactions.py +++ /dev/null @@ -1,31 +0,0 @@ -import os -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.relationships import has_many - - -class Articles(Model): - pass - - -class User(Model): - @has_many("id", "user_id") - def articles(self): - return Articles - - -if os.getenv("RUN_MYSQL_DATABASE", False) == "True": - - class TestTransactions(unittest.TestCase): - pass - # def get_builder(self, table="users"): - # connection = ConnectionFactory().make("default") - # return QueryBuilder(MySQLGrammar, connection, table=table, model=User()) - - # def test_can_start_transaction(self, table="users"): - # builder = self.get_builder() - # builder.begin() - # builder.create({"name": "mike", "email": "mike@email.com"}) - # builder.rollback() - # self.assertFalse(builder.where("email", "mike@email.com").first()) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/connections/test_mysql_connection_selects.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/connections/test_mysql_connection_selects.py deleted file mode 100644 index acb09e50..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/connections/test_mysql_connection_selects.py +++ /dev/null @@ -1,46 +0,0 @@ -import os -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar - - -class MockUser(Model): - __table__ = "users" - - -if os.getenv("RUN_MYSQL_DATABASE", False) == "True": - - class TestMySQLSelectConnection(unittest.TestCase): - def setUp(self): - self.builder = QueryBuilder(MySQLGrammar, table="users") - - def test_can_compile_select(self): - to_sql = MockUser.where("id", 1).to_sql() - - sql = "SELECT * FROM `users` WHERE `users`.`id` = '1'" - self.assertEqual(to_sql, sql) - - def test_can_get_first_record(self): - user = MockUser.where("id", 1).first() - self.assertEqual(user.id, 1) - - def test_can_find_first_record(self): - user = MockUser.find(1) - self.assertEqual(user.id, 1) - - def test_can_get_all_records(self): - users = MockUser.all() - self.assertGreater(len(users), 1) - - def test_can_get_5_records(self): - users = MockUser.limit(5).get() - self.assertEqual(len(users), 5) - - def test_can_get_1_record_with_get(self): - users = MockUser.where("id", 1).limit(5).get() - self.assertEqual(len(users), 1) - - users = MockUser.limit(5).where("id", 1).get() - self.assertEqual(len(users), 1) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_delete_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_delete_grammar.py deleted file mode 100644 index 93a73a94..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_delete_grammar.py +++ /dev/null @@ -1,65 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar - - -class BaseDeleteGrammarTest: - def setUp(self): - self.builder = QueryBuilder(MySQLGrammar, table="users") - - def test_can_compile_delete(self): - to_sql = self.builder.delete("id", 1, query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_delete_in(self): - to_sql = self.builder.delete("id", [1, 2, 3], query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_delete_with_where(self): - to_sql = self.builder.where("age", 20).where("profile", 1).set_action("delete").delete(query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - -class TestMySQLDeleteGrammar(BaseDeleteGrammarTest, unittest.TestCase): - grammar = "mysql" - - def can_compile_delete(self): - """ - ( - self.builder - .delete('id', 1) - .to_sql() - ) - """ - return "DELETE FROM `users` WHERE `users`.`id` = '1'" - - def can_compile_delete_in(self): - """ - ( - self.builder - .delete('id', 1) - .to_sql() - ) - """ - return "DELETE FROM `users` WHERE `users`.`id` IN ('1','2','3')" - - def can_compile_delete_with_where(self): - """ - ( - self.builder - .where('age', 20) - .where('profile', 1) - .set_action('delete') - .delete() - .to_sql() - ) - """ - return "DELETE FROM `users` WHERE `users`.`age` = '20' AND `users`.`profile` = '1'" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_insert_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_insert_grammar.py deleted file mode 100644 index 7d3e727b..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_insert_grammar.py +++ /dev/null @@ -1,91 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar - - -class BaseInsertGrammarTest: - def setUp(self): - self.builder = QueryBuilder(MySQLGrammar, table="users") - - def test_can_compile_insert(self): - to_sql = self.builder.create({"name": "Joe"}, query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_insert_with_keywords(self): - to_sql = self.builder.create(name="Joe", query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create(self): - to_sql = self.builder.bulk_create( - # These keys are intentionally out of order to show column to value alignment works - [ - {"name": "Joe", "age": 5}, - {"age": 35, "name": "Bill"}, - {"name": "John", "age": 10}, - ], - query=True, - ).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create_qmark(self): - to_sql = self.builder.bulk_create([{"name": "Joe"}, {"name": "Bill"}, {"name": "John"}], query=True).to_qmark() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create_multiple(self): - to_sql = self.builder.bulk_create( - [ - {"name": "Joe", "active": "1"}, - {"name": "Bill", "active": "1"}, - {"name": "John", "active": "1"}, - ], - query=True, - ).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - -class TestMySQLUpdateGrammar(BaseInsertGrammarTest, unittest.TestCase): - grammar = "mysql" - - def can_compile_insert(self): - """ - self.builder.create({ - 'name': 'Joe' - }).to_sql() - """ - return "INSERT INTO `users` (`users`.`name`) VALUES ('Joe')" - - def can_compile_insert_with_keywords(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return "INSERT INTO `users` (`users`.`name`) VALUES ('Joe')" - - def can_compile_bulk_create(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return """INSERT INTO `users` (`age`, `name`) VALUES ('5', 'Joe'), ('35', 'Bill'), ('10', 'John')""" - - def can_compile_bulk_create_multiple(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return """INSERT INTO `users` (`active`, `name`) VALUES ('1', 'Joe'), ('1', 'Bill'), ('1', 'John')""" - - def can_compile_bulk_create_qmark(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return """INSERT INTO `users` (`name`) VALUES (?), (?), (?)""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_qmark.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_qmark.py deleted file mode 100644 index 532a22cf..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_qmark.py +++ /dev/null @@ -1,177 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar - - -class BaseQMarkTest: - def setUp(self): - self.builder = QueryBuilder(grammar=MySQLGrammar, table="users") - - def test_can_compile_select(self): - mark = self.builder.select("username").where("name", "Joe") - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_delete(self): - mark = self.builder.where("name", "Joe").delete(query=True) - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_update(self): - mark = self.builder.update({"name": "Bob"}, dry=True).where("name", "Joe") - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_where_in(self): - mark = self.builder.where_in("id", [1, 2, 3]) - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_where_not_null(self): - mark = self.builder.where_not_null("id") - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, []) - - def test_can_compile_where_with_falsy_values(self): - mark = self.builder.where("name", 0) - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_where_with_true_value(self): - mark = self.builder.where("is_admin", True) - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_where_with_false_value(self): - mark = self.builder.where("is_admin", False) - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_compile_sub_group_bindings(self): - mark = self.builder.where( - lambda query: query.where("challenger", 1).or_where("proposer", 1).or_where("referee", 1) - ) - - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(mark.to_qmark(), sql) - self.assertEqual(mark._bindings, bindings) - - def test_can_increment(self): - builder = self.builder.increment("age", dry=True) - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - - self.assertEqual(builder.to_qmark(), sql) - self.assertEqual(builder._bindings, bindings) - - def test_can_decrement(self): - builder = self.builder.decrement("age", dry=True) - sql, bindings = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - - self.assertEqual(builder.to_qmark(), sql) - self.assertEqual(builder._bindings, bindings) - - -class TestMySQLQmark(BaseQMarkTest, unittest.TestCase): - def can_compile_select(self): - """ - self.builder.select('username').where('name', 'Joe') - """ - return ( - "SELECT `users`.`username` FROM `users` WHERE `users`.`name` = ?", - ["Joe"], - ) - - def can_compile_delete(self): - """ - self.builder.where('name', 'Joe').delete() - """ - return "DELETE FROM `users` WHERE `users`.`name` = ?", ["Joe"] - - def can_compile_update(self): - """ - self.builder.update({ - 'name': 'Bob' - }).where('name', 'Joe') - """ - return ( - "UPDATE `users` SET `users`.`name` = ? WHERE `users`.`name` = ?", - ["Bob", "Joe"], - ) - - def can_compile_where_in(self): - """ - self.builder.where_in('id', [1,2,3]).to_qmark() - """ - return ( - "SELECT * FROM `users` WHERE `users`.`id` IN (?, ?, ?)", - [1, 2, 3], - ) - - def can_compile_where_not_null(self): - """ - self.builder.where_not_null("id").to_qmark() - """ - return ("SELECT * FROM `users` WHERE `users`.`id` IS NOT NULL", ()) - - def can_compile_where_with_falsy_values(self): - """ - self.builder.where_not_null("id").to_qmark() - """ - return ("SELECT * FROM `users` WHERE `users`.`name` = ?", [0]) - - def can_compile_where_with_true_value(self): - """ - self.builder.where("is_admin", True).to_qmark() - """ - return ("SELECT * FROM `users` WHERE `users`.`is_admin` = '1'", []) - - def can_compile_where_with_false_value(self): - """ - self.builder.where("is_admin", True).to_qmark() - """ - return ("SELECT * FROM `users` WHERE `users`.`is_admin` = '0'", []) - - def can_compile_sub_group_bindings(self): - """ - self.builder.where("is_admin", True).to_qmark() - """ - return ( - "SELECT * FROM `users` WHERE (`users`.`challenger` = ? OR `users`.`proposer` = ? OR `users`.`referee` = ?)", - [1, 1, 1], - ) - - def can_increment(self): - """ - self.builder.increment("age", dry=True) - """ - return ( - "UPDATE `users` SET `users`.`age` = `users`.`age` + ?", - [1], - ) - - def can_decrement(self): - """ - self.builder.decrement("age", dry=True) - """ - return ( - "UPDATE `users` SET `users`.`age` = `users`.`age` - ?", - [1], - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_select_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_select_grammar.py deleted file mode 100644 index 0d6ccb2c..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_select_grammar.py +++ /dev/null @@ -1,482 +0,0 @@ -import unittest - -from src.masoniteorm.query.grammars import MySQLGrammar -from src.masoniteorm.testing import BaseTestCaseSelectGrammar - - -class TestMySQLGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): - grammar = MySQLGrammar - - def can_compile_select(self): - """ - self.builder.to_sql() - """ - return "SELECT * FROM `users`" - - def can_compile_with_columns(self): - """ - self.builder.select('username', 'password').to_sql() - """ - return "SELECT `users`.`username`, `users`.`password` FROM `users`" - - def can_compile_order_by_and_first(self): - """ - self.builder.order_by('id', 'asc').first() - """ - return """SELECT * FROM `users` ORDER BY `id` ASC LIMIT 1""" - - def can_compile_with_where(self): - """ - self.builder.select('username', 'password').where('id', 1).to_sql() - """ - return "SELECT `users`.`username`, `users`.`password` FROM `users` WHERE `users`.`id` = '1'" - - def can_compile_with_several_where(self): - """ - self.builder.select('username', 'password').where('id', 1).where('username', 'joe').to_sql() - """ - return "SELECT `users`.`username`, `users`.`password` FROM `users` WHERE `users`.`id` = '1' AND `users`.`username` = 'joe'" - - def can_compile_with_several_where_and_limit(self): - """ - self.builder.select('username', 'password').where('id', 1).where('username', 'joe').limit(10).to_sql() - """ - return "SELECT `users`.`username`, `users`.`password` FROM `users` WHERE `users`.`id` = '1' AND `users`.`username` = 'joe' LIMIT 10" - - def can_compile_with_sum(self): - """ - self.builder.sum('age').to_sql() - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users`" - - def can_compile_with_max(self): - """ - self.builder.max('age').to_sql() - """ - return "SELECT MAX(`users`.`age`) AS age FROM `users`" - - def can_compile_with_max_and_columns(self): - """ - self.builder.select('username').max('age').to_sql() - """ - return "SELECT `users`.`username`, MAX(`users`.`age`) AS age FROM `users`" - - def can_compile_with_max_and_columns_different_order(self): - """ - self.builder.max('age').select('username').to_sql() - """ - return "SELECT `users`.`username`, MAX(`users`.`age`) AS age FROM `users`" - - def can_compile_with_order_by(self): - """ - self.builder.select('username').order_by('age', 'desc').to_sql() - """ - return "SELECT `users`.`username` FROM `users` ORDER BY `age` DESC" - - def can_compile_with_multiple_order_by(self): - """ - self.builder.select('username').order_by('age', 'desc').order_by('name').to_sql() - """ - return "SELECT `users`.`username` FROM `users` ORDER BY `age` DESC, `name` ASC" - - def can_compile_with_group_by(self): - """ - self.builder.select('username').group_by('age').to_sql() - """ - return "SELECT `users`.`username` FROM `users` GROUP BY `users`.`age`" - - def can_compile_where_in(self): - """ - self.builder.select('username').where_in('age', [1,2,3]).to_sql() - """ - return "SELECT `users`.`username` FROM `users` WHERE `users`.`age` IN ('1','2','3')" - - def can_compile_where_in_empty(self): - """ - self.builder.where_in('age', []).to_sql() - """ - return """SELECT * FROM `users` WHERE 0 = 1""" - - def can_compile_where_not_in(self): - """ - self.builder.select('username').where_not_in('age', [1,2,3]).to_sql() - """ - return "SELECT `users`.`username` FROM `users` WHERE `users`.`age` NOT IN ('1','2','3')" - - def can_compile_where_null(self): - """ - self.builder.select('username').where_null('age').to_sql() - """ - return "SELECT `users`.`username` FROM `users` WHERE `users`.`age` IS NULL" - - def can_compile_where_not_null(self): - """ - self.builder.select('username').where_not_null('age').to_sql() - """ - return "SELECT `users`.`username` FROM `users` WHERE `users`.`age` IS NOT NULL" - - def can_compile_where_raw(self): - """ - self.builder.where_raw("`age` = '18'").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` = '18'" - - def can_compile_where_raw_and_where_with_multiple_bindings(self): - """ - self.builder.where_raw("`age` = ? AND `is_admin` = ?", [18, True]).where("email", "test@example.com") - """ - return "SELECT * FROM `users` WHERE `age` = ? AND `is_admin` = ? AND `users`.`email` = ?" - - def can_compile_having_raw(self): - """ - self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 18").to_sql() - """ - return "SELECT COUNT(*) as counts FROM `users` HAVING counts > 18" - - def can_compile_select_raw(self): - """ - self.builder.select_raw("COUNT(*)").to_sql() - """ - return "SELECT COUNT(*) FROM `users`" - - def can_compile_limit_and_offset(self): - """ - self.builder.limit(10).offset(10).to_sql() - """ - return "SELECT * FROM `users` LIMIT 10 OFFSET 10" - - def can_compile_select_raw_with_select(self): - """ - self.builder.select('id').select_raw("COUNT(*)").to_sql() - """ - return "SELECT `users`.`id`, COUNT(*) FROM `users`" - - def can_compile_count(self): - """ - self.builder.count().to_sql() - """ - - return "SELECT COUNT(*) AS m_count_reserved FROM `users`" - - def can_compile_count_column(self): - """ - self.builder.count().to_sql() - """ - - return "SELECT COUNT(`users`.`money`) AS money FROM `users`" - - def can_compile_where_column(self): - """ - self.builder.where_column('name', 'email').to_sql() - """ - - return "SELECT * FROM `users` WHERE `users`.`name` = `users`.`email`" - - def can_compile_or_where(self): - """ - self.builder.where('name', 2).or_where('name', 3).to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`name` = '2' OR `users`.`name` = '3'" - - def can_grouped_where(self): - """ - self.builder.where(lambda query: query.where('age', 2).where('name', 'Joe')).to_sql() - """ - return "SELECT * FROM `users` WHERE (`users`.`age` = '2' AND `users`.`name` = 'Joe')" - - def can_compile_sub_select(self): - """ - self.builder.where_in('name', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age') - ).to_sql() - """ - - return "SELECT * FROM `users` WHERE `users`.`name` IN (SELECT `users`.`age` FROM `users`)" - - def can_compile_sub_select_where(self): - """ - self.builder.where_in('age', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age').where('age', 2).where('name', 'Joe') - ).to_sql() - """ - - return "SELECT * FROM `users` WHERE `users`.`age` IN (SELECT `users`.`age` FROM `users` WHERE `users`.`age` = '2' AND `users`.`name` = 'Joe')" - - def can_compile_sub_select_value(self): - """ - self.builder.where('name', - self.builder.new().sum('age') - ).to_sql() - """ - - return "SELECT * FROM `users` WHERE `users`.`name` = (SELECT SUM(`users`.`age`) AS age FROM `users`)" - - def can_compile_complex_sub_select(self): - """ - self.builder.where_in('name', - (QueryBuilder(GrammarFactory.make(self.grammar), table='users') - .select('age').where_in('email', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('email') - )) - ).to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`name` IN (SELECT `users`.`age` FROM `users` WHERE `users`.`email` IN (SELECT `users`.`email` FROM `users`))" - - def can_compile_exists(self): - """ - self.builder.select('age').where_exists( - self.builder.new().select('username').where('age', 12) - ).to_sql() - """ - return "SELECT `users`.`age` FROM `users` WHERE EXISTS (SELECT `users`.`username` FROM `users` WHERE `users`.`age` = '12')" - - def can_compile_not_exists(self): - """ - self.builder.select('age').where_not_exists( - self.builder.new().select('username').where('age', 12) - ).to_sql() - """ - return "SELECT `users`.`age` FROM `users` WHERE NOT EXISTS (SELECT `users`.`username` FROM `users` WHERE `users`.`age` = '12')" - - def can_compile_having(self): - """ - builder.sum('age').group_by('age').having('age').to_sql() - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users` GROUP BY `users`.`age` HAVING `users`.`age`" - - def can_compile_having_order(self): - """ - builder.sum('age').group_by('age').having('age').order_by('age', 'desc').to_sql() - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users` GROUP BY `users`.`age` HAVING `users`.`age` ORDER `users`.`age` DESC" - - def can_compile_having_with_expression(self): - """ - builder.sum('age').group_by('age').having('age', 10).to_sql() - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users` GROUP BY `users`.`age` HAVING `users`.`age` = '10'" - - def can_compile_having_with_greater_than_expression(self): - """ - builder.sum('age').group_by('age').having('age', '>', 10).to_sql() - """ - return "SELECT SUM(`users`.`age`) AS age FROM `users` GROUP BY `users`.`age` HAVING `users`.`age` > '10'" - - def can_compile_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return "SELECT * FROM `users` INNER JOIN `contacts` ON `users`.`id` = `contacts`.`user_id`" - - def can_compile_left_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return "SELECT * FROM `users` LEFT JOIN `contacts` ON `users`.`id` = `contacts`.`user_id`" - - def can_compile_multiple_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return "SELECT * FROM `users` INNER JOIN `contacts` ON `users`.`id` = `contacts`.`user_id` INNER JOIN `posts` ON `comments`.`post_id` = `posts`.`id`" - - def can_compile_between(self): - """ - builder.between('age', 18, 21).to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` BETWEEN '18' AND '21'" - - def can_compile_not_between(self): - """ - builder.not_between('age', 18, 21).to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` NOT BETWEEN '18' AND '21'" - - def test_can_compile_where_raw(self): - to_sql = self.builder.where_raw("`age` = '18'").to_sql() - self.assertEqual(to_sql, "SELECT * FROM `users` WHERE `age` = '18'") - - def test_can_compile_having_raw(self): - to_sql = self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 10").to_sql() - self.assertEqual(to_sql, "SELECT COUNT(*) as counts FROM `users` HAVING counts > 10") - - def test_can_compile_having_raw_order(self): - to_sql = ( - self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 10").order_by_raw("counts DESC").to_sql() - ) - self.assertEqual( - to_sql, - "SELECT COUNT(*) as counts FROM `users` HAVING counts > 10 ORDER BY counts DESC", - ) - - def test_can_compile_select_raw(self): - to_sql = self.builder.select_raw("COUNT(*)").to_sql() - self.assertEqual(to_sql, "SELECT COUNT(*) FROM `users`") - - def test_can_compile_select_raw_with_select(self): - to_sql = self.builder.select("id").select_raw("COUNT(*)").to_sql() - self.assertEqual(to_sql, "SELECT `users`.`id`, COUNT(*) FROM `users`") - - def can_compile_first_or_fail(self): - """ - builder = self.get_builder() - builder.where("is_admin", "=", True).first_or_fail() - """ - return """SELECT * FROM `users` WHERE `users`.`is_admin` = '1' LIMIT 1""" - - def where_not_like(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` NOT LIKE '%name%'" - - def where_regexp(self): - """ - builder = self.get_builder() - builder.where("age", "regexp", "Joe").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` REGEXP 'Joe'" - - def where_not_regexp(self): - """ - builder = self.get_builder() - builder.where("age", "not regexp", "Joe").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` NOT REGEXP 'Joe'" - - def where_like(self): - """ - builder = self.get_builder() - builder.where("age", "like", "%name%").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`age` LIKE '%name%'" - - def can_compile_join_clause(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on("bgt.fund", "=", "rg.fund") - .on_value("bgt.active", "=", "1") - .or_on_value("bgt.acct", "=", "1234") - ) - builder.join(clause).to_sql() - """ - return "SELECT * FROM `users` INNER JOIN `report_groups` AS `rg` ON `bgt`.`fund` = `rg`.`fund` AND `bgt`.`dept` = `rg`.`dept` AND `bgt`.`acct` = `rg`.`acct` AND `bgt`.`sub` = `rg`.`sub`" - - def can_compile_join_clause_with_value(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_value("bgt.active", "=", "1") - .or_on_value("bgt.acct", "=", "1234") - ) - builder.join(clause).to_sql() - """ - return ( - "SELECT * FROM `users` INNER JOIN `report_groups` AS `rg` ON `bgt`.`active` = '1' OR `bgt`.`acct` = '1234'" - ) - - def can_compile_join_clause_with_null(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_null("bgt.acct") - .or_on_null("bgt.dept") - .on_value("rg.abc", 10) - ) - builder.join(clause).to_sql() - """ - return "SELECT * FROM `users` INNER JOIN `report_groups` AS `rg` ON `acct` IS NULL OR `dept` IS NULL AND `rg`.`abc` = '10'" - - def can_compile_join_clause_with_not_null(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_not_null("bgt.acct") - .or_on_not_null("bgt.dept") - .on_value("rg.abc", 10) - ) - builder.join(clause).to_sql() - """ - return "SELECT * FROM `users` INNER JOIN `report_groups` AS `rg` ON `acct` IS NOT NULL OR `dept` IS NOT NULL AND `rg`.`abc` = '10'" - - def can_compile_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .on_null("bgt") - ), - ).to_sql() - """ - return ( - "SELECT * FROM `users` INNER JOIN `report_groups` AS `rg` ON `bgt`.`fund` = `rg`.`fund` AND `bgt` IS NULL" - ) - - def can_compile_left_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.left_join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .or_on_null("bgt") - ), - ).to_sql() - """ - return "SELECT * FROM `users` LEFT JOIN `report_groups` AS `rg` ON `bgt`.`fund` = `rg`.`fund` OR `bgt` IS NULL" - - def can_compile_right_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.right_join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .or_on_null("bgt") - ), - ).to_sql() - """ - return "SELECT * FROM `users` RIGHT JOIN `report_groups` AS `rg` ON `bgt`.`fund` = `rg`.`fund` OR `bgt` IS NULL" - - def shared_lock(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`votes` >= '100' LOCK IN SHARE MODE" - - def update_lock(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return "SELECT * FROM `users` WHERE `users`.`votes` >= '100' FOR UPDATE" - - def can_user_where_raw_and_where(self): - """ - builder.where_raw("`age` = '18'").where("name", "=", "James").to_sql() - """ - return "SELECT * FROM `users` WHERE age = '18' AND `users`.`name` = 'James'" - - def where_exists_with_lambda(self): - return """SELECT * FROM `users` WHERE EXISTS (SELECT * FROM `users` WHERE `users`.`age` = '1')""" - - def where_not_exists_with_lambda(self): - return """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `users` WHERE `users`.`age` = '1')""" - - def where_date(self): - return """SELECT * FROM `users` WHERE DATE(`users`.`created_at`) = '2022-06-01'""" - - def or_where_null(self): - return """SELECT * FROM `users` WHERE `users`.`column1` IS NULL OR `users`.`column2` IS NULL""" - - def select_distinct(self): - return """SELECT DISTINCT `users`.`group` FROM `users`""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_update_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_update_grammar.py deleted file mode 100644 index 713410b8..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/grammar/test_mysql_update_grammar.py +++ /dev/null @@ -1,98 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar -from src.masoniteorm.expressions import Raw - - -class BaseTestCaseUpdateGrammar: - def setUp(self): - self.builder = QueryBuilder(self.grammar, table="users") - - def test_can_compile_update(self): - to_sql = self.builder.where("name", "bob").update({"name": "Joe"}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_multiple_update(self): - to_sql = self.builder.update({"name": "Joe", "email": "user@email.com"}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_update_with_multiple_where(self): - to_sql = self.builder.where("name", "bob").where("age", 20).update({"name": "Joe"}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - # def test_can_compile_increment(self): - # to_sql = self.builder.increment("age") - - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(to_sql, sql) - - # def test_can_compile_decrement(self): - # to_sql = self.builder.decrement("age", 20).to_sql() - - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(to_sql, sql) - - def test_raw_expression(self): - to_sql = self.builder.update({"name": Raw("`username`")}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - - self.assertEqual(to_sql, sql) - - -class TestMySQLUpdateGrammar(BaseTestCaseUpdateGrammar, unittest.TestCase): - grammar = MySQLGrammar - - def can_compile_update(self): - """ - builder.where('name', 'bob').update({ - 'name': 'Joe' - }).to_sql() - """ - return "UPDATE `users` SET `users`.`name` = 'Joe' WHERE `users`.`name` = 'bob'" - - def raw_expression(self): - """ - builder.where('name', 'bob').update({ - 'name': 'Joe' - }).to_sql() - """ - return "UPDATE `users` SET `users`.`name` = `username`" - - def can_compile_multiple_update(self): - """ - self.builder.update({"name": "Joe", "email": "user@email.com"}, dry=True).to_sql() - """ - return "UPDATE `users` SET `users`.`name` = 'Joe', `users`.`email` = 'user@email.com'" - - def can_compile_update_with_multiple_where(self): - """ - builder.where('name', 'bob').where('age', 20).update({ - 'name': 'Joe' - }).to_sql() - """ - return "UPDATE `users` SET `users`.`name` = 'Joe' WHERE `users`.`name` = 'bob' AND `users`.`age` = '20'" - - def can_compile_increment(self): - """ - builder.increment('age').to_sql() - """ - return "UPDATE `users` SET `users`.`age` = `users`.`age` + '1'" - - def can_compile_decrement(self): - """ - builder.decrement('age', 20).to_sql() - """ - return "UPDATE `users` SET `users`.`age` = `users`.`age` - '20'" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_accessors_and_mutators.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_accessors_and_mutators.py deleted file mode 100644 index c18f25a7..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_accessors_and_mutators.py +++ /dev/null @@ -1,35 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model - - -class User(Model): - __casts__ = {"is_admin": "bool"} - - def get_name_attribute(self): - return f"Hello, {self.get_raw_attribute('name')}" - - def set_name_attribute(self, attribute): - return str(attribute).upper() - - -class SetUser(Model): - __casts__ = {"is_admin": "bool"} - - def set_name_attribute(self, attribute): - return str(attribute).upper() - - -class TestAccessor(unittest.TestCase): - def test_can_get_accessor(self): - user = User.hydrate({"name": "joe", "email": "joe@masoniteproject.com", "is_admin": 1}) - self.assertEqual(user.email, "joe@masoniteproject.com") - self.assertEqual(user.name, "Hello, joe") - self.assertTrue(user.is_admin is True, f"{user.is_admin} is not True") - - def test_mutator(self): - user = SetUser.hydrate({"email": "joe@masoniteproject.com", "is_admin": 1}) - - user.name = "joe" - - self.assertEqual(user.name, "JOE") diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_model.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_model.py deleted file mode 100644 index daacb17d..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/model/test_model.py +++ /dev/null @@ -1,330 +0,0 @@ -import datetime -import json -import os -import unittest - -import pendulum - -from src.masoniteorm.collection import Collection -from src.masoniteorm.exceptions import ModelNotFound -from src.masoniteorm.models import Model -from tests.User import User - - -class ProfileFillable(Model): - __fillable__ = ["name"] - __table__ = "profiles" - __timestamps__ = None - - -class ProfileFillTimeStamped(Model): - __fillable__ = ["*"] - __table__ = "profiles" - - -class ProfileFillAsterisk(Model): - __fillable__ = ["*"] - __table__ = "profiles" - __timestamps__ = None - - -class ProfileGuarded(Model): - __guarded__ = ["email"] - __table__ = "profiles" - __timestamps__ = None - - -class ProfileGuardedAsterisk(Model): - __guarded__ = ["*"] - __table__ = "profiles" - __timestamps__ = None - - -class ProfileSerialize(Model): - __fillable__ = ["*"] - __table__ = "profiles" - __hidden__ = ["password"] - - -class ProfileSerializeWithVisible(Model): - __fillable__ = ["*"] - __table__ = "profiles" - __visible__ = ["name", "email"] - - -class ProfileSerializeWithVisibleAndHidden(Model): - __fillable__ = ["*"] - __table__ = "profiles" - __visible__ = ["name", "email"] - __hidden__ = ["password"] - - -class Profile(Model): - pass - - -class Company(Model): - pass - - -class User(Model): - @property - def meta(self): - return {"is_subscribed": True} - - -class ProductNames(Model): - pass - - -class TestModel(unittest.TestCase): - def test_create_can_use_fillable(self): - sql = ProfileFillable.create({"name": "Joe", "email": "user@example.com"}, query=True).to_sql() - - self.assertEqual(sql, "INSERT INTO `profiles` (`profiles`.`name`) VALUES ('Joe')") - - def test_create_can_use_fillable_asterisk(self): - sql = ProfileFillAsterisk.create({"name": "Joe", "email": "user@example.com"}, query=True).to_sql() - - self.assertEqual( - sql, - "INSERT INTO `profiles` (`profiles`.`name`, `profiles`.`email`) VALUES ('Joe', 'user@example.com')", - ) - - def test_create_can_use_guarded(self): - sql = ProfileGuarded.create({"name": "Joe", "email": "user@example.com"}, query=True).to_sql() - - self.assertEqual(sql, "INSERT INTO `profiles` (`profiles`.`name`) VALUES ('Joe')") - - def test_create_can_use_guarded_asterisk(self): - sql = ProfileGuardedAsterisk.create({"name": "Joe", "email": "user@example.com"}, query=True).to_sql() - - # An asterisk guarded attribute excludes all fields from mass-assignment. - # This would raise a DB error if there are any required fields. - self.assertEqual(sql, "INSERT INTO `profiles` (*) VALUES ()") - - def test_bulk_create_can_use_fillable(self): - query_builder = ProfileFillable.bulk_create( - [ - {"name": "Joe", "email": "user@example.com"}, - {"name": "Joe II", "email": "userII@example.com"}, - ], - query=True, - ) - - self.assertEqual( - query_builder.to_sql(), - "INSERT INTO `profiles` (`name`) VALUES ('Joe'), ('Joe II')", - ) - - def test_bulk_create_can_use_fillable_asterisk(self): - query_builder = ProfileFillAsterisk.bulk_create( - [ - {"name": "Joe", "email": "user@example.com"}, - {"name": "Joe II", "email": "userII@example.com"}, - ], - query=True, - ) - - self.assertEqual( - query_builder.to_sql(), - "INSERT INTO `profiles` (`email`, `name`) VALUES ('user@example.com', 'Joe'), ('userII@example.com', 'Joe II')", - ) - - def test_bulk_create_can_use_guarded(self): - query_builder = ProfileGuarded.bulk_create( - [ - {"name": "Joe", "email": "user@example.com"}, - {"name": "Joe II", "email": "userII@example.com"}, - ], - query=True, - ) - - self.assertEqual( - query_builder.to_sql(), - "INSERT INTO `profiles` (`name`) VALUES ('Joe'), ('Joe II')", - ) - - def test_bulk_create_can_use_guarded_asterisk(self): - query_builder = ProfileGuardedAsterisk.bulk_create( - [ - {"name": "Joe", "email": "user@example.com"}, - {"name": "Joe II", "email": "userII@example.com"}, - ], - query=True, - ) - - # An asterisk guarded attribute excludes all fields from mass-assignment. - # This would obviously raise an invalid SQL syntax error. - # TODO: Raise a clearer error? - self.assertEqual(query_builder.to_sql(), "INSERT INTO `profiles` () VALUES (), ()") - - def test_update_can_use_fillable(self): - query_builder = ProfileFillable().update({"name": "Joe", "email": "user@example.com"}, dry=True) - - self.assertEqual( - query_builder.to_sql(), - "UPDATE `profiles` SET `profiles`.`name` = 'Joe'", - ) - - def test_update_can_use_fillable_asterisk(self): - query_builder = ProfileFillAsterisk().update({"name": "Joe", "email": "user@example.com"}, dry=True) - - self.assertEqual( - query_builder.to_sql(), - "UPDATE `profiles` SET `profiles`.`name` = 'Joe', `profiles`.`email` = 'user@example.com'", - ) - - def test_update_can_use_guarded(self): - query_builder = ProfileGuarded().update({"name": "Joe", "email": "user@example.com"}, dry=True) - - self.assertEqual( - query_builder.to_sql(), - "UPDATE `profiles` SET `profiles`.`name` = 'Joe'", - ) - - def test_update_can_use_guarded_asterisk(self): - profile = ProfileGuardedAsterisk() - initial_sql = profile.get_builder().to_sql() - query_builder = profile.update({"name": "Joe", "email": "user@example.com"}, dry=True) - - # An asterisk guarded attribute excludes all fields from mass-assignment. - # The query builder's sql should not have been altered in any way. - self.assertEqual(query_builder.to_sql(), initial_sql) - - def test_table_name(self): - table_name = Profile.get_table_name() - self.assertEqual(table_name, "profiles") - - table_name = Company.get_table_name() - self.assertEqual(table_name, "companies") - - table_name = ProductNames.get_table_name() - self.assertEqual(table_name, "product_names") - - def test_serialize(self): - profile = ProfileFillAsterisk.hydrate({"name": "Joe", "id": 1}) - - self.assertEqual(profile.serialize(), {"name": "Joe", "id": 1}) - - def test_json(self): - profile = ProfileFillAsterisk.hydrate({"name": "Joe", "id": 1}) - - self.assertEqual(profile.to_json(), '{"name": "Joe", "id": 1}') - - def test_serialize_with_hidden(self): - profile = ProfileSerialize.hydrate({"name": "Joe", "id": 1, "password": "secret"}) - - self.assertTrue(profile.serialize().get("name")) - self.assertTrue(profile.serialize().get("id")) - self.assertFalse(profile.serialize().get("password")) - - def test_serialize_with_visible(self): - profile = ProfileSerializeWithVisible.hydrate( - { - "name": "Joe", - "id": 1, - "password": "secret", - "email": "joe@masonite.com", - } - ) - self.assertTrue({"name": "Joe", "email": "joe@masonite.com"}, profile.serialize()) - - def test_serialize_with_visible_and_hidden_raise_error(self): - profile = ProfileSerializeWithVisibleAndHidden.hydrate( - { - "name": "Joe", - "id": 1, - "password": "secret", - "email": "joe@masonite.com", - } - ) - with self.assertRaises(AttributeError): - profile.serialize() - - def test_serialize_with_on_the_fly_appends(self): - user = User.hydrate({"name": "Joe", "id": 1}) - - user.set_appends(["meta"]) - - serialized = user.serialize() - self.assertEqual(serialized["id"], 1) - self.assertEqual(serialized["name"], "Joe") - self.assertEqual(serialized["meta"]["is_subscribed"], True) - - def test_serialize_with_model_appends(self): - User.__appends__ = ["meta"] - user = User.hydrate({"name": "Joe", "id": 1}) - serialized = user.serialize() - self.assertEqual(serialized["id"], 1) - self.assertEqual(serialized["name"], "Joe") - self.assertEqual(serialized["meta"]["is_subscribed"], True) - - def test_serialize_with_date(self): - user = User.hydrate({"name": "Joe", "created_at": pendulum.now()}) - - self.assertTrue(json.dumps(user.serialize())) - - def test_set_as_date(self): - user = User.hydrate( - { - "name": "Joe", - "created_at": pendulum.now().add(days=10).to_datetime_string(), - } - ) - - self.assertTrue(user.created_at) - self.assertTrue(user.created_at.is_future()) - - def test_access_as_date(self): - user = User.hydrate( - { - "name": "Joe", - "created_at": datetime.datetime.now() + datetime.timedelta(days=1), - } - ) - - self.assertTrue(user.created_at) - self.assertTrue(user.created_at.is_future()) - - def test_hydrate_with_none(self): - profile = ProfileFillAsterisk.hydrate(None) - - self.assertEqual(profile, None) - - def test_serialize_with_dirty_attribute(self): - profile = ProfileFillAsterisk.hydrate({"name": "Joe", "id": 1}) - - profile.age = 18 - self.assertEqual(profile.serialize(), {"age": 18, "name": "Joe", "id": 1}) - - def test_attribute_check_with_hasattr(self): - self.assertFalse(hasattr(Profile(), "__password__")) - - -if os.getenv("RUN_MYSQL_DATABASE", "false").lower() == "true": - - class MysqlTestModel(unittest.TestCase): - # TODO: these tests aren't getting run in CI... is that intentional? - def test_can_find_first(self): - user = User.find(1) - self.assertIsInstance(user, User) - - def test_can_touch(self): - profile = ProfileFillTimeStamped.hydrate({"name": "Joe", "id": 1}) - - sql = profile.touch("now", query=True).to_sql() - - self.assertEqual( - sql, - "UPDATE `profiles` SET `profiles`.`updated_at` = 'now' WHERE `profiles`.`id` = '1'", - ) - - def test_find_or_fail_raise_an_exception_if_not_exists(self): - with self.assertRaises(ModelNotFound): - User.find(100) - - def test_returns_correct_data_type(self): - self.assertIsInstance(User.all(), Collection) - # self.assertIsInstance(User.first(), User) - # self.assertIsInstance(User.first(), User) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_belongs_to_many.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_belongs_to_many.py deleted file mode 100644 index f28055e9..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_belongs_to_many.py +++ /dev/null @@ -1,162 +0,0 @@ -import unittest - -from dotenv import load_dotenv - -from src.masoniteorm.models import Model -from src.masoniteorm.relationships import ( - belongs_to_many, - has_one, -) - -load_dotenv(".env") - - -class User(Model): - @has_one - def profile(self): - return Profile - - -class Profile(Model): - pass - - -class Permission(Model): - @belongs_to_many("permission_id", "role_id", "id", "id") - def role(self): - return Role - - -class PermissionSelect(Model): - __table__ = "permissions" - - __selects__ = ["permission_id"] - - @belongs_to_many("permission_id", "role_id", "id", "id") - def role(self): - return Role - - -class Role(Model): - @belongs_to_many("role_id", "permission_id", "id", "id") - def permissions(self): - return Permission - - -class MySQLRelationships(unittest.TestCase): - maxDiff = None - - def test_belongs_to_many(self): - sql = Permission.where_has("role", lambda query: query.where("slug", "users")).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `permissions` WHERE EXISTS (SELECT * FROM `roles` INNER JOIN `permission_role` ON `roles`.`id` = `permission_role`.`role_id` WHERE `permission_role`.`permission_id` = `permissions`.`id` AND `roles`.`id` IN (SELECT `roles`.`id` FROM `roles` WHERE `roles`.`slug` = 'users'))""", - ) - - def test_belongs_to_many_has(self): - sql = Role.has("permissions").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id`)""", - ) - - def test_belongs_to_many_or_has(self): - sql = Role.where("name", "role_name").or_has("permissions").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE `roles`.`name` = 'role_name' OR EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id`)""", - ) - - def test_belongs_to_many_or_where_has(self): - sql = ( - Role.where("name", "role_name").or_where_has("permissions", lambda q: q.where("permission_id", 1)).to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE `roles`.`name` = 'role_name' OR EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id` AND `permissions`.`id` IN (SELECT `permissions`.`id` FROM `permissions` WHERE `permissions`.`permission_id` = '1'))""", - ) - - def test_belongs_to_many_or_doesnt_have(self): - sql = Role.where("name", "role_name").or_doesnt_have("permissions").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE `roles`.`name` = 'role_name' OR NOT EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id`)""", - ) - - def test_where_doesnt_have(self): - sql = ( - Role.where("name", "role_name") - .where_doesnt_have("permissions", lambda q: q.where("name", "Creates Users")) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE `roles`.`name` = 'role_name' AND NOT EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id` AND `permissions`.`id` IN (SELECT `permissions`.`id` FROM `permissions` WHERE `permissions`.`name` = 'Creates Users'))""", - ) - - def test_or_where_doesnt_have(self): - sql = ( - Role.where("name", "role_name") - .or_where_doesnt_have("permissions", lambda q: q.where("name", "Creates Users")) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE `roles`.`name` = 'role_name' OR NOT EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id` AND `permissions`.`id` IN (SELECT `permissions`.`id` FROM `permissions` WHERE `permissions`.`name` = 'Creates Users'))""", - ) - - def test_belongs_to_many_where_has(self): - sql = Role.where_has("permissions", lambda q: q.where("name", "Creates Users")).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `roles` WHERE EXISTS (SELECT * FROM `permissions` INNER JOIN `permission_role` ON `permissions`.`id` = `permission_role`.`permission_id` WHERE `permission_role`.`role_id` = `roles`.`id` AND `permissions`.`id` IN (SELECT `permissions`.`id` FROM `permissions` WHERE `permissions`.`name` = 'Creates Users'))""", - ) - - def test_belongs_to_many_relate_method(self): - permission = Permission.hydrate({"id": 1, "name": "Create Users"}) - sql = permission.related("role").to_sql() - - self.assertEqual( - sql, - """SELECT `roles`.*, `permission_role`.`permission_id` AS permission_role_id, `permission_role`.`role_id` AS m_reserved2, `permission_role`.`id` AS m_reserved3 FROM `permissions` INNER JOIN `permission_role` ON `permission_role`.`permission_id` = `permissions`.`id` INNER JOIN `roles` ON `permission_role`.`role_id` = `roles`.`id`""", - ) - - def test_belongs_to_many_relate_method_reversed(self): - role = Role.hydrate({"id": 1, "name": "Create Users"}) - sql = role.related("permissions").to_sql() - - self.assertEqual( - sql, - """SELECT `permissions`.*, `permission_role`.`role_id` AS permission_role_id, `permission_role`.`permission_id` AS m_reserved2, `permission_role`.`id` AS m_reserved3 FROM `roles` INNER JOIN `permission_role` ON `permission_role`.`role_id` = `roles`.`id` INNER JOIN `permissions` ON `permission_role`.`permission_id` = `permissions`.`id`""", - ) - - def test_belongs_to_many_joins(self): - sql = Role.joins("permissions").to_sql() - self.assertEqual( - sql, - """SELECT `roles`.*, `permission_role`.`role_id` AS permission_role_id, `permission_role`.`permission_id` AS m_reserved2, `permission_role`.`id` AS m_reserved3 FROM `roles` INNER JOIN `permission_role` ON `permission_role`.`role_id` = `roles`.`id` INNER JOIN `permissions` ON `permission_role`.`id` = `permissions`.`id`""", - ) - - def test_with_count(self): - sql = Permission.with_count("role").to_sql() - - self.assertEqual( - sql, - """SELECT `permissions`.*, (SELECT COUNT(*) AS m_count_reserved FROM `permission_role` WHERE `permissions`.`id` = `permission_role`.`permission_id`) AS roles_count FROM `permissions`""", - ) - - def test_with_count_with_selects(self): - sql = PermissionSelect.with_count("role").to_sql() - - self.assertEqual( - sql, - """SELECT `permissions`.`permission_id`, (SELECT COUNT(*) AS m_count_reserved FROM `permission_role` WHERE `permissions`.`id` = `permission_role`.`permission_id`) AS roles_count FROM `permissions`""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_many_through.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_many_through.py deleted file mode 100644 index f4f93bc3..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_many_through.py +++ /dev/null @@ -1,83 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.relationships import ( - has_many_through, -) -from dotenv import load_dotenv - -load_dotenv(".env") - - -class InboundShipment(Model): - @has_many_through("port_id", "country_id", "from_port_id", "country_id") - def from_country(self): - return Country, Port - - -class Country(Model): - pass - - -class Port(Model): - pass - - -class MySQLRelationships(unittest.TestCase): - maxDiff = None - - def test_has_query(self): - sql = InboundShipment.has("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`)""", - ) - - def test_or_has(self): - sql = InboundShipment.where("name", "Joe").or_has("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE `inbound_shipments`.`name` = 'Joe' OR EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`)""", - ) - - def test_where_has_query(self): - sql = InboundShipment.where_has("from_country", lambda query: query.where("name", "USA")).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id` AND `countries`.`name` = 'USA')""", - ) - - def test_or_where_has(self): - sql = ( - InboundShipment.where("name", "Joe") - .or_where_has("from_country", lambda query: query.where("name", "USA")) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE `inbound_shipments`.`name` = 'Joe' OR EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id` AND `countries`.`name` = 'USA')""", - ) - - def test_doesnt_have(self): - sql = InboundShipment.doesnt_have("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE NOT EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`)""", - ) - - def test_or_where_doesnt_have(self): - sql = ( - InboundShipment.where("name", "Joe") - .or_where_doesnt_have("from_country", lambda query: query.where("name", "USA")) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE `inbound_shipments`.`name` = 'Joe' OR NOT EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id` AND `countries`.`name` = 'USA')""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_one_through.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_one_through.py deleted file mode 100644 index 73fdadaa..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_has_one_through.py +++ /dev/null @@ -1,91 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.relationships import ( - has_one_through, -) -from dotenv import load_dotenv - -load_dotenv(".env") - - -class InboundShipment(Model): - @has_one_through(None, "from_port_id", "country_id", "port_id", "country_id") - def from_country(self): - return Country, Port - - -class Country(Model): - pass - - -class Port(Model): - pass - - -class MySQLHasOneThroughRelationship(unittest.TestCase): - maxDiff = None - - def test_has_query(self): - sql = InboundShipment.has("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`)""", - ) - - def test_or_has(self): - sql = InboundShipment.where("name", "Joe").or_has("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE `inbound_shipments`.`name` = 'Joe' OR EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`)""", - ) - - def test_where_has_query(self): - sql = InboundShipment.where_has("from_country", lambda query: query.where("name", "USA")).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id` AND `countries`.`name` = 'USA')""", - ) - - def test_or_where_has(self): - sql = ( - InboundShipment.where("name", "Joe") - .or_where_has("from_country", lambda query: query.where("name", "USA")) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE `inbound_shipments`.`name` = 'Joe' OR EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id` AND `countries`.`name` = 'USA')""", - ) - - def test_doesnt_have(self): - sql = InboundShipment.doesnt_have("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE NOT EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`)""", - ) - - def test_or_where_doesnt_have(self): - sql = ( - InboundShipment.where("name", "Joe") - .or_where_doesnt_have("from_country", lambda query: query.where("name", "USA")) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `inbound_shipments` WHERE `inbound_shipments`.`name` = 'Joe' OR NOT EXISTS (SELECT * FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id` AND `countries`.`name` = 'USA')""", - ) - - def test_has_one_through_with_count(self): - sql = InboundShipment.with_count("from_country").to_sql() - - self.assertEqual( - sql, - """SELECT `inbound_shipments`.*, (SELECT COUNT(*) AS m_count_reserved FROM `countries` INNER JOIN `ports` ON `ports`.`country_id` = `countries`.`country_id` WHERE `ports`.`port_id` = `inbound_shipments`.`from_port_id`) AS from_country_count FROM `inbound_shipments`""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_relationships.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_relationships.py deleted file mode 100644 index d0d742bb..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/relationships/test_relationships.py +++ /dev/null @@ -1,169 +0,0 @@ -import unittest - -from dotenv import load_dotenv - -from src.masoniteorm.models import Model -from src.masoniteorm.relationships import ( - has_one, -) - -load_dotenv(".env") - - -class User(Model): - @has_one - def profile(self): - return Profile - - -class Profile(Model): - @has_one - def identification(self): - return Identification - - -class Identification(Model): - pass - - -class MySQLRelationships(unittest.TestCase): - maxDiff = None - - def test_has(self): - sql = User.has("profile").to_sql() - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id`)""", - ) - - def test_has_nested(self): - sql = User.has("profile.identification").to_sql() - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `profiles`.`id`))""", - ) - - def test_or_has(self): - sql = User.where("name", "Joe").or_has("profile").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE `users`.`name` = 'Joe' OR EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id`)""", - ) - - def test_or_has_nested(self): - sql = User.where("name", "Joe").or_has("profile.identification").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE `users`.`name` = 'Joe' OR EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `profiles`.`id`))""", - ) - - def test_relationship_where_has(self): - sql = User.where("name", "Joe").where_has("profile", lambda q: q.where("profile_id", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE `users`.`name` = 'Joe' AND EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND `profiles`.`profile_id` = '1')""", - ) - - def test_relationship_where_has_nested(self): - sql = ( - User.where("name", "Joe") - .where_has( - "profile.identification", - lambda q: q.where("identification_id", 1), - ) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE `users`.`name` = 'Joe' AND EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `profiles`.`id` AND `identifications`.`identification_id` = '1'))""", - ) - - def test_relationship_or_where_has(self): - sql = User.where("name", "Joe").or_where_has("profile", lambda q: q.where("profile_id", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE `users`.`name` = 'Joe' OR EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND `profiles`.`profile_id` = '1')""", - ) - - def test_relationship_or_where_has_nested(self): - sql = ( - User.where("name", "Joe") - .or_where_has( - "profile.identification", - lambda q: q.where("identification_id", 1), - ) - .to_sql() - ) - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE `users`.`name` = 'Joe' OR EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `profiles`.`id` AND `identifications`.`identification_id` = '1'))""", - ) - - def test_relationship_doesnt_have(self): - sql = User.doesnt_have("profile").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id`)""", - ) - - def test_relationship_doesnt_have_nested(self): - sql = User.doesnt_have("profile.identification").to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `profiles`.`id`))""", - ) - - def test_relationship_where_doesnt_have(self): - sql = User.where_doesnt_have("profile", lambda q: q.where("profile_id", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND `profiles`.`profile_id` = '1')""", - ) - - def test_relationship_where_doesnt_have_nested(self): - sql = User.where_doesnt_have("profile.identification", lambda q: q.where("identification_id", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id`) AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `users`.`id` AND `identifications`.`identification_id` = '1')""", - ) - - def test_relationship_or_where_doesnt_have(self): - sql = User.or_where_doesnt_have("profile", lambda q: q.where("profile_id", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id` AND `profiles`.`profile_id` = '1')""", - ) - - def test_relationship_or_where_doesnt_have_nested(self): - sql = User.or_where_doesnt_have("profile.identification", lambda q: q.where("identification_id", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` WHERE NOT EXISTS (SELECT * FROM `profiles` WHERE `profiles`.`profile_id` = `users`.`id`) AND EXISTS (SELECT * FROM `identifications` WHERE `identifications`.`identification_id` = `users`.`id` AND `identifications`.`identification_id` = '1')""", - ) - - def test_joins(self): - sql = User.joins("profile").to_sql() - self.assertEqual( - sql, - """SELECT * FROM `users` INNER JOIN `profiles` ON `users`.`id` = `profiles`.`profile_id`""", - ) - - def test_join_on(self): - sql = User.join_on("profile", lambda q: q.where("active", 1)).to_sql() - - self.assertEqual( - sql, - """SELECT * FROM `users` INNER JOIN `profiles` ON `users`.`id` = `profiles`.`profile_id` WHERE (`profiles`.`active` = '1')""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder.py deleted file mode 100644 index 39fab42f..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder.py +++ /dev/null @@ -1,380 +0,0 @@ -import os -import unittest - -from src.masoniteorm import Model -from tests.integrations.config.database import DATABASES -from src.masoniteorm.connections import MySQLConnection -from src.masoniteorm.schema import Schema -from src.masoniteorm.schema.platforms import MySQLPlatform - -from tests.integrations.config.database import DATABASES - - -class Discussion(Model): - pass - - -class TestMySQLSchemaBuilder(unittest.TestCase): - maxDiff = None - - def setUp(self): - self.schema = Schema( - connection_class=MySQLConnection, - connection="mysql", - connection_details=DATABASES, - platform=MySQLPlatform, - dry=True, - ).on("mysql") - - def test_can_add_columns1(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`name` VARCHAR(255) NOT NULL, `age` INT(11) NOT NULL)"], - ) - - def test_can_add_tiny_text(self): - with self.schema.create("users") as blueprint: - blueprint.tiny_text("description") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`description` TINYTEXT NOT NULL)"], - ) - - def test_can_add_unsigned_decimal(self): - with self.schema.create("users") as blueprint: - blueprint.unsigned_decimal("amount", 19, 4) - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`amount` DECIMAL(19, 4) UNSIGNED NOT NULL)"], - ) - - def test_can_create_table_if_not_exists(self): - with self.schema.create_table_if_not_exists("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE IF NOT EXISTS `users` (`name` VARCHAR(255) NOT NULL, `age` INT(11) NOT NULL)"], - ) - - def test_can_add_columns_with_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - (blueprint.unique("name"),) - (blueprint.unique("name", name="table_unique"),) - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (`name` VARCHAR(255) NOT NULL, `age` INT(11) NOT NULL, CONSTRAINT users_name_unique UNIQUE (name), CONSTRAINT table_unique UNIQUE (name))" - ], - ) - - def test_add_column_comment(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").comment("A users username") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`name` VARCHAR(255) NOT NULL COMMENT 'A users username')"], - ) - - def test_can_add_table_comment(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.table_comment("A users table") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`name` VARCHAR(255) NOT NULL) COMMENT 'A users table'"], - ) - - def test_can_add_columns_with_foreign_key_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.foreign("profile_id").references("id").on("profiles") - blueprint.foreign_id("post_id").references("id").on("posts") - blueprint.foreign_id_for(Discussion).references("id").on("discussions") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (`name` VARCHAR(255) NOT NULL, " - "`age` INT(11) NOT NULL, " - "`profile_id` INT(11) NOT NULL, " - "`post_id` BIGINT UNSIGNED NOT NULL, " - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_profile_id_foreign FOREIGN KEY (`profile_id`) REFERENCES `profiles`(`id`), " - "CONSTRAINT users_profile_id_foreign FOREIGN KEY (`post_id`) REFERENCES `posts`(`id`)), " - "CONSTRAINT users_discussions_id_foreign FOREIGN KEY (`discussion_id`) REFERENCES `posts`(`id`))" - ], - ) - - def test_can_add_columns_with_foreign_key_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.add_foreign("profile_id.id.profiles") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (`name` VARCHAR(255) NOT NULL, " - "`age` INT(11) NOT NULL, " - "`profile_id` INT(11) NOT NULL, " - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_profile_id_foreign FOREIGN KEY (`profile_id`) REFERENCES `profiles`(`id`))" - ], - ) - - def test_can_advanced_table_creation(self): - with self.schema.create("users") as blueprint: - blueprint.increments("id") - blueprint.id("id2") - blueprint.string("name") - blueprint.tiny_integer("active") - blueprint.string("email").unique() - blueprint.enum("gender", ["male", "female"]) - blueprint.string("password") - blueprint.decimal("money") - blueprint.integer("admin").default(0) - blueprint.string("option").default("ADMIN") - blueprint.string("remember_token").nullable() - blueprint.timestamp("verified_at").nullable() - blueprint.timestamps() - - self.assertEqual(len(blueprint.table.added_columns), 14) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (`id` INT UNSIGNED AUTO_INCREMENT NOT NULL, " - "`id2` BIGINT UNSIGNED AUTO_INCREMENT NOT NULL, " - "`name` VARCHAR(255) NOT NULL, `active` TINYINT(1) NOT NULL, `email` VARCHAR(255) NOT NULL, `gender` ENUM('male', 'female') NOT NULL, " - "`password` VARCHAR(255) NOT NULL, `money` DECIMAL(17, 6) NOT NULL, " - "`admin` INT(11) NOT NULL DEFAULT 0, `option` VARCHAR(255) NOT NULL DEFAULT 'ADMIN', `remember_token` VARCHAR(255) NULL, `verified_at` TIMESTAMP NULL, " - "`created_at` DATETIME NULL DEFAULT CURRENT_TIMESTAMP, `updated_at` DATETIME NULL DEFAULT CURRENT_TIMESTAMP, CONSTRAINT users_id_primary PRIMARY KEY (id), CONSTRAINT users_id2_primary PRIMARY KEY (id2), CONSTRAINT users_email_unique UNIQUE (email))" - ], - ) - - def test_can_add_primary_constraint_without_column_name(self): - with self.schema.create("users") as blueprint: - blueprint.integer("user_id").primary() - blueprint.string("name") - blueprint.string("email") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual(len(blueprint.table.added_constraints), 1) - - self.assertTrue(blueprint.to_sql()[0].startswith("CREATE TABLE `users` (`user_id` INT(11) NOT NULL")) - - def test_can_advanced_table_creation2(self): - with self.schema.create("users") as blueprint: - blueprint.big_increments("id") - blueprint.string("name") - blueprint.string("duration") - blueprint.string("url") - blueprint.inet("last_address").nullable() - blueprint.cidr("route_origin").nullable() - blueprint.macaddr("mac_address").nullable() - blueprint.datetime("published_at") - blueprint.string("thumbnail").nullable() - blueprint.integer("premium") - blueprint.integer("author_id").unsigned().nullable() - blueprint.foreign("author_id").references("id").on("users").on_delete("CASCADE") - blueprint.text("description") - blueprint.timestamps() - - self.assertEqual(len(blueprint.table.added_columns), 14) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (`id` BIGINT UNSIGNED AUTO_INCREMENT NOT NULL, `name` VARCHAR(255) NOT NULL, " - "`duration` VARCHAR(255) NOT NULL, `url` VARCHAR(255) NOT NULL, `last_address` VARCHAR(255) NULL, `route_origin` VARCHAR(255) NULL, `mac_address` VARCHAR(255) NULL, " - "`published_at` DATETIME NOT NULL, `thumbnail` VARCHAR(255) NULL, " - "`premium` INT(11) NOT NULL, `author_id` INT(11) UNSIGNED NULL, `description` TEXT NOT NULL, `created_at` DATETIME NULL DEFAULT CURRENT_TIMESTAMP, " - "`updated_at` DATETIME NULL DEFAULT CURRENT_TIMESTAMP, CONSTRAINT users_id_primary PRIMARY KEY (id), CONSTRAINT users_author_id_foreign FOREIGN KEY (`author_id`) REFERENCES `users`(`id`) ON DELETE CASCADE)" - ], - ) - - def test_can_add_columns_with_foreign_key_constraint_name(self): - with self.schema.create("users") as blueprint: - blueprint.integer("profile_id") - blueprint.foreign("profile_id", name="profile_foreign").references("id").on("profiles") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (" - "`profile_id` INT(11) NOT NULL, " - "CONSTRAINT profile_foreign FOREIGN KEY (`profile_id`) REFERENCES `profiles`(`id`))" - ], - ) - - def test_can_have_composite_keys(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.primary(["name", "age"]) - - self.assertEqual(len(blueprint.table.added_columns), 3) - print(blueprint.to_sql()) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` " - "(`name` VARCHAR(255) NOT NULL, " - "`age` INT(11) NOT NULL, " - "`profile_id` INT(11) NOT NULL, " - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_name_age_primary PRIMARY KEY (name, age))" - ], - ) - - def test_can_have_column_primary_key(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").primary() - blueprint.integer("age") - blueprint.integer("profile_id") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` " - "(`name` VARCHAR(255) NOT NULL, " - "`age` INT(11) NOT NULL, " - "`profile_id` INT(11) NOT NULL, " - "CONSTRAINT users_name_primary PRIMARY KEY (name))" - ], - ) - - def test_can_have_unsigned_columns(self): - with self.schema.create("users") as blueprint: - blueprint.integer("profile_id").unsigned() - blueprint.big_integer("big_profile_id").unsigned() - blueprint.tiny_integer("tiny_profile_id").unsigned() - blueprint.small_integer("small_profile_id").unsigned() - blueprint.medium_integer("medium_profile_id").unsigned() - blueprint.unsigned_integer("unsigned_profile_id") - blueprint.unsigned_big_integer("unsigned_big_profile_id") - - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE `users` (" - "`profile_id` INT(11) UNSIGNED NOT NULL, " - "`big_profile_id` BIGINT(32) UNSIGNED NOT NULL, " - "`tiny_profile_id` TINYINT(1) UNSIGNED NOT NULL, " - "`small_profile_id` SMALLINT(5) UNSIGNED NOT NULL, " - "`medium_profile_id` MEDIUMINT(7) UNSIGNED NOT NULL, " - "`unsigned_profile_id` INT UNSIGNED NOT NULL, " - "`unsigned_big_profile_id` BIGINT(32) UNSIGNED NOT NULL)" - ], - ) - - def test_can_have_default_blank_string(self): - with self.schema.create("users") as blueprint: - blueprint.string("profile_id").default("") - - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`profile_id` VARCHAR(255) NOT NULL DEFAULT '')"], - ) - - def test_can_have_float_type(self): - with self.schema.create("users") as blueprint: - blueprint.float("amount") - - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`amount` FLOAT(19, 4) NOT NULL)"], - ) - - def test_has_table(self): - schema_sql = self.schema.has_table("users") - - sql = f"SELECT * from information_schema.tables where table_name='users' AND table_schema = '{os.getenv('MYSQL_DATABASE_DATABASE')}'" - - self.assertEqual(schema_sql, sql) - - def test_can_truncate(self): - sql = self.schema.truncate("users") - - self.assertEqual(sql, "TRUNCATE `users`") - - def test_can_rename_table(self): - sql = self.schema.rename("users", "clients") - - self.assertEqual(sql, "ALTER TABLE `users` RENAME TO `clients`") - - def test_can_drop_table_if_exists(self): - sql = self.schema.drop_table_if_exists("users", "clients") - - self.assertEqual(sql, "DROP TABLE IF EXISTS `users`") - - def test_can_drop_table(self): - sql = self.schema.drop_table("users", "clients") - - self.assertEqual(sql, "DROP TABLE `users`") - - def test_has_column(self): - sql = self.schema.has_column("users", "name") - - self.assertEqual( - sql, - "SELECT column_name FROM information_schema.columns WHERE table_name='users' and column_name='name'", - ) - - def test_can_enable_foreign_keys(self): - sql = self.schema.enable_foreign_key_constraints() - - self.assertEqual(sql, "SET FOREIGN_KEY_CHECKS=1") - - def test_can_disable_foreign_keys(self): - sql = self.schema.disable_foreign_key_constraints() - - self.assertEqual(sql, "SET FOREIGN_KEY_CHECKS=0") - - def test_can_truncate_without_foreign_keys(self): - sql = self.schema.truncate("users", foreign_keys=True) - - self.assertEqual( - sql, - [ - "SET FOREIGN_KEY_CHECKS=0", - "TRUNCATE `users`", - "SET FOREIGN_KEY_CHECKS=1", - ], - ) - - def test_can_add_enum(self): - with self.schema.create("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ["CREATE TABLE `users` (`status` ENUM('active', 'inactive') NOT NULL DEFAULT 'active')"], - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder_alter.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder_alter.py deleted file mode 100644 index c48ecf62..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/schema/test_mysql_schema_builder_alter.py +++ /dev/null @@ -1,309 +0,0 @@ -import unittest - -from src.masoniteorm.connections import MySQLConnection -from src.masoniteorm.schema import Schema -from src.masoniteorm.schema.platforms import MySQLPlatform -from src.masoniteorm.schema.Table import Table -from tests.integrations.config.database import DATABASES - - -class TestMySQLSchemaBuilderAlter(unittest.TestCase): - maxDiff = None - - def setUp(self): - self.schema = Schema( - connection_class=MySQLConnection, - connection="mysql", - connection_details=DATABASES, - platform=MySQLPlatform, - dry=True, - ).on("mysql") - - def test_can_add_columns(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - - sql = ["ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL, ADD `age` INT(11) NOT NULL"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_add_column_comments(self): - with self.schema.table("users") as blueprint: - blueprint.string("name").comment("A users username") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - # sql = [ - # "ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL COMMENT 'A users username'" - # ] - - def test_can_add_table_comment(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.table_comment("A users username") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - # sql = [ - # "ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL COMMENT 'A users username'" - # ] - - def test_can_add_table_comment_with_no_columns(self): - with self.schema.table("users") as blueprint: - blueprint.table_comment("A users username") - - self.assertEqual(len(blueprint.table.added_columns), 0) - - sql = ["ALTER TABLE `users` COMMENT 'A users username'"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_add_column_after(self): - with self.schema.table("users") as blueprint: - blueprint.string("name").after("age") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = ["ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL AFTER `age`"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_rename(self): - with self.schema.table("users") as blueprint: - blueprint.rename("post", "comment", "integer") - - table = Table("users") - table.add_column("post", "integer") - blueprint.table.from_table = table - - sql = ["ALTER TABLE `users` CHANGE `post` `comment` INT NOT NULL"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_and_rename(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.rename("post", "comment", "string") - - table = Table("users") - table.add_column("post", "string") - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL", - "ALTER TABLE `users` CHANGE `post` `comment` VARCHAR NOT NULL", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_and_rename_to_string(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.rename("post", "comment", "string", length=200) - - table = Table("users") - table.add_column("post", "integer") - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL", - "ALTER TABLE `users` CHANGE `post` `comment` VARCHAR(200) NOT NULL", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop1(self): - with self.schema.table("users") as blueprint: - blueprint.drop_column("post") - - sql = ["ALTER TABLE `users` DROP COLUMN `post`"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_column_and_foreign_key(self): - with self.schema.table("users") as blueprint: - blueprint.unsigned_integer("playlist_id").nullable() - blueprint.foreign("playlist_id").references("id").on("playlists").on_delete("cascade") - - sql = [ - "ALTER TABLE `users` ADD `playlist_id` INT UNSIGNED NULL", - "ALTER TABLE `users` ADD CONSTRAINT users_playlist_id_foreign FOREIGN KEY (playlist_id) REFERENCES playlists(id) ON DELETE CASCADE", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_foreign_key(self): - with self.schema.table("users") as blueprint: - blueprint.drop_foreign("users_playlist_id_foreign") - - sql = ["ALTER TABLE `users` DROP FOREIGN KEY users_playlist_id_foreign"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_foreign_key_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_foreign(["playlist_id"]) - - sql = ["ALTER TABLE `users` DROP FOREIGN KEY users_playlist_id_foreign"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_unique_constraint(self): - with self.schema.table("users") as blueprint: - blueprint.drop_unique("users_playlist_id_unique") - - sql = ["ALTER TABLE `users` DROP INDEX users_playlist_id_unique"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_index(self): - with self.schema.table("users") as blueprint: - blueprint.index("playlist_id") - - sql = ["CREATE INDEX users_playlist_id_index ON `users`(playlist_id)"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_index(self): - with self.schema.table("users") as blueprint: - blueprint.drop_index("users_playlist_id_index") - - sql = ["ALTER TABLE `users` DROP INDEX users_playlist_id_index"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_primary(self): - with self.schema.table("users") as blueprint: - blueprint.primary("playlist_id") - - sql = ["ALTER TABLE `users` ADD CONSTRAINT users_playlist_id_primary PRIMARY KEY (playlist_id)"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_index_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_index(["playlist_id"]) - - sql = ["ALTER TABLE `users` DROP INDEX users_playlist_id_index"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_unique_constraint_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_unique(["playlist_id"]) - - sql = ["ALTER TABLE `users` DROP INDEX users_playlist_id_unique"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_primary(self): - with self.schema.table("users") as blueprint: - blueprint.drop_primary("users_id_primary") - - sql = ["ALTER TABLE `users` DROP INDEX users_id_primary"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_change(self): - with self.schema.table("users") as blueprint: - blueprint.integer("age").change() - blueprint.string("external_type").default("external") - blueprint.integer("gender").nullable().change() - blueprint.string("name") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual(len(blueprint.table.changed_columns), 2) - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE `users` ADD `external_type` VARCHAR(255) NOT NULL DEFAULT 'external', ADD `name` VARCHAR(255) NOT NULL", - "ALTER TABLE `users` MODIFY `age` INT(11) NOT NULL, MODIFY `gender` INT(11) NULL", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_timestamp_alter_add_nullable_column(self): - with self.schema.table("users") as blueprint: - blueprint.timestamp("due_date").nullable() - - self.assertEqual(len(blueprint.table.added_columns), 1) - - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = ["ALTER TABLE `users` ADD `due_date` TIMESTAMP NULL"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_drop_add_and_change(self): - with self.schema.table("users") as blueprint: - blueprint.integer("age").default(0).change() - blueprint.string("name") - blueprint.drop_column("email") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual(len(blueprint.table.changed_columns), 1) - table = Table("users") - table.add_column("age", "string") - table.add_column("email", "string") - - blueprint.table.from_table = table - - sql = [ - "ALTER TABLE `users` ADD `name` VARCHAR(255) NOT NULL", - "ALTER TABLE `users` MODIFY `age` INT(11) NOT NULL DEFAULT 0", - "ALTER TABLE `users` DROP COLUMN `email`", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_create_indexes(self): - with self.schema.table("users") as blueprint: - blueprint.index("name") - blueprint.index(["name", "email"]) - blueprint.unique("name") - blueprint.unique("name", name="table_unique") - blueprint.unique(["name", "email"]) - blueprint.fulltext("description") - - self.assertEqual(len(blueprint.table.added_columns), 0) - print(blueprint.to_sql()) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE INDEX users_name_index ON `users`(name)", - "CREATE INDEX users_name_email_index ON `users`(name,email)", - "ALTER TABLE `users` ADD CONSTRAINT UNIQUE INDEX users_name_unique(name)", - "ALTER TABLE `users` ADD CONSTRAINT UNIQUE INDEX table_unique(name)", - "ALTER TABLE `users` ADD CONSTRAINT UNIQUE INDEX users_name_email_unique(name,email)", - "ALTER TABLE `users` ADD FULLTEXT description_fulltext(description)", - ], - ) - - def test_can_add_column_enum(self): - with self.schema.table("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = ["ALTER TABLE `users` ADD `status` ENUM('active', 'inactive') NOT NULL DEFAULT 'active'"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_change_column_enum(self): - with self.schema.table("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active").change() - - self.assertEqual(len(blueprint.table.changed_columns), 1) - - sql = ["ALTER TABLE `users` MODIFY `status` ENUM('active', 'inactive') NOT NULL DEFAULT 'active'"] - - self.assertEqual(blueprint.to_sql(), sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_global_scopes.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_global_scopes.py deleted file mode 100644 index 0d881582..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_global_scopes.py +++ /dev/null @@ -1,38 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.scopes import ( - SoftDeletesMixin, -) - - -class UserSoft(Model, SoftDeletesMixin): - __dry__ = True - - -class User(Model): - __dry__ = True - - -class TestMySQLGlobalScopes(unittest.TestCase): - def test_can_use_global_scopes_on_select(self): - sql = "SELECT * FROM `user_softs` WHERE `user_softs`.`name` = 'joe' AND `user_softs`.`deleted_at` IS NULL" - self.assertEqual(sql, UserSoft.where("name", "joe").to_sql()) - - # def test_can_use_global_scopes_on_delete(self): - # sql = "UPDATE `users` SET `users`.`deleted_at` = 'now' WHERE `users`.`name` = 'joe'" - # self.assertEqual( - # sql, - # User.apply_scope(SoftDeletes) - # .where("name", "joe") - # .delete(query=True) - # .to_sql(), - # ) - - def test_can_use_global_scopes_on_time(self): - sql = "INSERT INTO `users` (`users`.`name`, `users`.`updated_at`, `users`.`created_at`) VALUES ('Joe'" - self.assertTrue(User.create({"name": "Joe"}, query=True).to_sql().startswith(sql)) - - # def test_can_use_global_scopes_on_inherit(self): - # sql = "SELECT * FROM `user_softs` WHERE `user_softs`.`deleted_at` IS NULL" - # self.assertEqual(sql, UserSoft.all(query=True)) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_scopes.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_scopes.py deleted file mode 100644 index 82f50a15..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_can_use_scopes.py +++ /dev/null @@ -1,39 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.scopes import SoftDeletesMixin, scope -from tests.User import User - - -class User(Model): - __dry__ = True - - @scope - def active(self, query, status): - return query.where("active", status) - - @scope - def gender(self, query, status): - return query.where("gender", status) - - -class UserSoft(Model, SoftDeletesMixin): - __dry__ = True - - -class TestMySQLScopes(unittest.TestCase): - def test_can_get_sql(self): - sql = "SELECT * FROM `users` WHERE `users`.`name` = 'joe'" - self.assertEqual(sql, User.where("name", "joe").to_sql()) - - def test_active_scope(self): - sql = "SELECT * FROM `users` WHERE `users`.`name` = 'joe' AND `users`.`active` = '1'" - self.assertEqual(sql, User.where("name", "joe").active(1).to_sql()) - - def test_active_scope_with_params(self): - sql = "SELECT * FROM `users` WHERE `users`.`active` = '2' AND `users`.`name` = 'joe'" - self.assertEqual(sql, User.active(2).where("name", "joe").to_sql()) - - def test_can_chain_scopes(self): - sql = "SELECT * FROM `users` WHERE `users`.`active` = '2' AND `users`.`gender` = 'W' AND `users`.`name` = 'joe'" - self.assertEqual(sql, User.active(2).gender("W").where("name", "joe").to_sql()) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_soft_delete.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_soft_delete.py deleted file mode 100644 index f8289abc..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/mysql/scopes/test_soft_delete.py +++ /dev/null @@ -1,84 +0,0 @@ -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import MySQLGrammar -from src.masoniteorm.scopes import SoftDeleteScope, SoftDeletesMixin -from tests.integrations.config.database import DATABASES -from tests.utils import MockConnectionFactory - - -class UserSoft(Model, SoftDeletesMixin): - __dry__ = True - __table__ = "users" - - -class UserSoftArchived(Model, SoftDeletesMixin): - __dry__ = True - __deleted_at__ = "archived_at" - __table__ = "users" - - -class TestSoftDeleteScope(unittest.TestCase): - def get_builder(self, table="users"): - connection = MockConnectionFactory().make("default") - return QueryBuilder( - grammar=MySQLGrammar, - connection_class=connection, - connection="mysql", - table=table, - connection_details=DATABASES, - dry=True, - ) - - def test_with_trashed(self): - sql = "SELECT * FROM `users`" - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - self.assertEqual(sql, builder.with_trashed().to_sql()) - - def test_force_delete(self): - sql = "DELETE FROM `users`" - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - self.assertEqual(sql, builder.force_delete(query=True).to_sql()) - - def test_restore(self): - sql = "UPDATE `users` SET `users`.`deleted_at` = 'None'" - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - self.assertEqual(sql, builder.restore().to_sql()) - - def test_force_delete_with_wheres(self): - sql = "DELETE FROM `users` WHERE `users`.`active` = '1'" - self.assertEqual(sql, UserSoft.where("active", 1).force_delete(query=True).to_sql()) - - def test_that_trashed_users_are_not_returned_by_default(self): - sql = "SELECT * FROM `users` WHERE `users`.`deleted_at` IS NULL" - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - self.assertEqual(sql, builder.to_sql()) - - def test_only_trashed(self): - sql = "SELECT * FROM `users` WHERE `users`.`deleted_at` IS NOT NULL" - builder = self.get_builder().set_global_scope(SoftDeleteScope()) - self.assertEqual(sql, builder.only_trashed().to_sql()) - - def test_only_trashed_on_model(self): - sql = "SELECT * FROM `users` WHERE `users`.`deleted_at` IS NOT NULL" - self.assertEqual(sql, UserSoft.only_trashed().to_sql()) - - def test_can_change_column(self): - sql = "SELECT * FROM `users` WHERE `users`.`archived_at` IS NOT NULL" - self.assertEqual(sql, UserSoftArchived.only_trashed().to_sql()) - - def test_find_with_global_scope(self): - find_sql = UserSoft.find("1", query=True).to_sql() - raw_sql = """SELECT * FROM `users` WHERE `users`.`id` = '1' AND `users`.`deleted_at` IS NULL""" - self.assertEqual(find_sql, raw_sql) - - def test_find_with_trashed_scope(self): - find_sql = UserSoft.with_trashed().find("1", query=True).to_sql() - raw_sql = """SELECT * FROM `users` WHERE `users`.`id` = '1'""" - self.assertEqual(find_sql, raw_sql) - - def test_find_with_only_trashed_scope(self): - find_sql = UserSoft.only_trashed().find("1", query=True).to_sql() - raw_sql = """SELECT * FROM `users` WHERE `users`.`deleted_at` IS NOT NULL AND `users`.`id` = '1'""" - self.assertEqual(find_sql, raw_sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_query_builder.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_query_builder.py deleted file mode 100644 index d77f82d4..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_query_builder.py +++ /dev/null @@ -1,701 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import PostgresGrammar -from tests.utils import MockConnectionFactory - - -class MockConnection: - connection_details = {} - - def make_connection(self): - return self - - @classmethod - def get_default_query_grammar(cls): - return - - -class ModelTest(Model): - __timestamps__ = False - - -class BaseTestQueryBuilder: - def get_builder(self, table="users", dry=True): - connection = MockConnectionFactory().make("postgres") - return QueryBuilder( - self.grammar, - connection_class=connection, - connection="postgres", - table=table, - model=ModelTest(), - dry=dry, - ) - - def test_sum(self): - builder = self.get_builder() - builder.sum("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_like(self): - builder = self.get_builder() - builder.where("age", "like", "%name%") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_like(self): - builder = self.get_builder() - builder.where("age", "not like", "%name%") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_max(self): - builder = self.get_builder() - builder.max("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_min(self): - builder = self.get_builder() - builder.min("age") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_avg(self): - builder = self.get_builder() - builder.avg("age") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_all(self): - builder = self.get_builder() - builder.all() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_get(self): - builder = self.get_builder() - builder.get() - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_first(self): - builder = self.get_builder().first(query=True) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_select(self): - builder = self.get_builder() - builder.select("name", "email") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_add_select_no_table(self): - builder = self.get_builder(table=None) - sql = ( - builder.add_select( - "other_test", - lambda q: q.max("updated_at").table("different_table"), - ) - .add_select( - "some_alias", - lambda q: q.max("updated_at").table("another_table"), - ) - .to_sql() - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_select_raw(self): - builder = self.get_builder() - builder.select_raw("count(email) as email_count") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_create(self): - builder = self.get_builder().without_global_scopes() - builder.create( - {"name": "Corentin All", "email": "corentin@yopmail.com"}, - query=True, - ) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_delete(self): - builder = self.get_builder() - builder.delete("name", "Joe", query=True) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where(self): - builder = self.get_builder() - builder.where("name", "Joe") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_exists(self): - builder = self.get_builder() - builder.where_exists("name") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_limit(self): - builder = self.get_builder() - builder.limit(5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_offset(self): - builder = self.get_builder() - builder.offset(5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_join(self): - builder = self.get_builder() - builder.join("profiles", "users.id", "=", "profiles.user_id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_left_join(self): - builder = self.get_builder() - builder.left_join("profiles", "users.id", "=", "profiles.user_id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_right_join(self): - builder = self.get_builder() - builder.right_join("profiles", "users.id", "=", "profiles.user_id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_update(self): - builder = self.get_builder().update({"name": "Joe", "email": "joe@yopmail.com"}, dry=True) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - # def test_increment(self): - # builder = self.get_builder() - # builder.increment("age", 1) - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(builder.to_sql(), sql) - - # def test_decrement(self): - # builder = self.get_builder() - # builder.decrement("age", 1) - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(builder.to_sql(), sql) - - def test_count(self): - builder = self.get_builder() - builder.count("id") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_order_by_asc(self): - builder = self.get_builder() - builder.order_by("email", "asc") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_order_by_desc(self): - builder = self.get_builder() - builder.order_by("email", "desc") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_column(self): - builder = self.get_builder() - builder.where_column("name", "username") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_in(self): - builder = self.get_builder() - builder.where_not_in("id", [1, 2, 3]) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_between(self): - builder = self.get_builder() - builder.between("id", 2, 5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_not_between(self): - builder = self.get_builder() - builder.not_between("id", 2, 5) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_in(self): - builder = self.get_builder() - builder.where_in("id", [1, 2, 3]) - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_null(self): - builder = self.get_builder() - builder.where_null("name") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_not_null(self): - builder = self.get_builder() - builder.where_not_null("name") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_having(self): - builder = self.get_builder(table="payments") - builder.select("user_id").avg("salary").group_by("user_id").having("salary", ">=", "1000") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_group_by(self): - builder = self.get_builder(table="payments") - builder.select("user_id").min("salary").group_by("user_id") - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_builder_alone(self): - self.assertTrue( - QueryBuilder( - connection_class=MockConnection, - connection="postgres", - connection_details={ - "default": "postgres", - "postgres": { - "driver": "postgres", - "host": "localhost", - "user": "postgres", - "password": "postgres", - "database": "orm", - "port": "5432", - "prefix": "", - "grammar": "postgres", - }, - }, - ).table("users") - ) - - def test_where_lt(self): - builder = self.get_builder() - builder.where("age", "<", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_lte(self): - builder = self.get_builder() - builder.where("age", "<=", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_gt(self): - builder = self.get_builder() - builder.where("age", ">", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_gte(self): - builder = self.get_builder() - builder.where("age", ">=", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_where_ne(self): - builder = self.get_builder() - builder.where("age", "!=", "20") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_or_where(self): - builder = self.get_builder() - builder.where("age", "20").or_where("age", "<", 20) - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_can_call_with_schema(self): - builder = self.get_builder() - sql = builder.table("information_schema.columns").select("table_name").where("table_name", "users").to_sql() - self.assertEqual( - sql, - """SELECT "information_schema"."columns"."table_name" FROM "information_schema"."columns" WHERE "information_schema"."columns"."table_name" = 'users'""", - ) - - def test_truncate(self): - builder = self.get_builder(dry=True) - sql = builder.truncate() - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - def test_truncate_without_foreign_keys(self): - builder = self.get_builder(dry=True) - sql = builder.truncate(foreign_keys=True) - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - def test_shared_lock(self): - builder = self.get_builder(dry=True) - sql = builder.where("votes", ">=", 100).shared_lock().to_sql() - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - def test_update_lock(self): - builder = self.get_builder(dry=True) - sql = builder.where("votes", ">=", 100).lock_for_update().to_sql() - sql_ref = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(sql, sql_ref) - - -class PostgresQueryBuilderTest(BaseTestQueryBuilder, unittest.TestCase): - grammar = PostgresGrammar - - def sum(self): - """ - builder = self.get_builder() - builder.sum('age') - """ - return """SELECT SUM("users"."age") AS age FROM "users\"""" - - def max(self): - """ - builder = self.get_builder() - builder.max('age') - """ - return """SELECT MAX("users"."age") AS age FROM "users\"""" - - def min(self): - """ - builder = self.get_builder() - builder.min('age') - """ - return """SELECT MIN("users"."age") AS age FROM "users\"""" - - def avg(self): - """ - builder = self.get_builder() - builder.avg('age') - """ - return """SELECT AVG("users"."age") AS age FROM "users\"""" - - def first(self): - """ - builder = self.get_builder() - builder.first() - """ - return """SELECT * FROM "users" LIMIT 1""" - - def all(self): - """ - builder = self.get_builder() - builder.all() - """ - return """SELECT * FROM "users\"""" - - def get(self): - """ - builder = self.get_builder() - builder.get() - """ - return """SELECT * FROM "users\"""" - - def select(self): - """ - builder = self.get_builder() - builder.select('name', 'email') - """ - return """SELECT "users"."name", "users"."email" FROM "users\"""" - - def add_select_no_table(self): - """ - builder = self.get_builder() - builder.select('name', 'email') - """ - return ( - "SELECT " - '(SELECT MAX("different_table"."updated_at") AS updated_at FROM "different_table") AS other_test, ' - '(SELECT MAX("another_table"."updated_at") AS updated_at FROM "another_table") AS some_alias' - ) - - def select_raw(self): - """ - builder = self.get_builder() - builder.select_raw('count(email) as email_count') - """ - return """SELECT count(email) as email_count FROM "users\"""" - - def create(self): - """ - builder = get_builder() - builder.create({"name": "Corentin All", 'email': 'corentin@yopmail.com'}) - """ - return """INSERT INTO "users" ("name", "email") VALUES ('Corentin All', 'corentin@yopmail.com') RETURNING *""" - - def delete(self): - """ - builder = get_builder() - builder.delete("name', 'Joe') - """ - return """DELETE FROM "users" WHERE "users"."name" = 'Joe'""" - - def where(self): - """ - builder = get_builder() - builder.where('name', 'Joe') - """ - return """SELECT * FROM "users" WHERE "users"."name" = 'Joe'""" - - def where_exists(self): - """ - builder = get_builder() - builder.where_exists('name') - """ - return """SELECT * FROM "users" WHERE EXISTS 'name'""" - - def limit(self): - """ - builder = get_builder() - builder.limit(5) - """ - return """SELECT * FROM "users" LIMIT 5""" - - def offset(self): - """ - builder = get_builder() - builder.offset(5) - """ - return """SELECT * FROM "users" OFFSET 5""" - - def join(self): - """ - builder.join("profiles", "users.id", "=", "profiles.user_id") - """ - return """SELECT * FROM "users" INNER JOIN "profiles" ON "users"."id" = "profiles"."user_id\"""" - - def left_join(self): - """ - builder.left_join("profiles", "users.id", "=", "profiles.user_id") - """ - return """SELECT * FROM "users" LEFT JOIN "profiles" ON "users"."id" = "profiles"."user_id\"""" - - def right_join(self): - """ - builder.right_join("profiles", "users.id", "=", "profiles.user_id") - """ - return """SELECT * FROM "users" RIGHT JOIN "profiles" ON "users"."id" = "profiles"."user_id\"""" - - def update(self): - """ - builder.update({"name": "Joe", "email": "joe@yopmail.com"}) - """ - return """UPDATE "users" SET "name" = 'Joe', "email" = 'joe@yopmail.com'""" - - def increment(self): - """ - builder.increment('age', 1) - """ - return """UPDATE "users" SET "age" = "age" + '1'""" - - def decrement(self): - """ - builder.decrement('age', 1) - """ - return """UPDATE "users" SET "age" = "age" - '1'""" - - def count(self): - """ - builder.count(id) - """ - return """SELECT COUNT("users"."id") AS id FROM "users\"""" - - def order_by_asc(self): - """ - builder.order_by('email', 'asc') - """ - return """SELECT * FROM "users" ORDER BY "email" ASC""" - - def order_by_desc(self): - """ - builder.order_by('email', 'des') - """ - return """SELECT * FROM "users" ORDER BY "email" DESC""" - - def where_column(self): - """ - builder.where_column('name', 'username') - """ - return """SELECT * FROM "users" WHERE "users"."name" = "users"."username\"""" - - def where_null(self): - """ - builder.where_null('name') - """ - return """SELECT * FROM "users" WHERE "users"."name" IS NULL""" - - def where_not_null(self): - """ - builder.where_null('name') - """ - return """SELECT * FROM "users" WHERE "users"."name" IS NOT NULL""" - - def where_not_in(self): - """ - builder.where_not_in('id', [1, 2, 3]) - """ - return """SELECT * FROM "users" WHERE "users"."id" NOT IN ('1','2','3')""" - - def where_in(self): - """ - builder.where_in('id', [1, 2, 3]) - """ - return """SELECT * FROM "users" WHERE "users"."id" IN ('1','2','3')""" - - def between(self): - """ - builder.between('id', 2, 5) - """ - return """SELECT * FROM "users" WHERE "users"."id" BETWEEN '2' AND '5'""" - - def not_between(self): - """ - builder.not_between('id', 2, 5) - """ - return """SELECT * FROM "users" WHERE "users"."id" NOT BETWEEN '2' AND '5'""" - - def having(self): - """ - builder.select('user_id').avg('salary').group_by('user_id').having('salary', '>=', '1000') - """ - return """SELECT "payments"."user_id", AVG("payments"."salary") AS salary FROM "payments" GROUP BY "payments"."user_id" HAVING "payments"."salary" >= '1000'""" - - def group_by(self): - """ - builder.select('user_id').min('salary').group_by('user_id') - """ - return """SELECT "payments"."user_id", MIN("payments"."salary") AS salary FROM "payments" GROUP BY "payments"."user_id\"""" - - def where_lt(self): - """ - builder = self.get_builder() - builder.where('age', '<', '20') - """ - return """SELECT * FROM "users" WHERE "users"."age" < '20'""" - - def where_lte(self): - """ - builder = self.get_builder() - builder.where('age', '<=', '20') - """ - return """SELECT * FROM "users" WHERE "users"."age" <= '20'""" - - def where_gt(self): - """ - builder = self.get_builder() - builder.where('age', '>', '20') - """ - return """SELECT * FROM "users" WHERE "users"."age" > '20'""" - - def where_gte(self): - """ - builder = self.get_builder() - builder.where('age', '>=', '20') - """ - return """SELECT * FROM "users" WHERE "users"."age" >= '20'""" - - def where_ne(self): - """ - builder = self.get_builder() - builder.where('age', '!=', '20') - """ - return """SELECT * FROM "users" WHERE "users"."age" != '20'""" - - def or_where(self): - """ - builder = self.get_builder() - builder.where('age', '20').or_where('age','<', 20) - """ - return """SELECT * FROM "users" WHERE "users"."age" = '20' OR "users"."age" < '20'""" - - def where_like(self): - """ - builder = self.get_builder() - builder.where("age", "like", "%name%") - """ - return """SELECT * FROM "users" WHERE "users"."age" ILIKE '%name%'""" - - def where_not_like(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%") - """ - return """SELECT * FROM "users" WHERE "users"."age" NOT ILIKE '%name%'""" - - def truncate(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return """TRUNCATE TABLE "users\"""" - - def truncate_without_foreign_keys(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return """TRUNCATE TABLE "users\"""" - - def update_lock(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return """SELECT * FROM "users" WHERE "users"."votes" >= '100' FOR UPDATE""" - - def shared_lock(self): - """ - builder = self.get_builder() - builder.truncate() - """ - return """SELECT * FROM "users" WHERE "users"."votes" >= '100' FOR SHARE""" - - def test_latest(self): - builder = self.get_builder() - builder.latest("email") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def test_oldest(self): - builder = self.get_builder() - builder.oldest("email") - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(builder.to_sql(), sql) - - def oldest(self): - """ - builder.order_by('email', 'asc') - """ - return """SELECT * FROM "users" ORDER BY "email" ASC""" - - def latest(self): - """ - builder.order_by('email', 'des') - """ - return """SELECT * FROM "users" ORDER BY "email" DESC""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_transaction.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_transaction.py deleted file mode 100644 index 2e7eda8b..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/builder/test_postgres_transaction.py +++ /dev/null @@ -1,37 +0,0 @@ -import os -import unittest - -from src.masoniteorm.connections import ConnectionFactory -from src.masoniteorm.models import Model -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import PostgresGrammar -from tests.integrations.config.database import DATABASES - -if os.getenv("RUN_POSTGRES_DATABASE") == "True": - - class User(Model): - __connection__ = "postgres" - __timestamps__ = False - - class BaseTestQueryRelationships(unittest.TestCase): - maxDiff = None - - def get_builder(self, table="users"): - connection = ConnectionFactory().make("postgres") - return QueryBuilder( - grammar=PostgresGrammar, - connection=connection, - table=table, - connection_details=DATABASES, - ).on("postgres") - - def test_transaction(self): - builder = self.get_builder() - builder.begin() - builder.create({"name": "phillip2", "email": "phillip2"}) - # builder.commit() - user = builder.where("name", "phillip2").first() - self.assertEqual(user["name"], "phillip2") - builder.rollback() - user = builder.where("name", "phillip2").first() - self.assertEqual(user, None) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_delete_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_delete_grammar.py deleted file mode 100644 index 3a1b5398..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_delete_grammar.py +++ /dev/null @@ -1,65 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import PostgresGrammar - - -class BaseDeleteGrammarTest: - def setUp(self): - self.builder = QueryBuilder(PostgresGrammar, table="users") - - def test_can_compile_delete(self): - to_sql = self.builder.delete("id", 1, query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_delete_in(self): - to_sql = self.builder.delete("id", [1, 2, 3], query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_delete_with_where(self): - to_sql = self.builder.where("age", 20).where("profile", 1).set_action("delete").delete(query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - -class TestPostgresDeleteGrammar(BaseDeleteGrammarTest, unittest.TestCase): - grammar = "postgres" - - def can_compile_delete(self): - """ - ( - self.builder - .delete('id', 1) - .to_sql() - ) - """ - return """DELETE FROM "users" WHERE "users"."id" = '1'""" - - def can_compile_delete_in(self): - """ - ( - self.builder - .delete('id', 1) - .to_sql() - ) - """ - return """DELETE FROM "users" WHERE "users"."id" IN ('1','2','3')""" - - def can_compile_delete_with_where(self): - """ - ( - self.builder - .where('age', 20) - .where('profile', 1) - .set_action('delete') - .delete() - .to_sql() - ) - """ - return """DELETE FROM "users" WHERE "users"."age" = '20' AND "users"."profile" = '1'""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_insert_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_insert_grammar.py deleted file mode 100644 index 85ec9138..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_insert_grammar.py +++ /dev/null @@ -1,72 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import PostgresGrammar - - -class BaseInsertGrammarTest: - def setUp(self): - self.builder = QueryBuilder(PostgresGrammar, table="users") - - def test_can_compile_insert(self): - to_sql = self.builder.create({"name": "Joe"}, query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_insert_with_keywords(self): - to_sql = self.builder.create(name="Joe", query=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create(self): - to_sql = self.builder.bulk_create( - # These keys are intentionally out of order to show column to value alignment works - [ - {"name": "Joe", "age": 5}, - {"age": 35, "name": "Bill"}, - {"name": "John", "age": 10}, - ], - query=True, - ).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_bulk_create_qmark(self): - to_sql = self.builder.bulk_create([{"name": "Joe"}, {"name": "Bill"}, {"name": "John"}], query=True).to_qmark() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - -class TestPostgresUpdateGrammar(BaseInsertGrammarTest, unittest.TestCase): - grammar = "postgres" - - def can_compile_insert(self): - """ - self.builder.create({ - 'name': 'Joe' - }).to_sql() - """ - return """INSERT INTO "users" ("name") VALUES ('Joe') RETURNING *""" - - def can_compile_insert_with_keywords(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return """INSERT INTO "users" ("name") VALUES ('Joe') RETURNING *""" - - def can_compile_bulk_create(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return """INSERT INTO "users" ("age", "name") VALUES ('5', 'Joe'), ('35', 'Bill'), ('10', 'John') RETURNING *""" - - def can_compile_bulk_create_qmark(self): - """ - self.builder.create(name="Joe").to_sql() - """ - return """INSERT INTO "users" ("name") VALUES (?), (?), (?) RETURNING *""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_select_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_select_grammar.py deleted file mode 100644 index 81e7bda8..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_select_grammar.py +++ /dev/null @@ -1,496 +0,0 @@ -import unittest - -from src.masoniteorm.query.grammars import PostgresGrammar -from src.masoniteorm.testing import BaseTestCaseSelectGrammar - - -class TestPostgresGrammar(BaseTestCaseSelectGrammar, unittest.TestCase): - grammar = PostgresGrammar - - def can_compile_select(self): - """ - self.builder.to_sql() - """ - return """SELECT * FROM "users\"""" - - def can_compile_with_columns(self): - """ - self.builder.select('username', 'password').to_sql() - """ - return """SELECT "users"."username", "users"."password" FROM "users\"""" - - def can_compile_with_where(self): - """ - self.builder.select('username', 'password').where('id', 1).to_sql() - """ - return """SELECT "users"."username", "users"."password" FROM "users" WHERE "users"."id" = '1'""" - - def can_compile_with_several_where(self): - """ - self.builder.select('username', 'password').where('id', 1).where('username', 'joe').to_sql() - """ - return """SELECT "users"."username", "users"."password" FROM "users" WHERE "users"."id" = '1' AND "users"."username" = 'joe'""" - - def can_compile_with_several_where_and_limit(self): - """ - self.builder.select('username', 'password').where('id', 1).where('username', 'joe').limit(10).to_sql() - """ - return """SELECT "users"."username", "users"."password" FROM "users" WHERE "users"."id" = '1' AND "users"."username" = 'joe' LIMIT 10""" - - def can_compile_with_sum(self): - """ - self.builder.sum('age').to_sql() - """ - return """SELECT SUM("users"."age") AS age FROM "users\"""" - - def can_compile_with_max(self): - """ - self.builder.max('age').to_sql() - """ - return """SELECT MAX("users"."age") AS age FROM "users\"""" - - def can_compile_with_max_and_columns(self): - """ - self.builder.select('username').max('age').to_sql() - """ - return """SELECT "users"."username", MAX("users"."age") AS age FROM "users\"""" - - def can_compile_with_max_and_columns_different_order(self): - """ - self.builder.max('age').select('username').to_sql() - """ - return """SELECT "users"."username", MAX("users"."age") AS age FROM "users\"""" - - def can_compile_with_order_by(self): - """ - self.builder.select('username').order_by('age', 'desc').to_sql() - """ - return """SELECT "users"."username" FROM "users" ORDER BY "age" DESC""" - - def can_compile_with_multiple_order_by(self): - """ - self.builder.select('username').order_by('age', 'desc').order_by('name').to_sql() - """ - return """SELECT "users"."username" FROM "users" ORDER BY "age" DESC, "name" ASC""" - - def can_compile_with_group_by(self): - """ - self.builder.select('username').group_by('age').to_sql() - """ - return """SELECT "users"."username" FROM "users" GROUP BY "users"."age\"""" - - def can_compile_where_in(self): - """ - self.builder.select('username').where_in('age', [1,2,3]).to_sql() - """ - return """SELECT "users"."username" FROM "users" WHERE "users"."age" IN ('1','2','3')""" - - def can_compile_where_in_empty(self): - """ - self.builder.where_in('age', []).to_sql() - """ - return """SELECT * FROM "users" WHERE 0 = 1""" - - def can_compile_where_not_in(self): - """ - self.builder.select('username').where_not_in('age', [1,2,3]).to_sql() - """ - return """SELECT "users"."username" FROM "users" WHERE "users"."age" NOT IN ('1','2','3')""" - - def can_compile_where_null(self): - """ - self.builder.select('username').where_null('age').to_sql() - """ - return """SELECT "users"."username" FROM "users" WHERE "users"."age" IS NULL""" - - def can_compile_where_not_null(self): - """ - self.builder.select('username').where_not_null('age').to_sql() - """ - return """SELECT "users"."username" FROM "users" WHERE "users"."age" IS NOT NULL""" - - def can_compile_where_raw(self): - """ - self.builder.where_raw(""age" = '18'").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" = '18'""" - - def can_compile_having_raw(self): - """ - self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 18").to_sql() - """ - return """SELECT COUNT(*) as counts FROM "users" HAVING counts > 18""" - - def can_compile_select_raw(self): - """ - self.builder.select_raw("COUNT(*)").to_sql() - """ - return """SELECT COUNT(*) FROM "users\"""" - - def can_compile_limit_and_offset(self): - """ - self.builder.limit(10).offset(10).to_sql() - """ - return """SELECT * FROM "users" LIMIT 10 OFFSET 10""" - - def can_compile_select_raw_with_select(self): - """ - self.builder.select('id').select_raw("COUNT(*)").to_sql() - """ - return """SELECT "users"."id", COUNT(*) FROM "users\"""" - - def can_compile_count(self): - """ - self.builder.count().to_sql() - """ - - return """SELECT COUNT(*) AS m_count_reserved FROM "users\"""" - - def can_compile_count_column(self): - """ - self.builder.count().to_sql() - """ - - return """SELECT COUNT("users"."money") AS money FROM "users\"""" - - def can_compile_where_column(self): - """ - self.builder.where_column('name', 'email').to_sql() - """ - - return """SELECT * FROM "users" WHERE "users"."name" = "users"."email\"""" - - def can_compile_or_where(self): - """ - self.builder.where('name', 2).or_where('name', 3).to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."name" = '2' OR "users"."name" = '3'""" - - def can_grouped_where(self): - """ - self.builder.where(lambda query: query.where('age', 2).where('name', 'Joe')).to_sql() - """ - return """SELECT * FROM "users" WHERE ("users"."age" = '2' AND "users"."name" = 'Joe')""" - - def can_compile_sub_select(self): - """ - self.builder.where_in('name', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age') - ).to_sql() - """ - - return """SELECT * FROM "users" WHERE "users"."name" IN (SELECT "users"."age" FROM "users")""" - - def can_compile_sub_select_from_lambda(self): - """ - self.builder.where_in('name', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age') - ).to_sql() - """ - - return """SELECT * FROM "users" WHERE "users"."name" IN (SELECT "users"."age" FROM "users")""" - - def can_compile_sub_select_where(self): - """ - self.builder.where_in('age', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('age').where('age', 2).where('name', 'Joe') - ).to_sql() - """ - - return """SELECT * FROM "users" WHERE "users"."age" IN (SELECT "users"."age" FROM "users" WHERE "users"."age" = '2' AND "users"."name" = 'Joe')""" - - def can_compile_sub_select_value(self): - """ - self.builder.where('name', - self.builder.new().sum('age') - ).to_sql() - """ - - return """SELECT * FROM "users" WHERE "users"."name" = (SELECT SUM("users"."age") AS age FROM "users")""" - - def can_compile_complex_sub_select(self): - """ - self.builder.where_in('name', - (QueryBuilder(GrammarFactory.make(self.grammar), table='users') - .select('age').where_in('email', - QueryBuilder(GrammarFactory.make(self.grammar), table='users').select('email') - )) - ).to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."name" IN (SELECT "users"."age" FROM "users" WHERE "users"."email" IN (SELECT "users"."email" FROM "users"))""" - - def can_compile_exists(self): - """ - self.builder.select('age').where_exists( - self.builder.new().select('username').where('age', 12) - ).to_sql() - """ - return """SELECT "users"."age" FROM "users" WHERE EXISTS (SELECT "users"."username" FROM "users" WHERE "users"."age" = '12')""" - - def can_compile_not_exists(self): - """ - self.builder.select('age').where_not_exists( - self.builder.new().select('username').where('age', 12) - ).to_sql() - """ - return """SELECT "users"."age" FROM "users" WHERE NOT EXISTS (SELECT "users"."username" FROM "users" WHERE "users"."age" = '12')""" - - def can_compile_having(self): - """ - builder.sum('age').group_by('age').having('age').to_sql() - """ - return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age\"""" - - def can_compile_having_order(self): - """ - builder.sum('age').group_by('age').having('age').order_by('age', 'desc').to_sql() - """ - return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age" ORDER "users"."age" DESC""" - - def can_compile_having_with_expression(self): - """ - builder.sum('age').group_by('age').having('age', 10).to_sql() - """ - return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age" = '10'""" - - def can_compile_order_by_and_first(self): - """ - self.builder.order_by('id', 'asc').first() - """ - return """SELECT * FROM "users" ORDER BY "id" ASC LIMIT 1""" - - def can_compile_having_with_greater_than_expression(self): - """ - builder.sum('age').group_by('age').having('age', '>', 10).to_sql() - """ - return """SELECT SUM("users"."age") AS age FROM "users" GROUP BY "users"."age" HAVING "users"."age" > '10'""" - - def can_compile_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "contacts" ON "users"."id" = "contacts"."user_id\"""" - - def can_compile_left_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return """SELECT * FROM "users" LEFT JOIN "contacts" ON "users"."id" = "contacts"."user_id\"""" - - def can_compile_multiple_join(self): - """ - builder.join('contacts', 'users.id', '=', 'contacts.user_id').to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "contacts" ON "users"."id" = "contacts"."user_id" INNER JOIN "posts" ON "comments"."post_id" = "posts"."id\"""" - - def can_compile_between(self): - """ - builder.between('age', 18, 21).to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" BETWEEN '18' AND '21'""" - - def can_compile_not_between(self): - """ - builder.not_between('age', 18, 21).to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" NOT BETWEEN '18' AND '21'""" - - def test_can_compile_where_raw(self): - to_sql = self.builder.where_raw(""" "age" = '18'""").to_sql() - self.assertEqual(to_sql, """SELECT * FROM "users" WHERE "age" = '18'""") - - def test_can_compile_having_raw(self): - to_sql = self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 10").to_sql() - self.assertEqual( - to_sql, - """SELECT COUNT(*) as counts FROM "users" HAVING counts > 10""", - ) - - def test_can_compile_having_raw_order(self): - to_sql = ( - self.builder.select_raw("COUNT(*) as counts").having_raw("counts > 10").order_by_raw("counts DESC").to_sql() - ) - self.assertEqual( - to_sql, - """SELECT COUNT(*) as counts FROM "users" HAVING counts > 10 ORDER BY counts DESC""", - ) - - def test_can_compile_where_raw_and_where_with_multiple_bindings(self): - query = self.builder.where_raw(""" "age" = ? AND "is_admin" = ?""", [18, True]).where( - "email", "test@example.com" - ) - self.assertEqual( - query.to_qmark(), - """SELECT * FROM "users" WHERE "age" = ? AND "is_admin" = ? AND "users"."email" = ?""", - ) - self.assertEqual(query._bindings, [18, True, "test@example.com"]) - - def test_can_compile_select_raw(self): - to_sql = self.builder.select_raw("COUNT(*)").to_sql() - self.assertEqual(to_sql, """SELECT COUNT(*) FROM "users\"""") - - def test_can_compile_select_raw_with_select(self): - to_sql = self.builder.select("id").select_raw("COUNT(*)").to_sql() - self.assertEqual(to_sql, """SELECT "users"."id", COUNT(*) FROM "users\"""") - - def can_compile_first_or_fail(self): - """ - builder = self.get_builder() - builder.where("is_admin", "=", True).first_or_fail() - """ - return """SELECT * FROM "users" WHERE "users"."is_admin" IS True LIMIT 1""" - - def where_not_like(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" NOT ILIKE '%name%'""" - - def where_like(self): - """ - builder = self.get_builder() - builder.where("age", "like", "%name%").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" ILIKE '%name%'""" - - def where_regexp(self): - """ - builder = self.get_builder() - builder.where("age", "regexp", "Joe").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" REGEXP 'Joe'""" - - def where_not_regexp(self): - """ - builder = self.get_builder() - builder.where("age", "regexp", "Joe").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."age" NOT REGEXP 'Joe'""" - - def can_compile_join_clause(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on("bgt.fund", "=", "rg.fund") - .on_value("bgt.active", "=", "1") - .or_on_value("bgt.acct", "=", "1234") - ) - builder.join(clause).to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" AND "bgt"."dept" = "rg"."dept" AND "bgt"."acct" = "rg"."acct" AND "bgt"."sub" = "rg"."sub\"""" - - def can_compile_join_clause_with_value(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_value("bgt.active", "=", "1") - .or_on_value("bgt.acct", "=", "1234") - ) - builder.join(clause).to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "bgt"."active" = '1' OR "bgt"."acct" = '1234'""" - - def can_compile_join_clause_with_null(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_null("bgt.acct") - .or_on_null("bgt.dept") - .on_value("rg.abc", 10) - ) - builder.join(clause).to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "acct" IS NULL OR "dept" IS NULL AND "rg"."abc" = '10'""" - - def can_compile_join_clause_with_not_null(self): - """ - builder = self.get_builder() - clause = ( - JoinClause("report_groups as rg") - .on_not_null("bgt.acct") - .or_on_not_null("bgt.dept") - .on_value("rg.abc", 10) - ) - builder.join(clause).to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "acct" IS NOT NULL OR "dept" IS NOT NULL AND "rg"."abc" = '10'""" - - def can_compile_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .on_null("bgt") - ), - ).to_sql() - """ - return """SELECT * FROM "users" INNER JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" AND "bgt" IS NULL""" - - def can_compile_left_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.left_join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .or_on_null("bgt") - ), - ).to_sql() - """ - return ( - """SELECT * FROM "users" LEFT JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" OR "bgt" IS NULL""" - ) - - def can_compile_right_join_clause_with_lambda(self): - """ - builder = self.get_builder() - builder.right_join( - "report_groups as rg", - lambda clause: ( - clause.on("bgt.fund", "=", "rg.fund") - .or_on_null("bgt") - ), - ).to_sql() - """ - return """SELECT * FROM "users" RIGHT JOIN "report_groups" AS "rg" ON "bgt"."fund" = "rg"."fund" OR "bgt" IS NULL""" - - def shared_lock(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."votes" >= '100' FOR SHARE""" - - def update_lock(self): - """ - builder = self.get_builder() - builder.where("age", "not like", "%name%").to_sql() - """ - return """SELECT * FROM "users" WHERE "users"."votes" >= '100' FOR UPDATE""" - - def can_user_where_raw_and_where(self): - """ - builder.where_raw("`age` = '18'").where("name", "=", "James").to_sql() - """ - return """SELECT * FROM "users" WHERE age = '18' AND "users"."name" = 'James'""" - - def where_exists_with_lambda(self): - return """SELECT * FROM "users" WHERE EXISTS (SELECT * FROM "users" WHERE "users"."age" = '1')""" - - def where_not_exists_with_lambda(self): - return """SELECT * FROM "users" WHERE NOT EXISTS (SELECT * FROM "users" WHERE "users"."age" = '1')""" - - def where_date(self): - return """SELECT * FROM "users" WHERE DATE("users"."created_at") = '2022-06-01'""" - - def or_where_null(self): - return """SELECT * FROM "users" WHERE "users"."column1" IS NULL OR "users"."column2" IS NULL""" - - def select_distinct(self): - return """SELECT DISTINCT "users"."group" FROM "users\"""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_update_grammar.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_update_grammar.py deleted file mode 100644 index a2c8a546..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/grammar/test_update_grammar.py +++ /dev/null @@ -1,107 +0,0 @@ -import inspect -import unittest - -from src.masoniteorm.connections import PostgresConnection -from src.masoniteorm.query import QueryBuilder -from src.masoniteorm.query.grammars import PostgresGrammar -from src.masoniteorm.expressions import Raw - - -class BaseTestCaseUpdateGrammar: - def setUp(self): - self.builder = QueryBuilder(PostgresGrammar, connection_class=PostgresConnection, table="users") - - def test_can_compile_update(self): - to_sql = self.builder.where("name", "bob").update({"name": "Joe"}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_multiple_update(self): - to_sql = self.builder.update({"name": "Joe", "email": "user@email.com"}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - def test_can_compile_update_with_multiple_where(self): - to_sql = self.builder.where("name", "bob").where("age", 20).update({"name": "Joe"}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - self.assertEqual(to_sql, sql) - - # def test_can_compile_increment(self): - # to_sql = self.builder.increment("age").to_sql() - - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(to_sql, sql) - - # def test_can_compile_decrement(self): - # to_sql = self.builder.decrement("age", 20).to_sql() - - # sql = getattr( - # self, inspect.currentframe().f_code.co_name.replace("test_", "") - # )() - # self.assertEqual(to_sql, sql) - - def test_raw_expression(self): - to_sql = self.builder.update({"name": Raw('"username"')}, dry=True).to_sql() - - sql = getattr(self, inspect.currentframe().f_code.co_name.replace("test_", ""))() - - self.assertEqual(to_sql, sql) - - def test_update_null(self): - to_sql = self.builder.update({"name": None}, dry=True).to_sql() - print(to_sql) - - sql = """UPDATE "users" SET "name" = \'None\'""" - - self.assertEqual(to_sql, sql) - - -class TestPostgresUpdateGrammar(BaseTestCaseUpdateGrammar, unittest.TestCase): - grammar = "postgres" - - def can_compile_update(self): - """ - builder.where('name', 'bob').update({ - 'name': 'Joe' - }).to_sql() - """ - return """UPDATE "users" SET "name" = 'Joe' WHERE "name" = 'bob'""" - - def raw_expression(self): - """ - builder.where('name', 'bob').update({ - 'name': 'Joe' - }).to_sql() - """ - return """UPDATE "users" SET "name" = "username\"""" - - def can_compile_multiple_update(self): - """ - self.builder.update({"name": "Joe", "email": "user@email.com"}, dry=True).to_sql() - """ - return """UPDATE "users" SET "name" = 'Joe', "email" = 'user@email.com'""" - - def can_compile_update_with_multiple_where(self): - """ - builder.where('name', 'bob').where('age', 20).update({ - 'name': 'Joe' - }).to_sql() - """ - return """UPDATE "users" SET "name" = 'Joe' WHERE "name" = 'bob' AND "age" = '20'""" - - def can_compile_increment(self): - """ - builder.increment('age').to_sql() - """ - return """UPDATE "users" SET "age" = "age" + '1'""" - - def can_compile_decrement(self): - """ - builder.decrement('age', 20).to_sql() - """ - return """UPDATE "users" SET "age" = "age" - '20'""" diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/relationships/test_postgres_relationships.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/relationships/test_postgres_relationships.py deleted file mode 100644 index 023fd536..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/relationships/test_postgres_relationships.py +++ /dev/null @@ -1,131 +0,0 @@ -import os -import unittest - -from src.masoniteorm.models import Model -from src.masoniteorm.relationships import belongs_to, has_many - -if os.getenv("RUN_POSTGRES_DATABASE", False) == "True": - - class Profile(Model): - __table__ = "profiles" - __connection__ = "postgres" - - class Articles(Model): - __table__ = "articles" - __connection__ = "postgres" - - @belongs_to("id", "article_id") - def logo(self): - return Logo - - class Logo(Model): - __table__ = "logos" - __connection__ = "postgres" - - class User(Model): - __connection__ = "postgres" - - _eager_loads = () - - __casts__ = {"is_admin": "bool"} - - @belongs_to("id", "user_id") - def profile(self): - return Profile - - @has_many("id", "user_id") - def articles(self): - return Articles - - def get_is_admin(self): - return "You are an admin" - - class TestRelationships(unittest.TestCase): - maxDiff = None - - def test_relationship_can_be_callable(self): - self.assertEqual( - User.profile().where("name", "Joe").to_sql(), - """SELECT * FROM "profiles" WHERE "profiles"."name" = 'Joe'""", - ) - - def test_can_access_relationship(self): - for user in User.where("id", 1).get(): - self.assertIsInstance(user.profile, Profile) - - def test_can_access_has_many_relationship(self): - user = User.hydrate(User.where("id", 1).first()) - self.assertEqual(len(user.articles), 4) - - def test_can_access_relationship_multiple_times(self): - user = User.hydrate(User.where("id", 1).first()) - self.assertEqual(len(user.articles), 4) - self.assertEqual(len(user.articles), 4) - - def test_loading(self): - users = User.with_("articles").get() - for user in users: - user - - def test_casting(self): - users = User.with_("articles").where("is_admin", True).get() - for user in users: - user - - def test_setting(self): - users = User.with_("articles").where("is_admin", True).get() - for user in users: - user.name = "Joe" - user.is_admin = 1 - user.save() - - def test_relationship_has(self): - to_sql = User.has("articles").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM "users" WHERE EXISTS (""" - """SELECT * FROM "articles" WHERE "articles"."user_id" = "users"."id\"""" - """)""", - ) - - def test_relationship_has_off_builder(self): - to_sql = User.where("active", 1).has("articles").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM "users" WHERE "users"."active" = '1' AND EXISTS (""" - """SELECT * FROM "articles" WHERE "articles"."user_id" = "users"."id\"""" - """)""", - ) - - def test_relationship_multiple_has(self): - to_sql = User.has("articles", "profile").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM "users" WHERE EXISTS (""" - """SELECT * FROM "articles" WHERE "articles"."user_id" = "users"."id\"""" - """) AND EXISTS (""" - """SELECT * FROM "profiles" WHERE "profiles"."user_id" = "users"."id\"""" - """)""", - ) - - count = User.has("articles", "profile").get().count() - self.assertEqual(count, 2) - - def test_nested_has(self): - to_sql = User.has("articles.logo").to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM "users" WHERE EXISTS (SELECT * FROM "articles" WHERE "articles"."user_id" = "users"."id" AND EXISTS (SELECT * FROM "logos" WHERE "logos"."article_id" = "articles"."id"))""", - ) - - count = User.has("articles.logo").get().count() - self.assertEqual(count, 2) - - def test_relationship_where_has(self): - to_sql = User.where_has("articles", lambda q: q.where("status", 1)).to_sql() - self.assertEqual( - to_sql, - """SELECT * FROM "users" WHERE EXISTS (""" - """SELECT * FROM "articles" WHERE "articles"."user_id" = "users"."id" AND "articles"."status" = '1'""" - """)""", - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder.py deleted file mode 100644 index 5a27c3d3..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder.py +++ /dev/null @@ -1,371 +0,0 @@ -import unittest - -from tests.integrations.config.database import DATABASES -from src.masoniteorm.connections import PostgresConnection -from src.masoniteorm.schema import Schema -from src.masoniteorm.schema.platforms import PostgresPlatform - - -class TestPostgresSchemaBuilder(unittest.TestCase): - maxDiff = None - - def setUp(self): - self.schema = Schema( - connection_class=PostgresConnection, - connection="postgres", - connection_details=DATABASES, - platform=PostgresPlatform, - dry=True, - ) - - def test_can_add_columns(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - ['CREATE TABLE "users" ("name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL)'], - ) - - def test_can_add_tiny_text(self): - with self.schema.create("users") as blueprint: - blueprint.tiny_text("description") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual(blueprint.to_sql(), ['CREATE TABLE "users" ("description" TEXT NOT NULL)']) - - def test_can_add_unsigned_decimal(self): - with self.schema.create("users") as blueprint: - blueprint.unsigned_decimal("amount", 19, 4) - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - ['CREATE TABLE "users" ("amount" DECIMAL(19, 4) NOT NULL)'], - ) - - def test_can_create_table_if_not_exists(self): - with self.schema.create_table_if_not_exists("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - ['CREATE TABLE IF NOT EXISTS "users" ("name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL)'], - ) - - def test_can_add_column_comment(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").comment("A users username") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ("name" VARCHAR(255) NOT NULL)', - """COMMENT ON COLUMN "users"."name" is 'A users username'""", - ], - ) - - def test_can_add_table_comment(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.table_comment("A users table") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ("name" VARCHAR(255) NOT NULL)', - """COMMENT ON TABLE "users" is 'A users table'""", - ], - ) - - def test_can_truncate(self): - sql = self.schema.truncate("users") - - self.assertEqual(sql, 'TRUNCATE "users"') - - def test_can_rename_table(self): - sql = self.schema.rename("users", "clients") - - self.assertEqual(sql, 'ALTER TABLE "users" RENAME TO "clients"') - - def test_can_drop_table_if_exists(self): - sql = self.schema.drop_table_if_exists("users", "clients") - - self.assertEqual(sql, 'DROP TABLE IF EXISTS "users"') - - def test_can_drop_table(self): - sql = self.schema.drop_table("users", "clients") - - self.assertEqual(sql, 'DROP TABLE "users"') - - def test_has_column(self): - sql = self.schema.has_column("users", "name") - - self.assertEqual( - sql, - "SELECT column_name FROM information_schema.columns WHERE table_name='users' and column_name='name'", - ) - - def test_can_add_columns_with_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - blueprint.unique("name") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ("name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT users_name_unique UNIQUE (name))' - ], - ) - - def test_can_add_columns_with_long_text(self): - with self.schema.create("users") as blueprint: - blueprint.long_text("description") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual(blueprint.to_sql(), ['CREATE TABLE "users" ("description" TEXT NOT NULL)']) - - def test_can_have_unsigned_columns(self): - with self.schema.create("users") as blueprint: - blueprint.integer("profile_id").unsigned() - blueprint.big_integer("big_profile_id").unsigned() - blueprint.tiny_integer("tiny_profile_id").unsigned() - blueprint.small_integer("small_profile_id").unsigned() - blueprint.medium_integer("medium_profile_id").unsigned() - - self.assertEqual( - blueprint.to_sql(), - [ - """CREATE TABLE "users" (""" - """"profile_id" INTEGER NOT NULL, """ - """"big_profile_id" BIGINT NOT NULL, """ - """"tiny_profile_id" TINYINT NOT NULL, """ - """"small_profile_id" SMALLINT NOT NULL, """ - """"medium_profile_id" MEDIUMINT NOT NULL)""" - ], - ) - - def test_can_add_columns_with_foreign_key_constaint(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.foreign("profile_id").references("id").on("profiles") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ("name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, ' - '"profile_id" INTEGER NOT NULL, CONSTRAINT users_name_unique UNIQUE (name), ' - 'CONSTRAINT users_profile_id_foreign FOREIGN KEY ("profile_id") REFERENCES "profiles"("id"))' - ], - ) - - def test_can_advanced_table_creation(self): - with self.schema.create("users") as blueprint: - blueprint.increments("id") - blueprint.string("name") - blueprint.string("email").unique() - blueprint.string("password") - blueprint.integer("admin").default(0) - blueprint.string("remember_token").nullable() - blueprint.timestamp("verified_at").nullable() - blueprint.timestamps() - - self.assertEqual(len(blueprint.table.added_columns), 9) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ("id" SERIAL UNIQUE NOT NULL, "name" VARCHAR(255) NOT NULL, ' - '"email" VARCHAR(255) NOT NULL, "password" VARCHAR(255) NOT NULL, "admin" INTEGER NOT NULL DEFAULT 0, ' - '"remember_token" VARCHAR(255) NULL, "verified_at" TIMESTAMP NULL, ' - '"created_at" TIMESTAMPTZ NULL DEFAULT CURRENT_TIMESTAMP, "updated_at" TIMESTAMPTZ NULL DEFAULT CURRENT_TIMESTAMP, ' - "CONSTRAINT users_id_primary PRIMARY KEY (id), CONSTRAINT users_email_unique UNIQUE (email))" - ], - ) - - def test_can_advanced_table_creation2(self): - with self.schema.create("users") as blueprint: - blueprint.big_increments("id") - blueprint.string("name") - blueprint.enum("gender", ["male", "female"]) - blueprint.string("duration") - blueprint.decimal("money") - blueprint.string("url") - blueprint.string("option").default("ADMIN") - blueprint.jsonb("payload") - blueprint.inet("last_address").nullable() - blueprint.cidr("route_origin").nullable() - blueprint.macaddr("mac_address").nullable() - blueprint.datetime("published_at") - blueprint.string("thumbnail").nullable() - blueprint.integer("premium") - blueprint.double("amount").default(0.0) - blueprint.integer("author_id").unsigned().nullable() - blueprint.foreign("author_id").references("id").on("authors").on_delete("CASCADE") - blueprint.text("description") - blueprint.timestamps() - - self.assertEqual(len(blueprint.table.added_columns), 19) - self.assertEqual( - blueprint.to_sql(), - ( - [ - """CREATE TABLE "users" ("id" BIGSERIAL UNIQUE NOT NULL, "name" VARCHAR(255) NOT NULL, "gender" VARCHAR(255) CHECK(gender IN ('male', 'female')) NOT NULL, """ - """"duration" VARCHAR(255) NOT NULL, "money" DECIMAL(17, 6) NOT NULL, "url" VARCHAR(255) NOT NULL, "option" VARCHAR(255) NOT NULL DEFAULT 'ADMIN', "payload" JSONB NOT NULL, "last_address" INET NULL, """ - '"route_origin" CIDR NULL, "mac_address" MACADDR NULL, "published_at" TIMESTAMPTZ NOT NULL, "thumbnail" VARCHAR(255) NULL, "premium" INTEGER NOT NULL, "amount" DOUBLE PRECISION NOT NULL DEFAULT 0.0, ' - '"author_id" INTEGER NULL, "description" TEXT NOT NULL, "created_at" TIMESTAMPTZ NULL DEFAULT CURRENT_TIMESTAMP, ' - '"updated_at" TIMESTAMPTZ NULL DEFAULT CURRENT_TIMESTAMP, ' - 'CONSTRAINT users_id_primary PRIMARY KEY (id), CONSTRAINT users_author_id_foreign FOREIGN KEY ("author_id") REFERENCES "authors"("id") ON DELETE CASCADE)' - ] - ), - ) - - def test_can_add_uuid_column(self): - # might not be the right place for this test + other column types - # are not tested => just for testing the PR now - with self.schema.create("users") as table: - table.uuid("id").default_raw("uuid_generate_v4()") - table.primary("id") - table.string("name") - table.uuid("public_id").nullable() - table.uuid("other_id").default_raw("uuid_generate_v4()") - - self.assertEqual(len(table.table.added_columns), 4) - self.assertEqual( - table.to_sql(), - [ - 'CREATE TABLE "users" ("id" UUID NOT NULL DEFAULT uuid_generate_v4(), "name" VARCHAR(255) NOT NULL, "public_id" UUID NULL, "other_id" UUID NOT NULL DEFAULT uuid_generate_v4(), CONSTRAINT users_id_primary PRIMARY KEY (id))' - ], - ) - - def test_can_add_columns_with_foreign_key_constraint_name(self): - with self.schema.create("users") as blueprint: - blueprint.integer("profile_id") - blueprint.foreign("profile_id", name="profile_foreign").references("id").on("profiles") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" (' - '"profile_id" INTEGER NOT NULL, ' - 'CONSTRAINT profile_foreign FOREIGN KEY ("profile_id") REFERENCES "profiles"("id"))' - ], - ) - - def test_can_have_composite_keys(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").unique() - blueprint.integer("age") - blueprint.integer("profile_id") - blueprint.primary(["name", "age"]) - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ' - '("name" VARCHAR(255) NOT NULL, ' - '"age" INTEGER NOT NULL, ' - '"profile_id" INTEGER NOT NULL, ' - "CONSTRAINT users_name_unique UNIQUE (name), " - "CONSTRAINT users_name_age_primary PRIMARY KEY (name, age))" - ], - ) - - def test_can_have_column_primary_key(self): - with self.schema.create("users") as blueprint: - blueprint.string("name").primary() - blueprint.integer("age") - blueprint.integer("profile_id") - - self.assertEqual(len(blueprint.table.added_columns), 3) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE TABLE "users" ' - '("name" VARCHAR(255) NOT NULL, ' - '"age" INTEGER NOT NULL, ' - '"profile_id" INTEGER NOT NULL, ' - "CONSTRAINT users_name_primary PRIMARY KEY (name))" - ], - ) - - def test_can_add_other_integer_types_column(self): - with self.schema.create("integer_types") as table: - table.tiny_integer("tiny") - table.small_integer("small") - table.medium_integer("medium") - table.big_integer("big") - - self.assertEqual(len(table.table.added_columns), 4) - self.assertEqual( - table.to_sql(), - [ - 'CREATE TABLE "integer_types" ("tiny" TINYINT NOT NULL, "small" SMALLINT NOT NULL, "medium" MEDIUMINT NOT NULL, "big" BIGINT NOT NULL)' - ], - ) - - def test_can_add_binary_column(self): - with self.schema.create("binary_storing") as table: - table.binary("filecontent") - - self.assertEqual(len(table.table.added_columns), 1) - self.assertEqual( - table.to_sql(), - ['CREATE TABLE "binary_storing" ("filecontent" BYTEA NOT NULL)'], - ) - - def test_can_have_float_type(self): - with self.schema.create("users") as blueprint: - blueprint.float("amount") - - self.assertEqual( - blueprint.to_sql(), - ["""CREATE TABLE "users" (""" """\"amount" FLOAT(19, 4) NOT NULL)"""], - ) - - def test_can_enable_foreign_keys(self): - sql = self.schema.enable_foreign_key_constraints() - - self.assertEqual(sql, "") - - def test_can_disable_foreign_keys(self): - sql = self.schema.disable_foreign_key_constraints() - - self.assertEqual(sql, "") - - def test_can_truncate_without_foreign_keys(self): - sql = self.schema.truncate("users", foreign_keys=True) - - self.assertEqual( - sql, - [ - 'ALTER TABLE "users" DISABLE TRIGGER ALL', - 'TRUNCATE "users"', - 'ALTER TABLE "users" ENABLE TRIGGER ALL', - ], - ) - - def test_can_add_enum(self): - with self.schema.create("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual( - blueprint.to_sql(), - [ - "CREATE TABLE \"users\" (\"status\" VARCHAR(255) CHECK(status IN ('active', 'inactive')) NOT NULL " - "DEFAULT 'active')" - ], - ) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder_alter.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder_alter.py deleted file mode 100644 index a37e423d..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/postgres/schema/test_postgres_schema_builder_alter.py +++ /dev/null @@ -1,319 +0,0 @@ -import unittest - -from tests.integrations.config.database import DATABASES -from src.masoniteorm.connections import PostgresConnection -from src.masoniteorm.schema import Schema -from src.masoniteorm.schema.platforms import PostgresPlatform -from src.masoniteorm.schema.Table import Table - - -class TestPostgresSchemaBuilderAlter(unittest.TestCase): - maxDiff = None - - def setUp(self): - self.schema = Schema( - connection_class=PostgresConnection, - connection="postgres", - connection_details=DATABASES, - platform=PostgresPlatform, - dry=True, - ).on("postgres") - - def test_can_add_columns(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.integer("age") - - self.assertEqual(len(blueprint.table.added_columns), 2) - - sql = ['ALTER TABLE "users" ADD COLUMN "name" VARCHAR(255) NOT NULL, ADD COLUMN "age" INTEGER NOT NULL'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_add_column_comments(self): - with self.schema.table("users") as blueprint: - blueprint.string("name").comment("A users username") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = [ - 'ALTER TABLE "users" ADD COLUMN "name" VARCHAR(255) NOT NULL', - """COMMENT ON COLUMN "users"."name" is 'A users username'""", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_add_table_comment(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.table_comment("A users table") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = [ - 'ALTER TABLE "users" ADD COLUMN "name" VARCHAR(255) NOT NULL', - """COMMENT ON TABLE "users" is 'A users table'""", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_rename(self): - with self.schema.table("users") as blueprint: - blueprint.rename("post", "comment", "integer") - - table = Table("users") - table.add_column("post", "integer") - blueprint.table.from_table = table - - sql = ['ALTER TABLE "users" RENAME COLUMN "post" TO "comment"'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_and_rename(self): - with self.schema.table("users") as blueprint: - blueprint.string("name") - blueprint.rename("post", "comment", "integer") - - table = Table("users") - table.add_column("post", "integer") - blueprint.table.from_table = table - - sql = [ - 'ALTER TABLE "users" ADD COLUMN "name" VARCHAR(255) NOT NULL', - 'ALTER TABLE "users" RENAME COLUMN "post" TO "comment"', - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop(self): - with self.schema.table("users") as blueprint: - blueprint.drop_column("post") - - sql = ['ALTER TABLE "users" DROP COLUMN "post"'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_column_and_foreign_key(self): - with self.schema.table("users") as blueprint: - blueprint.unsigned_integer("playlist_id").nullable() - blueprint.foreign("playlist_id").references("id").on("playlists").on_delete("cascade") - - sql = [ - 'ALTER TABLE "users" ADD COLUMN "playlist_id" INTEGER NULL', - 'ALTER TABLE "users" ADD CONSTRAINT users_playlist_id_foreign FOREIGN KEY ("playlist_id") REFERENCES "playlists"("id") ON DELETE CASCADE', - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_create_indexes(self): - with self.schema.table("users") as blueprint: - blueprint.index("name") - blueprint.index(["name", "email"]) - blueprint.unique("name") - blueprint.unique(["name", "email"]) - blueprint.fulltext("description") - - self.assertEqual(len(blueprint.table.added_columns), 0) - self.assertEqual( - blueprint.to_sql(), - [ - 'CREATE INDEX users_name_index ON "users"(name)', - 'CREATE INDEX users_name_email_index ON "users"(name,email)', - 'ALTER TABLE "users" ADD CONSTRAINT users_name_unique UNIQUE(name)', - 'ALTER TABLE "users" ADD CONSTRAINT users_name_email_unique UNIQUE(name,email)', - ], - ) - - def test_alter_drop_foreign_key(self): - with self.schema.table("users") as blueprint: - blueprint.drop_foreign("users_playlist_id_foreign") - - sql = ['ALTER TABLE "users" DROP CONSTRAINT users_playlist_id_foreign'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_foreign_key_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_foreign(["playlist_id"]) - - sql = ['ALTER TABLE "users" DROP CONSTRAINT users_playlist_id_foreign'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_unique_constraint(self): - with self.schema.table("users") as blueprint: - blueprint.drop_unique("users_playlist_id_unique") - - sql = ['ALTER TABLE "users" DROP CONSTRAINT users_playlist_id_unique'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_index(self): - with self.schema.table("users") as blueprint: - blueprint.index("playlist_id") - - sql = ['CREATE INDEX users_playlist_id_index ON "users"(playlist_id)'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_add_primary(self): - with self.schema.table("users") as blueprint: - blueprint.primary("playlist_id") - - sql = ['ALTER TABLE "users" ADD CONSTRAINT users_playlist_id_primary PRIMARY KEY (playlist_id)'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_index(self): - with self.schema.table("users") as blueprint: - blueprint.drop_index("users_playlist_id_index") - - sql = ["DROP INDEX users_playlist_id_index"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_index_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_index(["playlist_id"]) - - sql = ["DROP INDEX users_playlist_id_index"] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_primary(self): - with self.schema.table("users") as blueprint: - blueprint.drop_primary("users_id_primary") - - sql = ['ALTER TABLE "users" DROP CONSTRAINT users_id_primary'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_unique_constraint_shortcut(self): - with self.schema.table("users") as blueprint: - blueprint.drop_unique(["playlist_id"]) - - sql = ['ALTER TABLE "users" DROP CONSTRAINT users_playlist_id_unique'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_has_table(self): - schema_sql = self.schema.has_table("users") - - sql = "SELECT * from information_schema.tables where table_name='users' AND table_schema = 'public'" - - self.assertEqual(schema_sql, sql) - - def test_drop_table(self): - schema_sql = self.schema.has_table("users") - - sql = "SELECT * from information_schema.tables where table_name='users' AND table_schema = 'public'" - - self.assertEqual(schema_sql, sql) - - def test_change(self): - with self.schema.table("users") as blueprint: - blueprint.integer("age").change() - blueprint.string("name") - - self.assertEqual(len(blueprint.table.added_columns), 1) - self.assertEqual(len(blueprint.table.changed_columns), 1) - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = [ - 'ALTER TABLE "users" ADD COLUMN "name" VARCHAR(255) NOT NULL', - 'ALTER TABLE "users" ALTER COLUMN "age" TYPE INTEGER, ALTER COLUMN "age" SET NOT NULL', - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_change_string(self): - with self.schema.table("users") as blueprint: - blueprint.string("name", 93).change() - - self.assertEqual(len(blueprint.table.changed_columns), 1) - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = ['ALTER TABLE "users" ALTER COLUMN "name" TYPE VARCHAR(93), ALTER COLUMN "name" SET NOT NULL'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_drop_add_and_change(self): - with self.schema.table("users") as blueprint: - blueprint.integer("age").default(0).nullable().change() - blueprint.string("name") - blueprint.string("external_type").default("external") - blueprint.drop_column("email") - - self.assertEqual(len(blueprint.table.added_columns), 2) - self.assertEqual(len(blueprint.table.changed_columns), 1) - table = Table("users") - table.add_column("age", "string") - table.add_column("email", "string") - - blueprint.table.from_table = table - - sql = [ - """ALTER TABLE "users" ADD COLUMN "name" VARCHAR(255) NOT NULL, ADD COLUMN "external_type" VARCHAR(255) NOT NULL DEFAULT 'external'""", - 'ALTER TABLE "users" DROP COLUMN "email"', - 'ALTER TABLE "users" ALTER COLUMN "age" TYPE INTEGER, ALTER COLUMN "age" DROP NOT NULL, ALTER COLUMN "age" SET DEFAULT 0', - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_timestamp_alter_add_nullable_column(self): - with self.schema.table("users") as blueprint: - blueprint.timestamp("due_date").nullable() - - self.assertEqual(len(blueprint.table.added_columns), 1) - - table = Table("users") - table.add_column("age", "string") - - blueprint.table.from_table = table - - sql = ['ALTER TABLE "users" ADD COLUMN "due_date" TIMESTAMP NULL'] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_alter_drop_on_table_schema_table(self): - schema = Schema( - connection_class=PostgresConnection, - connection="postgres", - connection_details=DATABASES, - ).on("postgres") - - with schema.table("table_schema") as blueprint: - blueprint.drop_column("name") - - with schema.table("table_schema") as blueprint: - blueprint.string("name") - - def test_can_add_column_enum(self): - with self.schema.table("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active") - - self.assertEqual(len(blueprint.table.added_columns), 1) - - sql = [ - "ALTER TABLE \"users\" ADD COLUMN \"status\" VARCHAR(255) CHECK(status IN ('active', 'inactive')) NOT NULL DEFAULT 'active'", - ] - - self.assertEqual(blueprint.to_sql(), sql) - - def test_can_change_column_enum(self): - with self.schema.table("users") as blueprint: - blueprint.enum("status", ["active", "inactive"]).default("active").change() - - self.assertEqual(len(blueprint.table.changed_columns), 1) - - sql = [ - 'ALTER TABLE "users" ALTER COLUMN "status" TYPE VARCHAR(255) CHECK(status IN (\'active\', \'inactive\')), ALTER COLUMN "status" SET NOT NULL, ALTER COLUMN "status" SET DEFAULT active', - ] - - self.assertEqual(blueprint.to_sql(), sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/scopes/test_default_global_scopes.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/scopes/test_default_global_scopes.py deleted file mode 100644 index 0a7b7568..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/scopes/test_default_global_scopes.py +++ /dev/null @@ -1,145 +0,0 @@ -"""Test the default global scopes available in ORM.""" - -import unittest -import uuid - -import pendulum - -from src.masoniteorm.models import Model -from src.masoniteorm.scopes import ( - SoftDeletesMixin, - TimeStampsMixin, - TimeStampsScope, - UUIDPrimaryKeyMixin, - UUIDPrimaryKeyScope, -) - - -class MockBuilder: - def __init__(self, model): - self._model = model() - self._creates = {} - self._updates = {} - - -class UserWithUUID(Model, UUIDPrimaryKeyMixin): - __dry__ = True - - -class UserWithTimeStamps(Model, TimeStampsMixin): - __dry__ = True - - -class UserWithCustomTimeStamps(Model, TimeStampsMixin): - __dry__ = True - date_updated_at = "updated_ts" - date_created_at = "created_ts" - - -class UserSoft(Model, SoftDeletesMixin): - __dry__ = True - - -class TestUUIDPrimaryKeyScope(unittest.TestCase): - def setUp(self): - self.builder = MockBuilder(UserWithUUID) - self.scope = UUIDPrimaryKeyScope() - # reset User attributes before each test - UserWithUUID.__primary_key__ = "id" - flags = { - "__uuid_version__", - "__uuid_namespace__", - "__uuid_name__", - "__uuid_bytes__", - } - for flag in flags: - if hasattr(UserWithUUID, flag): - delattr(UserWithUUID, flag) - - def test_default_to_uuid4(self): - self.scope.set_uuid_create(self.builder) - uuid_value = uuid.UUID(self.builder._creates["id"]) - self.assertEqual(4, uuid_value.version) - - def test_can_set_uuid_version(self): - # required for uuid 3 and 5 - UserWithUUID.__uuid_namespace__ = uuid.NAMESPACE_DNS - UserWithUUID.__uuid_name__ = "domain.com" - for version in [1, 3, 4, 5]: - UserWithUUID.__uuid_version__ = version - self.scope.set_uuid_create(self.builder) - uuid_value = uuid.UUID(self.builder._creates["id"]) - self.assertEqual(version, uuid_value.version) - del self.builder._creates["id"] - - def test_default_to_uuid_str(self): - # Generates UUIDs as strings by default - self.scope.set_uuid_create(self.builder) - self.assertIsInstance(self.builder._creates["id"], str) - - def test_can_set_uuid_bytes(self): - # Generates UUIDs in bytes instead of strings - UserWithUUID.__uuid_bytes__ = True - self.scope.set_uuid_create(self.builder) - self.assertIsInstance(self.builder._creates["id"], bytes) - - def test_works_with_custom_pk_column(self): - UserWithUUID.__primary_key__ = "ref" - self.scope.set_uuid_create(self.builder) - self.assertIn("ref", self.builder._creates) - - -class TestSoftDeletesScope(unittest.TestCase): - def test_soft_deletes_changes_delete_to_update(self): - UserSoft.__timestamps__ = False - user = UserSoft.hydrate({"id": 1}) - sql = user.delete(query=True).to_sql() - self.assertTrue(sql.startswith("UPDATE")) - - -class TestTimeStampsScope(unittest.TestCase): - def setUp(self): - self.builder = MockBuilder(UserWithTimeStamps) - self.scope = TimeStampsScope() - try: - del UserWithTimeStamps.__timestamps__ - except Exception: - pass - - def test_updated_and_created_dates_are_set_when_create(self): - self.scope.set_timestamp_create(self.builder) - self.assertIn("created_at", self.builder._creates) - self.assertIn("updated_at", self.builder._creates) - created_at = pendulum.parse(self.builder._creates["created_at"]) - updated_at = pendulum.parse(self.builder._creates["updated_at"]) - self.assertIsInstance(created_at, pendulum.DateTime) - self.assertIsInstance(updated_at, pendulum.DateTime) - - def test_timestamps_can_be_disabled(self): - UserWithTimeStamps.__timestamps__ = False - self.scope.set_timestamp_create(self.builder) - self.assertNotIn("created_at", self.builder._creates) - self.assertNotIn("updated_at", self.builder._creates) - - def test_uses_custom_timestamp_columns_on_create(self): - self.builder = MockBuilder(UserWithCustomTimeStamps) - self.scope.set_timestamp_create(self.builder) - created_column = UserWithCustomTimeStamps.date_created_at - updated_column = UserWithCustomTimeStamps.date_updated_at - self.assertNotIn("created_at", self.builder._creates) - self.assertNotIn("updated_at", self.builder._creates) - self.assertIn(created_column, self.builder._creates) - self.assertIn(updated_column, self.builder._creates) - self.assertIsInstance( - pendulum.parse(self.builder._creates[created_column]), - pendulum.DateTime, - ) - self.assertIsInstance( - pendulum.parse(self.builder._creates[updated_column]), - pendulum.DateTime, - ) - - def test_uses_custom_updated_column_on_update(self): - user = UserWithCustomTimeStamps.hydrate({"id": 1}) - sql = user.update({"id": 2}).to_sql() - self.assertTrue(UserWithCustomTimeStamps.date_updated_at in sql) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/seeds/test_seeds.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/seeds/test_seeds.py deleted file mode 100644 index cfa11009..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/seeds/test_seeds.py +++ /dev/null @@ -1,12 +0,0 @@ -import unittest - -from databases.seeds.user_table_seeder import UserTableSeeder -from src.masoniteorm.seeds import Seeder - - -class TestSeeds(unittest.TestCase): - def test_can_run_seeds(self): - seeder = Seeder(dry=True) - seeder.call(UserTableSeeder) - - self.assertEqual(seeder.ran_seeds, [UserTableSeeder]) diff --git a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/utils.py b/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/utils.py deleted file mode 100644 index bfb698c3..00000000 --- a/fastapi_startkit/src/fastapi_startkit/masoniteorm.backup/tests/utils.py +++ /dev/null @@ -1,57 +0,0 @@ -from unittest import mock - -from src.masoniteorm.connections.ConnectionFactory import ConnectionFactory -from src.masoniteorm.connections.MySQLConnection import MySQLConnection -from src.masoniteorm.connections.SQLiteConnection import SQLiteConnection -from src.masoniteorm.schema.platforms import MySQLPlatform - - -class MockMySQLConnection(MySQLConnection): - def make_connection(self): - self._connection = mock.MagicMock() - self._cursor = mock.MagicMock() - - return self - - @classmethod - def get_default_platform(cls): - return MySQLPlatform - - -class MockMSSQLConnection(MySQLConnection): - def make_connection(self): - self._connection = mock.MagicMock() - self._cursor = mock.MagicMock() - - return self - - @classmethod - def get_default_platform(cls): - return MySQLPlatform - - -class MockPostgresConnection(MySQLConnection): - def make_connection(self): - self._connection = mock.MagicMock() - - return self - - -class MockSQLiteConnection(SQLiteConnection): - def make_connection(self): - self._connection = mock.MagicMock() - - return self - - def query(self, *args, **kwargs): - return {} - - -class MockConnectionFactory(ConnectionFactory): - _connections = { - "mysql": MockMySQLConnection, - "mssql": MockMSSQLConnection, - "postgres": MockPostgresConnection, - "sqlite": MockSQLiteConnection, - "oracle": "", - }