class TestFileStorage(unittest.TestCase):
"""
Unittest for file_storage.py
"""
storage = FileStorage()
path = storage._FileStorage__file_path
bm_instance = BaseModel(**my_dict)
storage.new(bm_instance)
def test_module_docstring(self):
"""
Tests docstring for module
"""
self.assertTrue(len(mrdoc) > 20)
def test_methods_docstring(self):
"""
Tests docstring for methods
"""
methods = inspect.getmembers(FileStorage, predicate=inspect.ismethod)
for name, func in methods:
self.assertTrue(len(func.__doc__) > 20)
methods = inspect.getmembers(FileStorage, predicate=inspect.isfunction)
for name, func in methods:
self.assertTrue(len(func.__doc__) > 20)
def test_pep8(self):
"""
Tests for PEP-8
"""
pep8style = pep8.StyleGuide(quiet=True)
result = pep8style.check_files(["models/base_model.py"])
self.assertEqual(result.total_errors, 0)
def test_docstring_for_test(self):
"""
Tests docstring for this test
"""
self.assertTrue(len(__doc__) > 20)
def test_docstring_class_test(self):
"""
Tests dosctring for class TestBaseModel
"""
self.assertTrue(len(TestFileStorage.__doc__) > 20)
def test_docstring_methods(self):
"""
Tests docstring for all methods in TestBaseModel class
"""
methods = inspect.getmembers(
TestFileStorage, predicate=inspect.ismethod)
for name, func in methods:
self.assertTrue(len(func.__doc__) > 20)
def test_storage_isinstance(self):
"""
Tests if storage is an instance of FileStorage
"""
self.assertIsInstance(TestFileStorage.storage, FileStorage)
def test_file_json(self):
"""
Tests for path existence
"""
TestFileStorage.storage.save()
self.assertTrue(os.path.exists(TestFileStorage.path))
def test_reload(self):
"""
Test for instances reloaded from path
"""
key = my_dict["__class__"] + "." + my_dict["id"]
with open(TestFileStorage.path, mode="r", encoding="utf-8") as f:
reader = json.load(f)
attributes = reader[key]
self.assertEqual(my_dict, attributes)
self.assertIsInstance(TestFileStorage.storage.all()[key], BaseModel)
def test_save_another_instance(self):
"""
Tests for save another instance in path
"""
bm2_instance = BaseModel()
bm2_instance.save()
key = type(bm2_instance).__name__ + "." + str(bm2_instance.id)
with open(TestFileStorage.path, mode="r", encoding="utf-8") as f:
reader = json.load(f)
self.assertEqual(
reader[key], TestFileStorage.storage.all()[key].to_dict())
def setUp(self):
'''
Initializing classes
'''
self.storage = FileStorage()
self.my_model = BaseModel()
#!/usr/bin/python3
"""create a unique FileStorage instance for your application"""
from models.base_model import BaseModel
from models.user import User
from models.state import State
from models.city import City
from models.amenity import Amenity
from models.place import Place
from models.review import Review
from os import getenv
if getenv('HBNB_TYPE_STORAGE') == 'db':
from models.engine.db_storage import DBStorage
storage = DBStorage()
else:
from models.engine.file_storage import FileStorage
storage = FileStorage()
storage.reload()
def test_00_all_method(self):
'''checks if class method all returns a dict'''
my_obj = FileStorage()
my_obj.reload()
all_objs = my_obj.all()
self.assertEqual(type(all_objs), dict)
def setUpClass(cls):
cls.usr = User()
cls.usr.first_name = "Mundo"
cls.usr.last_name = "Malito"
cls.usr.email = "*****@*****.**"
cls.storage = FileStorage()
def test_save(self):
"""Test the save method"""
storage = FileStorage()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertEqual(f.read(), '{}')
ba = BaseModel()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[ba.__class__.__name__ + '.' + ba.id],
ba.to_dict())
us = User()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[us.__class__.__name__ + '.' + us.id],
us.to_dict())
st = State()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[st.__class__.__name__ + '.' + st.id],
st.to_dict())
ci = City()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[ci.__class__.__name__ + '.' + ci.id],
ci.to_dict())
am = Amenity()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[am.__class__.__name__ + '.' + am.id],
am.to_dict())
pl = Place()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[pl.__class__.__name__ + '.' + pl.id],
pl.to_dict())
re = Review()
storage.save()
self.assertTrue(path.isfile('file.json'))
with open("file.json") as f:
self.assertIsInstance(json.loads(f.read()), dict)
with open("file.json") as f:
self.assertEqual(
json.loads(f.read())[re.__class__.__name__ + '.' + re.id],
re.to_dict())
def test_instance_attribute_presence(self):
"""Test that the FileStorage instance has the same attributes"""
l1 = dir(FileStorage())
self.assertIn('_FileStorage__file_path', l1)
self.assertIn('_FileStorage__objects', l1)
def test_generate_file(self):
instance = FileStorage()
instance.save()
self.assertTrue(
os.path.exists("storage.json") and os.path.isfile("storage.json"))
def test_reload_from_nonexistent_file(self):
instance = FileStorage()
instance.reload()
instance.save()
self.assertEqual({}, instance.all())
def test_check_type_of_file_storage_objects(self):
instance = FileStorage()
self.assertIsInstance(instance.all(), dict)
def test_add_new_object_to_file_storage(self):
instance = FileStorage()
obj = BaseModel()
self.assertIn(obj,
instance.all().values(), "object isn't in file storage")
def test_create_instance_with_args(self):
with (self.assertRaises(TypeError)) as context:
instance = FileStorage(1)
self.assertIsNotNone("takes no parameters" in str(context.exception))
def test_create_instance(self):
instance = FileStorage()
self.assertIsInstance(instance, FileStorage)
def test_new_in_storage(self):
"""Checks that a new instance of an object is saved to __objects"""
a = BaseModel()
storage = FileStorage()
a_key = 'BaseModel' + '.' + a.id
self.assertEqual(True, a_key in storage.all().keys())
def setUp(self):
'''
simple set up
'''
self.my_model = BaseModel()
self.storage = FileStorage()
def test_reload_with_args(self):
instance = FileStorage()
with (self.assertRaises(TypeError)) as context:
instance.reload(98)
self.assertTrue(
"reload() takes 1 positional argument" in str(context.exception))
def setUpClass(cls):
'''setting method to tests instance'''
cls.insta = FileStorage()
def test_storage_isinstance(self):
"""Tests if storage is an instance of FileStorage"""
prueba = FileStorage()
self.assertIsInstance(prueba, FileStorage)
def test_reload(self):
"""Test the reload method"""
storage = FileStorage()
ba = BaseModel()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[ba.__class__.__name__ + '.' +
ba.id], BaseModel)
self.assertEqual(
FileStorage._FileStorage__objects[ba.__class__.__name__ + '.' +
ba.id].to_dict(), ba.to_dict())
us = User()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[us.__class__.__name__ + '.' +
us.id], User)
self.assertEqual(
FileStorage._FileStorage__objects[us.__class__.__name__ + '.' +
us.id].to_dict(), us.to_dict())
st = State()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[st.__class__.__name__ + '.' +
st.id], State)
self.assertEqual(
FileStorage._FileStorage__objects[st.__class__.__name__ + '.' +
st.id].to_dict(), st.to_dict())
ci = City()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[ci.__class__.__name__ + '.' +
ci.id], City)
self.assertEqual(
FileStorage._FileStorage__objects[ci.__class__.__name__ + '.' +
ci.id].to_dict(), ci.to_dict())
am = Amenity()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[am.__class__.__name__ + '.' +
am.id], Amenity)
self.assertEqual(
FileStorage._FileStorage__objects[am.__class__.__name__ + '.' +
am.id].to_dict(), am.to_dict())
pl = Place()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[pl.__class__.__name__ + '.' +
pl.id], Place)
self.assertEqual(
FileStorage._FileStorage__objects[pl.__class__.__name__ + '.' +
pl.id].to_dict(), pl.to_dict())
re = Review()
storage.save()
storage.reload()
self.assertIsInstance(FileStorage._FileStorage__objects, dict)
self.assertIsInstance(
FileStorage._FileStorage__objects[re.__class__.__name__ + '.' +
re.id], Review)
self.assertEqual(
FileStorage._FileStorage__objects[re.__class__.__name__ + '.' +
re.id].to_dict(), re.to_dict())
def test_FileStorage_empty(self):
"""File Storage type class test"""
self.assertEqual(FileStorage, type(FileStorage()))
self.assertEqual(FileStorage, type(storage))
self.assertEqual(storage.all(), {})
def setUp(self):
'''Set up test case'''
self.f = FileStorage()
self.base = BaseModel()
self.model = BaseModel()
def test_FileStorage_init_none(self):
"""File Storage none test"""
with self.assertRaises(TypeError):
FileStorage(None)
def setUpClass(cls):
''' Set FileStorage Class '''
cls.test_inst = FileStorage()
#!/usr/bin/python3
"""A module for unittests for the user class"""
import unittest
import os
from models.amenity import Amenity
from models.engine.file_storage import FileStorage
fs = FileStorage()
class TestUser(unittest.TestCase):
"""class to test Amenity"""
def test_name(self):
if os.path.exists(fs._FileStorage__file_path):
os.remove(fs._FileStorage__file_path)
u1 = Amenity()
self.assertIsInstance(u1.name, str)
if __name__ == '__main__':
unittest.main()
def setUpClass(cls):
'''Set Stuff Up for Class'''
cls.fs_o = FileStorage()
def setUpClass(cls):
""" set up class instances for FileStorage tests """
storage = FileStorage()
def test_FileStorage_standard_instantiation(self):
self.assertEqual(type(FileStorage()), FileStorage)
def test_is_an_instance(self):
""" function test_is_an_instance """
my_model = FileStorage()
self.assertIsInstance(my_model, FileStorage)
def test_all_first(self):
"""Test method all"""
f = FileStorage()
self.assertIsInstance(f.all(), dict)
def test_User_is_dict(self):
"""testing if dict"""
st = FileStorage()
st_dict = st.all()
self.assertTrue(st_dict)
self.assertEqual(dict, type(st_dict))
