def test_user_subscribed_is_run_when_user_tier_is_changed_to_paid(
self, user_subscribed, session):
free_user = UserFactory(tier="free")
free_user.plan = Plan.paid()
session.add(free_user)
session.commit()
user_subscribed.assert_called_with(free_user.id, Plan.paid().id)
def test_after_commit_hooks_are_specific_to_a_session(
self, user_subscribed, session, app):
# What does this test prove? Well - we start by showing
# the thing works and by setting up a an "after_commit" hook
# on the session. (There SHOULD BE one session per request.)
# The next request should NOT fire the "after_commit" hook
# because it has a new session. IE - we are not leaking
# Model instances across requests, and not firing subscribe
# events for instances we didn't change
free_user = UserFactory(tier="free")
free_user.plan = Plan.paid()
session.add(free_user)
session.commit()
session.expire_all()
user_subscribed.assert_called_with(free_user.id, Plan.paid().id)
user_subscribed.reset_mock()
sess = db.create_scoped_session()
free_user2 = UserFactory(tier="free", email="*****@*****.**")
session.expunge(free_user2.plan)
sess.add(free_user2)
sess.commit()
user_subscribed.assert_not_called()
sess.remove()
def test_user_unsubscribed_is_run_when_user_tier_is_changed_to_free(
self, user_unsubscribed, session):
user = UserFactory()
user.plan = Plan.free()
session.add(user)
session.commit()
user_unsubscribed.assert_called_with(user.id)
def test_factory(self, db):
"""Test user factory."""
user = UserFactory(password='******')
db.session.commit()
assert bool(user.username)
assert bool(user.email)
assert user.check_password('myprecious')
def test_model_add_duplicated_email(self):
""" Add a duplicated email """
user = UserFactory()
with self.assertRaises(sqlalchemy.exc.IntegrityError):
repository.new(
User(username=faker.user_name(),
email=user.email,
password=user.password,
role=faker.job()))
def test_model_user_schema_serialize(self):
""" Test UserSchema Serialize """
user_schema = UserSchema()
uf = UserFactory.build()
user = User(username=uf.username,
email=uf.email,
role=uf.role,
password=uf.password)
data = user_schema.dump(user).data
self.assertIsInstance(data, dict)
self.assertEqual(data['username'], uf.username)
self.assertEqual(data['email'], uf.email)
self.assertEqual(data['role'], uf.role)
def create_factories(self):
super().create_factories()
self.hss = BuildingFactory(site__name="Hochschulstraße")
UserFactory(login='******',
name="Hans Sarpei",
room__building=self.hss)
UserFactory(login='******', name="Franz Wurst", room__building=self.hss)
UserFactory(login='******') # not living in the HSS
def test_user_can_report_limts(self, session):
user = UserFactory(email="*****@*****.**")
session.add(user)
session.flush()
assert user.limits() == UserLimit(
tunnel_count=5, bandwidth=100000, forwards=9999, reserved_subdomains=5
)
def test_sign_in_with_wrong_password(client):
UserFactory.create_with_hashed_password(email='*****@*****.**',
password='******')
payload = {'email': '*****@*****.**', 'password': '******'}
response = client.post('/api/sign-in', json=payload)
assert response.status_code == 401
assert response.json['errors'] == 'Invalid Credentials'
def user(self):
user = UserFactory.build()
copy_user = UserFactory.build(email=user.email, password=user.password)
user.encode_password()
self.session.add(user)
self.session.commit()
return copy_user
def test_sign_in_with_user_not_activated(client):
UserFactory.create_with_hashed_password(email='*****@*****.**',
password='******',
is_active=False)
payload = {'email': '*****@*****.**', 'password': '******'}
response = client.post('/api/sign-in', json=payload)
assert response.status_code == 401
assert response.json['errors'] == 'Not activated'
def test_user_has_authorized_on_spotify(self):
user = UserFactory()
user.spotify_id = '54774645'
db.session.add(user)
db.session.commit()
url = url_for('users.user', pk=user.id)
response = self.client.get(url)
assert response.status_code == 200
assert response.json['spotify_playlists'].startswith('http')
def test_add_some_tracks_into_queue(self):
tracks = [TrackFactory(), TrackFactory(), TrackFactory()]
users = [UserFactory(), UserFactory(), UserFactory()]
db.session.add_all(tracks + users)
db.session.commit()
response = self.client.post(url_for('player.random'),
data=json.dumps({'tracks': 2}))
assert response.status_code == httplib.CREATED
assert Queue.length() == 2
def test_view_get_all_users(self):
""" Get all users """
user1 = UserFactory()
user2 = UserFactory()
with self.client:
response = self.client.get('/users/')
data = json.loads(response.data.decode())
self.assertEqual(response.status_code, 200)
self.assertEqual(len(data), 2)
self.assertEqual(user1.username, data[0]['username'])
self.assertEqual(user2.role, data[1]['role'])
def test_sign_in_ok(client):
UserFactory.create_with_hashed_password(email='*****@*****.**',
password='******')
payload = {'email': '*****@*****.**', 'password': '******'}
response = client.post('/api/sign-in', json=payload)
response_data = response.json['data']
assert response.status_code == 200
assert response_data['access_token']
assert response_data['refresh_token']
assert response_data['expires_in']
assert response_data['token_type']
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_notify_event_role(db):
invite = RoleInviteSubFactory()
role, _ = get_or_create(Role, name='owner', title_name='Owner')
UsersEventsRoles(user=UserFactory(), event=invite.event, role=role)
user = UserFactory()
db.session.commit()
notify_event_role_invitation(invite, user, invite.event.owner)
notification = Notification.query.first()
assert notification.user == user
assert notification.content.type == NotificationType.EVENT_ROLE
assert notification.content.target == invite
assert notification.content.actors[0].actor == invite.event.owner
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_send_monthly_invoice(self):
"""Method to test monthly invoices"""
with self.app.test_request_context():
TicketFeesFactory(service_fee=10.23, maximum_fee=11)
test_event = EventFactoryBasic(state='published')
test_user = UserFactory()
test_order = OrderFactory(status='completed')
test_order.completed_at = datetime.datetime.now(
) - datetime.timedelta(days=30)
test_order.amount = 100
test_order.event = test_event
test_ticket_holder = AttendeeFactory()
test_ticket_holder.event = test_event
test_ticket_holder.order = test_order
test_event.owner = test_user
db.session.commit()
send_monthly_event_invoice()
event_invoice = EventInvoice.query.get(1)
self.assertEqual(event_invoice.amount, 10.23)
def should_return_track_data(self):
track = TrackFactory(duration=10000)
user = UserFactory()
db.session.add_all([track, user])
db.session.commit()
now = datetime.datetime.utcnow()
start = now - datetime.timedelta(seconds=5)
start = start.replace(tzinfo=dateutil.tz.tzutc())
mock_redis_values = {
'fm:player:current':
json.dumps({
'uri': track.spotify_uri,
'user': user.id
}),
'fm:player:start_time':
start.isoformat()
}
self.redis.get.side_effect = lambda x: mock_redis_values.get(x)
url = url_for('player.current')
# We have to mock utcnow so we don't get drift in the test
with mock.patch('fm.views.player.datetime') as _dt:
_dt.utcnow.return_value = now
response = self.client.get(url)
assert response.status_code == 200, response.json
assert response.json['track'] == TrackSerializer().serialize(track)
assert response.json['user'] == UserSerializer().serialize(user)
assert response.json['player']['elapsed_time'] == 5000
assert response.json['player']['elapsed_percentage'] == 50
assert response.json['player']['elapsed_seconds'] == 5
def should_return_zero_when_elapsed_time_cant_be_pulled(self):
track = TrackFactory()
user = UserFactory()
db.session.add_all([track, user])
db.session.commit()
mock_redis_values = {
'fm:player:current':
json.dumps({
'uri': track.spotify_uri,
'user': user.id
}),
'fm:player:elapsed_time':
None
}
self.redis.get.side_effect = lambda x: mock_redis_values.get(x)
url = url_for('player.current')
response = self.client.get(url)
assert response.status_code == 200
assert response.json['track'] == TrackSerializer().serialize(track)
assert response.json['user'] == UserSerializer().serialize(user)
assert response.json['player']['elapsed_time'] == 0
assert response.json['player']['elapsed_percentage'] == 0
assert response.json['player']['elapsed_seconds'] == 0
def test_create_customer(self):
""" Create a Stripe Customer for a User """
# NOTE This is recorded - if you re-record you'll have to modify the stripe_id
user = UserFactory()
assert UserStripe(user).create_customer()
assert user.stripe_id == "cus_FPz8Z3uTNswpjq"
def setup(self):
user = UserFactory()
db.session.add(user)
db.session.commit()
self.user = User.query.one()
patch = mock.patch('fm.logic.player.redis', mock_redis_client())
self.redis = patch.start()
self.redis.publish = mock.MagicMock()
self.addPatchCleanup(patch)
patch = mock.patch('fm.tasks.queue.update_genres')
self.update_genres = patch.start()
self.update_genres.return_value = []
self.addPatchCleanup(patch)
# Patch Requests to EchoNest
self.requests = mock.MagicMock()
self.requests.get.return_value = mock.MagicMock(
status_code=httplib.OK,
json=mock.MagicMock(return_value=ECHONEST_ARTIST_GENRES))
self.requests.ConnectionError = requests.ConnectionError
patch = mock.patch(
'fm.thirdparty.echonest.requests',
new_callable=mock.PropertyMock(return_value=self.requests))
patch.start()
self.addPatchCleanup(patch)
def should_fire_stop_event(self):
track = TrackFactory()
user = UserFactory()
db.session.add_all([track, user])
db.session.commit()
self.redis.get.return_value = json.dumps({
'uri': track.spotify_uri,
'user': user.id,
})
url = url_for('player.current')
response = self.client.delete(url)
assert response.status_code == 200
self.redis.publish.assert_called_once_with(
self.app.config.get('PLAYER_CHANNEL'),
json.dumps({
'event': 'stop',
'user': str(user.id),
'track': str(track.id),
'uri': str(track.spotify_uri),
'by': str(current_user.id),
}))
def test_order_get(client, db, user, jwt):
user1 = UserFactory(is_admin=False)
order_id = create_order(db, user1)
order = Order.query.get(order_id)
attendee = AttendeeSubFactory(order=order, email=user.email)
db.session.commit()
response = client.get(
f'/v1/orders/{order_id}?include=user',
content_type='application/vnd.api+json',
headers=jwt,
)
assert response.status_code == 200
assert json.loads(
response.data)['data']['relationships']['user']['data'] == None
response = client.get(
f'/v1/attendees/{attendee.id}?include=order.user',
content_type='application/vnd.api+json',
headers=jwt,
)
assert response.status_code == 200
assert (json.loads(
response.data)['included'][0]['relationships']['user']['data'] == None)
def target_comment(self, target_group, user):
wrong_user = UserFactory()
comment = CommentFactory(comment_group_id=target_group.id,
user_id=wrong_user.id,
user=wrong_user,
status=CommentStatus.DELETED)
return comment
def post_id(self, user):
another_user = UserFactory()
post = PostFactory()
LikeFactory(post_id=post.id, user_id=another_user.id)
return post.id
def test_auth_user_invalid_logout(self):
""" Testing invalid user logout """
user = UserFactory.build()
with self.client:
initial_datetime = datetime.datetime(2017, 1, 1)
other_datetime = datetime.datetime(2017, 1, 2)
with freeze_time(initial_datetime) as frozen_datetime:
helper = UserHelpers(self.client)
helper.register(user)
resp_login = helper.login(user)
# Expire the token
frozen_datetime.move_to(other_datetime)
response = self.client.post(
'/auth/logout',
headers=dict(
Authorization='Bearer ' +
json.loads(resp_login.data.decode())['auth_token']))
data = json.loads(response.data.decode())
self.assertEqual(data['message'],
'Signature Expired, please login again')
self.assertEqual(response.status_code, 401)
def authenticated(request, db, app):
if not getattr(request.instance, 'unauthenticated', False):
user = UserFactory()
db.session.add(user)
db.session.commit()
g.user = user
def test_add_track_into_queue(self):
track = TrackFactory()
user = UserFactory()
db.session.add_all([track, user])
db.session.commit()
Queue.add(track.spotify_uri, user.id)
assert Queue.length() == 1
def test_spotify_playlist_returns_204_for_unauthorized_on_spotify(self):
user = UserFactory()
db.session.add(user)
db.session.commit()
response = self.client.get(
url_for('users.user_spotify_playlists', user_pk=user.id))
assert response.status_code == httplib.NO_CONTENT
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 setUp(self):
super().setUp()
property_group_data = {
# name, granted, denied
'active': ({'login', 'mail'}, set()),
'mail_only': ({'mail'}, set()),
'violation': (set(), {'login'}),
}
self.groups = {}
for name, (granted, denied) in property_group_data.items():
self.groups[name] = PropertyGroupFactory.create(name=name,
granted=granted,
denied=denied)
self.users = dict(zip(['active', 'mail', 'violator', 'former'],
UserFactory.create_batch(4)))
memberships = [
# user, group, delta_days_start, delta_days_end
('active', 'active', -1, None),
('mail', 'mail_only', -1, +1),
('mail', 'active', +2, None),
('violator', 'active', -1, None),
('violator', 'violation', -1, None),
('former', 'active', -10, -1),
('former', 'violation', -9, -5),
]
for username, groupname, delta_days_start, delta_days_end in memberships:
start = (datetime.now() + timedelta(delta_days_start)
if delta_days_start is not None else None)
end = (datetime.now() + timedelta(delta_days_end)
if delta_days_end is not None else None)
MembershipFactory.create(user=self.users[username],
group=self.groups[groupname],
begins_at=start, ends_at=end)
session.session.commit()
def step_impl(context):
user = UserFactory(username='******', email='*****@*****.**')
user.set_password('bar')
user.save()
