def test_new_classes(self):
""" check new method is valid """
obj = BaseModel(id='123')
obj_key = 'BaseModel' + '.' + obj.id
obj1 = User(id='01')
obj1_key = 'User' + '.' + obj1.id
obj2 = City(id='02')
obj2_key = 'City' + '.' + obj2.id
obj3 = Amenity(id='03')
obj3_key = 'Amenity' + '.' + obj3.id
obj4 = Place(id='04')
obj4_key = 'Place' + '.' + obj4.id
obj5 = Review(id='05')
obj5_key = 'Review' + '.' + obj5.id
obj6 = State(id='06')
obj6_key = 'State' + '.' + obj6.id
self.assertEqual(storage.all(), {})
obj.id = 123
storage.new(obj)
storage.new(obj1)
storage.new(obj2)
storage.new(obj3)
storage.new(obj4)
storage.new(obj5)
storage.new(obj6)
self.assertEqual(obj, storage.all()[obj_key])
self.assertEqual(obj1, storage.all()[obj1_key])
self.assertEqual(obj2, storage.all()[obj2_key])
self.assertEqual(obj3, storage.all()[obj3_key])
self.assertEqual(obj4, storage.all()[obj4_key])
self.assertEqual(obj5, storage.all()[obj5_key])
self.assertEqual(obj6, storage.all()[obj6_key])
def test_reload(self):
""" Tests reload method """
from json import dumps
# Check if reloading without doing anything reloads the same thing
old_dict = storage.all()
storage.reload()
new_dict = storage.all()
self.assertEqual(old_dict.keys(), new_dict.keys())
# Make new object and a dictionary for that object
obj = BaseModel()
obj.id = 1
dict_dict = {"BaseModel.1": obj.to_dict()}
obje_dict = {"BaseModel.1": obj}
# Overwrite file.json so that it includes just this dictionary
if os.path.exists("file.json"):
os.remove("file.json")
with open("file.json", 'w') as f:
f.write(dumps(dict_dict))
# Reload
storage.reload()
self.assertEqual(storage.all().keys(), obje_dict.keys())
def test_init(self):
""" testing init of attributes """
BM = BaseModel()
BM.id = 12
BM_dict = {
"created_at": "2021-02-16T15:53:02.772060",
"updated_at": "2021-02-16T15:53:02.772085",
"id": "d30aaea6-89e5-4381-b772-046fb7b452c7",
"first_name": "Reginald"
}
BM_kwargs = BaseModel(**BM_dict)
self.assertEqual(BM.id, 12)
self.assertIsInstance(BM, BaseModel)
self.assertIsNotNone(BM.created_at)
self.assertIsNotNone(BM.updated_at)
self.assertIn("created_at", BM.__dict__)
self.assertIn("updated_at", BM.__dict__)
self.assertIn("id", BM.__dict__)
self.assertIsInstance(BM.created_at, datetime)
self.assertIsInstance(BM.updated_at, datetime)
self.assertEqual(BM_kwargs.id, "d30aaea6-89e5-4381-b772-046fb7b452c7")
self.assertIsInstance(BM_kwargs, BaseModel)
self.assertIsNotNone(BM.created_at)
self.assertIsNotNone(BM.updated_at)
self.assertIn("created_at", BM_kwargs.__dict__)
self.assertIn("updated_at", BM_kwargs.__dict__)
self.assertIn("id", BM_kwargs.__dict__)
self.assertIsInstance(BM_kwargs.created_at, datetime)
self.assertIsInstance(BM_kwargs.updated_at, datetime)
def test_change_id(self):
"""
tests when id is changed manually.
"""
m1 = BaseModel()
m2 = BaseModel()
m1.id = m2.id
self.assertEqual(m1.id, m2.id)
def test_base_id(self):
"""
basic tests id
"""
test_model = BaseModel()
self.assertIsNotNone(test_model.id)
test_model.id = "1234"
self.assertEqual("1234", test_model.id)
def test_new_method(self):
"""Test for the new method of FileStorage"""
my_model = BaseModel()
len1 = len(models.storage.all())
my_model.id = 56
models.storage.new(my_model)
len2 = len(models.storage.all())
self.assertTrue(len1 < len2)
def test_str_return_new_id(self):
"""
tests that str will update with an updated id.
"""
m1 = BaseModel()
class_name = "BaseModel"
m1.id = "1"
m1_dict = str(m1.__dict__)
str_m1 = "[{}] (1) {}".format(class_name, m1_dict)
self.assertEqual(str_m1, str(m1))
def test_str_representation(self):
dt = datetime.today()
dt_repr = repr(dt)
bm = BaseModel()
bm.id = "123456"
bm.created_at = bm.updated_at = dt
bmstr = bm.__str__()
self.assertIn("[BaseModel] (123456)", bmstr)
self.assertIn("'id': '123456'", bmstr)
self.assertIn("'created_at': " + dt_repr, bmstr)
self.assertIn("'updated_at': " + dt_repr, bmstr)
def test_base_model_uuid_wrong_format(self):
"""...
...
...
"""
bm = BaseModel()
bm.id = 'Monty Python'
warn = 'badly formed hexadecimal UUID string'
with self.assertRaises(ValueError) as msg:
uuid.UUID(bm.id)
self.assertEqual(warn, str(msg.exception))
def test_all_str(self):
date_time = datetime.today()
date_repr = repr(date_time)
Bmodel = BaseModel()
Bmodel.id = "456789123"
Bmodel.created_at = Bmodel.updated_at = date_time
Bmodel_str = Bmodel.__str__()
self.assertIn("[BaseModel] (456789123)", Bmodel_str)
self.assertIn("'id': '456789123'", Bmodel_str)
self.assertIn("'created_at': " + date_repr, Bmodel_str)
self.assertIn("'updated_at': " + date_repr, Bmodel_str)
def test_str(self):
"""Test __str___"""
date1 = datetime.today()
tester1 = BaseModel()
tester1.id = 821983719274
tester1.created_at = date1
tester1.updated_at = date1
testerstr = tester1.__str__()
self.assertIn("[BaseModel] (821983719274)", testerstr)
self.assertIn("'id': 821983719274", testerstr)
self.assertIn("'created_at': " + repr(date1), testerstr)
self.assertIn("'updated_at': " + repr(date1), testerstr)
def test_to_dict_output(self):
dt = datetime.today()
bm = BaseModel()
bm.id = "123456"
bm.created_at = bm.updated_at = dt
tdict = {
'id': '123456',
'__class__': 'BaseModel',
'created_at': dt.isoformat(),
'updated_at': dt.isoformat()
}
self.assertDictEqual(bm.to_dict(), tdict)
def testto_dict(self):
dt = datetime.today()
Bmodel = BaseModel()
Bmodel.id = "123"
Bmodel.created_at = Bmodel.updated_at = dt
todict = {
"id": "123",
"created_at": dt.isoformat(),
"updated_at": dt.isoformat(),
"__class__": "BaseModel"
}
self.assertDictEqual(Bmodel.to_dict(), todict)
def test_str_return(self):
'''Check returns of his __str__ '''
date = datetime.today()
date_repr = repr(date)
base = BaseModel()
base.id = "123456"
base.created_at = base.updated_at = date
bmstr = base.__str__()
self.assertIn("[BaseModel] (123456)", bmstr)
self.assertIn("'id': '123456'", bmstr)
self.assertIn("'created_at': " + date_repr, bmstr)
self.assertIn("'updated_at': " + date_repr, bmstr)
def test_basestr(self):
""" Test for str method """
date1 = datetime.today()
test1 = BaseModel()
test1.id = 712456769374
test1.created_at = date1
test1.updated_at = date1
testerstr = test1.__str__()
self.assertIn("[BaseModel] (712456769374)", testerstr)
self.assertIn("'id': 712456769374", testerstr)
self.assertIn("'created_at': " + repr(date1), testerstr)
self.assertIn("'updated_at': " + repr(date1), testerstr)
def test_savemethod(self):
"""This function tests the save method"""
base1 = BaseModel()
oldtime = base1.updated_at
sleep(.5)
base1.id = 98
base1.save()
newtime = base1.updated_at
self.assertTrue(hasattr(base1, "id"))
self.assertTrue(base1.id == 98)
self.assertNotEqual(oldtime, newtime)
with open("file.json", "r", encoding="utf-8") as content:
self.assertTrue("\"id\": 98" in content.read())
def test_todict(self):
""" dict method """
time = datetime.datetime.now()
bm = BaseModel()
bm.id = "7"
bm.created_at = bm.updated_at = time
newdict = {
"id": "7",
"created_at": time.isoformat(),
"updated_at": time.isoformat(),
"__class__": "BaseModel"
}
self.assertDictEqual(bm.to_dict(), newdict)
def test_id(self):
"""Task 3. BaseModel
Tests public instance attribute `id`.
"""
# Normal use:
bm1 = BaseModel()
test_default_id(self, bm1)
# id is functionally unique for each instance
bm2 = BaseModel()
bm3 = BaseModel()
self.assertNotEqual(bm1.id, bm2.id)
self.assertNotEqual(bm2.id, bm3.id)
# id is public attr, can be manually reassigned
bm1.id = bm2.id
self.assertEqual(bm1.id, bm2.id)
# direct manual reassignment risks invalid UUID format
bm3.id = '1234567890'
UUIDv4_regex = ('^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-'
'[89ab][a-f0-9]{3}-[a-f0-9]{12}$')
self.assertIsNone(re.match(UUIDv4_regex, bm3.id, re.IGNORECASE))
def test_for_save(self):
"""test for save"""
b2 = BaseModel()
time1 = b2.updated_at
sleep(.5)
b2.id = 12
b2.save()
time2 = b2.updated_at
self.assertEqual(type(time2), type(datetime.now()))
self.assertNotEqual(time1, time2)
self.assertTrue(time1 < time2)
self.assertTrue(b2.id == 12)
self.assertTrue(hasattr(b2, "id"))
with open("file.json") as f:
self.assertTrue('"id": 12' in f.read())
def test_attrb(self):
"""test atttr"""
bm = BaseModel()
bm1 = BaseModel()
self.assertRaises(AttributeError)
self.assertTrue(isinstance(bm, BaseModel))
bm.name = "bz"
self.assertEqual(bm.name, "bz")
bm.id = "1"
self.assertEqual(bm.id, "1")
self.assertTrue(hasattr(bm1, "created_at"))
self.assertTrue(hasattr(bm1, "updated_at"))
self.assertTrue(hasattr(bm1, "created_at"))
self.assertNotEqual(bm.id, bm1.id)
self.assertNotEqual(bm.id, bm1.id)
self.assertNotEqual(bm.created_at, bm1.created_at)
self.assertNotEqual(bm.updated_at, bm1.updated_at)
self.assertTrue(isinstance(bm.created_at, datetime))
self.assertTrue(isinstance(bm.updated_at, datetime))
self.assertTrue(type(bm1.to_dict()), dict)
def test_init(self):
""" instantiation test """
self.assertTrue(hasattr(self.base, "id"))
self.assertTrue(hasattr(self.base, "created_at"))
self.assertTrue(hasattr(self.base, "updated_at"))
self.assertTrue(isinstance(self.base.created_at, datetime))
self.assertTrue(isinstance(self.base.updated_at, datetime))
b = BaseModel()
b.name = "Holberton"
b.my_number = 89
b.id = 1
self.assertTrue(hasattr(b, "id"))
self.assertTrue(hasattr(b, "created_at"))
self.assertTrue(hasattr(b, "updated_at"))
self.assertTrue(hasattr(b, "name"))
self.assertTrue(hasattr(b, "my_number"))
self.assertEqual(b.name, "Holberton")
self.assertEqual(b.my_number, 89)
self.assertNotEqual(b.id, self.base.id)
self.assertEqual(b.id, 1)
self.assertTrue(os.path.exists("file.json"))
test = BaseModel(**self.base.to_dict())
self.assertEqual(test.id, self.base.id)
def test_base_model_change_id(self):
a = BaseModel()
a.id = 10
self.assertEqual(a.id, 10)
def test_id_public(self):
msj = "Id isn't public"
my_model1 = BaseModel()
my_model1.id = "HELLO"
self.assertEqual(my_model1.id, "HELLO")
