def create_factories(self):
super().create_factories()
self.bank_account = BankAccountFactory.create(
name="Hauptkonto",
bank="Spaßkasse",
account__name="Bankkonto 3120219540",
account_number='3120219540',
)
self.fee_account = AccountFactory.create(name="Membership Fees",
type='REVENUE')
self.user = UserFactory.create(name="Dummy User",
account__name="Dummy User")
self.author = UserFactory.create()
def test_profile_ok(client):
user = UserFactory.create()
session = Session(
user=user,
refresh_token='token_123'
)
session.save(force_insert=True)
token_data = TokenData(
id=user.id,
full_name=user.full_name,
email=user.email,
session_id=session.id
)
token = Token.generate_token(token_data=token_data)
headers = {
'Authorization': f'Bearer {token}'
}
response = client.get(
'/api/profile',
headers=headers
)
response_data = response.json['data']
assert response.status_code == 200
assert response_data['id'] == str(user.id)
assert response_data['full_name'] == user.full_name
assert response_data['email'] == user.email
def test_activate_ok(client):
user = UserFactory.create()
payload = {
'activation_token': user.activation_token,
}
response = client.post('/api/users/activate', json=payload)
assert response.status_code == 204
def test_model_user_auth_token(self):
""" Test JWT auth tokens """
uf = UserFactory.create()
user = User.query.filter_by(username=uf.username).first()
auth_tkn = encode_auth_token(user.id)
self.assertTrue(isinstance(auth_tkn, bytes))
self.assertEqual(decode_auth_token(auth_tkn), user.id)
self.assertTrue(decode_auth_token(auth_tkn.decode("utf-8")) == 1)
def test_create_reset_password_token_ok(client):
user = UserFactory.create(reset_password_token=None)
payload = {
'email': user.email,
}
response = client.post('/api/reset-password', json=payload)
assert response.status_code == 204
def test_slug_field_should_automatically_slugify_title(self):
user = UserFactory.create()
article = Article(
title='This is a title',
author=user,
content='Blah blah some content'
)
article.save()
article.slug | should | equal_to('this-is-a-title')
def test_reset_password_ok(client):
user = UserFactory.create()
payload = {
'password': '******',
}
response = client.post(f'/api/reset-password/{user.reset_password_token}',
json=payload)
assert response.status_code == 204
def test_activate_with_expired_activation_token(client):
expired_date = datetime.datetime.now() - datetime.timedelta(seconds=8000)
user = UserFactory.create(activation_token_created_at=expired_date)
payload = {
'activation_token': user.activation_token,
}
response = client.post('/api/users/activate', json=payload)
assert response.status_code == 400
assert response.json['errors']['activation_token'] == 'Token expired'
def test_sign_out_ok(client):
user = UserFactory.create()
session = Session(user=user, refresh_token='token_123')
session.save(force_insert=True)
token_data = TokenData(id=user.id,
full_name=user.full_name,
email=user.email,
session_id=session.id)
token = Token.generate_token(token_data=token_data)
headers = {'Authorization': f'Bearer {token}'}
response = client.post('/api/sign-out', headers=headers)
assert response.status_code == 204
def create_factories(self):
ConfigFactory.create()
self.processor = UserFactory.create()
self.last_month_last = session.utcnow().replace(day=1) - timedelta(1)
self.last_month_last_date = self.last_month_last.date()
self.membership_fee_last = MembershipFeeFactory.create(
begins_on=self.last_month_last_date.replace(day=1),
ends_on=self.last_month_last_date)
payment_deadline = timedelta(14)
payment_deadline_final = timedelta(62)
no_pid_action_date = session.utcnow() - payment_deadline + timedelta(1)
pid_state_date = no_pid_action_date - timedelta(1)
pid_no_end_membership_date = session.utcnow(
) - payment_deadline_final + timedelta(1)
pid_end_membership_date = pid_no_end_membership_date - timedelta(1)
self.membership_fee_no_pid_action = MembershipFeeFactory.create(
begins_on=no_pid_action_date,
ends_on=no_pid_action_date,
booking_begin=timedelta(1),
booking_end=timedelta(1),
)
self.membership_fee_pid_state = MembershipFeeFactory.create(
begins_on=pid_state_date,
ends_on=pid_state_date,
booking_begin=timedelta(1),
booking_end=timedelta(1),
)
self.membership_fee_no_end_membership = MembershipFeeFactory.create(
begins_on=pid_no_end_membership_date,
ends_on=pid_no_end_membership_date,
booking_begin=timedelta(1),
booking_end=timedelta(1),
)
self.membership_fee_pid_end_membership = MembershipFeeFactory.create(
begins_on=pid_end_membership_date,
ends_on=pid_end_membership_date,
booking_begin=timedelta(1),
booking_end=timedelta(1),
)
def create_factories(self):
ConfigFactory.create()
self.user = UserFactory.create()
self.user_membership = MembershipFactory.create(
active_during=closedopen(session.utcnow() - timedelta(weeks=52),
None),
user=self.user,
group=config.member_group)
last_month_last = session.utcnow().date().replace(day=1) - timedelta(1)
self.membership_fee_current = MembershipFeeFactory.create()
self.membership_fee_last = MembershipFeeFactory.create(
begins_on=last_month_last.replace(day=1), ends_on=last_month_last)
def test_sign_in_ok(client):
user = UserFactory.create()
Session(
user=user,
refresh_token='token_123'
).save(force_insert=True)
payload = {
'refresh_token': 'token_123'
}
response = client.post(
'/api/sign-in/refresh',
json=payload
)
response_data = response.json['data']
assert 'refresh_token' not in response_data
assert response.status_code == 200
assert response_data['access_token']
assert response_data['expires_in']
assert response_data['token_type']
def signup_user(self):
return UserFactory.create(account='avery',
password=bcrypt.hashpw(
'abc123'.encode('utf8'),
bcrypt.gensalt()).decode('utf-8'))
def user(self):
user = UserFactory.create()
self.session.commit()
return user
def not_logged_in_user(session):
user = UserFactory.create()
session.commit()
return user
def another_user(self):
return UserFactory.create()
def logged_in_user(self):
return UserFactory.create()
