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 do_show(self, args):
'''
Print the string representation of an instance baed on
the class name and id given as args.
'''
args = shlex.split(args)
if len(args) == 0:
print("** class name missing **")
return
if len(args) == 1:
print("** instance id missing **")
return
storage = FileStorage()
storage.reload()
obj_dict = storage.all()
try:
eval(args[0])
except NameError:
print("** class doesn't exist **")
return
key = args[0] + "." + args[1]
key = args[0] + "." + args[1]
try:
value = obj_dict[key]
print(value)
except KeyError:
print("** no instance found **")
def test_Filestorage_new(self):
"""Tests new method"""
tmpstor = FileStorage()
tmpdic = tmpstor.all()
Bob = User()
Bob.id = 1996
Bob.name = "Robert"
tmpstor.new(Bob)
k = "{}.{}".format(Bob.__class__.__name__, str(Bob.id))
self.assertIsNotNone(tmpdic[k])
def test_new(self):
"""test when new is created"""
storage = FileStorage()
obj = storage.all()
user = User()
user.id = 123455
user.name = "Kevin"
storage.new(user)
key = user.__class__.__name__ + "." + str(user.id)
self.assertIsNotNone(obj[key])
def test_new(self):
""" test method new """
store = FileStorage()
store_dict = store.all()
gary = User()
gary.id = 69
gary.name = "Morpheous"
store.new(gary)
key = "{}.{}".format(gary.__class__.__name__, gary.id)
self.assertIsNotNone(store_dict[key])
def test_save(self):
for item in self.test_objects:
self.storage.new(item[2])
self.storage.save()
new_storage = FileStorage()
new_storage._FileStorage__objects = {}
new_storage._FileStorage__file_path = "atestfile.json"
new_storage.reload()
for key in self.storage.all():
self.assertIn(key, new_storage.all())
def cities(self):
""" Getter that return a list of City instances """
# <all> method in file_storage.py returns the dictionary .__objects
# the __objects contains all created instances
obj_dictionary = FileStorage.all()
city_instances = []
for key, value in obj_dictionary.items():
if value.state_id == self.id:
city_instances.append(value)
return (city_instances)
def test_new(self):
"""test if new set key properly with user as example"""
storage = FileStorage()
obj = storage.all()
user = User()
user.id = "38f22813-2753-4d42-b37c-57a17f1e4f88"
user.name = "Betty"
storage.new(user)
key = user.__class__.__name__ + "." + str(user.id)
self.assertIsNotNone(obj[key])
def test_using_json(self):
'''Check serialization and deserialization json file'''
storage = FileStorage()
all_objs = storage.all()
self.assertIsInstance(all_objs, dict, "es diccionario") # Test all
self.obj.name = "Betty"
self.obj.my_number = 89
self.obj.save()
with open("file.json", "r", encoding='utf-8') as f:
self.assertTrue(self.obj.name in f.read()) # Test save
def test_new(self):
"""
Tests the new method
"""
fs = FileStorage()
bm = BaseModel()
bmc = BaseModel.__class__.__name__
bmid = bm.id
dic = fs.all()
fs.new(bm)
def test_delete(self):
""" Tests delete method to delete objects in __object """
storage = FileStorage()
obj_dict = storage.all()
usr = User()
usr.id = 12345
storage.new(usr)
storage.delete(usr)
key = usr.__class__.__name__ + "." + str(usr.id)
self.assertFalse(key in obj_dict.keys())
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 default(self, line):
"""
Default method for line
"""
methods = {'all': self.do_all,
'show': self.do_show,
'destroy': self.do_destroy,
'update': self.do_update}
arg = re.split(r'\.', line)
obj = arg[0]
arg1 = re.split('[()]', arg[1])
func = arg1[0]
uid = ''
flag = 0
if obj in self.classes:
command = eval(arg[0])
if func == 'all':
funtion = methods[func]
funtion(obj)
elif func == "count":
storage = FileStorage()
dict1 = storage.all()
count = 0
for key, val in dict1.items():
if command == val.__class__:
count += 1
print(count)
elif func in methods:
funtion = methods[func]
if func == 'update':
uid = eval(arg1[1])
new_list = list(uid)
print(type(new_list[1]))
uid = new_list[0]
if isinstance(new_list[1], dict):
for key, value in new_list[1].items():
attr = key
val = str(value)
line = obj + " " + uid + " " + attr + " " + val
funtion(line)
flag = 1
else:
attr = new_list[1]
val = str(new_list[2])
line = obj + " " + uid + " " + attr + " " + val
else:
if arg1[1] != '':
uid = eval(arg1[1])
line = obj + " " + uid
if flag == 0:
funtion(line)
else:
print("*** Unknown syntax:", line)
else:
print("*** Unknown syntax:", line)
class Test_FileStorage(unittest.TestCase):
"""
Test the file storage class
"""
def setUp(self):
self.arr = []
self.cli = HBNBCommand()
self.store = FileStorage()
test_args = {
'updated_at': datetime(2017, 2, 12, 00, 31, 53, 331997),
'id': 'f519fb40-1f5c-458b-945c-2ee8eaaf4900',
'created_at': datetime(2017, 2, 12, 00, 31, 53, 331900)
}
self.model = BaseModel(test_args)
self.test_len = 0
if os.path.isfile("file.json"):
self.test_len = len(self.store.all())
def test_all(self):
self.assertEqual(len(self.store.all()), self.test_len)
def test_new(self):
self.assertEqual(len(self.store.all()), self.test_len)
self.model.save()
self.assertEqual(len(self.store.all()), self.test_len + 1)
a = BaseModel()
a.save()
self.assertEqual(len(self.store.all()), self.test_len + 2)
self.cli.do_destroy("BaseModel f519fb40-1f5c-458b-945c-2ee8eaaf4900")
self.cli.do_destroy("BaseModel " + a.id)
def test_save(self):
self.test_len = len(self.store.all())
a = BaseModel()
a.save()
self.assertEqual(len(self.store.all()), self.test_len + 1)
b = User()
self.assertNotEqual(len(self.store.all()), self.test_len + 2)
b.save()
self.assertEqual(len(self.store.all()), self.test_len + 2)
self.cli.do_destroy("BaseModel " + a.id)
self.cli.do_destroy("User " + b.id)
def test_reload(self):
pass
def test_delete(self):
"""Tests the method delete (obj, called from destroy method)"""
storage = FileStorage()
state = State()
state.id = 123455
state.name = "Medellin"
key = state.__class__.__name__ + "." + str(state.id)
storage.new(state)
storage.delete(state)
obj = storage.all()
self.assertTrue(key not in obj.keys())
def test_new(self):
"""Tests the new method"""
temp_storage = FileStorage()
temp_dict = temp_storage.all()
Holberton = User()
Holberton.id = 972
Holberton.name = "Holberton"
temp_storage.new(Holberton)
class_name = Holberton.__class__.__name__
key = "{}.{}".format(class_name, str(Holberton.id))
self.assertIsNotNone(temp_dict[key])
def test_all_no_class(self):
"""Test all without class"""
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_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_all_state(self):
"""Tests all method with State class"""
storage = FileStorage()
state = State()
state.name = "Minnesota"
state.id = "55975"
storage.new(state)
obj = storage.all(State)
key = state.__class__.__name__ + "." + str(state.id)
self.assertIn(key, obj)
self.assertIsInstance(obj[key], State)
def test_new(self):
""" Tests method: new (saves new object into dictionary)
"""
m_storage = FileStorage()
instances_dic = m_storage.all()
user1 = User()
user1.id = 999999
user1.name = "user1"
m_storage.new(user1)
key = user1.__class__.__name__ + "." + str(user1.id)
self.assertIsNotNone(instances_dic[key])
def test_new(self):
"""Tests the new method"""
temp_storage = FileStorage()
temp_dict = temp_storage.all()
notrebloh = User()
notrebloh.id = 972
notrebloh.name = "notrebloh"
temp_storage.new(notrebloh)
class_name = notrebloh.__class__.__name__
key = "{}.{}".format(class_name, str(notrebloh.id))
self.assertIsNotNone(temp_dict[key])
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_all(self):
"""
Test the `all` method fills
values into the `__objects` dict.
"""
fs = FileStorage()
dic = fs.all()
self.assertIsNotNone(dic)
self.assertEqual(type(dic), dict)
self.assertIs(dic, fs._FileStorage__objects)
def test_des_and_serialization(self):
'''check serialization and deserialization'''
storage = FileStorage()
all_objs = storage.all()
self.assertIsInstance(all_objs, dict, "es diccionario") # Test all
my_model = User()
my_model.name = "Paparoachchchch"
my_model.my_number = 95
my_model.save()
with open("file.json", "r", encoding='utf-8') as f:
self.assertTrue(my_model.name in f.read()) # Test save
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_n(self):
"""
"""
storage = FileStorage()
obj = storage.all()
user = User()
user.id = 12345
user.name = "Karen"
storage.new(user)
key = user.__class__.__name__ + "." + str(user.id)
self.assertIsNotNone(obj[key])
def test_all_instance(self):
am = Amenity()
keyam = str(am.__class__.__name__) + '.' + str(am.id)
ci = City()
keyci = str(ci.__class__.__name__) + '.' + str(ci.id)
pl = Place()
keypl = str(pl.__class__.__name__) + '.' + str(pl.id)
rev = Review()
keyrev = str(rev.__class__.__name__) + '.' + str(rev.id)
st = State()
keyst = str(st.__class__.__name__) + '.' + str(st.id)
us = User()
keyus = str(us.__class__.__name__) + '.' + str(us.id)
all_obj = FileStorage()
self.assertTrue(keyam in all_obj.all())
self.assertTrue(keyci in all_obj.all())
self.assertTrue(keypl in all_obj.all())
self.assertTrue(keyrev in all_obj.all())
self.assertTrue(keyst in all_obj.all())
self.assertTrue(keyus in all_obj.all())
def test_new(self):
""" Cheking when new object is created
"""
fileStorage = FileStorage()
new_obj = fileStorage.all()
city = City()
city.state_id = "123abc"
city.name = "Cali"
fileStorage.new(city)
k = "{}.{}".format(type(city).__name__, city.id)
self.assertIsNotNone(new_obj[k])
def test_create_00(self):
''' Tests for the create command. '''
# Create console session.
cons = self.create_session()
# Test "create {} name='California'".
with patch('sys.stdout', new=StringIO()) as Output:
cons.onecmd('create State name=\"California\"')
create_stdout = Output.getvalue().strip()
create_stdout = 'State.{}'.format(create_stdout)
self.assertTrue(create_stdout in Storage.all())
def test_class_variables(self):
""" slkjdfgh """
subject = FileStorage()
to_d = []
if os.path.exists('file.json'):
os.remove('file.json')
for e in subject.all().keys():
to_d.append(subject.all()[e])
for e in to_d:
del subject.all()[e.__class__.__name__ + '.' + e.id]
# check attributes exist
self.assertFalse(hasattr(FileStorage, '__file_path'))
self.assertFalse(hasattr(FileStorage, '__objects'))
self.assertFalse(hasattr(subject, '__file_path'))
self.assertFalse(hasattr(subject, '__objects'))
del subject
if os.path.exists('file.json'):
print('file still exists')
os.remove('file.json')
class Test_FileStorage(unittest.TestCase):
"""
Test FileStorage
"""
def setUp(self):
self.store = FileStorage()
test_args = {
'updated_at': datetime(2019, 7, 6, 1, 0, 0, 100000),
'id': '12345678-0123-0123-0123-012345678901',
'created_at': datetime(2019, 7, 5, 1, 0, 0, 100000)
}
self.model = BaseModel(test_args)
self.test_len = 0
if os.path.isfile("file.json"):
self.test_len = len(self.store.all())
def tearDown(self):
import os
if os.path.isfile("file.json"):
os.remove('file.json')
def test_all(self):
self.assertEqual(len(self.store.all()), self.test_len)
def test_new(self):
self.assertEqual(len(self.store.all()), self.test_len)
self.model.save()
self.assertEqual(len(self.store.all()), self.test_len + 1)
a = BaseModel()
a.save()
self.assertEqual(len(self.store.all()), self.test_len + 2)
def test_save(self):
self.test_len = len(self.store.all())
a = BaseModel()
a.save()
self.assertEqual(len(self.store.all()), self.test_len + 1)
b = User()
self.assertNotEqual(len(self.store.all()), self.test_len + 2)
b.save()
self.assertEqual(len(self.store.all()), self.test_len + 2)
def test_reload(self):
pass
def test_new(self):
"""
Tests the new method
"""
new_fs = FileStorage()
dict_2 = new_fs.all()
Holbie = User()
Holbie.id = 8888
Holbie.name = "Dennis"
new_fs.new(Dennis)
key = new_fs.__class__.__name__ + "." + str(new_fs.id)
self.assertIsNotNone(dict_2[key])
def do_count(self, args):
'''
Counts/retrieves the number of instances.
'''
obj_list = []
storage = FileStorage()
storage.reload()
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(len(obj_list))
def do_update(self, args):
'''
Update an instance based on the class name and id
sent as args.
'''
storage = FileStorage()
storage.reload()
args = shlex.split(args)
if len(args) == 0:
print("** class name missing **")
return
elif len(args) == 1:
print("** instance id missing **")
return
elif len(args) == 2:
print("** attribute name missing **")
return
elif len(args) == 3:
print("** value missing **")
return
try:
eval(args[0])
except NameError:
print("** class doesn't exist **")
return
key = args[0] + "." + args[1]
obj_dict = storage.all()
try:
obj_value = obj_dict[key]
except KeyError:
print("** no instance found **")
return
try:
attr_type = type(getattr(obj_value, args[2]))
args[3] = attr_type(args[3])
except AttributeError:
pass
setattr(obj_value, args[2], args[3])
obj_value.save()
def do_all(self, args):
'''
Prints all string representation of all instances
based or not on the class name.
'''
obj_list = []
storage = FileStorage()
storage.reload()
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)
class Test_FileStorage(unittest.TestCase):
"""
Test the file storage class
"""
def setUp(self):
self.store = FileStorage()
test_args = {'updated_at': datetime(2017, 2, 12, 00, 31, 53, 331997),
'id': 'f519fb40-1f5c-458b-945c-2ee8eaaf4900',
'created_at': datetime(2017, 2, 12, 00, 31, 53, 331900)}
self.model = BaseModel(**test_args)
self.test_len = len(self.store.all())
# @classmethod
# def tearDownClass(cls):
# import os
# if os.path.isfile("test_file.json"):
# os.remove('test_file.json')
def test_all(self):
self.assertEqual(len(self.store.all()), self.test_len)
def test_all_arg(self):
"""test all(State)"""
new_obj = State()
new_obj.save()
everything = self.store.all()
nb_states = 0
for e in everything.values():
if e.__class__.__name__ == "State":
nb_states += 1
self.assertEqual(len(self.store.all("State")), nb_states)
# should test with a bad class name
def test_new(self):
# note: we cannot assume order of test is order written
test_len = len(self.store.all())
# self.assertEqual(len(self.store.all()), self.test_len)
new_obj = State()
new_obj.save()
self.assertEqual(len(self.store.all()), test_len + 1)
a = BaseModel()
a.save()
self.assertEqual(len(self.store.all()), self.test_len + 2)
def test_save(self):
self.test_len = len(self.store.all())
a = BaseModel()
a.save()
self.assertEqual(len(self.store.all()), self.test_len + 1)
b = User()
self.assertNotEqual(len(self.store.all()), self.test_len + 2)
b.save()
self.assertEqual(len(self.store.all()), self.test_len + 2)
def test_reload(self):
self.model.save()
a = BaseModel()
a.save()
self.store.reload()
for value in self.store.all().values():
self.assertIsInstance(value.created_at, datetime)
def test_state(self):
"""test State creation with an argument"""
a = State(name="Kamchatka", id="Kamchatka666")
a.save()
self.assertIn("Kamchatka666", self.store.all("State").keys())
def test_count(self):
"""test count all"""
test_len = len(self.store.all())
a = Amenity(name="test_amenity")
a.save()
self.assertEqual(test_len + 1, self.store.count())
def test_count_arg(self):
"""test count with an argument"""
test_len = len(self.store.all("Amenity"))
a = Amenity(name="test_amenity_2")
a.save()
self.assertEqual(test_len + 1, self.store.count("Amenity"))
def test_count_bad_arg(self):
"""test count with dummy class name"""
self.assertEqual(-1, self.store.count("Dummy"))
def test_get(self):
"""test get with valid cls and id"""
a = Amenity(name="test_amenity3", id="test_3")
a.save()
result = self.store.get("Amenity", "test_3")
self.assertEqual(a.name, result.name)
self.assertEqual(a.created_at, result.created_at)
def test_get_bad_cls(self):
"""test get with invalid cls"""
result = self.store.get("Dummy", "test")
self.assertIsNone(result)
def test_get_bad_id(self):
"""test get with invalid id"""
result = self.store.get("State", "very_bad_id")
self.assertIsNone(result)
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)