[#6] Fixed DeleteQuery & Model tests.

tests/test_deletequery.py

@@ -21,7 +21,7 @@ def test_is_filterable(self):
 
     def test_can_output_selectquery_as_string(self):
         result = str(DeleteQuery(Trainer).where(Trainer.age > 18))
-        expected = "(DELETE FROM trainer WHERE trainer.age > 18)"
+        expected = '(DELETE FROM trainer WHERE trainer.age > 18)'
         assert result == expected
 
 
@@ -32,23 +32,29 @@ def test_delete_all_rows(self):
         nrows = Trainer._db._connection.execute('SELECT count(*) FROM trainer').fetchone()[0]
         assert nrows == 3
         DeleteQuery(Trainer).execute()
-        nrows = Trainer._db._connection.execute('SELECT count(*) FROM trainer').fetchone()[0]
+        nrows = Trainer._db._connection.execute(
+            "SELECT count(*) FROM trainer WHERE name != 'Giovanni'"
+        ).fetchone()[0]
         assert nrows == 0
 
     def test_delete_with_filter(self):
         self.add_trainer(['Giovanni', 'James', 'Jessie'])
         nrows = Trainer._db._connection.execute('SELECT count(*) FROM trainer').fetchone()[0]
         assert nrows == 3
         DeleteQuery(Trainer).where(Trainer.name == 'Giovanni').execute()
-        nrows = Trainer._db._connection.execute('SELECT count(*) FROM trainer').fetchone()[0]
+        nrows = Trainer._db._connection.execute(
+            "SELECT count(*) FROM trainer WHERE name != 'Giovanni'"
+        ).fetchone()[0]
         assert nrows == 2
 
     def test_filter_with_subquery(self):
         self.add_trainer(['Giovanni', 'James', 'Jessie'])
         nrows = Trainer._db._connection.execute('SELECT count(*) FROM trainer').fetchone()[0]
         assert nrows == 3
-        query_filter = SelectQuery(Trainer).select(Trainer.name).where(Trainer.name == 'Giovanni')
-        DeleteQuery(Trainer).where(Trainer.name == query_filter).execute()
-        nrows = Trainer._db._connection.execute('SELECT count(*) FROM trainer').fetchone()[0]
+        giovanni_name = SelectQuery(Trainer).select(Trainer.name).where(Trainer.name == 'Giovanni')
+        DeleteQuery(Trainer).where(Trainer.name == giovanni_name).execute()
+        nrows = Trainer._db._connection.execute(
+            "SELECT count(*) FROM trainer WHERE name != 'Giovanni'"
+        ).fetchone()[0]
         assert nrows == 2
 

tests/test_model.py

@@ -1,11 +1,11 @@
-from plume.plume import Database, Model
+from plume.plume import Database, DeleteQuery, Model, SelectQuery, UpdateQuery
 
-from utils import DB_NAME, Pokemon, Trainer
+from utils import BaseTestCase, Pokemon, Trainer
 
 import pytest
 import sqlite3
 
-class TestModel:
+class TestModelAPI:
 
     def test_custom_model_is_sloted(self):
         sacha = Trainer(name='Sacha', age=42)
@@ -23,53 +23,63 @@ def test_pk_field_is_empty_by_default_on_model_instance(self):
     def test_pk_field_can_be_set_as_model_instance_init_param(self):
         m = Model(pk=1)
         assert Model.pk == 1
-        
-    def test_two_equivalent_models_are_equals(self):
+
+    def test_two_models_with_same_pk_are_equals(self):
         m1 = Model(pk=1)
         m2 = Model(pk=1)
         assert m1 == m2
 
-    def test_two_different_models_are_not_equals(self):
+    def test_two_models_with_differents_pk_are_not_equals(self):
         m1 = Model(pk=1)
         m2 = Model(pk=2)
         assert m1 != m2
+
+    def test_can_make_update_query(self):
+        query = Trainer.update(Trainer.age == 42)
+        expected = '(UPDATE trainer SET age = 42)'
+        assert isinstance(query, UpdateQuery) is True
+        assert str(query) == expected
+
+    def test_can_make_delete_query(self):
+        query = Trainer.delete(Trainer.age == 42)
+        expected = '(DELETE FROM trainer WHERE trainer.age = 42)'
+        assert isinstance(query, DeleteQuery) is True
+        assert str(query) == expected
+
+    def test_can_make_select_query_with_select(self):
+        query = Trainer.select(Trainer.age)
+        expected = '(SELECT trainer.age FROM trainer)'
+        assert isinstance(query, SelectQuery) is True
+        assert str(query) == expected
 
-    def test_model_is_sloted(self):
-        m1 = Model(pk=1)
+    def test_can_make_select_query_with_where(self):
+        query = Trainer.where(Trainer.age == 42)
+        expected = '(SELECT * FROM trainer WHERE trainer.age = 42)'
+        assert isinstance(query, SelectQuery) is True
+        assert str(query) == expected
 
-        with pytest.raises(AttributeError):
-            m1.__dict__
 
-    def test_create_from_manager_returns_an_instance_with_pk_set(self):
-        db = Database(DB_NAME)
-        db.register(Trainer)
+class TestModelResult(BaseTestCase):    
+    def test_create_returns_an_instance_with_pk_set(self):
         giovanni = Trainer.create(name='Giovanni', age=42)
         assert giovanni.pk == 1
         assert giovanni.name == 'Giovanni'
         assert giovanni.age == 42
 
-    def test_create_from_manager_returns_an_instance_with_pk_set_to_next_available_id(self):
-        db = Database(DB_NAME)
-        db.register(Trainer)
+    def test_create_returns_an_instance_with_pk_set_to_next_available_id(self):
         giovanni = Trainer.create(name='Giovanni', age=42)
         james = Trainer.create(name='James', age=21)
         assert giovanni.pk == 1
         assert james.pk == 2
 
-    def test_create_from_manager_allows_model_instance_as_parameter_for_foreign_key_field(self):
-        db = Database(DB_NAME)
-        db.register(Trainer, Pokemon)
-
+    def test_create_allows_model_instance_as_parameter_for_foreign_key_field(self):
         james = Trainer.create(name='James', age=21)
         meowth = Pokemon.create(name='Meowth', level=19, trainer=james)
 
         assert james.pk == 1
         assert meowth.trainer.pk == james.pk
 
-    def test_create_from_manager_checks_for_integrity(self):
-        db = Database(DB_NAME)
-        db.register(Trainer, Pokemon)
-
+    def test_create_checks_for_integrity(self):
         james = Trainer.create(name='James', age=21)
 
         with pytest.raises(sqlite3.IntegrityError):