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_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_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_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_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_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_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_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_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_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 post_amenity(amenity_id=None):
"""state"""
try:
willy = request.get_json()
except:
abort(400, 'Not a JSON')
if willy is None:
abort(400, 'Not a JSON')
elif "name" not in willy.keys():
abort(400, 'Missing name')
else:
new_amenity = Amenity(name=willy['name'])
new_amenity.save()
return jsonify(new_amenity.to_dict()), 201
def post_amenities():
"""
Creates a Amenity
"""
content = request.get_json()
if content is None:
return (jsonify({"error": "Not a JSON"}), 400)
name = content.get("name")
if name is None:
return (jsonify({"error": "Missing name"}), 400)
new_amenity = Amenity(**content)
new_amenity.save()
return (jsonify(new_amenity.to_dict()), 201)
def post(self):
"""Creates an Amenity
"""
req_data = request.get_json()
if not req_data:
abort(400, 'Not a JSON')
if 'name' not in req_data:
abort(400, 'Missing name')
amenity = Amenity(**req_data)
amenity.save()
return jsonify(amenity.to_dict()), 201
def test_file(self):
""" test storege """
self.assertTrue(os.path.exists("file.json"))
x = 0
u1 = Amenity()
u1.save()
models.storage.reload()
d = models.storage.all()
for k in d.keys():
if u1.id in k:
x = 1
self.assertEqual(x, 1)
def post_amenity():
"""
Creates an amenity
"""
if not request.get_json():
abort(400, description="Not a JSON")
if 'name' not in request.get_json():
abort(400, description="Missing name")
data = request.get_json()
instance = Amenity(**data)
instance.save()
return make_response(jsonify(instance.to_dict()), 201)
def create_amenity():
"""create amenities"""
n = 'name'
if not request.get_json():
return make_response(jsonify({'error': 'Not a JSON'}), 400)
if n not in request.get_json():
return make_response(jsonify({'error': 'Missing name'}), 400)
req_data = request.get_json()
amenity = Amenity()
amenity.name = req_data['name']
amenity.save()
return make_response(jsonify(amenity.to_dict()), 201)
def create_amenity():
""" Creates an Amenity object, or returns a 400 if the HTTP body request is not
valid JSON, or if the dict doesnt contain the key name """
data = ""
data = request.get_json()
if data is None:
abort(400, "Not a JSON")
name = data.get("name")
if name is None:
abort(400, "Missing name")
new_amenity = Amenity()
new_amenity.name = name
new_amenity.save()
return (jsonify(new_amenity.to_dict())), 201
def new_amenity():
"""Creates an Amenity
"""
new_obj = request.get_json()
if new_obj is None:
abort(400, "Not a JSON")
if "name" not in new_obj.keys():
abort(400, "Missing name")
new_amenity = Amenity(**new_obj)
new_amenity.save()
storage.reload()
return jsonify(new_amenity.to_dict()), 201
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 all_amenities():
""" all_amenities
Return: all amenities
"""
if request.method == 'GET':
return jsonify([i.to_dict() for i in storage.all('Amenity').values()])
elif request.method == 'POST':
if request.get_json() is None:
abort(400, 'Not a JSON')
if "name" not in request.get_json().keys():
abort(400, 'Missing name')
instance = Amenity(**request.get_json())
instance.save()
return jsonify(instance.to_dict()), 201
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_create_pla_amenity_error(self):
'''This is the 'test_create_pla_amenity_error' method.
Tests the 'create_place_amenity' method with invalid amenity.
'''
amenity_args = {"name": "testA", "id": "TA"}
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_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_02_save_consistency(self):
'''Check for consistency after save'''
models.storage.all().clear()
obj1 = Amenity()
old = obj1.__dict__.copy()
try:
obj1.save()
except:
self.fail("Failed to save")
new = obj1.__dict__.copy()
del old['updated_at']
del new['updated_at']
self.assertEqual(old, new, "Failed to maintain consistency after save")
del obj1
class TestModels(unittest.TestCase):
""" Funtion to test the BaseModel"""
def setUp(self):
""" Set a variable """
self.amenity_1 = Amenity()
print("setUp")
def tearDown(self):
""" End variable """
print("tearDown")
@classmethod
def setUpClass(cls):
""" define class """
print("setUpClass")
@classmethod
def tearDownClass(cls):
""" close the class """
print("tearDownClass")
def test_amenity_doc(self):
""" Check the documentation """
self.assertIsNotNone(Amenity.__doc__)
self.assertIsNotNone(Amenity.__init__.__doc__)
def test_place_city(self):
""" check if the amenity methods exists """
self.amenity_1.save()
self.assertTrue(os.path.isfile('file.json'))
self.assertTrue(hasattr(self.amenity_1, "__init__"))
self.assertTrue(hasattr(self.amenity_1, "name"))
def test_amenity_name(self):
""" check if the name is create """
self.amenity_1.name = 'Good'
self.assertEqual(self.amenity_1.name, 'Good')
def test_models_to_dict(self):
model_1 = self.amenity_1.to_dict()
self.assertIsInstance(model_1["created_at"], str)
self.assertIsInstance(model_1["updated_at"], str)
self.assertIsInstance(model_1["id"], str)
def test_amenity_instance(self):
""" check if amenity_1 is instance of Amenity """
self.assertIsInstance(self.amenity_1, 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_count(self):
"""Test if count method counts number of objects in storage"""
counter = models.storage.count()
new_state = State(name="California")
new_state.save()
self.assertNotEqual(models.storage.count(State), 0)
self.assertEqual(storage.count(Amenity), 1)
new_amenity = Amenity(name="Smoking allowed")
new_amenity.save()
self.assertNotEqual(models.storage.count(Amenity), 0)
self.assertIsInstance(models.storage.count(), int)
self.assertIsInstance(models.storage.count(Amenity), int)
self.assertNotEqual(models.storage.count(Amenity), None)
new_state.delete()
new_amenity.delete()
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 amenity_post():
"""
creates new amenity object instance
"""
new_amenity = Amenity()
req = request.get_json()
if req is None:
return ("Not a JSON", 400)
if 'name' not in req.keys():
return ("Missing name", 400)
new_amenity.__dict__.update(req)
new_amenity.save()
return (jsonify(new_amenity.to_json()), 201)
def post_amenity():
""" Creates a Amenity"""
req = request.get_json()
if req:
if 'name' in req:
new_amenity = Amenity(**req)
new_amenity.save()
return make_response(jsonify(new_amenity.to_dict()), 201)
else:
return make_response(jsonify("Missing name"), 400)
else:
return make_response(jsonify("Not a JSON"), 400)
def amenities():
"""Define GET /amenities
"""
if request.method == "GET":
return jsonify([amenity.to_dict()
for amenity in storage.all("Amenity").values()])
doc = request.get_json(silent=True)
if doc is None:
return "Not a JSON", 400
if doc.get("name") is None:
return "Missing name", 400
amenity = Amenity(**doc)
amenity.save()
return jsonify(amenity.to_dict()), 201
def p_amenities():
"""add new state"""
if request.method == 'POST':
data = request.get_json()
if data:
if "name" not in data.keys():
raise abort(400, "Missing name")
else:
instance = Amenity(name=data["name"])
instance.save()
return jsonify(BaseModel.to_dict(
storage.get("Amenity", instance.id))), 201
else:
raise abort(400, "Not a JSON")
return jsonify({})
def amenities_unlinked():
"""amenities not linked to an object
"""
if request.method == 'GET':
all_amenity = [amenity.to_dict() for amenity in storage.
all("Amenity").values()]
return (jsonify(all_amenity), 200)
if request.method == 'POST':
if not request.get_json():
return make_response(jsonify({'error': 'Not a JSON'}), 400)
if 'name' not in request.get_json():
return make_response(jsonify({'error': 'Missing name'}), 400)
amenity = Amenity(**request.get_json())
amenity.save()
return make_response(jsonify(amenity.to_dict()), 201)
def test_save(self):
"""Test save method"""
# storage = FileStorage()
am = Amenity()
temp = am.__dict__['updated_at']
self.assertFalse(path.isfile('file.json'))
am.save()
self.assertTrue(path.isfile('file.json'))
self.assertNotEqual(am.__dict__['updated_at'], temp)
temp = am.__dict__['updated_at']
# storage.reload()
models.storage.reload()
self.assertEqual(am.__dict__['updated_at'], temp)
def test_delete_pla_no_amenity(self):
'''This is the 'test_delete_pla_no_amenity' method.
Tests the 'delete_place_amenity' method for an amenity not in a
given place.
'''
amenity_args = {"name": "testA", "id": "TA"}
amenity = Amenity(**amenity_args)
amenity.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 handle_amenities():
"""Retrieves the list of all Amenity objects or
create a new Amenity object"""
if request.method == 'GET':
return jsonify(
[obj.to_dict() for obj in storage.all("Amenity").values()]), 200
if request.method == 'POST':
if not request.get_json(silent=True):
abort(400, "Not a JSON")
if not request.get_json(silent=True).get('name'):
abort(400, "Missing name")
kwargs = request.get_json(silent=True)
new_amenity = Amenity(**kwargs)
new_amenity.save()
return jsonify(new_amenity.to_dict()), 201
def test_update_amenity_id_error(self):
'''This is the 'test_update_amenity_id_error' method.
Tests for updating an Amenity object with an invalid id.
'''
amenity_args = {"name": "test", "id": "TS"}
amenity = Amenity(**amenity_args)
amenity.save()
rv = self.app.put('{}/amenities/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"id": "T"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
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 create_a_amenity():
"""
Creates a new Amenity object according to
the HTTP body request dictionary
"""
body = request.get_json(silent=True)
if body is None:
return make_response(jsonify({'error': 'Not a JSON'}), 400)
if "name" not in body:
return make_response(jsonify({'error': 'Missing name'}), 400)
new = Amenity(**body)
new.save()
return make_response(jsonify(new.to_dict()), 201)
def amenities_base():
"""Retrieves the list of all Amenity objects"""
if request.method == "GET":
out = []
for amenity in storage.all("Amenity").values():
out.append(amenity.to_dict())
return jsonify(out)
if request.method == "POST":
if not request.is_json:
return "Not a JSON", 400
out = Amenity(**request.get_json())
if "name" not in out.to_dict().keys():
return "Missing name", 400
out.save()
return out.to_dict(), 201
def amenity_route():
if request.method == 'GET':
amenity_list = [
amenity.to_dict() for amenity in storage.all("Amenity").values()
]
return jsonify(amenity_list)
if request.method == 'POST':
req_dict = request.get_json(silent=True)
if req_dict is None:
return jsonify({"error": "Not a JSON"}), 400
if 'name' not in req_dict.keys():
return jsonify({"error": "Missing name"}), 400
new = Amenity(**req_dict)
new.save()
return jsonify(new.to_dict()), 201
def amenities_get_id(amenity_id=None):
"""Retrieves a amenities object by its id"""
amenity_dict = storage.all(Amenity)
obj_list = []
if amenity_id is not None:
my_amenities_obj = storage.get(Amenity, amenity_id)
if my_amenities_obj is not None:
if request.method == 'DELETE':
storage.delete(my_amenities_obj)
return make_response(jsonify({}), 200)
if request.method == 'GET':
return jsonify(my_amenities_obj.to_dict())
if request.method == 'PUT':
update_dict = request.get_json(silent=True)
if update_dict is not None:
for key, value in update_dict.items():
setattr(my_amenities_obj, key, value)
my_amenities_obj.save()
return make_response(jsonify(my_amenities_obj.to_dict()),
200)
else:
abort(400, "Not a JSON")
else:
abort(404)
else:
# In case amenity_id is None
if request.method == 'POST':
my_json = request.get_json(silent=True)
if my_json is not None:
if "name" in my_json:
name = my_json["name"]
new_amenities = Amenity(name=name)
new_amenities.save()
return make_response(jsonify(new_amenities.to_dict()), 201)
else:
abort(400, "Missing name")
else:
# print("funcionó el none!")
abort(400, "Not a JSON")
for value in amenity_dict.values():
obj_list.append(value.to_dict())
return jsonify(obj_list)
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 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)
