def test_count_amenity(self):
"""test count with an argument"""
test_len = len(storage.all("Amenity"))
a = Amenity(name="test_amenity_2")
a.save()
self.assertEqual(test_len + 1, storage.count("Amenity"))
storage.delete(a)
self.assertEqual(test_len, storage.count("Amenity"))
def test_new(self):
# note: we cannot assume order of test is order written
test_len = len(storage.all())
# self.assertEqual(len(storage.all()), self.test_len)
self.model.save()
self.assertEqual(len(storage.all()), test_len + 1)
a = Amenity(name="thing")
a.save()
self.assertEqual(len(storage.all()), test_len + 2)
def test_save(self):
test_len = len(storage.all())
a = Amenity(name="another")
a.save()
self.assertEqual(len(storage.all()), test_len + 1)
b = State(name="california")
self.assertNotEqual(len(storage.all()), test_len + 2)
b.save()
self.assertEqual(len(storage.all()), test_len + 2)
def test_delete_amenity_wrong(self):
"""the id does not match a amenity"""
amenity_args = {"name": "quokka", "id": "QO"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.delete('{}/amenities/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(amenity)
def test_link_bad_amenity_place(self):
"""test linking a non existing amenity to a place"""
amenity_args = {"name": "bear", "id": "BA"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.post('{}/places/{}/amenities/{}/'.format(
self.path, self.place.id, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(amenity)
def test_count(self):
"""test count all"""
test_len = len(storage.all())
a = Amenity(name="test_amenity")
a.save()
self.assertEqual(test_len + 1, storage.count())
b = State(name="State test count")
b.save()
self.assertEqual(test_len + 2, storage.count())
storage.delete(b)
self.assertEqual(test_len + 1, storage.count())
def test_update_amenity_bad_id(self):
"""test update with no matching id"""
amenity_args = {"name": "quokka", "id": "QO"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.put('{}/amenities/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"id": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(amenity)
def test_delete_amenity_not_in_place(self):
"""test remove an amenity from a place without this amenity"""
amenity_args = {"name": "bear", "id": "BA"}
amenity = Amenity(**amenity_args)
amenity.save()
# self.place.save()
rv = self.app.delete('{}/places/{}/amenities/{}/'.format(
self.path, self.place.id, amenity.id),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(amenity)
def test_update_amenity_bad_json(self):
"""test update with ill formed json"""
amenity_args = {"name": "quokka", "id": "QO2"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.put('{}/amenities/{}/'.format(self.path, amenity.id),
content_type="application/json",
data={"id": "Z"},
follow_redirects=True)
self.assertEqual(rv.status_code, 400)
self.assertEqual(rv.get_data(), b"Not a JSON")
storage.delete(amenity)
def test_view_one_amenity(self):
"""test retrieving one amenity"""
amenity_args = {"name": "quokka", "id": "QO2"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.get('{}/amenities/{}'.format(
self.path, amenity_args["id"]), follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format.get("name"), amenity_args["name"])
self.assertEqual(json_format.get("id"), amenity_args["id"])
storage.delete(amenity)
def test_delete_amenity(self):
"""test delete a amenity"""
amenity_args = {"name": "quokka", "id": "QO"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.delete('{}/amenities/{}/'.format(
self.path, amenity_args["id"]),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format, {})
self.assertIsNone(storage.get("Amenity", amenity_args["id"]))
def test_getamenities(self):
"""test listing all amenities"""
amenity_args = {"name": "quokka"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.get('{}/amenities/'.format(self.path),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertTrue(type(json_format), list)
self.assertIn(amenity_args["name"],
[e.get("name") for e in json_format])
storage.delete(amenity)
def test_delete_amenity_in_place(self):
"""test remove an amenity from a place"""
amenity_args = {"name": "bear", "id": "BA"}
amenity = Amenity(**amenity_args)
self.place.amenities.append(amenity)
amenity.save()
rv = self.app.delete('{}/places/{}/amenities/{}/'.format(
self.path, self.place.id, "BA"),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format, {})
self.assertIsNotNone(storage.get("Amenity", amenity.id))
storage.delete(amenity)
def test_update_amenity_id(self):
"""test cannot update amenity id"""
amenity_args = {"name": "quokka", "id": "QO1"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.put('{}/amenities/{}/'.format(self.path, amenity.id),
content_type="application/json",
data=json.dumps({"id": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 200)
self.assertEqual(rv.headers.get("Content-Type"), "application/json")
json_format = getJson(rv)
self.assertEqual(json_format.get("name"), amenity_args["name"])
self.assertEqual(json_format.get("id"), amenity_args["id"])
storage.delete(amenity)
def test_link_amenity_place(self):
"""test linking an amenity to a place"""
amenity_args = {"name": "bear", "id": "BA"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.post('{}/places/{}/amenities/{}/'.format(
self.path, self.place.id, amenity.id),
follow_redirects=True)
self.assertEqual(rv.status_code, 201)
json_format = getJson(rv)
self.assertEqual(json_format.get("name"), amenity_args["name"])
self.assertEqual(json_format.get("id"), amenity_args["id"])
self.assertIn(self.amenity.id,
[a.id for a in storage.get("Place",
self.place.id).amenities])
storage.delete(amenity)
def test_get_amenity(self):
"""test get with valid cls and id"""
a = Amenity(name="test_amenity3", id="test_3")
a.save()
result = storage.get("Amenity", "test_3")
self.assertEqual(a.name, result.name)
# does not work as the database loses last argument tzinfo for datetime
# self.assertEqual(a.created_at, result.created_at)
self.assertEqual(a.created_at.year, result.created_at.year)
self.assertEqual(a.created_at.month, result.created_at.month)
self.assertEqual(a.created_at.day, result.created_at.day)
self.assertEqual(a.created_at.hour, result.created_at.hour)
self.assertEqual(a.created_at.minute, result.created_at.minute)
self.assertEqual(a.created_at.second, result.created_at.second)
storage.delete(a)
result = storage.get("Amenity", "test_3")
self.assertIsNone(result)
def setUpClass(cls):
"""Called before test in an individual class are run
"""
cls.a = Amenity()
cls.a.name = "Pool"
# creation of a User
user = User(email="*****@*****.**",
password="******",
first_name="john",
last_name="snow")
user.save()
# creation of 2 Places
place_1 = Place(user_id=user.id, city_id=city.id, name="House 1")
place_1.save()
place_2 = Place(user_id=user.id, city_id=city.id, name="House 2")
place_2.save()
# creation of 3 various Amenity
amenity_1 = Amenity(name="Wifi")
amenity_1.save()
amenity_2 = Amenity(name="Cable")
amenity_2.save()
amenity_3 = Amenity(name="Oven")
amenity_3.save()
# link place_1 with 2 amenities
place_1.amenities.append(amenity_1)
place_1.amenities.append(amenity_2)
# link place_2 with 3 amenities
place_2.amenities.append(amenity_1)
place_2.amenities.append(amenity_2)
place_2.amenities.append(amenity_3)
def test_subclass(self):
"""test if subclass of BaseModel"""
amenity = Amenity()
self.assertTrue(issubclass(amenity.__class__, BaseModel))
def test_reload(self):
"""not actually testing reload as it creates a parallel new session"""
a = Amenity(name="different")
a.save()
for value in storage.all().values():
self.assertIsInstance(value.created_at, datetime)
def test_instance(self):
""" pass """
a = Amenity()
assert isinstance(a, Amenity)
print("-- Create a new State --")
my_state = State()
my_state.name = "Bogota D.C"
my_state.save()
print(my_state)
print("-- Create a new City --")
my_city = City()
my_city.state_id = "948"
my_city.name = "Bogota"
my_city.save()
print(my_city)
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
def test_Amenity_inheritence(self):
'''
tests that the Amenity class Inherits from BaseModel
'''
new_amenity = Amenity()
self.assertIsInstance(new_amenity, BaseModel)
def test_amenity_name_string(self):
"""testing if amenity name is a string"""
self.amenity = Amenity()
self.assertEqual(type(self.amenity.name), str)
def CheckId(self):
"""
Checks for a valid ID
"""
am1 = Amenity()
self.assertEqual(type(am1.id) is str, True)
def Check_updated_at(self):
"""
Checks for updated_at from BaseModel
"""
am1 = Amenity()
self.assertEqual(type(am1.updated_at) is datetime, True)
def Check_BaseModel_Inheritance(self):
"""
Checks that Amenty inherits from BaseModel
"""
am1 = Amenity()
self.assertEqual(issubclass(type(am1), BaseModel), True)
def test_father(self):
"""
Test attributes of Class Amenity
"""
amenity1 = Amenity()
self.assertTrue(issubclass(amenity1.__class__, BaseModel))
def test_class(self):
"""
Test attributes of Class Amenity
"""
amenity1 = Amenity()
self.assertEqual(amenity1.__class__.__name__, "Amenity")
def setUp(self):
""" setting up basic object """
self.am = Amenity()
def test_amenity(self):
"""Test attributes of Class Amenity"""
my_amenity = Amenity()
my_amenity.name = "Wi-Fi"
self.assertEqual(my_amenity.name, 'Wi-Fi')
def setUpClass(cls):
""" xdxdxd """
cls.amenity = Amenity()
cls.amenity.name = "Breakfast"
def test_Amenity_attributes(self):
'''
Test that Amenity class had name attribute.
'''
new_amenity = Amenity()
self.assertTrue("name" in new_amenity.__dir__())
def test_hasattribute(self):
"""Tests if the instance of BaseModel"""
a = Amenity()
self.assertTrue(hasattr(a, "name"))
def test_str(self):
''' test correct output'''
my_am = Amenity()
my_str = "[Amenity] ({}) {}".format(my_am.id, my_am.__dict__)
self.assertEqual(my_str, str(my_am))
def setUp(self):
"""setup"""
self.am = Amenity()
def test_attribute_types(self):
"""test if amenity attrs are correct type"""
amenity = Amenity()
self.assertEqual(type(amenity.name), str)
def test_id(self):
""" id testing """
u = Amenity()
u1 = Amenity()
self.assertNotEqual(u.id, u1.id)
def test_docstrings(self):
"""test if docstrings exist"""
amenity = Amenity()
self.assertTrue(len(amenity.__doc__) > 0)
for method in dir(amenity):
self.assertTrue(len(method.__doc__) > 0)
def test_to_dict(self):
"""to_dict testing"""
dic = Amenity()
self.assertIsInstance(dic.to_dict(), dict)
def setUpClass(cls):
"""set up for test"""
cls.amenity = Amenity()
cls.amenity.name = "Breakfast"
def setUpClass(cls):
""" Example Data """
cls.amen = Amenity()
cls.amen.name = "Wifi"
def test_task9(self):
""" test instantiatione in the user class """
a = Amenity()
self.assertEqual(str(type(a)), "<class 'models.amenity.Amenity'>")
self.assertIsInstance(a, Amenity)
self.assertTrue(issubclass(type(a), Amenity))
def test_typeAttr(self):
dic = {"name": "Louis"}
a = Amenity(**dic)
self.assertEqual(type(a.name), str)
def setUp(self):
""" Sets up Amenity for every test """
self.amenity = Amenity()
def test_type(self):
a = Amenity()
self.assertEqual(type(a.name), str)
def test_type(self):
'''test attr type'''
my_am = Amenity()
self.assertTrue(type(my_am.name) is str)
def test_Amenity_attributes(self):
'''
Test that Amenity class had name attribute.
'''
new_amenity = Amenity()
self.assertTrue("name" in new_amenity.__dir__())
