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
