def test_delete_recipe_in_category_catid_recipeid_not_number(self):
     """
     Test for deleting recipe in category
     """
     response = self.register_user("Patrick", "Walukagga",
                                   "*****@*****.**", "telnetcmd123")
     # registered user login
     rep_login = self.login_user("*****@*****.**", "telnetcmd123")
     # valid token
     headers = dict(Authorization='Bearer ' +
                    json.loads(rep_login.data.decode())['auth_token'])
     category = RecipeCategory(name="Breakfast",
                               description="How to make breakfast",
                               user_id=1)
     category.save()
     response = self.create_category("LunchBuffe",
                                     "How to make lunch buffe", headers)
     recipe = Recipe(name="Rolex for Lunch",
                     cat_id=2,
                     user_id=1,
                     ingredients="oil, Onions, Tomatoes",
                     description="How to make breakfast rolex")
     recipe.save()
     response = self.create_recipe_in_category(2, "Chicken Lunch Buffe",
                                               "oil, Onions,Tomatoes",
                                               "Mix and boil", headers)
     response = self.client.delete('/recipe_category/a/recipes/2',
                                   headers=headers)
     self.assertEqual(response.status_code, 400)
     self.assertIn('Category ID must be an integer', str(response.data))
     # recipe id not number
     response = self.client.delete('/recipe_category/2/recipes/a',
                                   headers=headers)
     self.assertEqual(response.status_code, 400)
     self.assertIn('Recipe ID must be an integer', str(response.data))
    def test_user_retrieves_recipe_categories_with_limit(self):
        """
        Test for user retrieves recipe categories with limit pagination
        """
        with self.client:
            response = self.register_user("Patrick", "Walukagga",
                                          "*****@*****.**",
                                          "telnetcmd123")
            # registered user login
            rep_login = self.login_user("*****@*****.**", "telnetcmd123")

            # valid token
            headers = dict(Authorization='Bearer ' +
                           json.loads(rep_login.data.decode())['auth_token'])
            category = RecipeCategory(name="Morningfast",
                                      description="How to make morningfast",
                                      user_id=1)
            category.save()
            response = self.create_category("Breakfast",
                                            "How to make breakfast", headers)

            response = self.create_category("Lunchfast",
                                            "How to make lunchfast", headers)
            response = self.client.get('/recipe_category?limit=2',
                                       headers=headers)
            self.assertEqual(response.status_code, 200)
            self.assertIn('How to make morningfast', str(response.data))
            self.assertIn('How to make breakfast', str(response.data))
            self.assertNotIn('How to make lunchfast', str(response.data))
Ejemplo n.º 3
0
 def test_recipe_creation_with_name_has_numbers(self):
     """
     Test for recipe creation with name has numbers
     """
     response = self.register_user(
         "Patrick", "Walukagga", 
         "*****@*****.**", "telnetcmd123"
     )
     # registered user login
     rep_login = self.login_user("*****@*****.**", "telnetcmd123")
     # valid token
     headers=dict(
         Authorization='Bearer ' + json.loads(
             rep_login.data.decode()
         )['auth_token']
     )
     category = RecipeCategory(
         name="Breakfast",
         description="How to make breakfast",
         user_id=1
     )
     category.save()
     response = self.create_category("LunchBuffe", 
                                     "How to make lunch buffe", 
                                     headers)
     response = self.create_recipe_in_category(2, 
         1273839393,
         "oil, Onions,Tomatoes",
         "Mix and boil",
         headers
     )
     self.assertEqual(response.status_code, 400)
     self.assertIn('Bad request, body field must be of type string', 
                    str(response.data))
 def test_category_creation_which_exists(self):
     """
     Test for category creation which already exists
     """
     with self.client:
         response = self.register_user(
             "Patrick", "Walukagga", 
             "*****@*****.**", "telnetcmd123"
         )
         # registered user login
         rep_login = self.login_user("*****@*****.**", "telnetcmd123")
         # valid token
         headers=dict(
             Authorization='Bearer ' + json.loads(
                 rep_login.data.decode()
             )['auth_token']
         )
         category = RecipeCategory(
             name="Breakfast",
             description="How to make breakfast",
             user_id=1
         )
         category.save()
         response = self.create_category("Breakfast", 
                                         "How to make breakfast", 
                                         headers)
         self.assertEqual(response.status_code, 200)
         self.assertIn('Category already exists', 
                     str(response.data))
         self.assertIn('fail', str(response.data))
Ejemplo n.º 5
0
 def test_recipe_creation_in_category(self):
     """
     Test for recipe creation in category
     """
     response = self.register_user(
         "Patrick", "Walukagga", 
         "*****@*****.**", "telnetcmd123"
     )
     # registered user login
     rep_login = self.login_user("*****@*****.**", "telnetcmd123")
     # valid token
     headers=dict(
         Authorization='Bearer ' + json.loads(
             rep_login.data.decode()
         )['auth_token']
     )
     category = RecipeCategory(
         name="Breakfast",
         description="How to make breakfast",
         user_id=1
     )
     category.save()
     response = self.create_category("LunchBuffe", 
                                     "How to make lunch buffe", 
                                     headers)
     response = self.create_recipe_in_category(2, 
         "Chicken Lunch Buffe",
         "oil, Onions,Tomatoes",
         "Mix and boil",
         headers
     )
     self.assertEqual(response.status_code, 201)
     self.assertIn('New recipe added to category', 
                    str(response.data))
     # create recipe with same name
     response = self.create_recipe_in_category(2, 
         "Chicken Lunch Buffe",
         "oil, Onions,Tomatoes",
         "Mix and boil",
         headers
     )
     self.assertEqual(response.status_code, 200)
     self.assertIn('Recipe already exists', 
                    str(response.data))
     # create recipe in category which doesnot exit
     response = self.create_recipe_in_category(3, 
         "Chicken Lunch Buffe",
         "oil, Onions,Tomatoes",
         "Mix and boil",
         headers
     )
     self.assertEqual(response.status_code, 404)
     self.assertIn('Category not found in database', 
                    str(response.data))
     # create recipe with empty fields
     response = self.create_recipe_in_category(2, "", "", "", headers)
     self.assertEqual(response.status_code, 200)
     self.assertIn('field names not provided', 
                    str(response.data))
 def post(self, current_user):
     auth_header = request.headers['Authorization']
     if auth_header:
         auth_token = auth_header.split(" ")[1]
     else:
         auth_token = ""
     if auth_token:
         resp = current_user.decode_auth_token(auth_token)
         if not isinstance(resp, str):
             if not request.get_json(force=True):
                 abort(400)
             data = request.get_json(force=True)
             if data:
                 category_key_missing_in_body(data)
                 if key_is_not_string(data):
                     response_object = {
                         'error':
                         'Bad request, body field must be of type string'
                     }
                     return jsonify(response_object), 400
                 if data['name'] == "" or data["description"] == "":
                     responseObject = {
                         'status': 'fail',
                         'message': 'field names not provided'
                     }
                     return make_response(jsonify(responseObject)), 200
                 if RecipeCategory.query.filter_by(
                         user_id=current_user.id,
                         name=data['name']).first():
                     responseObject = {
                         'status': 'fail',
                         'message': 'Category already exists'
                     }
                     return make_response(jsonify(responseObject)), 200
                 category = RecipeCategory(name=data['name'],
                                           description=data['description'],
                                           user_id=current_user.id)
                 category.save()
                 responseObject = {
                     'status': 'success',
                     'message': 'New recipe category created!'
                 }
                 return make_response(jsonify(responseObject)), 201
             else:
                 responseObject = {
                     'status': 'fail',
                     'message': 'New recipe category not created!'
                 }
                 return make_response(jsonify(responseObject)), 200
         else:
             responseObject = {'status': 'fail', 'message': resp}
             return make_response(jsonify(responseObject)), 401
     else:
         responseObject = {
             'status': 'fail',
             'message': 'Provide a valid auth token.'
         }
         return make_response(jsonify(responseObject)), 403
 def test_get_single_recipe_in_category(self):
     """
     Test for getting single recipe in category
     """
     response = self.register_user(
         "Patrick", "Walukagga", 
         "*****@*****.**", "telnetcmd123"
     )
     # registered user login
     rep_login = self.login_user("*****@*****.**", "telnetcmd123")
     # valid token
     headers=dict(
         Authorization='Bearer ' + json.loads(
             rep_login.data.decode()
         )['auth_token']
     )
     category = RecipeCategory(
         name="Breakfast",
         description="How to make breakfast",
         user_id=1
     )
     category.save()
     response = self.create_category("LunchBuffe", 
                                     "How to make lunch buffe", 
                                     headers)
     recipe = Recipe(
         name="Rolex for Lunch",
         cat_id=2,
         user_id=1,
         ingredients="oil, Onions, Tomatoes",
         description="How to make breakfast rolex"            
     )
     recipe.save()
     response = self.create_recipe_in_category(2, 
         "Chicken Lunch Buffe",
         "oil, Onions,Tomatoes",
         "Mix and boil",
         headers
     )
     response = self.client.get('/recipe_category/2/recipes/1', 
                                 headers=headers)
     self.assertEqual(response.status_code, 200)
     self.assertIn('Rolex for Lunch', str(response.data))
     self.assertNotIn('Mix and boil', str(response.data))
     # get recipe not yet in database
     response = self.client.get('/recipe_category/2/recipes/4', 
                                 headers=headers)
     self.assertEqual(response.status_code, 404)
     self.assertIn('Recipe not found', str(response.data))
     # get recipe in category not yet in database
     response = self.client.get('/recipe_category/3/recipes/1', 
                                 headers=headers)
     self.assertEqual(response.status_code, 404)
     self.assertIn('Category not found in database', 
                   str(response.data))
    def test_update_recipe_in_category_with_one_field(self):
        """
        Test for editing recipe in category with one field
        """
        response = self.register_user("Patrick", "Walukagga",
                                      "*****@*****.**", "telnetcmd123")
        # registered user login
        rep_login = self.login_user("*****@*****.**", "telnetcmd123")
        # valid token
        headers = dict(Authorization='Bearer ' +
                       json.loads(rep_login.data.decode())['auth_token'])
        category = RecipeCategory(name="Breakfast",
                                  description="How to make breakfast",
                                  user_id=1)
        category.save()
        response = self.create_category("LunchBuffe",
                                        "How to make lunch buffe", headers)
        recipe = Recipe(name="Rolex for Lunch",
                        cat_id=2,
                        user_id=1,
                        ingredients="oil, Onions, Tomatoes",
                        description="How to make breakfast rolex")
        recipe.save()
        response = self.create_recipe_in_category(2, "Chicken Lunch Buffe",
                                                  "oil, Onions,Tomatoes",
                                                  "Fresh chicken",
                                                  "Mix and boil", headers)
        recipe_data = json.dumps({"name": "Chicken Lunch Buffes"})
        response = self.client.put('/recipe_category/2/recipes/1',
                                   headers=headers,
                                   data=recipe_data)
        self.assertEqual(response.status_code, 200)
        self.assertIn('Recipe has been updated', str(response.data))
        response = self.client.get('/recipe_category/2/recipes/1',
                                   headers=headers)
        self.assertEqual(response.status_code, 200)
        self.assertIn('Chicken Lunch Buffes', str(response.data))

        recipe_data = json.dumps({"ingredients": "oil, Onions"})
        response = self.client.put('/recipe_category/2/recipes/1',
                                   headers=headers,
                                   data=recipe_data)
        self.assertEqual(response.status_code, 200)
        self.assertIn('Recipe has been updated', str(response.data))

        recipe_data = json.dumps({"description": "Mix and boils"})
        response = self.client.put('/recipe_category/2/recipes/1',
                                   headers=headers,
                                   data=recipe_data)
        self.assertEqual(response.status_code, 200)
        self.assertIn('Recipe has been updated', str(response.data))
 def test_search_user_recipes(self):
     """
     Test for searching all user recipes
     """
     response = self.register_user("Patrick", "Walukagga",
                                   "*****@*****.**", "telnetcmd123")
     # registered user login
     rep_login = self.login_user("*****@*****.**", "telnetcmd123")
     # valid token
     headers = dict(Authorization='Bearer ' +
                    json.loads(rep_login.data.decode())['auth_token'])
     category = RecipeCategory(name="Breakfast",
                               description="How to make breakfast",
                               user_id=1)
     category.save()
     response = self.create_category("LunchBuffe",
                                     "How to make lunch buffe", headers)
     recipe = Recipe(name="Rolex for Lunch",
                     cat_id=2,
                     user_id=1,
                     ingredients="oil, Onions, Tomatoes",
                     description="How to make lunch rolex")
     recipe.save()
     recipe = Recipe(name="Rolex for Breakfast",
                     cat_id=1,
                     user_id=1,
                     ingredients="oil, Onions, Tomatoes",
                     description="How to make breakfast rolex")
     recipe.save()
     response = self.create_recipe_in_category(2, "Chicken Lunch Buffe",
                                               "oil, Onions,Tomatoes",
                                               "Fresh chicken",
                                               "Mix and boil", headers)
     response = self.client.get('/search_recipes?q=Rolex', headers=headers)
     self.assertEqual(response.status_code, 200)
     self.assertIn('Rolex for Breakfast', str(response.data))
     self.assertIn('Rolex for Lunch', str(response.data))
     self.assertNotIn('Mix and boil', str(response.data))
     # get recipes in category with limit
     response = self.client.get('/search_recipes?limit=1&page=2',
                                headers=headers)
     self.assertEqual(response.status_code, 200)
     self.assertIn('Rolex for Breakfast', str(response.data))
     self.assertNotIn('Mix and boil', str(response.data))
     # get recipes in category with limit=a&page=b
     response = self.client.get('/search_recipes?limit=a&page=b',
                                headers=headers)
     self.assertEqual(response.status_code, 400)
     self.assertIn('limit and page query parameters should be integers',
                   str(response.data))
     self.assertNotIn('Mix and boil', str(response.data))
 def test_recipe_crud_when_not_logged_in(self):
     """
     Test for recipe crud when not logged in
     """
     response = self.register_user(
         "Patrick", "Walukagga", 
         "*****@*****.**", "telnetcmd123"
     )
     
     headers=dict(Authorization='Bearer ')
     category = RecipeCategory(
         name="Breakfast",
         description="How to make breakfast",
         user_id=1
     )
     category.save()
     response = self.create_category("LunchBuffe", 
                                     "How to make lunch buffe", 
                                     headers)
     self.assertEqual(response.status_code, 401)
     self.assertIn('Token is missing', str(response.data))
     recipe = Recipe(
         name="Rolex for breakfast",
         cat_id=1,
         user_id=1,
         ingredients="oil, Onions, Tomatoes",
         description="How to make breakfast rolex"            
     )
     recipe.save()
     response = self.create_recipe_in_category(2, 
         "Chicken Lunch Buffe",
         "oil, Onions,Tomatoes",
         "Mix and boil",
         headers
     )
     response = self.client.delete('/recipe_category/2/recipes/2', 
                                 headers=headers)
     self.assertEqual(response.status_code, 401)
     self.assertIn('Token is missing', str(response.data))
     # delete recipe not yet in database
     response = self.client.delete('/recipe_category/2/recipes/4', 
                                 headers=headers)
     self.assertEqual(response.status_code, 401)
     self.assertIn('Token is missing', str(response.data))
     # delete recipe in category not yet in database
     response = self.client.delete('/recipe_category/3/recipes/1', 
                                 headers=headers)
     self.assertEqual(response.status_code, 401)
     self.assertIn('Token is missing', str(response.data))
 def test_get_paginated_categories(self):
     """
     Test for pagination of categories
     """
     response = self.register_user("Patrick", "Walukagga",
                                   "*****@*****.**", "telnetcmd123")
     # registered user login
     rep_login = self.login_user("*****@*****.**", "telnetcmd123")
     # valid token
     headers = dict(Authorization='Bearer ' +
                    json.loads(rep_login.data.decode())['auth_token'])
     # create categories
     category = RecipeCategory(name="Breakfast",
                               description="How to make breakfast",
                               user_id=1)
     category.save()
     category = RecipeCategory(name="Lunch",
                               description="How to make Lunch",
                               user_id=1)
     category.save()
     category = RecipeCategory(name="Dinner",
                               description="How to make Dinner",
                               user_id=1)
     category.save()
     category = RecipeCategory(name="Chapati Fried",
                               description="How to make fried chapatis",
                               user_id=1)
     category.save()
     category = RecipeCategory(name="Luwombo",
                               description="How to make Luwombo",
                               user_id=1)
     category.save()
     response = self.client.get('/recipe_category?limit=2&page=1',
                                headers=headers)
     self.assertEqual(response.status_code, 200)
     self.assertIn('How to make breakfast', str(response.data))
     self.assertIn('How to make Lunch', str(response.data))
     self.assertNotIn('How to make Dinner', str(response.data))
     response = self.client.get('/recipe_category?limit=2&page=2',
                                headers=headers)
     self.assertEqual(response.status_code, 200)
     self.assertNotIn('How to make breakfast', str(response.data))
     self.assertNotIn('How to make lunchfast', str(response.data))
     self.assertIn('How to make Dinner', str(response.data))
     response = self.client.get('/recipe_category?limit=a&page=b',
                                headers=headers)
     self.assertEqual(response.status_code, 400)
     self.assertIn('limit and page query parameters should be integers',
                   str(response.data))