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): '''