def testSaveRectsToFile(self):
""" tests saving multiple rectangles to a file
"""
r = Rectangle(2, 2, 2, 2)
Rectangle.save_to_file([self.rect, r])
with open("Rectangle.json") as f:
self.assertEqual(len(json.load(f)), 2)
def test_load_from_file_one(self):
""" Test if load_from_file works with Rectangle
"""
Base._Base__nb_objects = 0
capturedOutput1 = io.StringIO()
sys.stdout = capturedOutput1
r1 = Rectangle(10, 7, 2, 8)
list_rectangles_input = [r1]
Rectangle.save_to_file(list_rectangles_input)
list_rectangles_output = Rectangle.load_from_file()
for rect in list_rectangles_output:
print(rect)
expected = "[Rectangle] (1) 2/8 - 10/7\n"
self.assertEqual(capturedOutput1.getvalue(), expected)
os.remove("./Rectangle.json")
sys.stdout = sys.__stdout__
def test_d_string_to_file(self):
"""test_string_to_file method"""
r1 = Rectangle(10, 7, 2, 8, 1)
r2 = Rectangle(2, 4, id=1)
Rectangle.save_to_file([r1, r2])
with open("Rectangle.json", "w+") as f:
self.assertTrue(type(f.read()) == str)
f.seek(0)
s1 = Square(10, 2, 8, 1)
s2 = Square(2, id=1)
Square.save_to_file([s1, s2])
with open("Square.json", "w+") as f:
self.assertTrue(type(f.read()) == str)
f.seek(0)
Rectangle.save_to_file(None)
with open("Rectangle.json", "w+") as f:
strrd = f.read()
self.assertTrue(type(strrd) == str)
CO = io.StringIO()
sys.stdout = CO
print(strrd)
self.assertEqual(CO.getvalue(), "\n")
sys.stdout = sys.__stdout__
Square.save_to_file(None)
with open("Square.json", "w+") as f:
strrd = f.read()
self.assertTrue(type(strrd) == str)
CO = io.StringIO()
sys.stdout = CO
print(strrd)
self.assertEqual(CO.getvalue(), "\n")
sys.stdout = sys.__stdout__
def test_rectangle(self):
""" Check if file is created with correct name """
name = "Rectangle.json"
r1 = Rectangle(10, 7, 2, 8)
r2 = Rectangle(2, 4)
Rectangle.save_to_file([r1, r2])
self.assertTrue(path.isfile(name))
def test_json_str_to_file_1(self):
"""test jason str to file"""
Base._Base__nb_objects = 0
Rectangle.save_to_file(None)
with open("Rectangle.json", "r") as file:
string = file.read()
self.assertEqual(string, '[]')
def test_load_from_file(self):
"""test load_from_file method"""
"""Rectangle"""
Base._Base__nb_objects = 0
r1 = Rectangle(10, 7, 2, 8)
r2 = Rectangle(2, 4)
list_rect_input = [r1, r2]
Rectangle.save_to_file(list_rect_input)
list_rect_output = Rectangle.load_from_file()
self.assertNotEqual(id(list_rect_input[0]), id(list_rect_output[0]))
self.assertNotEqual(id(list_rect_input[1]), id(list_rect_output[1]))
self.assertNotEqual(id(list_rect_output[0]), id(list_rect_output[1]))
self.assertEqual(list_rect_output[0].__str__(),
"[Rectangle] (1) 2/8 - 10/7")
self.assertEqual(list_rect_output[1].__str__(),
"[Rectangle] (2) 0/0 - 2/4")
"""square"""
s1 = Square(5)
s2 = Square(7, 9, 1)
list_sq_input = [s1, s2]
Square.save_to_file(list_sq_input)
list_sq_output = Square.load_from_file()
self.assertNotEqual(id(list_sq_input[0]), id(list_sq_output[0]))
self.assertNotEqual(id(list_sq_input[1]), id(list_sq_output[1]))
self.assertNotEqual(id(list_sq_output[0]), id(list_sq_output[1]))
self.assertEqual(list_sq_output[0].__str__(), "[Square] (5) 0/0 - 5")
self.assertEqual(list_sq_output[1].__str__(), "[Square] (6) 9/1 - 7")
def test_33a_save_to_file_no_args(self):
"""Test for no args in save_to_file"""
with self.assertRaises(TypeError) as e:
Rectangle.save_to_file()
self.assertEqual("save_to_file() missing 1 required positional" +
" argument: 'list_objs'",
str(e.exception))
def test_sumin(self):
""" omg i have to test if it woprks """
Rectangle.save_to_file(None)
with open("Rectangle.json", mode="r", encoding='utf-8') as f:
l = f.read()
l2 = "[]"
self.assertEqual(l, l2)
def testsavetofile3(self):
r1 = Rectangle(1, 2)
Rectangle.save_to_file([r1])
res = '[{"x": 0, "y": 0, "id": 24, "height": 2, "width": 1}]'
with open("Rectangle.json", "r") as file:
res2 = file.read()
self.assertEqual(len(res2), len(res))
def test_save_to_file_empty(self):
""" Test the save_to_file with empty list and None. """
r1 = Rectangle(1, 1)
if os.path.isfile("Rectangle.json"):
os.remove("Rectangle.json")
r1.save_to_file([])
self.assertTrue(os.path.isfile("Rectangle.json"))
def test_checker3(self):
""" checks none for save to file error """
test1 = Rectangle.save_to_file(None)
self.assertEqual(test1, None)
self.assertFalse(test1)
test2 = Rectangle.save_to_file([])
self.assertEqual(test2, None)
def test_12_save_file_rect(self):
"""
Test save_to_file() method of Rectangle to serialize
and write to a file. Removes file after test if test
was able to write to disk.
"""
Base._Base__nb_objects = 0
R1 = Rectangle(10, 7, 2, 8)
R2 = Rectangle(2, 4)
Rectangle.save_to_file([R1, R2])
self.assertTrue(os.path.exists("Rectangle.json"), True)
with open("Rectangle.json", mode='r') as myFile:
self.assertEqual(
json.loads(myFile.read()),
json.loads('[{"y": 8, '
'"x": 2, '
'"id": 1, '
'"width": 10, '
'"height": 7}, '
'{"y": 0, '
'"x": 0, '
'"id": 2, '
'"width": 2, '
'"height": 4}]'))
os.remove("Rectangle.json")
def test_rectangle_to_file(self):
'''
Rectangle save_to_file method
'''
Rectangle.save_to_file([])
with open('Rectangle.json') as f:
self.assertEqual(f.read(), '[]')
def testLoadNothingFromFile(self):
""" tests loading an empty list from a file
"""
elist = []
Rectangle.save_to_file(elist)
r = Rectangle.load_from_file()
self.assertEqual(elist, r)
def test_sumin1(self):
Rectangle.save_to_file([])
with open("Rectangle.json", mode="r", encoding='utf-8') as f:
l = f.read()
l2 = '[]'
self.assertEqual(l, l2)
def test_loadFromFileTooManyArgs(self):
"""Test too many args"""
r1 = Rectangle(10, 7, 2, 8)
r2 = Rectangle(2, 4)
list_rectangles_input = [r1, r2]
Rectangle.save_to_file(list_rectangles_input)
self.assertRaises(TypeError, Rectangle.load_from_file, 1)
def test_base_load_from_file(self):
l = Rectangle.load_from_file()
self.assertEqual(l, [])
l = Square.load_from_file()
self.assertEqual(l, [])
r1 = Rectangle(3, 1)
r2 = Rectangle(1, 2)
Rectangle.save_to_file([r1, r2])
list_objects = Rectangle.load_from_file()
self.assertTrue(all(o.id in [r1.id, r2.id] for o in list_objects))
s1 = Square(5)
s2 = Square(7, 9, 1)
Square.save_to_file([s1, s2])
list_objects = Square.load_from_file()
self.assertTrue(all(o.id in [s1.id, s2.id] for o in list_objects))
Rectangle.save_to_file([s1, r1, s2, r2])
l = Rectangle.load_from_file()
self.assertTrue(all(o.id in [s1.id, r1.id, s2.id, r2.id] for o in l))
with self.assertRaises(TypeError):
Base.load_from_file("no needed")
os.remove("Rectangle.json")
os.remove("Square.json")
def testSave(self):
"""test save to file method"""
try:
os.remove("Rectangle.json")
except FileNotFoundError:
pass
try:
os.remove("Square.json")
except FileNotFoundError:
pass
r1 = Rectangle(1, 2, 3, 4)
r2 = Rectangle(5, 5, 0, 0)
Rectangle.save_to_file([r1, r2])
self.assertTrue(os.access("Rectangle.json", os.F_OK))
self.assertNotEqual(os.path.getsize("Rectangle.json"), 2)
Rectangle.save_to_file(None)
self.assertEqual(os.path.getsize("Rectangle.json"), 2)
s1 = Square(2, 0, 0, 1)
s2 = Square(3, 0, 0, 2)
s3 = Square(5, 0, 0, 3)
Square.save_to_file([s1, s2, s3])
self.assertTrue(os.access("Square.json", os.F_OK))
self.assertNotEqual(os.path.getsize("Square.json"), 2)
Square.save_to_file(None)
self.assertEqual(os.path.getsize("Square.json"), 2)
def test_save_to_file_rectangle(self):
"""test save to file method"""
Base._Base__nb_objects = 0
r1 = Rectangle(10, 7, 2, 8)
r2 = Rectangle(2, 4)
Rectangle.save_to_file([r1, r2])
with open("Rectangle.json", "r") as file:
data = file.read()
expectData = [{
"y": 8,
"x": 2,
"id": 1,
"width": 10,
"height": 7
}, {
"y": 0,
"x": 0,
"id": 2,
"width": 2,
"height": 4
}]
list_dict = json.loads(data)
self.assertDictEqual(list_dict[0], expectData[0])
self.assertDictEqual(list_dict[1], expectData[1])
Rectangle.save_to_file(None)
with open("Rectangle.json", "r") as file:
data = file.read()
expectData = "[]"
self.assertEqual(data, expectData)
def test_sav_file1(self):
"""This will test the class rectangle"""
a = Rectangle(1, 2, 3, 4)
b = Rectangle(1, 2, 3, 4)
b.save_to_file([])
self.assertIsNotNone(b)
self.assertIsNotNone(a)
def test_checkNoneRec(self):
""" Checks Contents """
name = "Rectangle.json"
Rectangle.save_to_file(None)
with open(name, "r") as myfile:
r = myfile.read()
self.assertEqual(r, '[]')
def test_empty(self):
"""Empty file"""
filename = "Rectangle.json"
if os.path.isfile(filename):
os.remove(filename)
Rectangle.save_to_file(None)
with open("Rectangle.json", "r") as f:
self.assertEqual(f.read(), "[]")
filename = "Square.json"
if os.path.isfile(filename):
os.remove(filename)
Square.save_to_file(None)
with open("Square.json", "r") as f:
self.assertEqual(f.read(), "[]")
filename = "Rectangle.json"
if os.path.isfile(filename):
os.remove(filename)
Rectangle.save_to_file([])
with open("Rectangle.json", "r") as f:
self.assertEqual(f.read(), "[]")
filename = "Square.json"
if os.path.isfile(filename):
os.remove(filename)
Square.save_to_file([])
with open("Square.json", "r") as f:
self.assertEqual(f.read(), "[]")
def test_10_load_from_file(self):
"""Tests if the method load from file is returning correctly
if the file does not exist, it should return an empty list
"""
os.remove('Rectangle.json')
new_list_objects = Rectangle.load_from_file()
self.assertEqual(new_list_objects, [])
os.remove('Square.json')
new_list_objects = Square.load_from_file()
self.assertEqual(new_list_objects, [])
os.remove('Base.json')
new_list_objects = Base.load_from_file()
self.assertEqual(new_list_objects, [])
s1 = Square(100)
Square.save_to_file([s1])
list_Square = Square.load_from_file()
self.assertTrue(type(list_Square), list)
self.assertTrue(type(list_Square[0]), Square)
self.assertEqual(list_Square[0].size, 100)
self.assertEqual(list_Square[0].width, 100)
self.assertEqual(list_Square[0].height, 100)
self.assertEqual(list_Square[0].x, 0)
self.assertEqual(list_Square[0].y, 0)
r1 = Rectangle(4, 5, 1, 1, 89)
Rectangle.save_to_file([r1])
list_Rectangle = Rectangle.load_from_file()
self.assertTrue(type(list_Rectangle), list)
self.assertTrue(type(list_Rectangle[0]), Rectangle)
self.assertEqual(list_Rectangle[0].width, 4)
self.assertEqual(list_Rectangle[0].height, 5)
self.assertEqual(list_Rectangle[0].x, 1)
self.assertEqual(list_Rectangle[0].y, 1)
self.assertEqual(list_Rectangle[0].id, 89)
with self.assertRaises(TypeError):
Rectangle.load_from_file(1)
with self.assertRaises(TypeError):
Square.load_from_file([])
r1 = Rectangle(5, 6, 2, 2, 90)
r2 = Rectangle(2, 3, 0, 0, 70)
Rectangle.save_to_file([r1, r2])
list_Rectangle = Rectangle.load_from_file()
self.assertTrue(type(list_Rectangle), list)
self.assertTrue(type(list_Rectangle[0]), Rectangle)
self.assertEqual(list_Rectangle[0].width, 5)
self.assertEqual(list_Rectangle[0].height, 6)
self.assertEqual(list_Rectangle[0].x, 2)
self.assertEqual(list_Rectangle[0].y, 2)
self.assertEqual(list_Rectangle[0].id, 90)
self.assertTrue(type(list_Rectangle[1]), Rectangle)
self.assertEqual(list_Rectangle[1].width, 2)
self.assertEqual(list_Rectangle[1].height, 3)
self.assertEqual(list_Rectangle[1].x, 0)
self.assertEqual(list_Rectangle[1].y, 0)
self.assertEqual(list_Rectangle[1].id, 70)
def test_file_exists(self):
"""test file"""
file = "Rectangle.json"
r1 = Rectangle(10, 7, 2, 8)
r2 = Rectangle(2, 4)
Rectangle.save_to_file([r1, r2])
self.assertTrue(os.path.isfile(file))
def test_save_to_file_AND_load_from_file(self):
list_rectangles_input = [self.r1, self.r3]
Rectangle.save_to_file(list_rectangles_input)
self.assertTrue(os.path.isfile('Rectangle.json'))
with open('Rectangle.json', 'r') as f:
r_total = sum(1 for _ in f)
self.assertGreater(r_total, 0)
list_rectangles_output = Rectangle.load_from_file()
for rect in list_rectangles_input:
self.assertIsInstance(rect, Rectangle)
for rect in list_rectangles_output:
self.assertIsInstance(rect, Rectangle)
list_squares_input = [self.s1, self.s2]
Square.save_to_file(list_squares_input)
self.assertTrue(os.path.isfile('Square.json'))
with open('Square.json', 'r') as f:
s_total = sum(1 for _ in f)
self.assertGreater(s_total, 0)
list_squares_output = Square.load_from_file()
for square in list_squares_input:
self.assertIsInstance(square, Square)
for square in list_squares_output:
self.assertIsInstance(square, Square)
Base._Base__nb_objects -= 4
def test_save_to_file(self):
r1 = Rectangle(10, 7, 2, 8)
r2 = Rectangle(2, 4)
Rectangle.save_to_file([r1, r2])
s1 = Square(6, 5, 3)
s2 = Square(9)
Rectangle.save_to_file([r1, r2])
self.assertTrue(path.isfile('Rectangle.json'))
self.assertTrue(path.isfile('Square.json'))
contenido3 = []
Base.save_to_file(None)
with open("Base.json", encoding="utf-8") as Myfile2:
contenido3 = Myfile2.read()
contenido3_dict = json.loads(contenido3)
j3_string = []
self.assertEqual(contenido3_dict, j3_string)
contenido4 = []
Base.save_to_file("")
with open("Base.json", encoding="utf-8") as Myfile3:
contenido4 = Myfile3.read()
contenido4_dict = json.loads(contenido4)
j4_string = []
self.assertEqual(contenido4_dict, j4_string)
def test_save_to_file_one(self):
""" Test if save_to_file method works
"""
r1 = Rectangle(10, 7, 2, 8, 50)
s1 = Square(8, 2, 3, 60)
r1_dictionary = [{"y": 8, "x": 2, "id": 50, "width": 10, "height": 7}]
s1_dictionary = [{"id": 60, "y": 3, "x": 2, "size": 8}]
Rectangle.save_to_file([r1])
Square.save_to_file([s1])
with open("Rectangle.json", "r") as file1:
r1_file_dict = file1.read()
with open("Square.json", "r") as file2:
s1_file_dict = file2.read()
r1_file_dict = json.loads(r1_file_dict)
s1_file_dict = json.loads(s1_file_dict)
self.assertEqual(r1_file_dict, r1_dictionary)
self.assertEqual(s1_file_dict, s1_dictionary)
os.remove("./Rectangle.json")
os.remove("./Square.json")
def test_checker3(self):
test1 = Rectangle.save_to_file(None)
self.assertEqual(test1, None)
self.assertFalse(test1)
test2 = Rectangle.save_to_file([])
self.assertEqual(test2, None)
def test_json_file_none(self):
"""
Test to check from none empty
"""
Rectangle.save_to_file(None)
with open("Rectangle.json", mode="r") as myFile:
self.assertEqual([], json.load(myFile))
def test_load_from_file_first_rectangle(self):
""" Test First rectangle """
r_test = Rectangle(10, 7, 2, 8, 1)
r_test2 = Rectangle(2, 4, 5, 6, 2)
Rectangle.save_to_file([r_test, r_test2])
list_rectangles_output = Rectangle.load_from_file()
self.assertEqual(str(r_test), str(list_rectangles_output[0]))
