コード例 #1
0
        def test_not_author_cant_delete_recipe(self, api_client):
            new_recipe = RecipeFactory()
            random_user = UserFactory()
            api_client.force_authenticate(random_user)
            response = api_client.delete(new_recipe.get_absolute_url())

            assert response.status_code == 403
コード例 #2
0
        def test_author_can_update_own_recipe(self, api_client):
            new_recipe = RecipeFactory()
            api_client.force_authenticate(new_recipe.author)
            data = {'title': 'updated title'}
            response = api_client.patch(new_recipe.get_absolute_url(), data)

            assert response.status_code == 200
コード例 #3
0
        def test_not_author_cant_update_recipe(self, api_client):
            new_recipe = RecipeFactory()
            random_user = UserFactory()
            api_client.force_authenticate(random_user)
            data = {'title': 'updated title'}
            response = api_client.patch(new_recipe.get_absolute_url(), data)

            assert response.status_code == 403
コード例 #4
0
        def test_rating_recipe_calculate_account_stars(self, api_client):
            first_recipe = RecipeFactory()
            recipe_author = first_recipe.author
            api_client.force_authenticate(recipe_author)

            second_recipe = RecipeFactory.build()
            data = {
                'title': {second_recipe.title},
                'description': {second_recipe.description},
                'flavor_type': {second_recipe.flavor_type}, 
            }
            api_client.post(create_recipe_url, data)
            second_recipe = Recipe.objects.all().get(title=second_recipe.title)

            data = {
                'recipe': first_recipe.id,
                'stars': 5
            }

            api_client.post(rating_rate_url, data)
            
            data = {
                'recipe': second_recipe.id,
                'stars': 0
            }
            api_client.post(rating_rate_url, data)
            api_client.logout()


            second_user = UserFactory()
            api_client.force_authenticate(second_user)
            data = {
                'recipe': first_recipe.id,
                'stars': 5
            }
            api_client.post(rating_rate_url, data)

            data = {
                'recipe': second_recipe.id,
                'stars': 5
            }
            api_client.post(rating_rate_url, data)
            api_client.logout()


            first_recipe = Recipe.objects.all().get(title=first_recipe.title)
            second_recipe = Recipe.objects.all().get(title=second_recipe.title)
            user = UserAccount.objects.all().get(id=recipe_author.id)

            assert first_recipe.stars == '5.0'
            assert second_recipe.stars == '2.5'
            assert Rating.get_account_stars_score(user=user) == 3.75
            assert user.stars == '3.75'
コード例 #5
0
        def test_should_only_display_recipes_of_users_that_in_account_following_list(
                self, api_client):
            first_user = RecipeFactory().author
            api_client.force_authenticate(first_user)

            second_recipe = RecipeFactory()
            third_recipe = RecipeFactory()

            first_user.following.add(second_recipe.author)

            response = api_client.get(followed_users_recipes_url)

            assert f'{second_recipe}' in f'{response.content}'
            assert f'{third_recipe}' not in f'{response.content}'
コード例 #6
0
ファイル: test_api.py プロジェクト: aj07mm/code-interview
 def test_list_with_query_parameter(self):
     self.recipe = RecipeFactory.create(
         name='asd',
         prep_time=3,
         difficulty=1,
         vegetarian=True,
     )
     response = self.client.get(
         '/recipes/?name=asd', headers=[self.headers])
     response_recipes = json.loads(response.data.decode())
     self.assertEqual(
         self.recipe['name'],
         response_recipes['results'][0]['name']
     )
     self.assertEqual(
         self.recipe['prep_time'],
         response_recipes['results'][0]['prep_time']
     )
     self.assertEqual(
         self.recipe['vegetarian'],
         response_recipes['results'][0]['vegetarian']
     )
     self.assertEqual(
         self.recipe['difficulty'],
         response_recipes['results'][0]['difficulty']
     )
     self.assertEqual(response.status_code, HTTP_STATUS_CODE['200_OK'])
コード例 #7
0
ファイル: test_api.py プロジェクト: aj07mm/code-interview
 def setUp(self):
     self.recipe = RecipeFactory.create(
         name='asdasdas',
         prep_time=3,
         difficulty=1,
         vegetarian=True,
     )
コード例 #8
0
        def test_ratings_from_different_users(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()

            data = {
                'recipe': new_recipe.id,
                'stars': '5'
            }
            api_client.post(rating_rate_url, data)
            api_client.logout()

            new_user2 = UserFactory()
            api_client.force_authenticate(new_user2)
            data = {
                'recipe': new_recipe.id,
                'stars': '4'
            }
            api_client.post(rating_rate_url, data)

            first_rating = Rating.objects.all().get(author__exact=new_user.id)
            second_rating = Rating.objects.all().get(author__exact=new_user2.id)


            assert Rating.objects.all().count() == 2
            assert first_rating.stars == 5
            assert second_rating.stars== 4
コード例 #9
0
ファイル: test_model.py プロジェクト: nikolas/rolf
class BasicPushTest(TestCase):
    def test_push(self):
        self.u = UserFactory()
        self.d = DeploymentFactory()
        self.setting = SettingFactory(deployment=self.d)
        self.recipe = RecipeFactory()
        self.shell_recipe = ShellRecipeFactory()
        self.stage = StageFactory(
            deployment=self.d,
            recipe=self.recipe)
        self.stage2 = StageFactory(
            deployment=self.d,
            recipe=self.shell_recipe,
            name="test stage 2",
        )
        push = self.d.new_push(self.u, "test push")
        # haven't run anything so it should be inprogress
        self.assertEquals(push.status, "inprogress")
        for s in self.d.stage_set.all():
            push.run_stage(s.id)
        # should have completed successfully
        self.assertEquals(push.status, "ok")
        # and let's make sure a setting variable has round-tripped
        ps = push.pushstage_set.get(stage=self.stage2)
        self.assertEquals(ps.stdout(), "TEST_BAR\n")
        self.assertEquals(ps.stderr(), "")

        self.assertEquals(self.d.most_recent_push(), push)
        self.assertEquals(self.d.status(), push.status)
        self.assertEquals(self.d.last_message(), push.comment)
        self.assertEquals(self.d.last_push_date(), push.start_time)

        self.assertEquals(push.get_absolute_url(),
                          "/push/%d/" % push.id)

        push.run_stage(self.stage.id, rollback_id=self.stage.id)

        for pstage in push.reverse_pushstages():
            self.assertEquals(pstage.setting('foo'), '')

    def test_recipe_absolute_url(self):
        self.recipe = RecipeFactory()
        self.assertEquals(
            self.recipe.get_absolute_url(),
            "/cookbook/%d/" % self.recipe.id)

    def test_stage_absolute_url(self):
        self.stage = StageFactory()
        self.assertEquals(
            self.stage.get_absolute_url(),
            "/stage/%d/" % self.stage.id)

    def test_stage_all_recipes(self):
        self.shell_recipe = ShellRecipeFactory()
        self.stage = StageFactory()
        self.stage2 = StageFactory(recipe=self.shell_recipe)

        self.assertEquals(
            [r.id for r in self.stage.all_recipes()],
            [self.shell_recipe.id])
コード例 #10
0
def test_get_all_likes(api_client):
    new_recipe = RecipeFactory()
    new_user = new_recipe.author
    api_client.force_authenticate(new_user)
    like_url = reverse('likes:like')
    data = {'recipe': new_recipe.id}
    api_client.post(like_url, data)
    api_client.logout()

    new_user = UserFactory()
    api_client.force_authenticate(new_user)
    like_url = reverse('likes:like')
    data = {'recipe': new_recipe.id}
    api_client.post(like_url, data)

    assert new_recipe.get_all_likes() == 2
    assert new_recipe.get_all_likes() == new_recipe.likes.all().count()
コード例 #11
0
ファイル: test_views.py プロジェクト: eliyamelamed1/ZBite
        def test_like_post_request(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()
            data = {'recipe': new_recipe.id}
            response = api_client.post(like_url, data)

            assert response.status_code == 200
コード例 #12
0
ファイル: test_views.py プロジェクト: eliyamelamed1/ZBite
        def test_user_second_like_to_recipe_will_unlike(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()
            data = {'recipe': new_recipe.id}
            api_client.post(like_url, data)
            api_client.post(like_url, data)

            assert new_recipe.likes.all().count() == 0
コード例 #13
0
def search_comment_response(api_client):
    new_recipe = RecipeFactory()
    search_comment_url = '/api/comments/search/'

    data = {
        'recipe': {new_recipe.id},
    }

    response = api_client.post(search_comment_url, data)

    return response
コード例 #14
0
ファイル: test_models.py プロジェクト: aj07mm/code-interview
 def test_rating_recipe(self):
     recipe = RecipeFactory.create(
         name='asdasdas',
         prep_time=3,
         difficulty=1,
         vegetarian=True,
     )
     recipe.save()
     recipe.rate(2)
     rates = Rate.objects(recipe_id=recipe.id)
     self.assertTrue(rates)
コード例 #15
0
        def test_should_display_top_rated_recipes(self, api_client):
            for i in range(10):
                new_user = UserFactory()
                api_client.force_authenticate(new_user)
                recipe_data = RecipeFactory.build()
                data = {
                    'title': {recipe_data.title},
                    'description': {recipe_data.description},
                    'flavor_type': {recipe_data.flavor_type},
                }
                api_client.post(create_recipe_url, data)
                new_recipe = Recipe.objects.all().get(title=recipe_data.title)
                new_recipe.stars = 5
                new_recipe.save()
                api_client.logout()

            for i in range(10):
                new_user = UserFactory()
                api_client.force_authenticate(new_user)
                recipe_data = RecipeFactory.build()
                data = {
                    'title': {recipe_data.title},
                    'description': {recipe_data.description},
                    'flavor_type': {recipe_data.flavor_type},
                }
                api_client.post(create_recipe_url, data)
                new_recipe = Recipe.objects.all().get(title=recipe_data.title)
                new_recipe.stars = 4
                new_recipe.save()
                api_client.logout()

            api_client.force_authenticate(new_user)
            response = api_client.get(top_rated_recipes_url)
            top_rated_recipes = Recipe.objects.all().filter(stars=5)
            bottom_rated_recipes = Recipe.objects.all().filter(stars=4)

            for recipe in top_rated_recipes:
                assert f'{recipe}' in f'{response.content}'

            for recipe in bottom_rated_recipes:
                assert f'{recipe}' not in f'{response.content}'
コード例 #16
0
        def test_rate_post_request_should_fail(self, api_client):
            new_recipe = RecipeFactory()

            
            new_recipe = Recipe.objects.all().get(id__exact=new_recipe.id)
            data = {
                'recipe': new_recipe.id,
                'stars': 5
            }
            response = api_client.post(rating_rate_url, data)

            assert response.status_code == 401
コード例 #17
0
        def test_recipe_create_post_request(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            recipe_data = RecipeFactory.build()
            data = {
                'title': {recipe_data.title},
                'description': {recipe_data.description},
                'flavor_type': {recipe_data.flavor_type},
            }
            response = api_client.post(create_recipe_url, data)

            assert response.status_code == 201
コード例 #18
0
        def test_rate_post_request(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()
            new_recipe = Recipe.objects.all().get(id__exact=new_recipe.id)
            data = {
                'recipe': new_recipe.id,
                'stars': 5
            }
            response = api_client.post(rating_rate_url, data)

            assert response.status_code == 200
コード例 #19
0
        def test_recipe_create_post_request_not_allowed(self, api_client):
            new_user = UserFactory()
            recipe_data = RecipeFactory.build()
            data = {
                'author': {new_user.id},
                'title': {recipe_data.title},
                'description': {recipe_data.description},
                'flavor_type': {recipe_data.flavor_type},
            }
            response = api_client.post(create_recipe_url, data)

            assert response.status_code == 401
コード例 #20
0
ファイル: test_models.py プロジェクト: eliyamelamed1/ZBite
def test_get_account_stars_score(api_client):
    user = UserFactory()
    api_client.force_authenticate(user)

    first_recipe = RecipeFactory.build()
    create_recipe_url = reverse('recipes:create')
    data = {
        'title': {first_recipe.title},
        'description': {first_recipe.description},
        'flavor_type': {first_recipe.flavor_type},
    }
    api_client.post(create_recipe_url, data)

    second_recipe = RecipeFactory.build()
    data = {
        'title': {second_recipe.title},
        'description': {second_recipe.description},
        'flavor_type': {second_recipe.flavor_type},
    }
    api_client.post(create_recipe_url, data)

    first_recipe = Recipe.objects.all().get(title__exact=first_recipe.title)
    data = {'recipe': first_recipe.id, 'stars': 5}
    api_client.post(rating_create_url, data)
    second_recipe = Recipe.objects.all().get(title__exact=second_recipe.title)
    data = {'recipe': second_recipe.id, 'stars': 0}
    api_client.post(rating_create_url, data)

    second_user = UserFactory()
    api_client.force_authenticate(second_user)

    data = {'recipe': first_recipe.id, 'stars': 1}
    api_client.post(rating_create_url, data)
    data = {'recipe': second_recipe.id, 'stars': 3}
    api_client.post(rating_create_url, data)

    account_avg_stars = Rating.get_account_stars_score(user=user)

    assert account_avg_stars == 2.25
コード例 #21
0
ファイル: test_views.py プロジェクト: eliyamelamed1/ZBite
        def test_comment_create_post_request_not_allowed(self, api_client):
            new_user = UserFactory()
            comment_data = CommentFactory.build()
            new_recipe = RecipeFactory()

            data = {
                'title': {comment_data.title},
                'recipe': {new_recipe.id},
                'author': {new_user.id}
            }
            response = api_client.post(create_comment_url, data)

            assert response.status_code == 401
コード例 #22
0
        def test_recipe_author_is_current_logged_in_user(self, api_client):
            ''' testing the method perform_create '''
            first_user = UserFactory()
            api_client.force_authenticate(first_user)
            recipe_data = RecipeFactory.build()
            data = {
                'title': {recipe_data.title},
                'description': {recipe_data.description},
                'flavor_type': {recipe_data.flavor_type},
            }
            api_client.post(create_recipe_url, data)
            new_recipe = Recipe.objects.get(title=recipe_data.title)

            assert new_recipe.author == first_user
コード例 #23
0
ファイル: test_views.py プロジェクト: eliyamelamed1/ZBite
        def test_likes_from_different_users(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()
            data = {'recipe': new_recipe.id}
            api_client.post(like_url, data)
            api_client.logout()

            new_user2 = UserFactory()
            api_client.force_authenticate(new_user2)
            data = {'recipe': new_recipe.id}
            api_client.post(like_url, data)

            assert new_recipe.likes.all().count() == 2
コード例 #24
0
        def test_should_display_all_recipes_of_users_that_in_account_following_list(
                self, api_client):
            first_user = RecipeFactory().author

            second_user = UserFactory()
            api_client.force_authenticate(second_user)
            for i in range(10):
                recipe_data = RecipeFactory.build()
                data = {
                    'title': {recipe_data.title},
                    'description': {recipe_data.description},
                    'flavor_type': {recipe_data.flavor_type},
                }
                api_client.post(create_recipe_url, data)

            api_client.logout()
            api_client.force_authenticate(first_user)
            first_user.following.add(second_user)

            response = api_client.get(followed_users_recipes_url)
            recipes = Recipe.objects.all().filter(author=second_user)

            for recipe in recipes:
                assert f'{recipe}' in f'{response.content}'
コード例 #25
0
ファイル: test_models.py プロジェクト: eliyamelamed1/ZBite
def test_get_recipe_avg_rating_score(api_client):
    new_recipe = RecipeFactory()
    api_client.force_authenticate(new_recipe.author)
    new_recipe = Recipe.objects.all().get(id__exact=new_recipe.id)
    data = {'recipe': new_recipe.id, 'stars': 5}
    api_client.post(rating_create_url, data)
    api_client.logout()

    new_user = UserFactory()
    api_client.force_authenticate(new_user)
    data = {'recipe': new_recipe.id, 'stars': 1}
    api_client.post(rating_create_url, data)

    recipe_avg_stars = Rating.get_recipe_stars_score(recipe=new_recipe)

    assert recipe_avg_stars == 3.0
コード例 #26
0
ファイル: test_views.py プロジェクト: eliyamelamed1/ZBite
        def test_comment_author_is_current_logged_in_user(self, api_client):
            ''' testing the method perform_create '''
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()
            comment_data = CommentFactory.build()

            data = {
                'title': {comment_data.title},
                'recipe': {new_recipe.id},
                'author': {new_user.id}
            }
            api_client.post(create_comment_url, data)
            new_comment = Comment.objects.get(title=comment_data.title)

            assert new_comment.author == new_user
コード例 #27
0
ファイル: test_api.py プロジェクト: aj07mm/code-interview
 def test_pagination(self):
     self.recipes = RecipeFactory.create_batch(
         size=50,
         **{
             'name': 'asdasdas',
             'prep_time': 3,
             'difficulty': 1,
             'vegetarian': True,
         }
     )
     response = self.client.get('/recipes/?page=1', headers=[self.headers])
     response_recipes = json.loads(response.data.decode())
     self.assertEqual(30, len(response_recipes['results']))
     response = self.client.get('/recipes/?page=2', headers=[self.headers])
     response_recipes = json.loads(response.data.decode())
     self.assertEqual(21, len(response_recipes['results']))
     self.assertEqual(response.status_code, HTTP_STATUS_CODE['200_OK'])
コード例 #28
0
ファイル: test_views.py プロジェクト: eliyamelamed1/ZBite
        def test_recipe_author_can_delete_other_users_recipe_comments_on_his_recipe(
                self, api_client):
            new_recipe = RecipeFactory()
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            comment_data = CommentFactory.build()

            data = {
                'title': {comment_data.title},
                'recipe': {new_recipe.id},
                'author': {new_user.id}
            }
            response = api_client.post(create_comment_url, data)

            api_client.logout()
            api_client.force_authenticate(new_recipe.author)
            new_comment = Comment.objects.get(title=comment_data.title)
            response = api_client.delete(new_comment.get_delete_url())

            assert response.status_code == 204
コード例 #29
0
ファイル: test_model.py プロジェクト: ccnmtl/rolf
    def test_push(self):
        self.u = UserFactory()
        self.d = DeploymentFactory()
        self.setting = SettingFactory(deployment=self.d)
        self.recipe = RecipeFactory()
        self.shell_recipe = ShellRecipeFactory()
        self.stage = StageFactory(
            deployment=self.d,
            recipe=self.recipe)
        self.stage2 = StageFactory(
            deployment=self.d,
            recipe=self.shell_recipe,
            name="test stage 2",
        )
        push = self.d.new_push(self.u, "test push")
        # haven't run anything so it should be inprogress
        self.assertEquals(push.status, "inprogress")
        tempdir = tempfile.mkdtemp()
        with self.settings(SCRIPT_DIR=tempdir):
            for s in self.d.stage_set.all():
                push.run_stage(s.id)
        shutil.rmtree(tempdir)
        # should have completed successfully
        self.assertEquals(push.status, "ok")
        # and let's make sure a setting variable has round-tripped
        ps = push.pushstage_set.get(stage=self.stage2)
        self.assertEquals(ps.stdout(), "TEST_BAR\n")
        self.assertEquals(ps.stderr(), "")

        self.assertEquals(self.d.most_recent_push(), push)
        self.assertEquals(self.d.status(), push.status)
        self.assertEquals(self.d.last_message(), push.comment)
        self.assertEquals(self.d.last_push_date(), push.start_time)

        self.assertEquals(push.get_absolute_url(),
                          "/push/%d/" % push.id)

        push.run_stage(self.stage.id, rollback_id=self.stage.id)

        for pstage in push.reverse_pushstages():
            self.assertEquals(pstage.setting('foo'), '')
コード例 #30
0
        def test_user_second_rate_will_update_the_first_one(self, api_client):
            new_user = UserFactory()
            api_client.force_authenticate(new_user)
            new_recipe = RecipeFactory()
            new_recipe = Recipe.objects.all().get(id__exact=new_recipe.id)
            data = {
                'recipe': new_recipe.id,
                'stars': 5
            }
            
            api_client.post(rating_rate_url, data)
            data = {
                'recipe': new_recipe.id,
                'stars': 4
            }
            response = api_client.post(rating_rate_url, data)

            rating = Rating.objects.all().get(author__exact=new_user.id)

            assert response.status_code == 200
            assert rating.stars == 4
            assert Rating.objects.all().count() == 1  
コード例 #31
0
        def test_rating_recipe_calculate_recipe_stars(self, api_client):
            recipe = RecipeFactory()
            first_user = UserFactory()
            api_client.force_authenticate(first_user)

            data = {
                'recipe': recipe.id,
                'stars': 4
            }
            api_client.post(rating_rate_url, data)
            api_client.logout()

            second_user = UserFactory()
            api_client.force_authenticate(second_user)
            data = {
                'recipe': recipe.id,
                'stars': 2
            }
            api_client.post(rating_rate_url, data)
            recipe = Recipe.objects.all().get(id=recipe.id)

            assert recipe.stars == '3.0'
            assert recipe.stars == str(Rating.get_recipe_stars_score(recipe=recipe))
コード例 #32
0
        def test_author_can_delete_own_recipe(self, api_client):
            new_recipe = RecipeFactory()
            api_client.force_authenticate(new_recipe.author)
            response = api_client.delete(new_recipe.get_absolute_url())

            assert response.status_code == 204
コード例 #33
0
def test__str__():
    new_recipe = RecipeFactory()

    assert new_recipe.__str__() == new_recipe.title
コード例 #34
0
        def test_recipe_detail_page_render(self, api_client):
            new_recipe = RecipeFactory()
            response = api_client.get(new_recipe.get_absolute_url())

            assert response.status_code == 200
コード例 #35
0
        def test_recipe_delete(self, api_client):
            new_recipe = RecipeFactory()
            response = api_client.delete(new_recipe.get_absolute_url())

            assert response.status_code == 401
コード例 #36
0
ファイル: test_model.py プロジェクト: ccnmtl/rolf
 def test_recipe_absolute_url(self):
     self.recipe = RecipeFactory()
     self.assertEquals(
         self.recipe.get_absolute_url(),
         "/cookbook/%d/" % self.recipe.id)
コード例 #37
0
        def test_guest_user_cant_update_recipe(self, api_client):
            first_recipe = RecipeFactory()
            data = {'title': 'updated title'}
            response = api_client.patch(first_recipe.get_absolute_url(), data)

            assert response.status_code == 401