def do_destroy(self, args): ''' Deletes an instance based on the class name and id. ''' args = shlex.split(args) if len(args) == 0: print("** class name missing **") return elif len(args) == 1: print("** instance id missing **") return class_name = args[0] class_id = args[1] storage = FileStorage() storage.reload() obj_dict = storage.all() try: eval(class_name) except NameError: print("** class doesn't exist **") return key = class_name + "." + class_id try: del obj_dict[key] except KeyError: print("** no instance found **") storage.save()
def test_reload(self): """ Test reload method """ my_storage = FileStorage() my_storage.save() objects = my_storage.all() my_storage.reload() self.assertEqual(my_storage.all(), objects)
def test_save_method_serializes___objects_to_json_file(self): """tests that save() converts the __objects dict to json format and saves it to __file_path (file.json)""" f = FileStorage() model = BaseModel() f.new(model) f.save() result = os.path.isfile('file.json') self.assertEqual(result, True)
def test_delete_method(self): """Test delete method""" fs = FileStorage() new_state = State() fs.new(new_state) fs.save() self.assertIn(new_state, fs.all(State).values()) fs.delete(new_state) self.assertNotIn(new_state, fs.all(State).values())
def test_reload(self): '''test reload''' store = FileStorage() inst = BaseModel() inst_id = inst.id store.new(inst) store.save() store.reload() inst_dict = store.all() self.assertEqual(type(inst_dict), dict)
def test_save(self): """ test if file.json is saved or created""" store = FileStorage() self.assertIsInstance(store, FileStorage) b1 = BaseModel() store.new(b1) store.name = "Gary" store.my_number = 89 store.save() self.assertTrue(os.path.exists('file.json'))
def test_save(self): """Tests the save method of File Storage class""" Storage = FileStorage() Storage.reset() b1 = BaseModel() Storage.new(b1) self.assertFalse(path.exists("file.json")) Storage.save() self.assertTrue(path.exists("file.json"))
def test_delete(self): """tests if all works in File Storage""" storage = FileStorage() state_instance = State(name="California") self.assertIsNotNone(state_instance) storage.new(state_instance) storage.save() storage.delete(state_instance) obj_state = storage.all(State) self.assertEqual(len(obj_state), 0)
def test_03a_working_reload(self): """Checks reload functionality if file_path doesn't exist""" fs = FileStorage() b = BaseModel() key = "BaseModel" + '.' + b.id fs.new(b) fs.save() fs.reset() fs.reload() self.assertTrue(fs.all()[key])
def test_reload(self): """ test relaod """ b = BaseModel() f = FileStorage() f.new(b) f.save() d = f.all() f.reload() self.assertEqual(d, f.all())
def test_file_exist(self): """ Checking if JSON file exist and is reloading """ user1 = User() fileStorage = FileStorage() k = "{}.{}".format(type(user1).__name__, user1.id) fileStorage.new(user1) fileStorage.save() self.assertTrue(path.exists('file.json'))
def test_savebyreadingfile(self): """Tests the save method by reading file""" Storage = FileStorage() Storage.reset() b1 = BaseModel() Storage.new(b1) Storage.save() with open("file.json", "r", encoding='utf-8') as r: content = r.read() self.assertTrue("BaseModel.{}".format(b1.id) in content)
def test_get(self): """Tests the get() method, retrieves an object by its name """ storage = FileStorage() storage.reload() jur1 = Jurisdiction(**{"name": "Cauca", "victims": 3}) storage.save() jur1_clone = storage.get(Jurisdiction, "Cauca") self.assertTrue(jur1_clone is jur1)
def test_file_storage_new_method(self): """Test new method""" my_model = BaseModel() my_storage = FileStorage() my_storage.new(my_model) my_storage.save() desired_key = my_model.__class__.__name__ + '.' + my_model.id for key in my_storage._FileStorage__objects: if key == desired_key: self.assertEqual(desired_key, key)
def test_for_reload(self): """test for reload function""" f1 = FileStorage() f2 = BaseModel() key = "BaseModel" + "." + f2.id f1.new(f2) f1.save() f1._FileStorage__objects = {} f1.reload() self.assertTrue(f1.all()[key])
def test_reset(self): """ Tests if the reset method empties the database """ storage = FileStorage() storage.reload() jur1 = Jurisdiction(**{"name": "Cauca", "victims": 3}) storage.save() storage.reset() data = storage.all() self.assertTrue(data == {})
def test_FileStorage_save_file_key(self): """Test the save() method to check contents of file.json """ bm1 = BaseModel() class_name = bm1.__class__.__name__ key = class_name + '.' + str(bm1.id) storage = FileStorage() storage.new(bm1) storage.save() with open('file.json') as file: self.assertIn(key, file.read())
def test_base_model(self): """testing the BaseModel""" dog = FileStorage() self.assertIs(type(dog.id), str) self.assertIs(type(dog.created_at), datetime) self.assertIs(type(dog.updated_at), datetime) self.assertNotEqual(dog.created_at, dog.updated_at) self.assertFalse(dog.updated_at == datetime.utcnow()) old_updated = dog.updated_at dog.save()
def test_FileStorage_save_file_exists(self): """Test the save() method if file.json exists""" bm1 = BaseModel() class_name = bm1.__class__.__name__ key = class_name + '.' + str(bm1.id) storage = FileStorage() storage.new(bm1) storage.save() with open('file.json') as file: self.assertTrue(isinstance(file.read(), str))
class testFileStorage(unittest.TestCase): '''Testing the FileStorage class''' def setUp(self): '''Initializing classes''' self.storage = FileStorage() self.my_model = BaseModel() def tearDown(self): '''Cleaning up.''' try: os.remove("file.json") except FileNotFoundError: pass def test_all_return_type(self): ''' Tests the data type of the return value of the all method.''' storage_all = self.storage.all() self.assertIsInstance(storage_all, dict) def test_new_method(self): '''Tests that the new method sets the right key and value pair in the FileStorage.__object attribute''' self.storage.new(self.my_model) key = str(self.my_model.__class__.__name__ + "." + self.my_model.id) self.assertTrue(key in self.storage._FileStorage__objects) def test_objects_value_type(self): '''Tests that the type of value contained in the FileStorage.__object is of type obj.__class__.__name__''' self.storage.new(self.my_model) key = str(self.my_model.__class__.__name__ + "." + self.my_model.id) val = self.storage._FileStorage__objects[key] self.assertIsInstance(self.my_model, type(val)) def test_save_file_exists(self): ''' Tests that a file gets created with the name file.json''' self.storage.save() self.assertTrue(os.path.isfile("file.json")) def test_save_file_read(self): '''Testing the contents of the files inside the file.json''' self.storage.save() self.storage.new(self.my_model) with open("file.json", encoding="UTF8") as fd: content = json.load(fd) self.assertTrue(type(content) is dict)
def test_filestorage_count(self): ''' Testing Count method ''' filestor = FileStorage() old_count = filestor.count("State") new = State(name="Alabama") filestor.new(new) filestor.save() new_count = filestor.count("State") self.assertEqual(old_count + 1, new_count)
def test_save_method(self): """ Test for save method """ _dict = self.storage.to_dict() new_key = _dict['__class__'] + "." + _dict['id'] new = FileStorage() new.save() with open("file.json", 'r') as fd: file_r = json.load(fd) new = file_r[new_key] for key in new: self.assertEqual(_dict[key], new[key])
def test_change_length(self): """ Create an object and save it and checks the new length for dictionary """ new = FileStorage() len1 = len(new.all()) second = BaseModel() new.save() new.reload() len2 = len(new.all()) self.assertEqual(len1, len2 - 1)
def test_for_save(self): """test for save function""" s = FileStorage() s._FileStorage__objects = {} s.new(BaseModel()) self.assertFalse(os.path.exists("file.json")) s.save() self.assertTrue(os.path.exists("file.json")) with open("file.json", 'r') as f: self.assertEqual(type(f.read()), str) self.assertNotEqual(os.stat("file.json").st_size, 0)
class TestFileStorage(unittest.TestCase): """This is Unittest for the method FileStorage""" def setUp(self): """This is the setup method for Unittesting""" self.otter = FileStorage() self.otter.file_path = "test_file.json" self.otter.reload() self.objects = self.otter.objects self.UrchinA = self.objects["Amenity.\ 19b4933a-55d0-4287-99a0-773c1dcab528"] self.UrchinB = self.objects["BaseModel.\ 7152df91-ec26-4595-bf75-fd84f02a3bd9"] self.UrchinC = self.objects["City.\ f76cbf19-eb40-4901-88ca-569684490fd1"] self.UrchinP = self.objects["Place.\ 52cf288d-f402-4564-a91f-06c71004c6b7"] self.UrchinR = self.objects["Review.\ ac984526-613a-4ec8-933d-ab32a5f924b9"] self.UrchinS = self.objects["State.\ 125b2cf3-66d9-4185-b442-e8a49cb7801d"] self.UrchinU = self.objects["User.\ bf654f25-d81f-4d02-a3c0-1777c5bfeda5"] def test_all(self): """This is the Unittest for the method all""" test_dict = self.otter.all() self.assertIsInstance(test_dict, dict) for key in test_dict: self.assertEqual(test_dict[key], self.otter.objects[key]) def test_new(self): """This is a Unittest for the method new""" new_obj = copy.deepcopy(self.UrchinB) new_obj.id = "7152df91-ec26-4595-bf75-fd84f02atest" self.otter.new(new_obj) otter_dict = self.otter.objects test_obj = otter_dict["BaseModel.7152df91-ec26-4595-bf75-fd84f02atest"] self.assertIsInstance(test_obj, BaseModel) self.assertEqual(test_obj.id, "7152df91-ec26-4595-bf75-fd84f02atest") def test_save(self): """This is a Unittest for the the method save""" if os.path.isfile("test_save.json"): os.remove("test_save.json") self.otter.reload() self.otter.file_path = "test_save.json" self.otter.save() with open(self.otter.file_path, "r") as FILE: test_save_dict = json.loads(FILE.read()) with open("test_file.json", "r") as FILE: test_file_dict = json.loads(FILE.read()) self.assertDictEqual(test_save_dict, test_file_dict) os.remove("test_save.json") self.otter.file_path = "test_file.json"
def test_all_no_specification(self): ''' tests all when no class is passed ''' return True fs = FileStorage() new_state1 = State() fs.new(new_state1) fs.save() new_user1 = User() fs.new(new_user1) fs.save() self.assertEqual(8, len(fs.all()))
def test_FileStorage_reload_successful(self): """Test the reload() method to see if object reloads successfully""" FileStorage._FileStorage__objects = {} bm1 = BaseModel() class_name = bm1.__class__.__name__ key = class_name + '.' + str(bm1.id) storage = FileStorage() storage.new(bm1) storage.save() storage.reload() self.assertIn(key, FileStorage._FileStorage__objects)
class TestFileStorage(unittest.TestCase): ''' Test cases for file_storage class ''' def setUp(self): ''' simple set up ''' self.my_model = BaseModel() self.storage = FileStorage() def tearDown(self): ''' tear down method ''' if os.path.exists("file.json"): os.remove("file.json") else: pass def test_new(self): ''' tests new method in file storage ''' self.storage.new(self.my_model) new_dict = self.storage.all() key = self.my_model.__class__.__name__ + '.' + self.my_model.id self.assertIsInstance(new_dict[key], BaseModel) def test_all(self): ''' tests if all returns a dict ''' self.assertIsInstance(self.storage.all(), dict) def test_save(self): ''' tests the save method of file storage class ''' self.storage.save() self.assertTrue(os.path.exists("file.json")) def test_json_file_content_type(self): ''' tests if the content of the json file is type dict ''' self.storage.save() self.storage.new(self.my_model) with open("file.json", encoding='utf-8') as fd: data = json.load(fd) self.assertIsInstance(data, dict)
def test_reload_2(self): '''Tests reload normal''' Storage = FileStorage() b1 = BaseModel() Storage.new(b1) Storage.save() Storage.reset() Storage.reload() self.assertTrue(Storage.all()["BaseModel.{}".format(b1.id)]) self.assertTrue(Storage._FileStorage__objects["BaseModel.{}".format( b1.id)])
def test_empty_reload(self): """ Empty reload function """ my_obj = FileStorage() new_obj = BaseModel() my_obj.new(new_obj) my_obj.save() my_dict1 = my_obj.all() os.remove("test.json") my_obj.reload() my_dict2 = my_obj.all() self.assertTrue(my_dict2 == my_dict1)
def test_save_FileStorage(self): '''Test if is saving the changes''' dic1 = self.my_model.to_dict() key1 = dic1['__class__'] + "." + dic1['id'] s = FileStorage() s.save() with open("file.json", mode='r') as f: str1 = json.load(f) new = str1[key1] for key in new: self.assertEqual(dic1[key], new[key])
class testFileStorage(unittest.TestCase): ''' Testing the FileStorage class ''' def setUp(self): ''' Initializing classes ''' self.storage = FileStorage() self.my_model = BaseModel() def tearDown(self): ''' Cleaning up. ''' try: os.remove("file.json") except FileNotFoundError: pass def test_all_return_type(self): ''' Tests the data type of the return value of the all method. ''' storage_all = self.storage.all() self.assertIsInstance(storage_all, dict) def test_new_method(self): ''' Tests that the new method sets the right key and value pair in the FileStorage.__object attribute ''' self.storage.new(self.my_model) key = str(self.my_model.__class__.__name__ + "." + self.my_model.id) self.assertTrue(key in self.storage._FileStorage__objects) def test_objects_value_type(self): ''' Tests that the type of value contained in the FileStorage.__object is of type obj.__class__.__name__ ''' self.storage.new(self.my_model) key = str(self.my_model.__class__.__name__ + "." + self.my_model.id) val = self.storage._FileStorage__objects[key] self.assertIsInstance(self.my_model, type(val)) def test_save_file_exists(self): ''' Tests that a file gets created with the name file.json ''' self.storage.save() self.assertTrue(os.path.isfile("file.json")) def test_save_file_read(self): ''' Testing the contents of the files inside the file.json ''' self.storage.save() self.storage.new(self.my_model) with open("file.json", encoding="UTF8") as fd: content = json.load(fd) self.assertTrue(type(content) is dict) def test_the_type_file_content(self): ''' testing the type of the contents inside the file. ''' self.storage.save() self.storage.new(self.my_model) with open("file.json", encoding="UTF8") as fd: content = fd.read() self.assertIsInstance(content, str) def test_reaload_without_file(self): ''' Tests that nothing happens when file.json does not exists and reload is called ''' try: self.storage.reload() self.assertTrue(True) except: self.assertTrue(False)