def do_destroy(self, args):
"""
Destroys an instance
Usage: destroy <ClassName> <id>
Order of arguments is not checked
**Arguments**
ClassName: name of class
id: unique user id of instance
"""
args = args.split()
if len(args) == 0:
print("** class name missing **")
return
if len(args) == 1:
print("** instance id missing **")
return
if args[0] not in HBNBCommand.valid_classes.keys():
print("** class doesn't exist **")
return
all_objs = storage.all()
for k, v in all_objs.items():
if k == args[1] and args[0] == v.__class__.__name__:
storage.delete(v)
return
print("** no instance found **")
def test_view_one_state_wrong(self):
"""the id does not match a state"""
state_args = {"name": "Zanzibar", "id": "ZA1"}
state = State(**state_args)
state.save()
rv = self.app.get('{}/states/{}/'.format(self.path, "noID"))
self.assertEqual(rv.status_code, 404)
storage.delete(state)
def test_view_one_city_wrong(self):
"""the id does not match a city"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/cities/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(city)
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_getcities_badstate(self):
"""test listing all cities with a bad state id"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/states/{}/cities'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(city)
def delete_city(city_id):
"""This function delete a state by id"""
cities = storage.all('City')
c_id = "City." + city_id
to_del = cities.get(c_id)
if to_del is None:
abort(404)
storage.delete(to_del)
storage.save()
return jsonify({}), 200
def delete_place(place_id):
"""
Delete a Place instance
"""
place = storage.get("Place", place_id)
if place:
storage.delete(place)
storage.save()
return jsonify({}), 200
abort(404)
def test_getreviews_bad_place(self):
"""test listing all reviews with a bad place id"""
review_args = {"text": "what a cage", "place_id": self.place.id,
"user_id": self.user.id}
review = Review(**review_args)
review.save()
rv = self.app.get('{}/places/{}/reviews/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(review)
def del_place(place_id):
"""
Delete a place by id
"""
place = storage.get("Place", place_id)
if place is not None:
storage.delete(place)
storage.save()
return jsonify({}), 200
return jsonify({"error": "Not found"}), 404
def del_place(place_id):
""" deletes one place """
place_del = storage.get(Place, place_id)
if place_del is None:
abort(404)
else:
storage.delete(place_del)
storage.save()
answer = {}
return jsonify(answer), 200
def delete_user(user_id):
"""Deletes a user
"""
user = storage.get("User", user_id)
if user is not None:
storage.delete(user)
storage.save()
return make_response(jsonify({}), 200)
else:
return abort(404)
def delete_place(place_id):
"""This method deletes a place
"""
p = storage.get("Place", place_id)
if p:
storage.delete(p)
storage.save()
return (jsonify({}), 200)
else:
abort(404)
def delete_a_city(city_id=None):
"""Delete a city according to its id"""
if city_id is None:
return abort(404)
my_city = storage.get(City, city_id)
if my_city is not None:
storage.delete(my_city)
storage.save()
return make_response(jsonify({}), 200)
return abort(404)
def deleter_places(place_id):
'''deleter_id - delete an object by id'''
id = storage.get(Place, place_id)
if id is not None:
storage.delete(id)
storage.save()
return jsonify({}), 200
else:
abort(404)
def delete_amenity(amenity_id):
"""Deletes an amenity
"""
amenity = storage.get("Amenity", amenity_id)
if amenity is not None:
storage.delete(amenity)
storage.save()
return make_response(jsonify({}), 200)
else:
abort(404)
def delete_review(review_id):
"""delete review by id
"""
for key, values in storage.all("Review").items():
if review_id in key:
storage.delete(values)
storage.save()
storage.close()
return jsonify({}), 200
abort(404)
def delete_amenities(amenity_id):
""" Delete amenities for ID """
my_amenities = storage.get("Amenity", amenity_id)
if my_amenities:
storage.delete(my_amenities)
storage.save()
storage.close()
return jsonify({}), 200
else:
abort(404)
def delete_amenity(amenity_id):
'''
Deletes a specified Amenity object from storage
'''
amenity = storage.get("Amenity", amenity_id)
if not amenity:
abort(404)
storage.delete(amenity)
storage.save()
return jsonify({}), 200
def test_delete_review_wrong(self):
"""the id does not match a review"""
review_args = {"text": "sad cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.delete('{}/reviews/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(review)
def test_getplaces_bad_city(self):
"""test listing all places with a bad city id"""
place_args = {"name": "cage", "city_id": self.city.id,
"user_id": self.user.id}
place = Place(**place_args)
place.save()
rv = self.app.get('{}/cities/{}/places'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(place)
def delete_by_id(state_id):
"""Deletes a State object"""
states = storage.all(State)
for k, v in states.items():
if v.id == state_id:
storage.delete(v)
storage.save()
d = {}
return jsonify(d), 200
abort(404)
def delete_user(user_id=None):
"""
This method delete a user
"""
user = storage.get(User, user_id)
if user_id is not None and user is not None:
storage.delete(user)
return make_response(jsonify({}), 200)
else:
return make_response(jsonify({"error": "Not found"}), 404)
def delete_city(city_id):
"""
Delete a City object by id
"""
city = storage.get("City", id=city_id)
if city:
storage.delete(city)
storage.save()
return jsonify({}), 200
abort(404)
def delete_city(cities_id):
"""
Deletes cities
"""
cities = storage.get("City", cities_id)
if cities is None:
return (abort(404))
else:
storage.delete(cities)
return (jsonify({}), 200)
def delete_review(review_id):
''' deletes review '''
value = storage.get('Review', review_id)
if value is None:
abort(404)
review_storage = storage.all('Review')
for review in review_storage.values():
if review.id == review_id:
storage.delete(review)
return jsonify({}), 200
def delete_state(state_id):
"""delete state by id
"""
for key, values in storage.all("State").items():
if state_id in key:
storage.delete(values)
storage.save()
storage.close()
return jsonify({}), 200
abort(404)
def DeleteUserById(user_id):
"""Deletes an user based on its id for DELETE HTTP method"""
all_users = storage.all(User)
u_id = "User." + user_id
to_del = all_users.get(u_id)
if to_del is None:
abort(404)
storage.delete(to_del)
storage.save()
return jsonify({}), 200
def delete_amenity(amenity_id=None):
""" Delete amenity """
amenity = storage.get(Amenity, amenity_id)
if amenity:
storage.delete(amenity)
storage.save()
return jsonify({}), 200
else:
return abort(404)
def del_city(city_id):
"""Deletes a specific city"""
city = storage.get("City", city_id)
if city is None:
abort(404)
else:
storage.delete(city)
storage.save()
return jsonify({}), 200
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 delete_amenity(amenity_id):
"""delete Amenity by id
"""
for key, values in storage.all("Amenity").items():
if amenity_id in key:
storage.delete(values)
storage.save()
storage.close()
return jsonify({}), 200
abort(404)
def delete_amenity_with_id(amenity_id):
"""Deletes a amenity with a particular ID"""
amenity = storage.all("Amenity").values()
for amenity in amenity:
if amenity.id == amenity_id:
storage.delete(amenity)
storage.save()
storage.close()
return jsonify({})
abort(404)
def delete_user(user_id=None):
''' deletes an individual user '''
obj = storage.get('User', user_id)
if obj is None:
''' if no state obj with that id '''
abort(404)
storage.delete(obj)
storage.save()
return jsonify({}), 200
def test_delete_place_wrong(self):
"""the id does not match a place"""
place_args = {"name": "cage", "city_id": self.city.id,
"user_id": self.user.id, "id": "CA"}
place = Place(**place_args)
place.save()
rv = self.app.delete('{}/places/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(place)
def delete_review(review_id=None):
"""
This method delete a review
"""
review = storage.get(Review, review_id)
if review is not None:
storage.delete(review)
return make_response(jsonify({}), 200)
else:
return make_response(jsonify({"error": "Not found"}), 404)
def test_delete_user_wrong(self):
"""the id does not match a user"""
user_args = {"first_name": "quokka", "id": "QO",
"email": "*****@*****.**", "password": "******"}
user = User(**user_args)
user.save()
rv = self.app.delete('{}/users/{}/'.format(self.path, "noID"),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(user)
def delete_state(state_id):
"""
Delete a State instance
"""
state = storage.get("State", id=state_id)
if state:
storage.delete(state)
storage.save()
return jsonify({}), 200
abort(404)
def list_review_delete(review_id):
"""Method delete"""
var = storage.get("Review", review_id)
if var is None:
abort(404)
else:
storage.delete(var)
storage.save()
dict_state = {}
return (jsonify(dict_state), 200)
def do_delete_review(review_id):
"""
Deletes a Review object
Return: an empty dictionary with the status code 200
"""
get_review = do_check_id(review.Review, review_id)
storage.delete(get_review)
storage.save()
response = {}
return jsonify(response)
def delete_review(review_id):
'''
function deletes a review given its id
'''
to_remove = storage.get("Review", review_id)
if to_remove is not None:
storage.delete(to_remove)
storage.save()
return jsonify({}), 200
abort(404)
def test_getstates_empty_db(self):
"""test listing all states in empty db"""
s = storage.all("State").values()
for e in s:
storage.delete(e)
rv = self.app.get('{}/states/'.format(self.path))
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.assertEqual(json_format, [])
def test_update_state_bad_id(self):
"""test update with no matching id"""
state_args = {"name": "Zanzibar", "id": "ZA6"}
state = State(**state_args)
state.save()
rv = self.app.put('{}/states/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"id": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(state)
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_city_bad_id(self):
"""test update with no matching id"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.put('{}/cities/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"name": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(city)
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_update_user_bad_id(self):
"""test update with no matching id"""
user_args = {"first_name": "quokka", "id": "QO",
"email": "*****@*****.**", "password": "******"}
user = User(**user_args)
user.save()
rv = self.app.put('{}/users/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"id": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(user)
def test_update_place_bad_id(self):
"""test update with no matching id"""
review_args = {"text": "cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.put('{}/reviews/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"text": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(review)
def test_update_city_bad_id(self):
"""test update with no matching id"""
place_args = {"name": "cage", "city_id": self.city.id,
"user_id": self.user.id, "id": "CA"}
place = Place(**place_args)
place.save()
rv = self.app.put('{}/places/{}/'.format(self.path, "noID"),
content_type="application/json",
data=json.dumps({"name": "Z"}),
follow_redirects=True)
self.assertEqual(rv.status_code, 404)
storage.delete(place)
def test_update_state_bad_json(self):
"""test update with ill formedt json"""
state_args = {"name": "Zanzibar", "id": "ZA5"}
state = State(**state_args)
state.save()
rv = self.app.put('{}/states/{}/'.format(self.path, state.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(state)
def test_getstates(self):
"""test listing all states"""
state_args = {"name": "Zanzibar"}
state = State(**state_args)
state.save()
rv = self.app.get('{}/states/'.format(self.path))
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(state_args["name"], [e.get("name") for e in json_format])
storage.delete(state)
def test_update_city_bad_json(self):
"""test update with ill formedt json"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.put('{}/cities/{}/'.format(self.path, city.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(city)
def test_view_one_state(self):
"""test retrieving one state"""
state_args = {"name": "Zanzibar", "id": "ZA3"}
state = State(**state_args)
state.save()
rv = self.app.get('{}/states/{}/'.format(self.path, state_args["id"]))
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"), state_args["name"])
self.assertEqual(json_format.get("id"), state_args["id"])
storage.delete(state)
def test_update_user_bad_json(self):
"""test update with ill formed json"""
user_args = {"first_name": "quokka", "id": "QO2",
"email": "*****@*****.**", "password": "******"}
user = User(**user_args)
user.save()
rv = self.app.put('{}/users/{}/'.format(self.path, user.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(user)
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_update_review_bad_json(self):
"""test update with ill formed json"""
review_args = {"text": "cage", "place_id": self.place.id,
"user_id": self.user.id, "id": "RCA"}
review = Review(**review_args)
review.save()
rv = self.app.put('{}/reviews/{}/'.format(self.path, review.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(review)
def test_update_place_bad_json(self):
"""test update with ill formed json"""
place_args = {"name": "cage", "city_id": self.city.id,
"user_id": self.user.id, "id": "CA"}
place = Place(**place_args)
place.save()
rv = self.app.put('{}/places/{}/'.format(self.path, place.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(place)
def test_view_one_city(self):
"""test retrieving one state"""
city_args = {"name": "Gaborone", "id": "GA", "state_id": "BO"}
city = City(**city_args)
city.save()
rv = self.app.get('{}/cities/{}'.format(self.path, city_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"), city_args["name"])
self.assertEqual(json_format.get("id"), city_args["id"])
storage.delete(city)
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)
