def test_amenity_ids(self):
"""
test the amenity_ids call attribute
"""
bill = Place()
bill.amenity_ids = ["abc"]
self.assertEqual(type(Place.amenity_ids), list)
def test_class_attributes(self):
""" Test User class attributes """
check = 0
my_place = Place()
"""
Test keys in User dictionary
"""
self.assertTrue(
sorted(list(my_place.__dict__.keys())) == [
'created_at', 'id', 'updated_at'
], True)
self.assertEqual(my_place.city_id, "")
self.assertEqual(my_place.user_id, "")
self.assertEqual(my_place.name, "")
self.assertEqual(my_place.description, "")
self.assertEqual(my_place.number_rooms, 0)
self.assertEqual(my_place.number_bathrooms, 0)
self.assertEqual(my_place.max_guest, 0)
self.assertEqual(my_place.price_by_night, 0)
self.assertEqual(my_place.latitude, 0.0)
self.assertEqual(my_place.longitude, 0.0)
self.assertEqual(my_place.amenity_ids, [])
"""
Test for class attributes in User
"""
my_place.name = "Hotel"
my_place.city_id = "12345678"
my_place.user_id = "12345678"
my_place.description = "12345678"
my_place.number_rooms = 3
my_place.number_bathrooms = 2
my_place.max_guest = 4
my_place.price_by_night = 100
my_place.latitude = 123456.789
my_place.longitude = 123456.789
my_place.amenity_ids = ["Pool", "Gym"]
my_place.save()
self.assertEqual(my_place.name, "Hotel")
self.assertEqual(my_place.city_id, "12345678")
self.assertEqual(my_place.user_id, "12345678")
self.assertEqual(my_place.description, "12345678")
self.assertEqual(my_place.number_rooms, 3)
self.assertEqual(my_place.number_bathrooms, 2)
self.assertEqual(my_place.max_guest, 4)
self.assertEqual(my_place.price_by_night, 100)
self.assertEqual(my_place.latitude, 123456.789)
self.assertEqual(my_place.longitude, 123456.789)
self.assertEqual(my_place.amenity_ids, ["Pool", "Gym"])
"""
Test file.json store the object just created
"""
if os.path.isfile(TestPlace.name):
with open(TestPlace.name, 'r') as f:
string = f.read()
dic = json.loads(string)
for key, value in dic.items():
if key.split('.')[1] == my_place.id:
check = 1
break
self.assertEqual(check, 1)
def test_attr(self):
""" Tests creation of new attributes """
m1 = Place()
m1.name = "John"
self.assertAlmostEqual(m1.name, "John")
m1.number = 123
self.assertAlmostEqual(m1.number, 123)
self.assertEqual(type(m1.id), str)
self.assertEqual(type(m1.created_at), datetime.datetime)
self.assertEqual(type(m1.updated_at), datetime.datetime)
m1.city_id = "123"
m1.user_id = "321"
m1.name = "Tacoville"
m1.description = "Not good at all"
m1.number_rooms = 543
m1.number_bathrooms = 1
m1.max_guest = 7
m1.price_by_night = 54352432
m1.latitude = 13.5
m1.longitude = 12.5
m1.amenity_ids = [1, 2, 3]
self.assertEqual(type(m1.city_id), str)
self.assertEqual(type(m1.user_id), str)
self.assertEqual(type(m1.name), str)
self.assertEqual(type(m1.description), str)
self.assertEqual(type(m1.number_rooms), int)
self.assertEqual(type(m1.number_bathrooms), int)
self.assertEqual(type(m1.max_guest), int)
self.assertEqual(type(m1.price_by_night), int)
self.assertEqual(type(m1.latitude), float)
self.assertEqual(type(m1.longitude), float)
self.assertEqual(type(m1.amenity_ids), list)
def test_amenity_ids(self):
"""test amenity attri"""
a = Place()
self.assertTrue(hasattr(a, "amenity_ids"))
self.assertEqual(a.amenity_ids, [])
a.amenity_ids = ["225LU", "FER82", "ROOT36"]
self.assertEqual(a.amenity_ids, ["225LU", "FER82", "ROOT36"])
def test_3_Place(self):
""" check if the Place methods exists """
Place_1 = Place()
Place_1.city_id = "LA"
Place_1.user_id = "12340858294"
Place_1.name = "Erika Osorio"
Place_1.description = "the area has a green area"
Place_1.number_rooms = 4
Place_1.number_bathrooms = 5
Place_1.max_guest = 2
Place_1.price_by_night = 123.304
Place_1.latitude = 34.05223
Place_1.longitude = -118.24368
Place_1.amenity_ids = "452342"
Place_1.save()
self.assertTrue(os.path.exists('file.json'))
self.assertTrue(Place_1.city_id, "CA")
self.assertTrue(Place_1.user_id, "12340858294")
self.assertTrue(Place_1.name, "Erika Osorio")
self.assertTrue(Place_1.description, "the area has a green area")
self.assertTrue(Place_1.number_rooms, 4)
self.assertTrue(Place_1.number_bathrooms, 5)
self.assertTrue(Place_1.max_guest, 2)
self.assertTrue(Place_1.price_by_night, 123.304)
self.assertTrue(Place_1.latitude, 34.05223)
self.assertTrue(Place_1.longitude, -118.24368)
self.assertTrue(Place_1.amenity_ids, "452342")
def test_set_attrs(self):
""" test the attrs of Place when set """
place2 = Place()
place2.name = "Le House"
place2.city_id = "1234"
place2.user_id = "Jack The House Man"
place2.description = "terrible"
place2.number_rooms = 1
place2.number_bathrooms = 8
place2.max_guest = 3
place2.price_by_night = 7392
place2.latitude = 5.5
place2.longitude = 5.5
place2.amenity_ids = [
"lame", "upscale", "forward thinking", "distant", "aloof"
]
self.assertEqual(place2.name, "Le House")
self.assertEqual(Place.name, "")
self.assertEqual(place2.city_id, "1234")
self.assertEqual(Place.city_id, "")
self.assertEqual(place2.user_id, "Jack The House Man")
self.assertEqual(Place.user_id, "")
self.assertEqual(place2.description, "terrible")
self.assertEqual(Place.description, "")
self.assertEqual(place2.number_rooms, 1)
self.assertEqual(Place.number_rooms, 0)
self.assertEqual(place2.number_bathrooms, 8)
self.assertEqual(Place.number_bathrooms, 0)
self.assertEqual(place2.max_guest, 3)
self.assertEqual(Place.max_guest, 0)
self.assertEqual(place2.price_by_night, 7392)
self.assertEqual(Place.price_by_night, 0)
self.assertEqual(place2.latitude, 5.5)
self.assertEqual(Place.latitude, 0.0)
self.assertEqual(place2.longitude, 5.5)
self.assertEqual(Place.longitude, 0.0)
self.assertEqual(
place2.amenity_ids,
["lame", "upscale", "forward thinking", "distant", "aloof"])
self.assertEqual(Place.amenity_ids, [])
def test_Place(self):
""" checks Place class """
p = Place()
self.assertEqual(type(p), Place)
self.assertEqual(p.city_id, "")
self.assertEqual(p.user_id, "")
self.assertEqual(p.name, "")
self.assertEqual(p.description, "")
self.assertEqual(p.number_rooms, 0)
self.assertEqual(p.number_bathrooms, 0)
self.assertEqual(p.max_guest, 0)
self.assertEqual(p.price_by_night, 0)
self.assertEqual(p.latitude, 0.0)
self.assertEqual(p.longitude, 0.0)
self.assertEqual(p.amenity_ids, [])
p.city_id = "a"
p.user_id = "b"
p.name = "c"
p.description = "d"
p.number_rooms = 1
p.number_bathrooms = 2
p.max_guest = 3
p.price_by_night = 4
p.latitude = 1.1
p.longitude = 2.2
p.amenity_ids = [1, 2]
self.assertEqual(p.city_id, "a")
self.assertEqual(p.user_id, "b")
self.assertEqual(p.name, "c")
self.assertEqual(p.description, "d")
self.assertEqual(p.number_rooms, 1)
self.assertEqual(p.number_bathrooms, 2)
self.assertEqual(p.max_guest, 3)
self.assertEqual(p.price_by_night, 4)
self.assertEqual(p.latitude, 1.1)
self.assertEqual(p.longitude, 2.2)
self.assertListEqual(p.amenity_ids, [1, 2])
def test_place(self):
"""
Test attributes of Class Place
"""
my_amenity = Amenity()
my_city = City()
my_user = User()
my_place = Place()
my_place.city_id = my_city.id
my_place.user_id = my_user.id
my_place.name = 'Coworking'
my_place.description = 'description'
my_place.number_rooms = 4
my_place.number_bathrooms = 2
my_place.max_guest = 4
my_place.price_by_night = 200
my_place.latitude = 25.0342808
my_place.longitude = -77.3962784
my_place.amenity_ids = str(my_amenity.id)
self.assertEqual(my_place.city_id, my_city.id)
self.assertEqual(my_place.user_id, my_user.id)
self.assertEqual(my_place.name, 'Coworking')
self.assertEqual(my_place.description, 'description')
self.assertEqual(my_place.number_rooms, 4)
self.assertTrue(type(my_place.number_rooms), int)
self.assertEqual(my_place.number_bathrooms, 2)
self.assertTrue(type(my_place.number_bathrooms), int)
self.assertEqual(my_place.max_guest, 4)
self.assertTrue(type(my_place.max_guest), int)
self.assertEqual(my_place.price_by_night, 200)
self.assertTrue(type(my_place.price_by_night), int)
self.assertEqual(my_place.latitude, 25.0342808)
self.assertTrue(type(my_place.latitude), float)
self.assertEqual(my_place.longitude, -77.3962784)
self.assertTrue(type(my_place.longitude), float)
self.assertEqual(my_place.amenity_ids, str(my_amenity.id))
self.assertTrue(type(my_place.amenity_ids), str)
def test_place_public_attributes(self):
a = Place()
a.city_id = "city"
a.user_id = "user"
a.name = "name"
a.description = "description"
a.number_rooms = 5
a.number_bathrooms = 4
a.max_guest = 5
a.price_by_night = 100
a.latitude = 60.5
a.longitude = 50.5
a.amenity_ids = ["this", "is", "a", "list"]
self.assertEqual(a.city_id, "city")
self.assertEqual(a.user_id, "user")
self.assertEqual(a.name, "name")
self.assertEqual(a.description, "description")
self.assertEqual(a.number_rooms, 5)
self.assertEqual(a.number_bathrooms, 4)
self.assertEqual(a.max_guest, 5)
self.assertEqual(a.price_by_night, 100)
self.assertEqual(a.longitude, 50.5)
self.assertEqual(a.latitude, 60.5)
self.assertEqual(a.amenity_ids, ["this", "is", "a", "list"])
def test_Place(self):
"""Task 9
Tests `Place` class.
"""
# Normal use: no args
p1 = Place()
self.assertIsInstance(p1, Place)
# attr `city_id` defaults to empty string
self.assertIsInstance(p1.city_id, str)
self.assertEqual(p1.city_id, '')
# attr `user_id` defaults to empty string
self.assertIsInstance(p1.user_id, str)
self.assertEqual(p1.user_id, '')
# attr `name` defaults to empty string
self.assertIsInstance(p1.name, str)
self.assertEqual(p1.name, '')
# attr `description` defaults to empty string
self.assertIsInstance(p1.description, str)
self.assertEqual(p1.description, '')
# attr `number_rooms` defaults to int 0
self.assertIsInstance(p1.number_rooms, int)
self.assertEqual(p1.number_rooms, 0)
# attr `number_bathrooms` defaults to int 0
self.assertIsInstance(p1.number_bathrooms, int)
self.assertEqual(p1.number_bathrooms, 0)
# attr `max_guest` defaults to empty int 0
self.assertIsInstance(p1.max_guest, int)
self.assertEqual(p1.max_guest, 0)
# attr `price_by_night` defaults to int 0
self.assertIsInstance(p1.price_by_night, int)
self.assertEqual(p1.price_by_night, 0)
# attr `latitude` defaults to float 0.0
self.assertIsInstance(p1.latitude, float)
self.assertEqual(p1.latitude, 0.0)
# attr `longitude` defaults to float 0.0
self.assertIsInstance(p1.longitude, float)
self.assertEqual(p1.longitude, 0.0)
# attr `amenity_ids` defaults to empty list
self.assertIsInstance(p1.amenity_ids, list)
self.assertEqual(p1.amenity_ids, [])
# Place can be serialized to JSON by FileStorage
p1.city_id = 'test1'
p1.user_id = 'test2'
p1.name = 'test3'
p1.description = 'test4'
p1.number_rooms = 1
p1.number_bathrooms = -2
p1.max_guest = 3
p1.price_by_night = -4
p1.latitude = -5.5
p1.longitude = 6.6
p1.amenity_ids = ['id1', 'id2']
self.assertIn(p1, storage._FileStorage__objects.values())
p1.save()
with open(storage._FileStorage__file_path, encoding='utf-8') as file:
content = file.read()
key = p1.__class__.__name__ + '.' + p1.id
self.assertIn(key, json.loads(content))
# Place can be deserialized from JSON by FileStorage
self.assertIn(key, storage._FileStorage__objects.keys())
storage._FileStorage__objects = dict()
storage.reload()
self.assertIn(key, storage._FileStorage__objects.keys())
print("-- Crate a new Amenity --")
my_amenity = Amenity()
my_amenity.name = "Wi-Fi"
print(my_amenity)
print("-----------------------")
print("-- Crate a new Place --")
my_place = Place()
my_place.city_id = my_city.id
my_place.user_id = my_user.id
my_place.name = 'Bahamas'
my_place.description = 'Las Bahamas es un lugar muy Cool'
my_place.number_rooms = 4
my_place.number_bathrooms = 2
my_place.max_guest = 4
my_place.price_by_night = 200
my_place.lalitude = 25.0342808
my_place.longitude = -77.3962784
my_place.amenity_ids = str(my_amenity.id)
print(my_place)
print("-----------------------")
print("-- Crate a new Review --")
my_review = Review()
my_review.place_id = my_place.id
my_review.user_id = my_user.id
my_review.text = 'Asombroso'
print(my_review)
print("-----------------------")
def test_amenity_ids(self):
test = Place()
test.amenity_ids = ["Amenity.12345", "Amenity.23456"]
self.assertListEqual(test.amenity_ids,
["Amenity.12345", "Amenity.23456"])
print("-- Create a Amenity --")
my_amenity = Amenity()
my_amenity.name = "wifi"
my_amenity.save()
print(my_amenity)
print("-- Create a Place --")
x = Place()
x.city_id = "1"
x.user_id = "primero"
x.name = "casa de Charlie"
x.description = "gran casa cuenta con 2 habitaciones y 1 bano, wifi y un TV"
x.number_rooms = 2
x.number_bathrooms = 1
x.max_guest = 1
x.price_by_night = 900000
x.latitude = 98.89
x.longitude = 41.14
x.amenity_ids = "wifi, luz, aire acondicionado"
x.save()
print(x)
print("-- Review --")
rev = Review()
rev.place_id = "123"
rev.user_id = "1908"
rev.text = "perfecto una experiencia agradable"
rev.save()
print(rev)
def test_amenity_ids(self):
"""test for amenity_ids"""
ln = Place()
ln.amenity_ids = "dasa"
self.assertEqual(type(Place.amenity_ids), list)
def test_amenity_ids_public(self):
msj = "Longitude isn't public"
my_model1 = Place()
my_model1.amenity_ids = ["b6a6e15c-c67d-4312-9a75-9d084935e579"]
self.assertEqual(my_model1.amenity_ids,
["b6a6e15c-c67d-4312-9a75-9d084935e579"])
