def do_all(self, args):
'''
Prints all string representation of all instances
based or not on the class name.
'''
obj_list = []
if os.environ.get('HBNB_TYPE_STORAGE') == 'db':
storage = DBStorage()
else:
storage = FileStorage()
if args:
objects = storage.all(eval(args)().__class__)
if not args:
objects = storage.all()
try:
if len(args) != 0:
eval(args)
except NameError:
print("** class doesn't exist **")
return
for key, val in objects.items():
if len(args) != 0:
if type(val) is eval(args):
obj_list.append(val)
else:
obj_list.append(val)
print(obj_list)
def test_all(self):
"""tests if all works in File Storage"""
storage = DBStorage()
storage.reload()
dict_len = len(storage.all())
s = State(name="test_all_state")
s.save()
storage.save()
self.assertIs(len(storage.all()), dict_len + 1)
def test_all(self):
"""tests all in File Storage"""
storage = DBStorage()
storage.reload()
len_of_dict = len(storage.all())
state = State(name="test_all_state")
state.save()
storage.save()
self.assertsIs(len(storage.all()), len_of_dict + 1)
def test_new(self):
"""test when new is created"""
storage = DBStorage()
user = User()
user.id = 123455
user.name = "Kevin"
storage.new(user)
obj = storage.all()
key = user.__class__.__name__ + "." + str(user.id)
self.assertIsNotNone(obj[key])
objt = storage.all(User)
self.assertIn(key, objt.keys())
class testDBstorage(unittest.TestCase):
""" Class to test the db storage method """
def __init__(self, *args, **kwargs):
""" Set up test environment """
super().__init__(*args, **kwargs)
self.s = DBStorage()
self.name = 'DBStorage'
self.values = DBStorage
self.s.__dict__['_DBStorage__engine'] = create_engine(
"mysql+mysqldb://{}:{}@{}:3306/{}".format('hbnb_test',
'hbnb_test_pwd',
'localhost',
'hbnb_test_db'),
pool_pre_ping=True)
self.s.reload()
self.q = self.s.__dict__['_DBStorage__session']
def setUp(self):
""" its a setup """
try:
Base.metadata.create_all(self.s)
except:
pass
def tearDown(self):
""" Remove db at end of tests """
try:
Base.metadata.drop_all(self.s)
except:
pass
def test_obj_list_empty(self):
""" __objects is initially empty """
self.assertEqual(len(self.s.all()), 0)
@unittest.skip("not working")
def test_new(self):
""" New object is correctly added to __objects """
new = User()
new.save()
for obj in self.s.all().values():
temp = obj
self.assertTrue(temp is obj)
def test_all(self):
""" __objects is properly returned """
new = BaseModel()
temp = self.s.all()
self.assertIsInstance(temp, dict)
def test_all(self):
"""tests if all works in DB Storage"""
storage = DBStorage()
obj = storage.all()
self.assertIsNotNone(obj)
self.assertEqual(type(obj), dict)
self.assertIs(obj, storage._DBStorage__objects)
class TestDBStorage(unittest.TestCase):
""" Class to test the file storage method """
@classmethod
def setUpClass(self):
"""setUpClass module"""
storage._DBStorage__session.close()
self.store = DBStorage()
self.store.reload()
@classmethod
def tearDownClass(self):
"""tearDownClass module"""
self.store._DBStorage__session.close()
storage.reload()
def test_all(self):
"""print alls objects"""
self.assertEqual(len(self.store.all()), 0)
new_obj = State()
new_obj.name = 'California'
self.store.new(new_obj)
self.assertEqual(len(self.store.all()), 1)
# Make all('classname') work without console
def test_new(self):
"""New objects"""
new_obj = State()
new_obj.name = "Texas"
new_obj.save()
self.assertTrue(len(self.store.all()), 1)
def test_save(self):
"""save objects"""
self.store.reload()
new_obj = State()
new_obj.name = 'Washington'
self.store.new(new_obj)
self.store.save()
self.assertEqual(len(self.store.all()), 4)
def test_delete(self):
new_obj = State()
new_obj.name = "Michigan"
self.store.new(new_obj)
self.store.save()
self.store.delete(new_obj)
self.assertFalse(new_obj in self.store.all())
def test_reload(self):
"""reload datas objects"""
new_obj = City()
self.store.new(new_obj)
self.store.reload()
test_len = len(self.store.all())
self.assertEqual(test_len, 3)
self.store.reload()
for value in self.store.all().values():
self.assertIsInstance(value.created_at, datetime)
def test_new(self):
"""test when new is created"""
storage = DBStorage()
obj = storage.all()
user = User()
user.id = 123455
user.name = "Kevin"
user.email = "x"
user.password = "******"
storage.new(user)
key = user.__class__.__name__ + "." + str(user.id)
if os.environ['HBNB_TYPE_STORAGE'] != 'db':
self.assertIsNotNone(obj[key])
class TestDBStorage(unittest.TestCase):
'''this will test the DBStorage'''
def setUp(self):
"""set up for test"""
self.storage = DBStorage()
self.storage.reload()
def test_pep8_DBStorage(self):
"""Tests pep8 style"""
style = pep8.StyleGuide(quiet=True)
p = style.check_files(['models/engine/db_storage.py'])
self.assertEqual(p.total_errors, 0, "fix pep8")
def test_all(self):
"""test if all works in DBStorage"""
self.objs = self.storage.all()
self.assertIsNotNone(self.objs)
self.assertEqual(type(self.objs), dict)
def test_new(self):
"""Test that a new object is added to the DB"""
state1 = State()
setattr(state1, 'name', 'California')
state2 = State()
setattr(state2, 'name', 'Arizona')
state1.save()
state2.save()
session = self.storage._DBStorage__session
self.assertIsNotNone(session)
results = session.query(State).all()
self.assertIs(type(results), list)
"""TODO
Assess results
"""
def tearDown(self):
del self.storage
class TestDBStorage(unittest.TestCase):
"""Tests the DBStorage class"""
def test_pep8_FileStorage(self):
"""Tests pep8 style"""
style = pep8.StyleGuide(quiet=True)
p = style.check_files(['models/engine/db_storage.py'])
self.assertEqual(p.total_errors, 0, "fix pep8")
@classmethod
def setUpClass(cls):
"""set up for test"""
"""
environ['HBNB_ENV'] = 'test'
environ['HBNB_MYSQL_USER'] = '******'
environ['HBNB_MYSQL_PWD'] = 'hbnb_test_pwd'
environ['HBNB_MYSQL_HOST'] = 'localhost'
environ['HBNB_MYSQL_DB'] = 'hbnb_test_db'
environ['HBNB_TYPE_STORAGE'] = 'db'
"""
pass
@unittest.skipIf('HBNB_TYPE_STORAGE' not in environ or
environ['HBNB_TYPE_STORAGE'] != 'db', 'These tests\
should only be used when storage type is db')
def setUp(self):
"""Setup the class"""
self.user = User()
self.user.first_name = "Kev"
self.user.last_name = "Yo"
self.user.email = "*****@*****.**"
self.user.password = "******"
self.storage = DBStorage()
self.storage.reload()
def tearDownClass():
"""
del environ['HBNB_ENV']
del environ['HBNB_MYSQL_USER']
del environ['HBNB_MYSQL_PWD']
del environ['HBNB_MYSQL_HOST']
del environ['HBNB_MYSQL_DB']
del environ['HBNB_TYPE_STORAGE']
"""
pass
@unittest.skipIf('HBNB_TYPE_STORAGE' not in environ or
environ['HBNB_TYPE_STORAGE'] != 'db', 'These tests\
should only be used when storage type is db')
def test_all(self):
""" Tests db_storage all method to query objects in the database
"""
original_len = self.storage.all(User)
self.storage.new(self.user)
self.storage.save()
new_len = self.storage.all(User)
self.assertTrue(original_len != new_len)
@unittest.skipIf('HBNB_TYPE_STORAGE' not in environ or
environ['HBNB_TYPE_STORAGE'] != 'db', 'These tests\
should only be used when storage type is db')
def test_new(self):
""" Tests db_storage new method to add a new object"""
original_len = self.storage.all(User)
self.storage.new(self.user)
self.storage.save()
new_len = self.storage.all(User)
self.assertTrue(original_len != new_len)
@unittest.skipIf('HBNB_TYPE_STORAGE' not in environ or
environ['HBNB_TYPE_STORAGE'] != 'db', 'These tests\
should only be used when storage type is db')
def test_save(self):
""" Tests db_storage save method to save the added object """
original_len = self.storage.all(User)
self.storage.new(self.user)
self.storage.save()
new_len = self.storage.all(User)
self.assertTrue(original_len != new_len)
@unittest.skipIf('HBNB_TYPE_STORAGE' not in environ or
environ['HBNB_TYPE_STORAGE'] != 'db', 'These tests\
should only be used when storage type is db')
def test_delete(self):
""" Tests db_storage delete method to delete an object form the db
"""
original_len = self.storage.all(User)
self.storage.new(self.user)
self.storage.save()
self.storage.delete(self.user)
new_len = self.storage.all(User)
self.assertTrue(original_len == new_len)
@unittest.skipIf('HBNB_TYPE_STORAGE' not in environ or
environ['HBNB_TYPE_STORAGE'] != 'db', 'These tests\
should only be used when storage type is db')
def test_reload(self):
"""Tests db_storage delete method"""
pass
"""def test_reload(self):
class testDBStorage(unittest.TestCase):
'''
unittest class for testing DBStorage module
'''
def setUp(self):
'''
Sets up the environment for testing DBStorage
'''
os.environ['HBNB_TYPE_STORAGE'] = 'db'
os.environ['HBNB_MYSQL_USER'] = '******'
os.environ['HBNB_MYSQL_PWD'] = 'hbnb_test_pwd'
os.environ['HBNB_MYSQL_HOST'] = 'localhost'
os.environ['HBNB_MYSQL_DB'] = 'hbnb_test_db'
self.storage = DBStorage()
self.my_model = models.BaseModel()
self.storage.reload()
def test_DBStorage_type_storage_environ(self):
'''
Test if environment is updating
'''
self.assertEqual(os.getenv('HBNB_TYPE_STORAGE'), 'db')
def test_DBStorage_all_method(self):
'''
Test all method
'''
new_dict = self.storage.all()
self.assertTrue(type(new_dict) == type(dict()))
def test_DBStorage_new_method(self):
'''
Test new method
'''
new_state = models.State()
self.storage.new(new_state)
self.assertTrue(new_state in self.storage._DBStorage__session)
def test_DBStorage_reload_method(self):
'''
Test reload method
'''
test = self.storage._DBStorage__engine.execute("show databases;")
test = [x for x in test]
new = False
for x in test:
if os.getenv('HBNB_MYSQL_DB') in x[0]:
new = True
self.assertTrue(new,)
def test_DBStorage_delete_method(self):
'''
Test delete method
'''
def test_DBStorage_delete_parent_deletes_children(self):
'''
Test if deleting a parent deletes the children as well
'''
def test_DBStorage_save_method(self):
'''
Test save method
'''
def test_DBStorage_in_correct_DB(self):
'''
Test if going to correct database
'''
def test_DBStorage_drop_all(self):
'''
