def test_base_errors_04(self):
with self.assertRaises(Exception) as e:
my_model = BaseModel()
my_model.__str__(32123213)
s = "__str__() takes 1 positional argument but 2 were given"
self.assertTrue(s in str(e.exception))
def do_all(self, args):
""" prints string rep of all class instances """
ListofArgs = args.split()
listerine = []
x = 0
if len(ListofArgs) == 0:
all_objs = storage.all()
for key, val in all_objs.items():
wouldbekwargs = all_objs[key]
if 'BaseModel' in key:
instance = BaseModel(None, **wouldbekwargs)
elif 'User' in key:
instance = User(None, **wouldbekwargs)
listerine.append(instance.__str__())
print(listerine)
elif ListofArgs[0] == 'BaseModel' or ListofArgs[0] == 'User':
all_objs = storage.all()
for key, val in all_objs.items():
if 'BaseModel' in key:
x = 1
wouldbekwargs = all_objs[key]
instance = BaseModel(None, **wouldbekwargs)
listerine.append(instance.__str__())
if 'User' in key:
x = 1
wouldbekwargs = all_objs[key]
instance = BaseModel(None, **wouldbekwargs)
listerine.append(instance.__str__())
if x == 1:
print(listerine)
else:
print("** class doesn\'t exist **")
else:
print("** class doesn\'t exist **")
def test_output_str(self):
str_dict = BaseModel()
self.assertIsInstance(str_dict.__str__(), str)
new_str_dict = BaseModel()
str_output = "[{}] ({}) {}".format(new_str_dict.__class__.__name__,
new_str_dict.id,
new_str_dict.__dict__)
self.assertEqual(str_output, new_str_dict.__str__())
def test_method_str(self):
"""Test method str"""
new = BaseModel()
self.assertEqual(
new.__str__(), "[{}] ({}) {}".format(new.__class__.__name__,
new.id, new.__dict__))
self.assertTrue(type(new.__str__()), str)
self.assertTrue(len(new.__str__()))
def test_str(self):
""" test the string representation of a 'BaseModel' instance,
must be [<class name>] (<self.id>) <self.__dict__> """
b = BaseModel()
result = b.__str__()
token = result.split()
self.assertEqual(token[0], '[BaseModel]')
self.assertEqual(token[1], "(" + b.__dict__['id'] + ")")
" compare the dict of the 3th section with b.__dict__ "
just_dict = (b.__str__()).split('{')
self.assertEqual(just_dict[1], (str(b.__dict__)).split('{')[1])
def test_str(self):
"""Test BaseModel str representation.
"""
new = BaseModel()
trex = r"\[BaseModel\] \(.*\) .*"
self.assertIsInstance(new, BaseModel)
self.assertTrue(type(new.__str__()) == str)
self.assertTrue(search(trex, new.__str__()))
args = ["hola", 2, 3.2, "poads"]
new = BaseModel(*args)
self.assertIsInstance(new, BaseModel)
new = BaseModel("hola", 2, 3.2, "poads")
self.assertIsInstance(new, BaseModel)
def test_str(self):
"""
test for str output
"""
bill = BaseModel()
string = "[BaseModel] ({}) {}".format(bill.id, bill.__dict__)
self.assertEqual(bill.__str__(), string)
def test_str(self):
"""
"""
test = BaseModel()
r = test.__str__()
f = "[{}] ({}) {}".format(type(test).__name__, test.id, test.__dict__)
self.assertEqual(r, f)
def test_str(self):
"""tests __str__ method of BaseModel class"""
testb = BaseModel()
testb_str = testb.__str__()
testb_str = testb_str.split()
self.assertEqual(testb_str[0], "[{}]".format(testb.__class__.__name__))
self.assertEqual(testb_str[1], "({})".format(testb.id))
def test_str_format(self):
"""Test str format"""
instance = BaseModel()
s = instance.__str__()
_format = "[{}] ({}) {}".\
format(instance.__class__.__name__, instance.id, instance.__dict__)
self.assertEqual(s, _format)
def test_str(self):
""" review format: [<class name>] (<self.id>) <self.__dict__>
"""
my_class = BaseModel()
string = "[{:s}] ({:s}) {}".format(my_class.__class__.__name__,
my_class.id, my_class.__dict__)
self.assertEqual(string, my_class.__str__())
def test_assert_str(self):
""" Test str method is ok """
a = BaseModel()
c = a.__str__()
d = a.id
d1 = a.__dict__
self.assertEqual(c, "[BaseModel] ({}) {}".format(d, d1))
def test_str(self):
"""Testing if attributes are strings"""
self.assertEqual(type(self.base.id), str)
new = BaseModel()
strrep = "[{}] ({}) {}".format(new.__class__.__name__, new.id,
new.__dict__)
self.assertEqual(new.__str__(), strrep)
def test_str(self):
"""Test __str__ method"""
ba = BaseModel()
string = '[' + ba.__class__.__name__ + ']' + ' (' + ba.id + ') ' + str(
ba.__dict__)
self.assertEqual(string, ba.__str__())
def test_4_str_method(self):
"""is the string representation is wrong"""
model_1 = BaseModel()
model_1.save()
str_model = "[" + str(model_1.__class__.__name__) + "] (" + \
str(model_1.id) + ") " + str(model_1.__dict__)
self.assertEqual(model_1.__str__(), str_model)
def test_str(self):
""" Tests __str__ method """
obj = BaseModel()
cls = type(obj).__name__
string = "[{}] ({}) {}".format(cls, obj.id, obj.__dict__)
# check if __str__ returns expected string representation
self.assertEqual(obj.__str__(), string)
def test_str_method(self):
"""str"""
s = "[BaseModel] ({}) {}"
my_base25 = BaseModel()
my_base25printed = my_base25.__str__()
self.assertEqual(my_base25printed,
s.format(my_base25.id, my_base25.__dict__))
def test_str(self):
"""Test __str__
"""
base = BaseModel()
printbase = base.__str__()
self.assertEqual(printbase,
"[BaseModel] ({}) {}".format(base.id, base.__dict__))
def test_base_model_str_method(self):
"""BaseModel str method creates accurate representation"""
base = BaseModel()
base_str = base.__str__()
self.assertIsInstance(base_str, str)
self.assertEqual(base_str[:11], '[BaseModel]')
self.assertEqual(base_str[12:50], '({})'.format(base.id))
self.assertDictEqual(eval(base_str[51:]), base.__dict__)
def test_str_method(self):
"""Checks for str in base_model"""
my_model = BaseModel()
name = "[{}] ({}) {}".format(my_model.__class__.__name__, my_model.id,
my_model.__dict__)
self.assertEqual(name, my_model.__str__())
def test_any(self):
"""Test"""
model = BaseModel()
str1 = "[BaseModel] "
str2 = "(" + model.id + ") "
str3 = str(model.__dict__)
string = str1 + str2 + str3
self.assertEqual(model.__str__(), string)
def test_3_str(self):
'''If str method work as expected'''
my_model_0 = BaseModel()
my_model_1 = BaseModel()
my_model_2 = BaseModel()
str_model_0 = "[" + str(type(my_model_0).__name__) + "] (" + \
str(my_model_0.id) + ") " + str(my_model_0.__dict__)
str_model_1 = "[" + str(type(my_model_1).__name__) + "] (" + \
str(my_model_1.id) + ") " + str(my_model_1.__dict__)
str_model_2 = "[" + str(type(my_model_2).__name__) + "] (" + \
str(my_model_2.id) + ") " + str(my_model_2.__dict__)
self.assertEqual(str(my_model_0), str_model_0)
self.assertEqual(my_model_1.__str__(), str_model_1)
self.assertEqual(my_model_2.__str__(), str_model_2)
def test_string(self):
"""check that it displays the correct string format output"""
bm_instance1_json = self.bm_instance1.to_dict()
bm_instance3 = BaseModel(**bm_instance1_json)
self.assertEqual(bm_instance3.__str__(),
"[{}] ({}) {}".format(bm_instance3.__class__.__name__,
bm_instance3.id,
bm_instance3.__dict__))
def test_str(self):
"""
check if str complies to format
"""
testinstance = BaseModel()
a, b = testinstance.__class__.__name__, testinstance.id,
c = testinstance.__dict__
self.assertEqual("[{}] ({}) {}".format(a, b, c),
testinstance.__str__())
def test_str(self):
"""
test str
"""
test_model = BaseModel()
id = test_model.id
srt = test_model.__str__()
self.assertEqual(srt,
"[BaseModel] ({}) {}".format(id, test_model.__dict__))
def test_str(self):
""" test print """
b1 = BaseModel()
b2 = BaseModel(id='Betty')
s = "[{}] ({}) {}".format("BaseModel", b1.id, b1.__dict__)
self.assertEqual(print(s), print(b1))
self.assertIsInstance(b1.__str__(), str)
s = "[{}] ({}) {}".format("BaseModel", b2.id, b2.__dict__)
self.assertEqual(print(s), print(b2))
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_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)
class TestBaseModel(unittest.TestCase):
"""
Tests for the BaseModel class
"""
def setUp(self):
"""
Define instructions that will be executed before each test method
"""
self.base = BaseModel()
def test_instance(self):
"""
Test the instance of the initialization of the class
"""
self.assertIsInstance(self.base, BaseModel)
self.assertIsInstance(self.base.id, str)
self.assertIsInstance(self.base.created_at, datetime)
self.assertIsInstance(self.base.updated_at, datetime)
def test_str(self):
"""
Test for the str method
"""
test_str = self.base.__str__()
self.assertIsInstance(test_str, str)
def test_to_dict(self):
"""
Test for the to_dict method
"""
test_json = self.base.to_dict()
self.assertIsInstance(test_json, dict)
def test_save(self):
"""
Test for the save method
"""
test_up = self.base.updated_at
self.base.save()
self.assertTrue(self.base.updated_at != test_up)
def test_kwargs(self):
"""
Test for kwargs
"""
my_model_json = self.base.to_dict()
my_new_model = BaseModel(**my_model_json)
self.assertFalse(self.base is my_new_model)
def tearDown(self):
"""
To define instructions that will be executed after each test
"""
del self.base
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)
