fix pylance warnings in tests (#947)

tests/apps/app/commands/test_new.py

@@ -39,5 +39,7 @@ def test_new_with_clashing_name(self):
 
         exception = context.exception
         self.assertTrue(
-            exception.code.startswith("A module called sys already exists")
+            str(exception.code).startswith(
+                "A module called sys already exists"
+            )
         )

tests/apps/fixtures/commands/test_dump_load.py

@@ -276,5 +276,3 @@ def test_on_conflict(self):
 
         run_sync(load(path=json_file_path, on_conflict="DO NOTHING"))
         run_sync(load(path=json_file_path, on_conflict="DO UPDATE"))
-        run_sync(load(path=json_file_path, on_conflict="do nothing"))
-        run_sync(load(path=json_file_path, on_conflict="do update"))

tests/apps/fixtures/commands/test_shared.py

@@ -56,5 +56,5 @@ def test_shared(self):
         }
 
         model = pydantic_model(**data)
-        self.assertEqual(model.mega.SmallTable[0].id, 1)
-        self.assertEqual(model.mega.MegaTable[0].id, 1)
+        self.assertEqual(model.mega.SmallTable[0].id, 1)  # type: ignore
+        self.assertEqual(model.mega.MegaTable[0].id, 1)  # type: ignore

tests/apps/migrations/auto/test_migration_manager.py

@@ -1,5 +1,6 @@
 import asyncio
 import random
+import typing as t
 from io import StringIO
 from unittest import TestCase
 from unittest.mock import MagicMock, patch
@@ -267,7 +268,7 @@ def test_add_table(self, get_app_config: MagicMock):
         self.assertEqual(self.table_exists("musician"), False)
 
     @engines_only("postgres", "cockroach")
-    def test_add_column(self):
+    def test_add_column(self) -> None:
         """
         Test adding a column to a MigrationManager.
         """
@@ -304,21 +305,21 @@ def test_add_column(self):
             response = self.run_sync("SELECT * FROM manager;")
             self.assertEqual(response, [{"id": 1, "name": "Dave"}])
 
-        id = 0
+        row_id: t.Optional[int] = None
         if engine_is("cockroach"):
-            id = self.run_sync(
+            row_id = self.run_sync(
                 "INSERT INTO manager VALUES (default, 'Dave', '[email protected]') RETURNING id;"  # noqa: E501
-            )
+            )[0]["id"]
             response = self.run_sync("SELECT * FROM manager;")
             self.assertEqual(
                 response,
-                [{"id": id[0]["id"], "name": "Dave", "email": "[email protected]"}],
+                [{"id": row_id, "name": "Dave", "email": "[email protected]"}],
             )
 
             # Reverse
             asyncio.run(manager.run(backwards=True))
             response = self.run_sync("SELECT * FROM manager;")
-            self.assertEqual(response, [{"id": id[0]["id"], "name": "Dave"}])
+            self.assertEqual(response, [{"id": row_id, "name": "Dave"}])
 
         # Preview
         manager.preview = True
@@ -333,7 +334,7 @@ def test_add_column(self):
         if engine_is("postgres"):
             self.assertEqual(response, [{"id": 1, "name": "Dave"}])
         if engine_is("cockroach"):
-            self.assertEqual(response, [{"id": id[0]["id"], "name": "Dave"}])
+            self.assertEqual(response, [{"id": row_id, "name": "Dave"}])
 
     @engines_only("postgres", "cockroach")
     def test_add_column_with_index(self):

tests/apps/user/test_tables.py

@@ -221,15 +221,21 @@ def test_long_password_error(self):
 
     def test_no_username_error(self):
         with self.assertRaises(ValueError) as manager:
-            BaseUser.create_user_sync(username=None, password="abc123")
+            BaseUser.create_user_sync(
+                username=None,  # type: ignore
+                password="abc123",
+            )
 
         self.assertEqual(
             manager.exception.__str__(), "A username must be provided."
         )
 
     def test_no_password_error(self):
         with self.assertRaises(ValueError) as manager:
-            BaseUser.create_user_sync(username="bob", password=None)
+            BaseUser.create_user_sync(
+                username="bob",
+                password=None,  # type: ignore
+            )
 
         self.assertEqual(
             manager.exception.__str__(), "A password must be provided."
@@ -272,12 +278,14 @@ def test_hash_update(self):
             BaseUser.login_sync(username=username, password=password)
         )
 
-        hashed_password = (
+        user_data = (
             BaseUser.select(BaseUser.password)
             .where(BaseUser.id == user.id)
             .first()
-            .run_sync()["password"]
+            .run_sync()
         )
+        assert user_data is not None
+        hashed_password = user_data["password"]
 
         algorithm, iterations_, salt, hashed = BaseUser.split_stored_password(
             hashed_password

tests/base.py

@@ -19,19 +19,19 @@
 ENGINE = engine_finder()
 
 
-def engine_version_lt(version: float):
-    return ENGINE and run_sync(ENGINE.get_version()) < version
+def engine_version_lt(version: float) -> bool:
+    return ENGINE is not None and run_sync(ENGINE.get_version()) < version
 
 
-def is_running_postgres():
+def is_running_postgres() -> bool:
     return type(ENGINE) is PostgresEngine
 
 
-def is_running_sqlite():
+def is_running_sqlite() -> bool:
     return type(ENGINE) is SQLiteEngine
 
 
-def is_running_cockroach():
+def is_running_cockroach() -> bool:
     return type(ENGINE) is CockroachEngine
 
 
@@ -228,6 +228,8 @@ def get_postgres_varchar_length(
     ###########################################################################
 
     def create_tables(self):
+        assert ENGINE is not None
+
         if ENGINE.engine_type in ("postgres", "cockroach"):
             self.run_sync(
                 """
@@ -308,6 +310,8 @@ def create_tables(self):
             raise Exception("Unrecognised engine")
 
     def insert_row(self):
+        assert ENGINE is not None
+
         if ENGINE.engine_type == "cockroach":
             id = self.run_sync(
                 """
@@ -352,6 +356,8 @@ def insert_row(self):
             )
 
     def insert_rows(self):
+        assert ENGINE is not None
+
         if ENGINE.engine_type == "cockroach":
             id = self.run_sync(
                 """
@@ -428,6 +434,8 @@ def insert_many_rows(self, row_count=10000):
         self.run_sync(f"INSERT INTO manager (name) VALUES {values_string};")
 
     def drop_tables(self):
+        assert ENGINE is not None
+
         if ENGINE.engine_type in ("postgres", "cockroach"):
             self.run_sync("DROP TABLE IF EXISTS band CASCADE;")
             self.run_sync("DROP TABLE IF EXISTS manager CASCADE;")

tests/columns/foreign_key/test_all_columns.py

@@ -24,17 +24,17 @@ def test_all_columns_deep(self):
         """
         Make sure ``all_columns`` works when the joins are several layers deep.
         """
-        all_columns = Concert.band_1.manager.all_columns()
-        self.assertEqual(all_columns, [Band.manager.id, Band.manager.name])
+        all_columns = Concert.band_1._.manager.all_columns()
+        self.assertEqual(all_columns, [Band.manager._.id, Band.manager._.name])
 
         # Make sure the call chains are also correct.
         self.assertEqual(
             all_columns[0]._meta.call_chain,
-            Concert.band_1.manager.id._meta.call_chain,
+            Concert.band_1._.manager._.id._meta.call_chain,
         )
         self.assertEqual(
             all_columns[1]._meta.call_chain,
-            Concert.band_1.manager.name._meta.call_chain,
+            Concert.band_1._.manager._.name._meta.call_chain,
         )
 
     def test_all_columns_exclude(self):

tests/columns/foreign_key/test_all_related.py

@@ -38,13 +38,13 @@ def test_all_related_deep(self):
         """
         Make sure ``all_related`` works when the joins are several layers deep.
         """
-        all_related = Ticket.concert.band_1.all_related()
-        self.assertEqual(all_related, [Ticket.concert.band_1.manager])
+        all_related = Ticket.concert._.band_1.all_related()
+        self.assertEqual(all_related, [Ticket.concert._.band_1._.manager])
 
         # Make sure the call chains are also correct.
         self.assertEqual(
             all_related[0]._meta.call_chain,
-            Ticket.concert.band_1.manager._meta.call_chain,
+            Ticket.concert._.band_1._.manager._meta.call_chain,
         )
 
     def test_all_related_exclude(self):
@@ -57,6 +57,6 @@ def test_all_related_exclude(self):
         )
 
         self.assertEqual(
-            Ticket.concert.all_related(exclude=[Ticket.concert.venue]),
+            Ticket.concert.all_related(exclude=[Ticket.concert._.venue]),
             [Ticket.concert.band_1, Ticket.concert.band_2],
         )

tests/columns/foreign_key/test_attribute_access.py

@@ -60,6 +60,6 @@ def test_recursion_time(self):
         Make sure that a really large call chain doesn't take too long.
         """
         start = time.time()
-        Manager.manager.manager.manager.manager.manager.manager.name
+        Manager.manager._.manager._.manager._.manager._.manager._.manager._.name  # noqa: E501
         end = time.time()
         self.assertLess(end - start, 1.0)

tests/columns/foreign_key/test_foreign_key_self.py

@@ -1,10 +1,11 @@
 from unittest import TestCase
 
-from piccolo.columns import ForeignKey, Varchar
+from piccolo.columns import ForeignKey, Serial, Varchar
 from piccolo.table import Table
 
 
 class Manager(Table, tablename="manager"):
+    id: Serial
     name = Varchar()
     manager: ForeignKey["Manager"] = ForeignKey("self", null=True)
 

tests/columns/foreign_key/test_schema.py

@@ -84,7 +84,7 @@ def test_with_schema(self):
         query = Concert.select(
             Concert.start_date,
             Concert.band.name.as_alias("band_name"),
-            Concert.band.manager.name.as_alias("manager_name"),
+            Concert.band._.manager._.name.as_alias("manager_name"),
         )
         self.assertIn('"schema_1"."concert"', query.__str__())
         self.assertIn('"schema_1"."band"', query.__str__())