def test_send_when_logged_in_without_brand_contact_address(
self, send_email_mock):
sender = create_user(
'Alice',
user_id='a4903d8f-0bc6-4af9-aeb9-d7534a0a22e8',
email_address='*****@*****.**',
)
recipient = create_user('Bob', email_address='*****@*****.**')
text = '''\
Hi Bob,
please don't forget to take out the trash.
kthxbye,
Alice
'''
expected_response_location = f'http://example.com/users/{recipient.id}'
expected_email_sender = 'ACME Entertainment Convention <*****@*****.**>'
expected_email_recipients = ['Bob <*****@*****.**>']
expected_email_subject = 'Mitteilung von Alice (über acme.example.com)'
expected_email_body = '''\
Hallo Bob,
Alice möchte dir die folgende Mitteilung zukommen lassen.
Du kannst Alice hier antworten: http://example.com/user_messages/to/a4903d8f-0bc6-4af9-aeb9-d7534a0a22e8/create
ACHTUNG: Antworte *nicht* auf diese E-Mail, sondern folge dem Link.
---8<-------------------------------------
Hi Bob,
please don't forget to take out the trash.
kthxbye,
Alice
---8<-------------------------------------
--
Diese Mitteilung wurde über die Website acme.example.com gesendet.\
'''
response = self.send_request(recipient.id,
text,
current_user_id=sender.id)
assert response.status_code == 302
assert response.location == expected_response_location
send_email_mock.assert_called_once_with(
expected_email_sender,
expected_email_recipients,
expected_email_subject,
expected_email_body,
)
def setUp(self):
super().setUp()
brand = create_brand()
self.party = create_party(brand_id=brand.id)
self.category_id = self.create_category('Premium').id
self.owner_id = create_user('Ticket_Owner').id
self.admin_id = create_user('Orga').id
def test_user_should_create_review_if_already_did(client, db):
helpers.create_user(client)
helpers.login_user(client)
helpers.insert_complete_restaurant(db)
create_review(client)
res = create_review(client, rating=3)
assert res.status_code == 200
assert b"You already reviewed this restaraunt"
def test_user_should_see_review_form(client, db):
helpers.create_user(client)
helpers.login_user(client)
helpers.insert_complete_restaurant(db)
res = visit_restaurant_page(client)
assert res.status_code == 200
assert b"Add your review" in res.data
assert b"Your rating" in res.data
assert b"Your review" in res.data
def test_user_should_create_review(client, db):
helpers.create_user(client)
helpers.login_user(client)
helpers.insert_complete_restaurant(db)
res = create_review(client)
assert res.status_code == 200
assert b"mario" in res.data
assert b"5" in res.data
assert (
b"It was a delicious dinner, but initially the service was not so excellent in the speed of serving the meals."
in res.data)
def test_user_should_not_create_review_when_message_is_less_than_30_character(
client, db):
helpers.create_user(client)
helpers.login_user(client)
helpers.insert_complete_restaurant(db)
res = client.post(
"/restaurants/1",
data=dict(rating=4, message="It was a"),
follow_redirects=True,
)
assert res.status_code == 200
assert b"The review should be at least of 30 characters." in res.data
def test_delete__same_episode_exists__ok(
self,
client,
podcast,
episode_data,
mocked_s3,
same_episode_status,
delete_called,
dbs,
):
source_id = get_video_id()
user_1 = create_user(dbs)
user_2 = create_user(dbs)
podcast_1 = await_(
Podcast.async_create(dbs,
db_commit=True,
**get_podcast_data(created_by_id=user_1.id)))
podcast_2 = await_(
Podcast.async_create(dbs,
db_commit=True,
**get_podcast_data(created_by_id=user_2.id)))
episode_data["created_by_id"] = user_1.id
_ = create_episode(dbs,
episode_data,
podcast_1,
status=same_episode_status,
source_id=source_id)
episode_data["created_by_id"] = user_2.id
episode_2 = create_episode(dbs,
episode_data,
podcast_2,
status=Episode.Status.NEW,
source_id=source_id)
url = self.url.format(id=episode_2.id)
client.login(user_2)
response = client.delete(url)
assert response.status_code == 204, f"Delete API is not available: {response.text}"
assert await_(Episode.async_get(dbs, id=episode_2.id)) is None
if delete_called:
mocked_s3.delete_files_async.assert_called_with(
[episode_2.file_name])
else:
assert not mocked_s3.delete_files_async.called
def test_unsuspend(app):
admin_id = app.admin_id
user = create_user('TemporaryNuisance')
user_id = user.id
user_command_service.suspend_account(user_id, admin_id, 'Annoying')
reason = 'User showed penitence. Drop the ban.'
user_before = user_service.find_user(user_id)
assert user_before.suspended
events_before = event_service.get_events_for_user(user_before.id)
assert len(events_before) == 1
# -------------------------------- #
user_command_service.unsuspend_account(user_id, admin_id, reason)
# -------------------------------- #
user_after = user_service.find_user(user_id)
assert not user_after.suspended
events_after = event_service.get_events_for_user(user_after.id)
assert len(events_after) == 2
unsuspended_event = events_after[1]
assert unsuspended_event.event_type == 'user-unsuspended'
assert unsuspended_event.data == {
'initiator_id': str(admin_id),
'reason': reason,
}
def test_suspend(app):
admin_id = app.admin_id
user = create_user('Cheater')
user_id = user.id
reason = 'User has been caught cheating.'
user_before = user_service.find_user(user_id)
assert not user_before.suspended
events_before = event_service.get_events_for_user(user_before.id)
assert len(events_before) == 0
# -------------------------------- #
user_command_service.suspend_account(user_id, admin_id, reason)
# -------------------------------- #
user_after = user_service.find_user(user_id)
assert user_after.suspended
events_after = event_service.get_events_for_user(user_after.id)
assert len(events_after) == 1
suspended_event = events_after[0]
assert suspended_event.event_type == 'user-suspended'
assert suspended_event.data == {
'initiator_id': str(admin_id),
'reason': reason,
}
def test_disable(self):
user_id = create_user(enabled=True).id
user_before = user_command_service._get_user(user_id)
assert user_before.enabled
events_before = event_service.get_events_for_user(user_before.id)
assert len(events_before) == 0
# -------------------------------- #
user_command_service.disable_user(user_id, ADMIN_ID)
# -------------------------------- #
user_after = user_command_service._get_user(user_id)
assert not user_after.enabled
events_after = event_service.get_events_for_user(user_after.id)
assert len(events_after) == 1
user_disabled_event = events_after[0]
assert user_disabled_event.event_type == 'user-disabled'
assert user_disabled_event.data == {
'initiator_id': str(ADMIN_ID),
}
def superuser():
return create_user(
username='******',
email='*****@*****.**',
is_superuser=True,
is_staff=True,
)
def subscribers(db, newsletter_list):
for number, initialized, suspended, deleted, states in [
(1, True, False, False, [SubscriptionState.requested]),
(2, True, False, False, [SubscriptionState.declined]),
(3, False, False, False, [SubscriptionState.requested]),
(4, True, False, False,
[SubscriptionState.declined, SubscriptionState.requested]),
(5, True, False, False,
[SubscriptionState.requested, SubscriptionState.declined]),
(6, True, False, False, [SubscriptionState.requested]),
(7, True, True, False, [SubscriptionState.requested]),
(8, True, False, True, [SubscriptionState.requested]),
]:
user = create_user(
screen_name=f'User-{number:d}',
email_address=f'user{number:03d}@example.com',
initialized=initialized,
)
if suspended:
user.suspended = True
db.session.commit()
if deleted:
user.deleted = True
db.session.commit()
add_subscriptions(db, user.id, newsletter_list.id, states)
def test_change_screen_name_with_reason(self):
old_screen_name = 'Zero_Cool'
new_screen_name = 'Crash_Override'
reason = 'Do not reveal to Acid Burn.'
user_id = create_user(old_screen_name).id
user_before = user_command_service._get_user(user_id)
assert user_before.screen_name == old_screen_name
events_before = event_service.get_events_for_user(user_before.id)
assert len(events_before) == 0
# -------------------------------- #
user_command_service.change_screen_name(user_id, new_screen_name,
ADMIN_ID, reason=reason)
# -------------------------------- #
user_after = user_command_service._get_user(user_id)
assert user_after.screen_name == new_screen_name
events_after = event_service.get_events_for_user(user_after.id)
assert len(events_after) == 1
user_enabled_event = events_after[0]
assert user_enabled_event.event_type == 'user-screen-name-changed'
assert user_enabled_event.data == {
'old_screen_name': old_screen_name,
'new_screen_name': new_screen_name,
'initiator_id': str(ADMIN_ID),
'reason': reason,
}
def test_change_email_address_without_reason(self):
old_email_address = '*****@*****.**'
new_email_address = '*****@*****.**'
user_id = create_user('Propellerhead',
email_address=old_email_address).id
# -------------------------------- #
user_command_service.change_email_address(user_id, new_email_address,
ADMIN_ID)
# -------------------------------- #
user_after = user_command_service._get_user(user_id)
events_after = event_service.get_events_for_user(user_after.id)
user_enabled_event = events_after[0]
assert user_enabled_event.event_type == 'user-email-address-changed'
assert user_enabled_event.data == {
'old_email_address': old_email_address,
'new_email_address': new_email_address,
'initiator_id': str(ADMIN_ID),
}
def test_change_screen_name_without_reason(app):
admin_id = app.admin_id
old_screen_name = 'NameWithTyop'
new_screen_name = 'NameWithoutTypo'
user_id = create_user(old_screen_name).id
# -------------------------------- #
user_command_service.change_screen_name(user_id, new_screen_name, admin_id)
# -------------------------------- #
user_after = user_command_service._get_user(user_id)
events_after = event_service.get_events_for_user(user_after.id)
user_enabled_event = events_after[0]
assert user_enabled_event.event_type == 'user-screen-name-changed'
assert user_enabled_event.data == {
'old_screen_name': old_screen_name,
'new_screen_name': new_screen_name,
'initiator_id': str(admin_id),
}
def test_get_list__filter_by_created_by__ok(self, client, dbs):
user_1 = create_user(dbs)
user_2 = create_user(dbs)
podcast_data = get_podcast_data()
podcast_data["created_by_id"] = user_1.id
await_(Podcast.async_create(dbs, db_commit=True, **podcast_data))
podcast_data = get_podcast_data()
podcast_data["created_by_id"] = user_2.id
podcast_2 = await_(Podcast.async_create(dbs, db_commit=True, **podcast_data))
client.login(user_2)
response = client.get(self.url)
response_data = self.assert_ok_response(response)
assert response_data == [_podcast(podcast_2)]
def test_when_logged_in_form_is_available(self):
user = create_user()
login_user(user.id)
response = self.send_request(user_id=user.id)
assert response.status_code == 200
def setUp(self):
super().setUp()
create_email_config()
create_site()
self.user = create_user()
def test_when_logged_in_endpoint_is_available(self):
old_password = '******'
new_password = '******'
user = create_user()
password_service.create_password_hash(user.id, old_password)
login_user(user.id)
credential_before = self.find_credential(user.id)
assert credential_before is not None
session_token_before = self.find_session_token(user.id)
assert session_token_before is not None
form_data = {
'old_password': old_password,
'new_password': new_password,
'new_password_confirmation': new_password,
}
response = self.send_request(form_data, user_id=user.id)
assert response.status_code == 302
assert response.headers.get(
'Location') == 'http://example.com/authentication/login'
credential_after = self.find_credential(user.id)
session_token_after = self.find_session_token(user.id)
assert credential_after is not None
assert credential_before.password_hash != credential_after.password_hash
assert credential_before.updated_at != credential_after.updated_at
# Session token should have been removed after password change.
assert session_token_after is None
def setup_subscribers(self):
for number, enabled, suspended, deleted, states in [
(1, True, False, False, [SubscriptionState.requested ]),
(2, True, False, False, [SubscriptionState.declined ]),
(3, False, False, False, [SubscriptionState.requested ]),
(4, True, False, False, [SubscriptionState.declined, SubscriptionState.requested]),
(5, True, False, False, [SubscriptionState.requested, SubscriptionState.declined ]),
(6, True, False, False, [SubscriptionState.requested ]),
(7, True, True , False, [SubscriptionState.requested ]),
(8, True, False, True , [SubscriptionState.requested ]),
]:
user = create_user(
screen_name='User-{:d}'.format(number),
email_address='user{:03d}@example.com'.format(number),
enabled=enabled)
if suspended:
user.suspended = True
self.db.session.commit()
if deleted:
user.deleted = True
self.db.session.commit()
self.add_subscriptions(user, states)
def setUp(self):
super().setUp()
self.admin = create_user('Admin')
login_user(self.admin.id)
self.user = create_user('User')
self.brand = create_brand()
party = create_party(brand_id=self.brand.id)
create_email_config()
create_site(party.id)
self.board = create_board(self.brand.id)
site_settings_service \
.create_setting('acmecon-2014-website', 'board_id', self.board.id)
def setUp(self):
super().setUp()
create_email_config()
create_site()
self.user = create_user(initialized=False)
assert not self.user.initialized
def test_when_logged_in(self):
user = create_user('McFly')
login_user(user.id)
response = self.send_request(user_id=user.id)
assert response.status_code == 200
assert response.mimetype == 'text/html'
def test_recipient_formatting(site, params):
screen_name, email_address, expected = params
user = create_user(screen_name, email_address=email_address)
message = user_message_service.create_message(user.id, user.id, '', '',
site.id)
assert message.recipients == [expected]
def setUp(self):
super().setUp()
self.user = create_user(enabled=False)
brand = create_brand()
party = create_party(brand.id)
create_email_config()
create_site(party.id)
def create_shop_fragment(self, shop_id, name, body):
scope = Scope('shop', shop_id)
try:
self.admin
except AttributeError:
self.admin = create_user('Admin')
snippet_service.create_fragment(scope, name, self.admin.id, body)
def app(admin_app, db):
with admin_app.app_context():
with database_recreated(db):
_app = admin_app
admin = create_user('Administrator')
_app.admin_id = admin.id
yield _app
def create_admin(self):
admin = create_user('Admin')
permission_ids = {'admin.access', 'newsletter.export_subscribers'}
assign_permissions_to_user(admin.id, 'admin', permission_ids)
login_user(admin.id)
return admin
def test_get_awardings_of_badge(self):
user1 = create_user('User1')
user2 = create_user('User2')
with self.app.app_context():
badge = user_badge_service.create_badge(
'awesomeness', 'Certificate of Awesomeness', 'awesomeness.svg')
user_badge_service.award_badge_to_user(badge.id, user1.id)
user_badge_service.award_badge_to_user(badge.id, user1.id)
user_badge_service.award_badge_to_user(badge.id, user2.id)
actual = user_badge_service.get_awardings_of_badge(badge.id)
assert actual == {
QuantifiedBadgeAwarding(badge.id, user1.id, 2),
QuantifiedBadgeAwarding(badge.id, user2.id, 1),
}
def create_admin(self):
admin = create_user('Admin')
permission_ids = {'admin.access', 'shop_order.view'}
assign_permissions_to_user(admin.id, 'admin', permission_ids)
login_user(admin.id)
return admin
