def test_is_staff_works(graphql_client): def get_is_staff(): result = graphql_client.execute("query { session { isStaff } }") return result["data"]["session"]["isStaff"] assert get_is_staff() is False, "anonymous user is not staff" graphql_client.request.user = UserFactory.build(is_staff=False) assert get_is_staff() is False graphql_client.request.user = UserFactory.build(is_staff=True) assert get_is_staff() is True
def test_invalid_registration(self, api_client): proto_user = UserFactory.build() signup_payload = { "email": proto_user.email, "password1": proto_user._password, "password2": 'another_password', } response = api_client.post(self.registration_url, data=signup_payload) assert response.status_code == status.HTTP_400_BAD_REQUEST assert "The two password fields didn't match." in response.data[ "non_field_errors"] user = UserFactory() signup_payload = { "email": user.email, "password1": proto_user._password, "password2": proto_user._password, } response = api_client.post(self.registration_url, data=signup_payload) assert response.status_code == status.HTTP_400_BAD_REQUEST assert "A user is already registered with this e-mail address." in response.data[ "email"]
def test_clean_username(self): # A user with proto_user params does not exist yet. proto_user = UserFactory.build() form = UserCreationForm( { "username": proto_user.username, "password1": proto_user._password, "password2": proto_user._password, } ) assert form.is_valid() assert form.clean_username() == proto_user.username # Creating a user. form.save() # The user with proto_user params already exists, # hence cannot be created. form = UserCreationForm( { "username": proto_user.username, "password1": proto_user._password, "password2": proto_user._password, } ) assert not form.is_valid() assert len(form.errors) == 1 assert "username" in form.errors
def test_is_blocked(self): """ User is < 13 years old """ user = UserFactory.build(birthday=datetime.datetime(datetime.date.today().year - settings.USER_ALLOWED_AGE + 1, 1, 1)) return is_allowed(user) == 'blocked'
def test_set_username(self): proto_user = UserFactory.build() user = User(email=proto_user.email) user.set_password(proto_user._password) user.set_username() user.save() assert user.username
def test_create_user(self): proto_user = UserFactory.build() user = User.objects.create_user(email=proto_user.email, password=proto_user._password, first_name=proto_user.first_name, last_name=proto_user.last_name, username=proto_user.username) assert User.objects.filter(email=proto_user.email).exists() assert user.email == proto_user.email assert user.first_name == proto_user.first_name assert user.last_name == proto_user.last_name assert user.username == proto_user.username assert user.check_password(proto_user._password) assert not user.is_staff assert not user.is_superuser assert user.is_active assert not user.is_verified with pytest.raises(ValueError, match='The given email must be set'): User.objects.create_user(email='', password=proto_user._password, first_name=proto_user.first_name, last_name=proto_user.last_name, username=proto_user.username) with pytest.raises(ValueError, match='The given username must be set'): User.objects.create_user(email=proto_user.email, password=proto_user._password, first_name=proto_user.first_name, last_name=proto_user.last_name, username='')
def test_login_required_forms_succeed_when_authenticated(): assert execute_form_with_auth_query(user=UserFactory.build()) == { 'data': { 'formWithAuth': { 'errors': [] } } }
def setUp(self): ledger = Ledger() user1 = UserFactory.build() user1.save() ledger.user = user1 ledger.name = 'Test Ledger' ledger.save() self.ledger = ledger
def setUp(self): self.user = UserFactory.build() self.user.save() self.ledger = LedgerFactory.build() self.ledger.user = self.user self.ledger.save() self.url = reverse('api:ledger-detail', kwargs={'pk': self.ledger.pk}) self.client.credentials(HTTP_AUTHORIZATION='Token {}'.format(self.user.auth_token))
def setUp(self): user = UserFactory.build() user.save() self.user = user ledger = LedgerFactory.build() ledger.user = user ledger.save() self.ledger = ledger self.account_data = model_to_dict(AccountFactory.build())
def setUp(self): self.user = UserFactory.build() self.user.save() self.ledger = LedgerFactory.build() self.ledger.user = self.user self.ledger.save() self.client.credentials(HTTP_AUTHORIZATION='Token {}'.format(self.user.auth_token)) self.url = reverse('api:payees-list', kwargs={'ledger_pk': self.ledger.pk}) self.payee_data = model_to_dict(PayeeFactory.build())
def setUp(self): user = UserFactory.build() user.save() self.user = user ledger = LedgerFactory.build() ledger.user = user ledger.save() self.ledger = ledger self.payee_data = model_to_dict(PayeeFactory.build())
def test_first_and_last_name_works(graphql_client): def get(): result = graphql_client.execute( 'query { session { firstName, lastName } }') sess = result['data']['session'] return (sess['firstName'], sess['lastName']) assert get() == (None, None), "anonymous user has no first/last name" graphql_client.request.user = UserFactory.build(full_name="Boop Jones") assert get() == ("Boop", "Jones")
def test_user_can_login(self): u = UserFactory.build() u.set_password('123') u.active = True u.save() data = { 'email': u.email, 'password': '******', } url = reverse('account_login') response = self.client.post(url, data) self.assertEqual(response.status_code, 200)
def test_if_email_and_passwords_are_correct_then_must_create_correctly( self): user = UserFactory.build() response = self._create_account_request( user.email, user.password, user.password, ) self.assertEqual(response.status_code, status.HTTP_201_CREATED) self.assertEqual(User.objects.count(), 1)
def test_email_fields_work(graphql_client): def get(): result = graphql_client.execute( "query { session { email, isEmailVerified } }") sess = result["data"]["session"] return (sess["email"], sess["isEmailVerified"]) assert get() == (None, None), "anonymous user has no email info" graphql_client.request.user = UserFactory.build(email="*****@*****.**", is_email_verified=True) assert get() == ("*****@*****.**", True)
def test_first_and_last_name_works(graphql_client): def get(): result = graphql_client.execute( "query { session { firstName, lastName } }") sess = result["data"]["session"] return (sess["firstName"], sess["lastName"]) assert get() == (None, None), "anonymous user has no first/last name" graphql_client.request.user = UserFactory.build( full_legal_name="Boop Jones") assert get() == ("Boop", "Jones")
def test_registration(self, api_client): proto_user = UserFactory.build() signup_payload = { "email": proto_user.email, "password1": proto_user._password, "password2": proto_user._password, } response = api_client.post(self.registration_url, data=signup_payload) assert response.status_code == status.HTTP_201_CREATED, response.data assert User.objects.filter(email=proto_user.email).exists()
def test_creates_profile(self): proto_user = UserFactory.build() user = User.objects.create_user(email=proto_user.email, password=proto_user._password, first_name=proto_user.first_name, last_name=proto_user.last_name, username=proto_user.username) assert Profile.objects.filter(user=user).count() == 1 user.first_name = user.first_name[:-1] user.save() # assert doesn't create additional model assert Profile.objects.filter(user=user).count() == 1
def test_if_the_passwords_do_not_match_then_can_not_be_created(self): user = UserFactory.build() response = self._create_account_request( user.email, user.password, f"{user.password}error", ) self.assertEqual(User.objects.count(), 0) self.assertEqual( str(response.data['errors'][0]['message']), strings.passwords_should_match, )
def test_if_email_already_exists_then_can_not_be_created(self): user = UserFactory.build() User.objects.create(email=user.email) response = self._create_account_request( user.email, user.password, user.password, ) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual(User.objects.count(), 1) self.assertEqual( str(response.data['errors'][0]['message']), strings.email_already_created, )
def test_partial_update(self, api_client, user): api_client.force_authenticate(user) new_profile_data = ProfileFactory.build() new_user_data = UserFactory.build() data = { "description": new_profile_data.description, "last_name": new_user_data.last_name, } response = api_client.patch(self.profile_detail_url, data) assert response.status_code == status.HTTP_200_OK user.refresh_from_db() assert user.last_name == data["last_name"] assert user.profile.description == data["description"]
def setUp(self): self.user = UserFactory.build() self.user.save() self.ledger = LedgerFactory.build() self.ledger.user = self.user self.ledger.save() self.account = AccountFactory.build() self.account.ledger = self.ledger self.account.save() self.payee = PayeeFactory.build() self.payee.ledger = self.ledger self.payee.save() self.client.credentials(HTTP_AUTHORIZATION='Token {}'.format(self.user.auth_token)) self.url = reverse('api:transactions-list', kwargs={'ledger_pk': self.ledger.pk}) transaction = TransactionFactory.build() transaction.account = self.account self.transaction_data = model_to_dict(transaction)
def setUp(self): self.user = UserFactory.build() self.user.save() self.ledger = LedgerFactory.build() self.ledger.user = self.user self.ledger.save() self.account = AccountFactory.build() self.account.ledger = self.ledger self.account.save() self.payee = PayeeFactory.build() self.payee.ledger = self.ledger self.payee.save() self.transaction = TransactionFactory.build() self.transaction.ledger = self.ledger self.transaction.account = self.account self.transaction.payee = self.payee self.transaction.save() self.url = reverse('api:transaction-detail', kwargs={'pk': self.transaction.pk}) self.client.credentials(HTTP_AUTHORIZATION='Token {}'.format(self.user.auth_token))
def test_form(self): # A user with proto_user params does not exist yet. proto_user = UserFactory.build() form_payload = { 'email': proto_user.email, 'password1': proto_user._password, 'password2': proto_user._password, } form = UserCreationForm(form_payload) assert form.is_valid() # Creating a user. form.save() # The user with proto_user params already exists, hence cannot be created. form = UserCreationForm(form_payload) assert not form.is_valid() assert len(form.errors) == 1
def test_partial_update(self): user = UserFactory() profile = ProfileFactory(user=user) new_profile_data = ProfileFactory.build() new_user_data = UserFactory.build() data = { "description": new_profile_data.description, "last_name": new_user_data.last_name, } serializer = ProfileSerializer(instance=profile, data=data, partial=True) assert serializer.is_valid(), serializer.errors serializer.save() user.refresh_from_db() assert user.last_name == data["last_name"] profile.refresh_from_db() assert profile.description == data["description"]
def test_update(self): user = UserFactory() profile = ProfileFactory(user=user) new_profile_data = ProfileFactory.build() new_user_data = UserFactory.build() data = { "birth_date": new_profile_data.birth_date, "description": new_profile_data.description, "first_name": new_user_data.first_name, "last_name": new_user_data.last_name, "username": new_user_data.username, } serializer = ProfileSerializer(instance=profile, data=data) assert serializer.is_valid(), serializer.errors profile = serializer.save() assert profile.description == data["description"] assert profile.birth_date == data["birth_date"] assert profile.user.last_name == data["last_name"] assert profile.user.first_name == data["first_name"] assert profile.user.username == data["username"]
def test_it_does_nothing_if_annotations_exist(self): u = UserFactory.build() setattr(u, "boop", 1) apply_annotations_to_user(u, {"boop": "this value should never be used"})
def setUp(self): self.url = reverse('api:ledger-list') self.user = UserFactory.build() self.user.save() self.client.credentials(HTTP_AUTHORIZATION='Token {}'.format(self.user.auth_token)) self.ledger_data = model_to_dict(LedgerFactory.build())
def test_bizzfuzz_number(self): """ User random_number is not multiples of 5 or 3 """ user = UserFactory.build(random_number=26) return bizzfuzz(user) == 26