def test_update_typeError(self):
'''
Test for conditions that raise TypeError with update method
'''
r = Rectangle(10, 10, 10, 10, 10)
with self.assertRaisesRegex(TypeError, "width must be an integer"):
r.update(6, 's')
r.update(5, [1, 2], 2, 4)
r.update(4, (1, 2), 4, 5)
r.update(2, {'s': 3}, 6)
r.update(2, float('nan'))
r.update(width="hi")
r.update(width=[1, 2, 3], x=2)
r.update(height=3, width=(1, ))
r.update(height=3, width={"s": 3})
r.update(id=3, width=float('nan'))
r.update(y=4, width=float('inf'))
def test_update_args_invalid_width(self):
r = Rectangle(14, 14, 14, 14, 14)
with self.assertRaisesRegex(TypeError, "width must be an integer"):
r.update(109, "Hola")
def test_update_args_invalid_height(self):
r = Rectangle(14, 14, 14, 14, 14)
with self.assertRaisesRegex(TypeError, "height must be an integer"):
r.update(109, 1, "hola")
def test_update_args_more_sixargs(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update(109, 1, 2, 3, 4, 5)
self.assertEqual("[Rectangle] (109) 3/4 - 1/2", str(r))
def test_update_args_attr(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update(None, 1, 2, 3)
correct = "[Rectangle] ({}) 3/14 - 1/2".format(r.id)
self.assertEqual(correct, str(r))
class TestRectangle(unittest.TestCase):
"""
test class Rectangle
"""
def setUp(self):
"""
this is for testing
"""
self.test = Rectangle(6, 6, 6, 6, 6)
def test_id(self):
"""
test id
"""
self.assertEqual(self.test.id, 6)
def test_width(self):
"""
test width
"""
self.assertEqual(self.test.width, 6)
def test_get_set_width(self):
"""
test width getter/setter
"""
self.test.width = 9
self.assertEqual(self.test.width, 9)
def test_height(self):
"""
test height
"""
self.assertEqual(self.test.height, 6)
def test_get_set_height(self):
"""
test height getter/setter
"""
self.test.height = 9
self.assertEqual(self.test.height, 9)
def test_x(self):
"""
test x
"""
self.assertEqual(self.test.x, 6)
def test_get_set_x(self):
"""
test x getter/setter
"""
self.test.x = 9
self.assertEqual(self.test.x, 9)
def test_y(self):
"""
test y
"""
self.assertEqual(self.test.y, 6)
def test_get_set_y(self):
"""
test y getter/setter
"""
self.test.y = 9
self.assertEqual(self.test.y, 9)
def testArea(self):
"""
test area
"""
self.assertEqual(self.test.area(), 36)
def testDisplay(self):
"""
test display
"""
self.assertIsNone(self.test.display())
def testNoArgs(self):
"""
test no args
"""
with self.assertRaises(TypeError):
empty = Rectangle()
def testUpdateArgs(self):
"""
test update *args
"""
self.test.update(8, 8, 8, 8, 8)
self.assertEqual(self.test.id, 8)
self.assertEqual(self.test.width, 8)
self.assertEqual(self.test.height, 8)
self.assertEqual(self.test.x, 8)
self.assertEqual(self.test.y, 8)
def testUpdateKwargsId(self):
"""
test update **kwargs id
"""
self.test.update(id=6)
self.assertEqual(self.test.id, 6)
def testUpdateKwargsWidht(self):
"""
test update **kwargs width
"""
self.test.update(width=6)
self.assertEqual(self.test.width, 6)
def testUpdateKwargsHeight(self):
"""
test update **kwargs height
"""
self.test.update(height=6)
self.assertEqual(self.test.height, 6)
def testUpdateKwargs_x(self):
"""
test update **kwargs x
"""
self.test.update(x=6)
self.assertEqual(self.test.x, 6)
def testUpdateKwargs_y(self):
"""
test update **kwargs y
"""
self.test.update(y=6)
self.assertEqual(self.test.y, 6)
def test_update_args_case3(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update(109, 1, 1)
self.assertEqual("[Rectangle] (109) 14/14 - 1/1", str(r))
class TestRectangle(unittest.TestCase):
""" Test the Rectangle class """
def setUp(self):
Base._reset()
def test_parent(self):
self.rec = Rectangle(1, 2)
self.assertTrue(isinstance(self.rec, Base))
self.assertTrue(issubclass(Rectangle, Base))
self.assertEqual(self.rec.id, 1)
self.rec = Rectangle(1, 2)
self.rec = Rectangle(1, 2)
self.rec = Rectangle(1, 2)
self.assertEqual(self.rec.id, 4)
def test_init(self):
""" test all values """
self.rec = Rectangle(1, 2, 3, 4, 10)
self.assertEqual(self.rec.width, 1)
self.assertEqual(self.rec.height, 2)
self.assertEqual(self.rec.x, 3)
self.assertEqual(self.rec.y, 4)
self.assertEqual(self.rec.id, 10)
""" test default values """
self.rec = Rectangle(1, 2)
self.assertEqual(self.rec.x, 0)
self.assertEqual(self.rec.y, 0)
self.assertEqual(self.rec.id, 1)
def test_bad_types(self):
""" Test bad width types """
with self.assertRaises(TypeError):
self.rec = Rectangle('g', 1)
with self.assertRaises(TypeError):
self.rec = Rectangle(.3, 1)
with self.assertRaises(TypeError):
self.rec = Rectangle([3], 1)
with self.assertRaises(TypeError):
self.rec = Rectangle({2: 2}, 1)
with self.assertRaises(TypeError):
self.rec = Rectangle((2, ), 1)
""" Test bad height types """
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 'g')
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 1.2)
with self.assertRaises(TypeError):
self.rec = Rectangle(1, [3])
with self.assertRaises(TypeError):
self.rec = Rectangle(1, {2: 2})
with self.assertRaises(TypeError):
self.rec = Rectangle(1, (2, ))
""" Test bad x types """
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 'g')
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 1.2)
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, [3])
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, {2: 2})
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, (2, ))
""" Test bad y types """
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 3, 'g')
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 3, 1.2)
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 3, [3])
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 3, {2: 2})
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 1, 1, (2, ))
def test_bad_values(self):
""" Test bad width values """
with self.assertRaises(ValueError):
self.rec = Rectangle(-1, 2)
""" Test bad height values """
with self.assertRaises(ValueError):
self.rec = Rectangle(1, -2)
""" Test bad x values """
with self.assertRaises(ValueError):
self.rec = Rectangle(1, 2, -2)
""" Test bad y values """
with self.assertRaises(ValueError):
self.rec = Rectangle(1, 2, 2, -3)
def test_etc(self):
""" Test missing arguments """
with self.assertRaises(TypeError):
self.rec = Rectangle(1)
with self.assertRaises(TypeError):
self.rec = Rectangle()
""" Test too many arguments """
with self.assertRaises(TypeError):
self.rec = Rectangle(1, 2, 3, 4, 5, 6)
def test_area(self):
""" Test the area method """
self.rec = Rectangle(4, 2)
self.assertEqual(self.rec.area(), 8)
self.rec1 = Rectangle(8, 7, 0, 0, 12)
self.assertEqual(self.rec1.area(), 56)
def test_display(self):
""" Test the display: display will print the rectangle
to the std out with '#' """
self.rec = Rectangle(3, 3)
cap_out = io.StringIO()
sys.stdout = cap_out
self.rec.display()
sys.stdout = sys.__stdout__
self.assertEqual(cap_out.getvalue(), "###\n###\n###\n")
""" Test with x and y """
self.rec = Rectangle(2, 3, 1, 2)
cap_out = io.StringIO()
sys.stdout = cap_out
self.rec.display()
sys.stdout = sys.__stdout__
self.assertEqual(cap_out.getvalue(), "\n\n ##\n ##\n ##\n")
def test_str(self):
""" Test the __str__ method """
self.rec = Rectangle(4, 5)
self.assertEqual(self.rec.__str__(), "[Rectangle] (1) 0/0 - 4/5")
""" Test different values no default """
self.rec = Rectangle(4, 5, 12, 1, 24)
self.assertEqual(self.rec.__str__(), "[Rectangle] (24) 12/1 - 4/5")
def test_update(self):
""" Test updated rectangle """
self.rec = Rectangle(10, 10, 10, 10)
self.assertEqual(self.rec.__str__(), "[Rectangle] (1) 10/10 - 10/10")
self.rec.update(98)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 10/10 - 10/10")
self.rec.update(98, 2)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 10/10 - 2/10")
self.rec.update(98, 2, 3)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 10/10 - 2/3")
self.rec.update(98, 2, 3, 4)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 4/10 - 2/3")
self.rec.update(98, 2, 3, 4, 5)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 4/5 - 2/3")
""" Test update with a dictionary """
self.rec = Rectangle(10, 10, 10, 10)
self.assertEqual(self.rec.__str__(), "[Rectangle] (2) 10/10 - 10/10")
self.rec.update(id=98)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 10/10 - 10/10")
self.rec.update(id=98, width=2)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 10/10 - 2/10")
self.rec.update(id=98, width=2, height=3)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 10/10 - 2/3")
self.rec.update(id=98, width=2, height=3, x=4)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 4/10 - 2/3")
self.rec.update(id=98, width=2, height=3, x=4, y=5)
self.assertEqual(self.rec.__str__(), "[Rectangle] (98) 4/5 - 2/3")
""" Test update with a non_existant field """
with self.assertRaises(KeyError):
self.rec.update(chicken=3)
""" Test update with a bad value """
with self.assertRaises(TypeError):
self.rec.update('f')
with self.assertRaises(TypeError):
self.rec.update(width='f')
""" Test with both *args and **kwargs """
self.rec1 = Rectangle(1, 2)
self.rec1.update(3, 3, id=9)
self.assertEqual(self.rec1.__str__(), "[Rectangle] (3) 0/0 - 3/2")
def test_dictionary(self):
self.rec = Rectangle(10, 10, 10, 10, 10)
rec_dict = self.rec.to_dictionary()
self.assertEqual(rec_dict, {
'x': 10,
'y': 10,
'id': 10,
'height': 10,
'width': 10
})
self.assertTrue(isinstance(rec_dict, dict))
self.rec2 = Rectangle(1, 1)
self.rec2.update(**rec_dict)
self.assertFalse(self.rec == self.rec2)
def test_to_json(self):
self.rec = Rectangle(10, 10, 10, 10, 10)
rec_dict = self.rec.to_dictionary()
json_dict = Base.to_json_string([rec_dict])
self.assertTrue(isinstance(json_dict, str))
def test_save_json(self):
""" Test save_json: note* 52 characters per dict """
self.r1 = Rectangle(1, 2)
Rectangle.save_to_file([self.r1])
with open("Rectangle.json", "r") as f:
data = f.read()
self.assertEqual(len(data), 52)
self.r2 = Rectangle(3, 4)
Rectangle.save_to_file([self.r1, self.r2])
with open("Rectangle.json", "r") as f:
data = f.read()
self.assertEqual(len(data), 104)
""" Test empty list """
Rectangle.save_to_file([])
with open("Rectangle.json", "r") as f:
data = f.read()
self.assertEqual(len(data), 2)
def test_from_json(self):
""" Test the function from_json_string: returns a list of strings """
self.rec = Rectangle(1, 2)
li = [self.rec.to_dictionary()]
json_list_input = Rectangle.to_json_string(li)
from_json = Rectangle.from_json_string(json_list_input)
self.assertTrue(isinstance(from_json, list))
self.assertTrue(isinstance(from_json[0], dict))
""" Test empty or None """
self.assertEqual(Rectangle.from_json_string(None), [])
self.assertEqual(Rectangle.from_json_string("[]"), [])
def test_create_cls(self):
""" Test the function create: returns an instance with all attributes
set """
self.r1 = Rectangle(10, 10, 10)
self.r1_dict = self.r1.to_dictionary()
self.r2 = Rectangle.create(**self.r1_dict)
self.assertEqual(self.r2.__str__(), "[Rectangle] (1) 10/0 - 10/10")
self.assertTrue(self.r2 is not self.r1)
self.assertTrue(self.r2 != self.r1)
def test_update_kwargs_2(self):
"""Tests update() keyword args."""
r = Rectangle(5, 2)
d = r.__dict__.copy()
r.update(id=10)
d["id"] = 10
self.assertEqual(r.__dict__, d)
r.update(id=10, width=5)
d["_Rectangle__width"] = 5
self.assertEqual(r.__dict__, d)
r.update(id=10, width=5, height=17)
d["_Rectangle__height"] = 17
self.assertEqual(r.__dict__, d)
r.update(id=10, width=5, height=17, x=20)
d["_Rectangle__x"] = 20
self.assertEqual(r.__dict__, d)
r.update(id=10, width=5, height=17, x=20, y=25)
d["_Rectangle__y"] = 25
self.assertEqual(r.__dict__, d)
r.update(y=25, id=10, height=17, x=20, width=5)
self.assertEqual(r.__dict__, d)
Base._Base__nb_objects = 0
r1 = Rectangle(10, 10, 10, 10)
self.assertEqual(str(r1), "[Rectangle] (1) 10/10 - 10/10")
r1.update(height=1)
self.assertEqual(str(r1), "[Rectangle] (1) 10/10 - 10/1")
r1.update(width=1, x=2)
self.assertEqual(str(r1), "[Rectangle] (1) 2/10 - 1/1")
r1.update(y=1, width=2, x=3, id=89)
self.assertEqual(str(r1), "[Rectangle] (89) 3/1 - 2/1")
r1.update(x=1, height=2, y=3, width=4)
self.assertEqual(str(r1), "[Rectangle] (89) 1/3 - 4/2")
Base._Base__nb_objects = 0
r1 = Rectangle(10, 10, 10, 10)
self.assertEqual(str(r1), "[Rectangle] (1) 10/10 - 10/10")
r1.update(89)
self.assertEqual(str(r1), "[Rectangle] (89) 10/10 - 10/10")
r1.update(89, 2)
self.assertEqual(str(r1), "[Rectangle] (89) 10/10 - 2/10")
r1.update(89, 2, 3)
self.assertEqual(str(r1), "[Rectangle] (89) 10/10 - 2/3")
r1.update(89, 2, 3, 4)
self.assertEqual(str(r1), "[Rectangle] (89) 4/10 - 2/3")
r1.update(89, 2, 3, 4, 5)
self.assertEqual(str(r1), "[Rectangle] (89) 4/5 - 2/3")
def test_update(self):
""" Tests if update method works """
obj1 = Rectangle(1, 2, 3, 4, 5)
obj1.update(width=5, height=4, x=3, y=2, id=1)
def test_update(self):
""" test to confirm proper handling of update"""
r30 = Rectangle(5, 2, 0, 0, 65)
self.assertEqual(r30.id, 65)
r30.update(70)
self.assertEqual(r30.id, 70)
r30.update(x=1, y=2)
self.assertEqual(r30.x, 1)
self.assertEqual(r30.y, 2)
r40 = Rectangle(5, 2)
with self.assertRaises(TypeError):
r40.update(5, "10")
with self.assertRaises(ValueError):
r40.update(5, -1)
with self.assertRaises(TypeError):
r40.update(5, 4, "10")
with self.assertRaises(ValueError):
r40.update(5, 4, -1)
with self.assertRaises(TypeError):
r40.update(5, 4, 3, "1")
with self.assertRaises(ValueError):
r40.update(5, 4, 3, -1)
with self.assertRaises(TypeError):
r40.update(5, 4, 6, 7, "10")
with self.assertRaises(ValueError):
r40.update(5, 4, 5, 3, -1)
def test_seven_update(self):
"""
seven's set of sets
"""
r1 = Rectangle(10, 10, 10, 10)
r1.update(89)
self.assertEqual(r1.id, 89)
r1.update(89, 2)
self.assertEqual(r1.id, 89)
self.assertEqual(r1.width, 2)
r1.update(89, 2, 3)
self.assertEqual(r1.id, 89)
self.assertEqual(r1.width, 2)
self.assertEqual(r1.height, 3)
r1.update(89, 2, 3, 4)
self.assertEqual(r1.id, 89)
self.assertEqual(r1.width, 2)
self.assertEqual(r1.height, 3)
self.assertEqual(r1.x, 4)
r1.update(89, 2, 3, 4, 5)
self.assertEqual(r1.id, 89)
self.assertEqual(r1.width, 2)
self.assertEqual(r1.height, 3)
self.assertEqual(r1.x, 4)
self.assertEqual(r1.y, 5)
with self.assertRaises(ValueError):
r1.update(6, 2, 3, -4, 5)
with self.assertRaises(TypeError):
r1.update(1, "hello", 3, 4, 5)
with self.assertRaises(TypeError):
r1.update(1, 2, 3, 5, "7")
#!/usr/bin/python3
""" Doc """
from models.rectangle import Rectangle
if __name__ == "__main__":
r1 = Rectangle(10, 10, 10, 10)
print(r1)
r1.update(89)
print(r1)
r1.update(89, 2)
print(r1)
r1.update(89, 2, 3)
print(r1)
r1.update(89, 2, 3, 4)
print(r1)
r1.update(89, 2, 3, 4, 5, 6, 7, 8)
print(r1)
def test_update_typeError(self):
'''
Test for conditions that raise TypeError with update method
test with y is not an int
'''
r = Rectangle(10, 10, 10, 10, 10)
with self.assertRaisesRegex(TypeError, "y must be an integer"):
r.update(6, 3, 4, 5, 's')
r.update(5, 3, 4, 5, [1, 2], 2, 4)
r.update(4, 3, 4, 5, (1, 2), 4, 5)
r.update(2, 3, 4, 5, {'s': 3}, 6)
r.update(2, 3, 4, 5, float('nan'))
r.update(width=2, height=4, y="34")
r.update(width=2, height=4, y=[2, 3])
r.update(width=2, height=4, y=(1, 2))
r.update(width=2, height=4, y={"s": 3})
r.update(width=2, height=4, y=float('nan'))
r.update(width=2, height=4, y=float('inf'))
#!/usr/bin/python3
from models.rectangle import Rectangle
if __name__ == "__main__":
r1 = Rectangle(10, 2, 1, 9)
print(r1)
r1_dictionary = r1.to_dictionary()
print(r1_dictionary)
print(type(r1_dictionary))
r2 = Rectangle(1, 1)
print(r2)
r2.update(**r1_dictionary)
print(r2)
print(r1 == r2)
#!/usr/bin/python3
""" Doc """
from models.rectangle import Rectangle
if __name__ == "__main__":
r1 = Rectangle(10, 10, 10, 10)
print(r1)
r1.update(89)
print(r1)
r1.update(89, 2)
print(r1)
r1.update(89, 2, 3)
print(r1)
r1.update(89, 2, 3, 4)
print(r1)
r1.update(89, 2, 3, -87, 5)
print(r1)
def test_update(self):
r = Rectangle(4, 5, 45)
r.update(500)
self.assertEqual(500, r.id)
r.update(500, 2)
self.assertEqual(2, r.width)
r.update(500, 2, 3)
self.assertEqual(3, r.height)
r.update(500, 2, 3, 4)
self.assertEqual(4, r.x)
r.update(500, 2, 3, 4, 5)
self.assertEqual(5, r.y)
r.update(500, 2, 3, 4, 5, 6, 7, 8)
self.assertEqual(5, r.y)
def test_x_dict1(self):
"""test x dict"""
with self.assertRaises(ValueError):
rect_11 = Rectangle(20, 30, 40, 50)
rect_11.update(y=-3, x="hola")
def test_update_args_case0(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update()
self.assertEqual("[Rectangle] (14) 14/14 - 14/14", str(r))
def test_update_menor(self):
"""test update menor"""
rect_12 = Rectangle(4, 8)
rect_12.update(12, 34, 2, 1)
self.assertEqual(rect_12.__str__(), "[Rectangle] (12) 1/0 - 34/2")
def test_update_args_case5(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update(109, 1, 2, 3, 4)
self.assertEqual("[Rectangle] (109) 3/4 - 1/2", str(r))
def test_update_mayor(self):
"""test update mayor"""
rect_13 = Rectangle(4, 8, 3, 1)
rect_13.update(12, 34)
self.assertEqual(rect_13.__str__(), "[Rectangle] (12) 3/1 - 34/8")
def test_update_args_emptyid(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update(None)
correct = "[Rectangle] ({}) 14/14 - 14/14".format(r.id)
self.assertEqual(correct, str(r))
def test_update_height(self):
"""Test update height"""
with self.assertRaises(ValueError):
rect_13 = Rectangle(1, 5)
rect_13.update(2, 2, 3, -3)
def test_update_args_twice(self):
r = Rectangle(14, 14, 14, 14, 14)
r.update(109, 1, 2, 3, 5, 6)
r.update(6, 5, 3, 2, 1, 109)
self.assertEqual("[Rectangle] (6) 2/1 - 5/3", str(r))
def test_update_x(self):
"""Test update"""
with self.assertRaises(ValueError):
rect_16 = Rectangle(5, 6)
rect_16.update(2, 1, -3, 4)
def test_update_args_zero(self):
r = Rectangle(14, 14, 14, 14, 14)
with self.assertRaisesRegex(ValueError, "width must be > 0"):
r.update(109, 0)
#!/usr/bin/python3
""" 8-main """
from models.rectangle import Rectangle
if __name__ == "__main__":
r1 = Rectangle(10, 10, 10, 10)
print(r1)
r1.update(height=1)
print(r1)
r1.update(1, 2)
print(r1)
r1.update(y=1, width=2, x=3, id=89)
print(r1)
r1.update(x=1, height=2, y=3, width=4)
print(r1)
def test_update_args_negative2(self):
r = Rectangle(14, 14, 14, 14, 14)
with self.assertRaisesRegex(ValueError, "height must be > 0"):
r.update(109, 1, -5)
def test_update_arg(self):
'''
Test the update method of Rectangle.
Each attribute in the *arg is in order of
ID, Width, Height, X and Y
'''
r = Rectangle(10, 10, 10, 10, 10)
self.assertEqual(str(r), "[Rectangle] (10) 10/10 - 10/10")
r.update(89)
self.assertEqual(str(r), "[Rectangle] (89) 10/10 - 10/10")
r.update(8, 9)
self.assertEqual(str(r), "[Rectangle] (8) 10/10 - 9/10")
r.update(8, 9, 11)
self.assertEqual(str(r), "[Rectangle] (8) 10/10 - 9/11")
r.update(9, 10, 13, 12)
self.assertEqual(str(r), "[Rectangle] (9) 12/10 - 10/13")
r.update(9, 10, 13, 12, 14)
self.assertEqual(str(r), "[Rectangle] (9) 12/14 - 10/13")
ls = [2, 3, 4]
r.update(*ls)
self.assertEqual(str(r), "[Rectangle] (2) 12/14 - 3/4")
