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)