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)