fca41f92-5491-483e-b3a5-9a03e39bd6ef

Committed 31 Jul 2024 03:44PM CUT coverage: 85.431% (-0.02%) from 85.455%

Build # fca41f92-5491-483e-b3a5-9a03e39bd6ef

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #4913 from mozilla/dependabot/pip/typing-stubs-dc58c16c12

Bump the typing-stubs group with 2 updates

Run Details

4101 of 5252 branches covered (78.08%)

Branch coverage included in aggregate %.

11 of 14 new or added lines in 2 files covered. (78.57%)

1 existing line in 1 file now uncovered.

15971 of 18243 relevant lines covered (87.55%)

10.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.18

/api/tests/serializers_tests.py

from django.contrib.auth.models import User
from django.urls import reverse

import pytest
from model_bakery import baker
from rest_framework.authtoken.models import Token
from rest_framework.test import APITestCase
from waffle.models import Flag

from api.serializers.privaterelay import FlagSerializer
from emails.models import RelayAddress
from privaterelay.tests.utils import make_free_test_user, make_premium_test_user


class PremiumValidatorsTest(APITestCase):
    def _get_token_for_user(self, user: User) -> Token:
        """
        Get DRF Token for user with strict type checks.

        hasattr check prevents attr-defined error on Token
        isinstance check prevents no-any-return error

        See https://github.com/mozilla/fx-private-relay/pull/4913#discussion_r1698637372
        """
        if not hasattr(Token, "objects"):
            raise AttributeError("Token must have objects attribute.")
        token = Token.objects.get(user=user)
        if not isinstance(token, Token):
            raise TypeError("token must be of type Token.")
        return token

    def test_non_premium_cant_set_block_list_emails(self):
        free_user = make_free_test_user()
        free_alias = baker.make(RelayAddress, user=free_user)
        assert free_alias.block_list_emails is False

        url = reverse("relayaddress-detail", args=[free_alias.id])
        data = {"block_list_emails": True}
        free_token = self._get_token_for_user(free_user)
        self.client.credentials(HTTP_AUTHORIZATION="Token " + free_token.key)
        response = self.client.patch(url, data, format="json")

        assert response.status_code == 401
        assert free_alias.block_list_emails is False

    def test_non_premium_can_clear_block_list_emails(self):
        free_user = make_free_test_user()
        free_alias = baker.make(RelayAddress, user=free_user)
        assert free_alias.block_list_emails is False

        url = reverse("relayaddress-detail", args=[free_alias.id])
        data = {"block_list_emails": False}
        free_token = self._get_token_for_user(free_user)
        self.client.credentials(HTTP_AUTHORIZATION="Token " + free_token.key)
        response = self.client.patch(url, data, format="json")

        assert response.status_code == 200
        free_alias.refresh_from_db()
        assert free_alias.block_list_emails is False

    def test_premium_can_set_block_list_emails(self):
        premium_user = make_premium_test_user()
        premium_alias = baker.make(RelayAddress, user=premium_user)
        assert premium_alias.block_list_emails is False

        url = reverse("relayaddress-detail", args=[premium_alias.id])
        data = {"block_list_emails": True}
        premium_token = self._get_token_for_user(premium_user)
        self.client.credentials(HTTP_AUTHORIZATION="Token " + premium_token.key)
        response = self.client.patch(url, data, format="json")

        assert response.status_code == 200
        premium_alias.refresh_from_db()
        assert premium_alias.block_list_emails is True


@pytest.fixture
def test_flag(db):
    flag = Flag.objects.create(name="test_flag")
    assert flag.everyone is None
    return flag


def test_flag_serializer_enable(test_flag):
    serializer = FlagSerializer(test_flag, data={"everyone": True}, partial=True)
    assert serializer.is_valid()
    updated_flag = serializer.save()
    assert test_flag.name == updated_flag.name
    assert updated_flag.everyone is True


def test_flag_serializer_disable(test_flag):
    """
    Disabling through the API sets everyone to None, so that flag users will
    still be considered.
    """
    test_flag.everyone = True
    test_flag.save()
    serializer = FlagSerializer(test_flag, data={"everyone": False}, partial=True)
    assert serializer.is_valid()
    updated_flag = serializer.save()
    assert test_flag.name == updated_flag.name
    assert updated_flag.everyone is None


def test_flag_serializer_cannot_change_name_to_manage_flags(test_flag):
    serializer = FlagSerializer(
        test_flag, data={"name": "manage_flags", "everyone": False}, partial=True
    )
    assert not serializer.is_valid()
    expected = "Changing the `manage_flags` flag is not allowed."
    assert str(serializer.errors["non_field_errors"][0]) == expected

1	from django.contrib.auth.models import User	1✔
2	from django.urls import reverse	1✔
3
4	import pytest	1✔
5	from model_bakery import baker	1✔
6	from rest_framework.authtoken.models import Token	1✔
7	from rest_framework.test import APITestCase	1✔
8	from waffle.models import Flag	1✔
9
10	from api.serializers.privaterelay import FlagSerializer	1✔
11	from emails.models import RelayAddress	1✔
12	from privaterelay.tests.utils import make_free_test_user, make_premium_test_user	1✔
13
14
15	class PremiumValidatorsTest(APITestCase):	1✔
16	def _get_token_for_user(self, user: User) -> Token:	1✔
17	"""
18	Get DRF Token for user with strict type checks.
19
20	hasattr check prevents attr-defined error on Token
21	isinstance check prevents no-any-return error
22
23	See https://github.com/mozilla/fx-private-relay/pull/4913#discussion_r1698637372
24	"""
25	if not hasattr(Token, "objects"):	1!
NEW 26	raise AttributeError("Token must have objects attribute.")	×
27	token = Token.objects.get(user=user)	1✔
28	if not isinstance(token, Token):	1!
NEW 29	raise TypeError("token must be of type Token.")	×
30	return token	1✔
31
32	def test_non_premium_cant_set_block_list_emails(self):	1✔
33	free_user = make_free_test_user()	1✔
34	free_alias = baker.make(RelayAddress, user=free_user)	1✔
35	assert free_alias.block_list_emails is False	1✔
36
37	url = reverse("relayaddress-detail", args=[free_alias.id])	1✔
38	data = {"block_list_emails": True}	1✔
39	free_token = self._get_token_for_user(free_user)	1✔
40	self.client.credentials(HTTP_AUTHORIZATION="Token " + free_token.key)	1✔
41	response = self.client.patch(url, data, format="json")	1✔
42
43	assert response.status_code == 401	1✔
44	assert free_alias.block_list_emails is False	1✔
45
46	def test_non_premium_can_clear_block_list_emails(self):	1✔
47	free_user = make_free_test_user()	1✔
48	free_alias = baker.make(RelayAddress, user=free_user)	1✔
49	assert free_alias.block_list_emails is False	1✔
50
51	url = reverse("relayaddress-detail", args=[free_alias.id])	1✔
52	data = {"block_list_emails": False}	1✔
53	free_token = self._get_token_for_user(free_user)	1✔
54	self.client.credentials(HTTP_AUTHORIZATION="Token " + free_token.key)	1✔
55	response = self.client.patch(url, data, format="json")	1✔
56
57	assert response.status_code == 200	1✔
58	free_alias.refresh_from_db()	1✔
59	assert free_alias.block_list_emails is False	1✔
60
61	def test_premium_can_set_block_list_emails(self):	1✔
62	premium_user = make_premium_test_user()	1✔
63	premium_alias = baker.make(RelayAddress, user=premium_user)	1✔
64	assert premium_alias.block_list_emails is False	1✔
65
66	url = reverse("relayaddress-detail", args=[premium_alias.id])	1✔
67	data = {"block_list_emails": True}	1✔
68	premium_token = self._get_token_for_user(premium_user)	1✔
69	self.client.credentials(HTTP_AUTHORIZATION="Token " + premium_token.key)	1✔
70	response = self.client.patch(url, data, format="json")	1✔
71
72	assert response.status_code == 200	1✔
73	premium_alias.refresh_from_db()	1✔
74	assert premium_alias.block_list_emails is True	1✔
75
76
77	@pytest.fixture	1✔
78	def test_flag(db):	1✔
79	flag = Flag.objects.create(name="test_flag")	1✔
80	assert flag.everyone is None	1✔
81	return flag	1✔
82
83
84	def test_flag_serializer_enable(test_flag):	1✔
85	serializer = FlagSerializer(test_flag, data={"everyone": True}, partial=True)	1✔
86	assert serializer.is_valid()	1✔
87	updated_flag = serializer.save()	1✔
88	assert test_flag.name == updated_flag.name	1✔
89	assert updated_flag.everyone is True	1✔
90
91
92	def test_flag_serializer_disable(test_flag):	1✔
93	"""
94	Disabling through the API sets everyone to None, so that flag users will
95	still be considered.
96	"""
97	test_flag.everyone = True	1✔
98	test_flag.save()	1✔
99	serializer = FlagSerializer(test_flag, data={"everyone": False}, partial=True)	1✔
100	assert serializer.is_valid()	1✔
101	updated_flag = serializer.save()	1✔
102	assert test_flag.name == updated_flag.name	1✔
103	assert updated_flag.everyone is None	1✔
104
105
106	def test_flag_serializer_cannot_change_name_to_manage_flags(test_flag):	1✔
107	serializer = FlagSerializer(	1✔
108	test_flag, data={"name": "manage_flags", "everyone": False}, partial=True
109	)
110	assert not serializer.is_valid()	1✔
111	expected = "Changing the `manage_flags` flag is not allowed."	1✔
112	assert str(serializer.errors["non_field_errors"][0]) == expected	1✔

mozilla / fx-private-relay / fca41f92-5491-483e-b3a5-9a03e39bd6ef

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous