fix unittests to accomodate DBStorage

Author: alexaorrico

tests/test_models/test_amenity.py

@@ -5,6 +5,7 @@
 
 from datetime import datetime
 import inspect
+import models
 from models import amenity
 from models.base_model import BaseModel
 import pep8
@@ -70,16 +71,22 @@ def test_name_attr(self):
         """Test that Amenity has attribute name, and it's as an empty string"""
         amenity = Amenity()
         self.assertTrue(hasattr(amenity, "name"))
-        self.assertEqual(amenity.name, "")
+        if models.storage_t == 'db':
+            self.assertEqual(amenity.name, None)
+        else:
+            self.assertEqual(amenity.name, "")
 
     def test_to_dict_creates_dict(self):
         """test to_dict method creates a dictionary with proper attrs"""
         am = Amenity()
+        print(am.__dict__)
         new_d = am.to_dict()
         self.assertEqual(type(new_d), dict)
+        self.assertFalse("_sa_instance_state" in new_d)
         for attr in am.__dict__:
-            self.assertTrue(attr in new_d)
-            self.assertTrue("__class__" in new_d)
+            if attr is not "_sa_instance_state":
+                self.assertTrue(attr in new_d)
+        self.assertTrue("__class__" in new_d)
 
     def test_to_dict_values(self):
         """test that values in dict returned from to_dict are correct"""

tests/test_models/test_base_model.py

@@ -58,8 +58,7 @@ def test_func_docstrings(self):
 
 class TestBaseModel(unittest.TestCase):
     """Test the BaseModel class"""
-    @mock.patch('models.storage')
-    def test_instantiation(self, mock_storage):
+    def test_instantiation(self):
         """Test that object is correctly created"""
         inst = BaseModel()
         self.assertIs(type(inst), BaseModel)
@@ -76,7 +75,6 @@ def test_instantiation(self, mock_storage):
             with self.subTest(attr=attr, typ=typ):
                 self.assertIn(attr, inst.__dict__)
                 self.assertIs(type(inst.__dict__[attr]), typ)
-        self.assertTrue(mock_storage.new.called)
         self.assertEqual(inst.name, "Holberton")
         self.assertEqual(inst.number, 89)
 
@@ -158,4 +156,5 @@ def test_save(self, mock_storage):
         new_updated_at = inst.updated_at
         self.assertNotEqual(old_updated_at, new_updated_at)
         self.assertEqual(old_created_at, new_created_at)
+        self.assertTrue(mock_storage.new.called)
         self.assertTrue(mock_storage.save.called)

tests/test_models/test_city.py

@@ -5,6 +5,7 @@
 
 from datetime import datetime
 import inspect
+import models
 from models import city
 from models.base_model import BaseModel
 import pep8
@@ -70,22 +71,30 @@ def test_name_attr(self):
         """Test that City has attribute name, and it's an empty string"""
         city = City()
         self.assertTrue(hasattr(city, "name"))
-        self.assertEqual(city.name, "")
+        if models.storage_t == 'db':
+            self.assertEqual(city.name, None)
+        else:
+            self.assertEqual(city.name, "")
 
     def test_state_id_attr(self):
         """Test that City has attribute state_id, and it's an empty string"""
         city = City()
         self.assertTrue(hasattr(city, "state_id"))
-        self.assertEqual(city.state_id, "")
+        if models.storage_t == 'db':
+            self.assertEqual(city.state_id, None)
+        else:
+            self.assertEqual(city.state_id, "")
 
     def test_to_dict_creates_dict(self):
         """test to_dict method creates a dictionary with proper attrs"""
         c = City()
         new_d = c.to_dict()
         self.assertEqual(type(new_d), dict)
+        self.assertFalse("_sa_instance_state" in new_d)
         for attr in c.__dict__:
-            self.assertTrue(attr in new_d)
-            self.assertTrue("__class__" in new_d)
+            if attr is not "_sa_instance_state":
+                self.assertTrue(attr in new_d)
+        self.assertTrue("__class__" in new_d)
 
     def test_to_dict_values(self):
         """test that values in dict returned from to_dict are correct"""

tests/test_models/test_engine/test_db_storage.py

@@ -0,0 +1,88 @@
+#!/usr/bin/python3
+"""
+Contains the TestDBStorageDocs and TestDBStorage classes
+"""
+
+from datetime import datetime
+import inspect
+import models
+from models.engine import db_storage
+from models.amenity import Amenity
+from models.base_model import BaseModel
+from models.city import City
+from models.place import Place
+from models.review import Review
+from models.state import State
+from models.user import User
+import json
+import os
+import pep8
+import unittest
+DBStorage = db_storage.DBStorage
+classes = {"Amenity": Amenity, "City": City, "Place": Place,
+           "Review": Review, "State": State, "User": User}
+
+
+class TestDBStorageDocs(unittest.TestCase):
+    """Tests to check the documentation and style of DBStorage class"""
+    @classmethod
+    def setUpClass(cls):
+        """Set up for the doc tests"""
+        cls.dbs_f = inspect.getmembers(DBStorage, inspect.isfunction)
+
+    def test_pep8_conformance_db_storage(self):
+        """Test that models/engine/db_storage.py conforms to PEP8."""
+        pep8s = pep8.StyleGuide(quiet=True)
+        result = pep8s.check_files(['models/engine/db_storage.py'])
+        self.assertEqual(result.total_errors, 0,
+                         "Found code style errors (and warnings).")
+
+    def test_pep8_conformance_test_db_storage(self):
+        """Test tests/test_models/test_db_storage.py conforms to PEP8."""
+        pep8s = pep8.StyleGuide(quiet=True)
+        result = pep8s.check_files(['tests/test_models/test_engine/\
+test_db_storage.py'])
+        self.assertEqual(result.total_errors, 0,
+                         "Found code style errors (and warnings).")
+
+    def test_db_storage_module_docstring(self):
+        """Test for the db_storage.py module docstring"""
+        self.assertIsNot(db_storage.__doc__, None,
+                         "db_storage.py needs a docstring")
+        self.assertTrue(len(db_storage.__doc__) >= 1,
+                        "db_storage.py needs a docstring")
+
+    def test_db_storage_class_docstring(self):
+        """Test for the DBStorage class docstring"""
+        self.assertIsNot(DBStorage.__doc__, None,
+                         "DBStorage class needs a docstring")
+        self.assertTrue(len(DBStorage.__doc__) >= 1,
+                        "DBStorage class needs a docstring")
+
+    def test_dbs_func_docstrings(self):
+        """Test for the presence of docstrings in DBStorage methods"""
+        for func in self.dbs_f:
+            self.assertIsNot(func[1].__doc__, None,
+                             "{:s} method needs a docstring".format(func[0]))
+            self.assertTrue(len(func[1].__doc__) >= 1,
+                            "{:s} method needs a docstring".format(func[0]))
+
+
+class TestFileStorage(unittest.TestCase):
+    """Test the FileStorage class"""
+    @unittest.skipIf(models.storage_t != 'db', "not testing db storage")
+    def test_all_returns_dict(self):
+        """Test that all returns a dictionaty"""
+        self.assertIs(type(models.storage.all()), dict)
+
+    @unittest.skipIf(models.storage_t != 'db', "not testing db storage")
+    def test_all_no_class(self):
+        """Test that all returns all rows when no class is passed"""
+
+    @unittest.skipIf(models.storage_t != 'db', "not testing db storage")
+    def test_new(self):
+        """test that new adds an object to the database"""
+
+    @unittest.skipIf(models.storage_t != 'db', "not testing db storage")
+    def test_save(self):
+        """Test that save properly saves objects to file.json"""

tests/test_models/test_engine/test_file_storage.py

@@ -5,6 +5,7 @@
 
 from datetime import datetime
 import inspect
+import models
 from models.engine import file_storage
 from models.amenity import Amenity
 from models.base_model import BaseModel
@@ -54,9 +55,9 @@ def test_file_storage_module_docstring(self):
     def test_file_storage_class_docstring(self):
         """Test for the FileStorage class docstring"""
         self.assertIsNot(FileStorage.__doc__, None,
-                         "State class needs a docstring")
+                         "FileStorage class needs a docstring")
         self.assertTrue(len(FileStorage.__doc__) >= 1,
-                        "State class needs a docstring")
+                        "FileStorage class needs a docstring")
 
     def test_fs_func_docstrings(self):
         """Test for the presence of docstrings in FileStorage methods"""
@@ -69,13 +70,15 @@ def test_fs_func_docstrings(self):
 
 class TestFileStorage(unittest.TestCase):
     """Test the FileStorage class"""
+    @unittest.skipIf(models.storage_t == 'db', "not testing file storage")
     def test_all_returns_dict(self):
         """Test that all returns the FileStorage.__objects attr"""
         storage = FileStorage()
         new_dict = storage.all()
         self.assertEqual(type(new_dict), dict)
         self.assertIs(new_dict, storage._FileStorage__objects)
 
+    @unittest.skipIf(models.storage_t == 'db', "not testing file storage")
     def test_new(self):
         """test that new adds an object to the FileStorage.__objects attr"""
         storage = FileStorage()
@@ -91,9 +94,9 @@ def test_new(self):
                 self.assertEqual(test_dict, storage._FileStorage__objects)
         FileStorage._FileStorage__objects = save
 
+    @unittest.skipIf(models.storage_t == 'db', "not testing file storage")
     def test_save(self):
         """Test that save properly saves objects to file.json"""
-        os.remove("file.json")
         storage = FileStorage()
         new_dict = {}
         for key, value in classes.items():

tests/test_models/test_place.py

@@ -5,6 +5,7 @@
 
 from datetime import datetime
 import inspect
+import models
 from models import place
 from models.base_model import BaseModel
 import pep8
@@ -70,68 +71,99 @@ def test_city_id_attr(self):
         """Test Place has attr city_id, and it's an empty string"""
         place = Place()
         self.assertTrue(hasattr(place, "city_id"))
-        self.assertEqual(place.city_id, "")
+        if models.storage_t == 'db':
+            self.assertEqual(place.city_id, None)
+        else:
+            self.assertEqual(place.city_id, "")
 
     def test_user_id_attr(self):
         """Test Place has attr user_id, and it's an empty string"""
         place = Place()
         self.assertTrue(hasattr(place, "user_id"))
-        self.assertEqual(place.user_id, "")
+        if models.storage_t == 'db':
+            self.assertEqual(place.user_id, None)
+        else:
+            self.assertEqual(place.user_id, "")
 
     def test_name_attr(self):
         """Test Place has attr name, and it's an empty string"""
         place = Place()
         self.assertTrue(hasattr(place, "name"))
-        self.assertEqual(place.name, "")
+        if models.storage_t == 'db':
+            self.assertEqual(place.name, None)
+        else:
+            self.assertEqual(place.name, "")
 
     def test_description_attr(self):
         """Test Place has attr description, and it's an empty string"""
         place = Place()
         self.assertTrue(hasattr(place, "description"))
-        self.assertEqual(place.description, "")
+        if models.storage_t == 'db':
+            self.assertEqual(place.description, None)
+        else:
+            self.assertEqual(place.description, "")
 
     def test_number_rooms_attr(self):
         """Test Place has attr number_rooms, and it's an int == 0"""
         place = Place()
         self.assertTrue(hasattr(place, "number_rooms"))
-        self.assertEqual(type(place.number_rooms), int)
-        self.assertEqual(place.number_rooms, 0)
+        if models.storage_t == 'db':
+            self.assertEqual(place.number_rooms, None)
+        else:
+            self.assertEqual(type(place.number_rooms), int)
+            self.assertEqual(place.number_rooms, 0)
 
     def test_number_bathrooms_attr(self):
         """Test Place has attr number_bathrooms, and it's an int == 0"""
         place = Place()
         self.assertTrue(hasattr(place, "number_bathrooms"))
-        self.assertEqual(type(place.number_bathrooms), int)
-        self.assertEqual(place.number_bathrooms, 0)
+        if models.storage_t == 'db':
+            self.assertEqual(place.number_bathrooms, None)
+        else:
+            self.assertEqual(type(place.number_bathrooms), int)
+            self.assertEqual(place.number_bathrooms, 0)
 
     def test_max_guest_attr(self):
         """Test Place has attr max_guest, and it's an int == 0"""
         place = Place()
         self.assertTrue(hasattr(place, "max_guest"))
-        self.assertEqual(type(place.max_guest), int)
-        self.assertEqual(place.max_guest, 0)
+        if models.storage_t == 'db':
+            self.assertEqual(place.max_guest, None)
+        else:
+            self.assertEqual(type(place.max_guest), int)
+            self.assertEqual(place.max_guest, 0)
 
     def test_price_by_night_attr(self):
         """Test Place has attr price_by_night, and it's an int == 0"""
         place = Place()
         self.assertTrue(hasattr(place, "price_by_night"))
-        self.assertEqual(type(place.price_by_night), int)
-        self.assertEqual(place.price_by_night, 0)
+        if models.storage_t == 'db':
+            self.assertEqual(place.price_by_night, None)
+        else:
+            self.assertEqual(type(place.price_by_night), int)
+            self.assertEqual(place.price_by_night, 0)
 
     def test_latitude_attr(self):
         """Test Place has attr latitude, and it's a float == 0.0"""
         place = Place()
         self.assertTrue(hasattr(place, "latitude"))
-        self.assertEqual(type(place.latitude), float)
-        self.assertEqual(place.latitude, 0.0)
+        if models.storage_t == 'db':
+            self.assertEqual(place.latitude, None)
+        else:
+            self.assertEqual(type(place.latitude), float)
+            self.assertEqual(place.latitude, 0.0)
 
-    def test_latitude_attr(self):
+    def test_longitude_attr(self):
         """Test Place has attr longitude, and it's a float == 0.0"""
         place = Place()
         self.assertTrue(hasattr(place, "longitude"))
-        self.assertEqual(type(place.longitude), float)
-        self.assertEqual(place.longitude, 0.0)
+        if models.storage_t == 'db':
+            self.assertEqual(place.longitude, None)
+        else:
+            self.assertEqual(type(place.longitude), float)
+            self.assertEqual(place.longitude, 0.0)
 
+    @unittest.skipIf(models.storage_t == 'db', "not testing File Storage")
     def test_amenity_ids_attr(self):
         """Test Place has attr amenity_ids, and it's an empty list"""
         place = Place()
@@ -144,9 +176,11 @@ def test_to_dict_creates_dict(self):
         p = Place()
         new_d = p.to_dict()
         self.assertEqual(type(new_d), dict)
+        self.assertFalse("_sa_instance_state" in new_d)
         for attr in p.__dict__:
-            self.assertTrue(attr in new_d)
-            self.assertTrue("__class__" in new_d)
+            if attr is not "_sa_instance_state":
+                self.assertTrue(attr in new_d)
+        self.assertTrue("__class__" in new_d)
 
     def test_to_dict_values(self):
         """test that values in dict returned from to_dict are correct"""