def it_doesnt_create_a_magazine_email_if_no_match(self, db_session,
sample_uuid):
with pytest.raises(expected_exception=InvalidRequest):
create_email(magazine_id=sample_uuid,
email_type=MAGAZINE,
old_id=None)
assert Email.query.count() == 0
def it_returns_approved_emails(self, client, db, db_session):
event = create_event(title='Event 1')
event_2 = create_event(title='Event 2')
event_date = create_event_date(event_id=str(event.id),
event_datetime='2019-07-20 19:00')
event_date_2 = create_event_date(event_id=str(event_2.id),
event_datetime='2019-07-13 19:00')
approved_email = create_email(event_id=str(event.id),
created_at='2019-07-01 11:00',
send_starts_at='2019-07-10',
send_after='2019-07-01 11:00',
expires='2019-07-20',
email_state='approved')
create_email(event_id=str(event_2.id),
created_at='2019-07-02 11:00',
send_starts_at='2019-07-01',
expires='2019-07-12')
response = client.get(url_for('emails.get_approved_emails'),
headers=[('Content-Type', 'application/json'),
create_authorization_header()])
json_latest_emails = json.loads(response.get_data(as_text=True))
assert len(json_latest_emails) == 1
assert json_latest_emails[0] == approved_email.serialize()
def it_doesnt_create_email_for_imported_emails_already_imported(
self, client, db_session, sample_old_emails, sample_event):
create_email() # email with old_id=1
response = client.post(url_for('emails.import_emails'),
data=json.dumps(sample_old_emails),
headers=[('Content-Type', 'application/json'),
create_authorization_header()])
assert response.status_code == 201
json_resp = json.loads(response.get_data(as_text=True))
json_emails = json_resp['emails']
email_types = [EVENT, ANNOUNCEMENT, ANON_REMINDER]
assert len(json_emails) == len(sample_old_emails) - 1
for i in range(0, len(sample_old_emails) - 1):
assert json_emails[i]['email_type'] == email_types[i]
assert json_emails[i]['created_at'] == sample_old_emails[
i + 1]['timestamp'][:-3]
assert json_emails[i]['extra_txt'] == sample_old_emails[
i + 1]['extratxt']
assert json_emails[i]['details'] == sample_old_emails[
i + 1]['eventdetails']
assert str(json_emails[i]['old_id']) == sample_old_emails[i +
1]['id']
assert str(json_emails[i]['old_event_id']) == sample_old_emails[
i + 1]['eventid']
assert json_emails[i]['replace_all'] == (
True if sample_old_emails[i +
1]['replaceAll'] == 'y' else False)
json_errors = json_resp['errors']
assert json_errors == ['email already exists: 1']
def it_gets_emails_from_starting_date_from_specified_date(
self, db, db_session):
emails = [
create_email(details='more details', created_at='2019-02-01'),
create_email(details='more details', created_at='2018-02-01')
]
emails_from_db = dao_get_emails_for_year_starting_on('2018-01-01')
assert len(emails_from_db) == 1
assert emails[1] == emails_from_db[0]
def it_gets_latest_magazine_email_only(self, db_session, sample_magazine):
later_magazine = create_magazine(title='ignored magazine')
event_email = create_email()
create_email(email_type=MAGAZINE, magazine_id=sample_magazine.id)
later_magazine_email = create_email(email_type=MAGAZINE,
magazine_id=later_magazine.id)
emails = dao_get_latest_emails()
assert len(emails) == 2
assert set([event_email, later_magazine_email]) == set(emails)
def it_gets_approved_emails_for_sending(self, db, db_session):
create_email(send_starts_at="2020-10-30",
send_after="2020-10-30T20:30:00 BST+0100",
expires="2020-11-07",
email_state=APPROVED)
create_email(send_starts_at="2020-10-30",
send_after="2020-10-30T20:30:00 BST+0100",
expires="2020-11-07",
email_state=READY)
res = dao_get_approved_emails_for_sending()
assert len(res) == 1
def it_doesnt_send_email_out_of_hours(self, mocker, db_session,
sample_email, sample_member, now):
mock_get_emails = mocker.patch(
'app.na_celery.email_tasks.dao_get_approved_emails_for_sending')
create_email(send_starts_at='2020-06-02',
created_at='2020-06-01',
send_after='2020-06-03 9:00',
email_state=APPROVED)
with freeze_time(now):
send_periodic_emails()
assert not mock_get_emails.called
def it_gets_latest_announcement_event_magazine_emails(
self, db_session, sample_magazine):
event_email = create_email()
magazine_email = create_email(email_type=MAGAZINE,
magazine_id=sample_magazine.id)
announcement_email = create_email(email_type=ANNOUNCEMENT)
anon_reminder_email = create_email(email_type=ANON_REMINDER)
emails = dao_get_latest_emails()
assert len(emails) == 3
assert set([event_email, magazine_email,
announcement_email]) == set(emails)
assert anon_reminder_email not in emails
def sample_email(db):
return create_email(
details='<strong>Fees:</strong> 10, <strong>Concessions:</strong> 5',
created_at='2019-06-01',
expires='2019-07-01',
email_state=APPROVED
)
def it_creates_an_email(self, db_session):
email = create_email()
assert Email.query.count() == 1
email_from_db = Email.query.filter(Email.id == email.id).first()
assert email == email_from_db
def it_gets_past_hour_emails_for_provider(self, db, db_session,
sample_member, sample_email,
sample_email_provider):
email = create_email(send_starts_at="2020-10-30",
send_after="2020-10-30T20:30:00",
expires="2020-11-07",
email_state=APPROVED)
member = create_member(email="*****@*****.**")
email_to_member = create_email_to_member(
email_id=email.id, created_at="2020-10-31T12:00:00")
create_email_to_member(
member_id=sample_member.id,
email_id=email.id,
created_at="2020-10-31T10:00:00",
email_provider_id=email_to_member.email_provider_id)
create_email_to_member(
member_id=member.id,
email_id=email.id,
created_at="2020-10-31T11:31:00",
email_provider_id=email_to_member.email_provider_id)
# use another provider to show that it doesn't get that count
email_provider = create_email_provider(name="Another email provider")
create_email_to_member(
member_id=sample_member.id,
email_id=sample_email.id,
email_provider_id=email_provider.id,
created_at="2020-10-31T11:31:00",
)
count = dao_get_past_hour_email_count_for_provider(
email_to_member.email_provider_id)
assert count == 2
def it_sends_email_in_hours(self, mocker, db_session, sample_email,
sample_member, now):
mock_send_emails = mocker.patch(
'app.na_celery.email_tasks.send_emails')
event_date = create_event_date(event_datetime='2020-09-20 19:00')
event = create_event(event_dates=[event_date])
create_email(send_starts_at='2020-09-02',
created_at='2020-09-01',
send_after='2020-09-03 8:00',
expires=None,
email_state=APPROVED,
old_event_id=None,
event_id=event.id)
with freeze_time(now):
send_periodic_emails()
assert mock_send_emails.called
def it_gets_all_emails_count_for_chosen_provider(self, db, db_session):
email = create_email()
member = create_member(email='*****@*****.**', name='Test1')
create_email_to_member(email_id=email.id, member_id=member.id)
email_to_member = create_email_to_member()
assert dao_get_todays_email_count_for_provider(
email_to_member.email_provider_id) == 2
def it_creates_an_event_email(self, db_session, sample_event_with_dates):
email = create_email(event_id=sample_event_with_dates.id,
old_event_id=None)
assert Email.query.count() == 1
email_from_db = Email.query.filter(Email.id == email.id).first()
assert email == email_from_db
assert email_from_db.send_starts_at == \
datetime.strptime(sample_event_with_dates.get_first_event_date(), "%Y-%m-%d") - timedelta(weeks=2)
def sample_magazine_email(db):
magazine = create_magazine(title="New mag", filename="new_mag.pdf")
return create_email(
magazine_id=magazine.id,
details='<strong>Fees:</strong> 10, <strong>Concessions:</strong> 5',
created_at='2019-06-01',
expires='2019-07-01',
email_type=MAGAZINE,
email_state=APPROVED
)
def it_gets_emails_from_starting_date_from_last_year(
self, db, db_session, sample_email):
emails = [
create_email(details='more details', created_at='2019-01-01'),
sample_email
]
emails_from_db = dao_get_emails_for_year_starting_on()
assert Email.query.count() == 2
assert set(emails) == set(emails_from_db)
def it_returns_future_emails(self, client, db, db_session):
event = create_event(title='Event 1')
event_2 = create_event(title='Event 2')
event_3 = create_event(title='Event 3')
past_event = create_event(title='Past event')
event_date = create_event_date(event_id=str(event.id),
event_datetime='2019-07-20 19:00')
event_date_2 = create_event_date(event_id=str(event_2.id),
event_datetime='2019-07-13 19:00')
event_date_3 = create_event_date(event_id=str(event_3.id),
event_datetime='2019-08-13 19:00')
past_event_date = create_event_date(event_id=str(past_event.id),
event_datetime='2019-06-13 19:00')
future_email = create_email(event_id=str(event.id),
created_at='2019-07-01 11:00',
send_starts_at='2019-07-10',
expires='2019-07-20')
future_email_2 = create_email(event_id=str(event_2.id),
created_at='2019-07-01 11:00',
send_starts_at='2019-07-01',
expires='2019-07-12')
future_email_3 = create_email(event_id=str(event_3.id),
created_at='2019-07-01 11:00',
send_starts_at='2019-08-01',
expires='2019-08-12')
# email below will be ignored as its in the past
create_email(event_id=str(past_event.id),
created_at='2019-06-01 11:00',
send_starts_at='2019-06-01',
expires='2019-06-12')
response = client.get(url_for('emails.get_future_emails'),
headers=[('Content-Type', 'application/json'),
create_authorization_header()])
json_future_emails = json.loads(response.get_data(as_text=True))
assert len(json_future_emails) == 3
assert json_future_emails[0] == future_email.serialize()
assert json_future_emails[1] == future_email_2.serialize()
assert json_future_emails[2] == future_email_3.serialize()
def it_gets_future_emails(self, db, db_session):
active_email = create_email(created_at='2019-07-01 11:00',
send_starts_at='2019-07-10',
expires='2019-07-20')
active_email_2 = create_email(created_at='2019-07-01 11:00',
send_starts_at='2019-07-01',
expires='2019-07-12')
active_email_3 = create_email(created_at='2019-07-01 11:00',
send_starts_at='2019-07-11',
expires='2019-07-18')
# these emails below are not active
create_email(created_at='2019-07-01 11:00',
send_starts_at='2019-07-01',
expires='2019-07-09')
emails_from_db = dao_get_future_emails()
assert len(emails_from_db) == 3
assert emails_from_db[0] == active_email
assert emails_from_db[1] == active_email_2
assert emails_from_db[2] == active_email_3
def it_only_sends_approved_emails_periodically(self, mocker, db,
db_session, sample_email,
sample_member):
mock_send_emails = mocker.patch(
'app.na_celery.email_tasks.send_emails')
create_email(send_starts_at='2019-06-07',
created_at='2019-06-01',
send_after='2019-06-07 9:00')
create_email(send_starts_at='2019-08-08',
created_at='2019-06-01',
send_after='2019-07-14 9:00')
approved_email = create_email(send_starts_at='2019-06-02',
created_at='2019-06-01',
send_after='2019-06-03 9:00',
email_state=APPROVED)
send_periodic_emails()
assert mock_send_emails.call_count == 1
assert mock_send_emails.call_args_list[0][0][0] == approved_email.id
def it_creates_a_magazine_email(self, db_session):
magazine = create_magazine()
email = create_email(magazine_id=magazine.id,
email_type=MAGAZINE,
old_id=None)
assert Email.query.count() == 1
email_from_db = Email.query.filter(Email.id == email.id).first()
assert email == email_from_db
assert email_from_db.magazine_id == magazine.id
def it_gets_emails_count_only_for_today_only(self, db, db_session):
email = create_email()
member = create_member(email='*****@*****.**', name='Test1')
created_at = datetime.now() - timedelta(days=1)
create_email_to_member(created_at=created_at,
email_id=email.id,
member_id=member.id)
email_to_member = create_email_to_member()
assert dao_get_todays_email_count_for_provider(
email_to_member.email_provider_id) == 1
def it_sends_emails_anytime(self, mocker, db_session, sample_email,
sample_member, now):
mocker.patch.dict('app.application.config', {
'ENVIRONMENT': 'test',
'EMAIL_RESTRICT': None,
'EMAIL_ANYTIME': True
})
mock_send_emails = mocker.patch(
'app.na_celery.email_tasks.send_emails')
event_date = create_event_date(event_datetime='2020-09-20 19:00')
event = create_event(event_dates=[event_date])
create_email(send_starts_at='2020-09-02',
created_at='2020-09-01',
send_after='2020-09-03 8:00',
expires=None,
email_state=APPROVED,
old_event_id=None,
event_id=event.id)
with freeze_time(now):
send_periodic_emails()
assert mock_send_emails.called
def it_uploads_a_magazine_pdf_and_reuses_email(self, app, db_session,
mocker, sample_magazine,
sample_user):
mocker.patch('app.na_celery.upload_tasks.Storage')
mocker.patch('app.na_celery.upload_tasks.base64')
mocker.patch('app.na_celery.upload_tasks.extract_topics',
return_value='Philosophy: Meaning of Life And Death')
mock_send_email = mocker.patch(
'app.na_celery.upload_tasks.send_smtp_email', return_value=200)
email = create_email(magazine_id=sample_magazine.id,
email_type=MAGAZINE)
upload_magazine(sample_magazine.id, 'pdf data')
assert mock_send_email.called
assert '<div>Please review this email: {}/emails/{}</div>'.format(
app.config['FRONTEND_ADMIN_URL'],
str(email.id)) in mock_send_email.call_args[0][2]
def it_shows_email_json_on_serialize(self, db, db_session):
email = create_email(created_at='2019-06-01T10:00:00',
send_starts_at='2019-06-02T11:00:00')
assert email.serialize() == {
'id': str(email.id),
'subject': 'workshop: test title',
'event_id': str(email.event_id),
'old_id': email.old_id,
'old_event_id': email.old_event_id,
'created_at': '2019-06-01 10:00',
'extra_txt': u'test extra text',
'details': u'test event details',
'replace_all': False,
'email_type': u'event',
'email_state': u'draft',
'send_starts_at': '2019-06-02',
'expires': '2019-06-21',
'task_id': None
}
def it_get_emails_sent_count_for_specified_month(self, db, db_session,
sample_member,
sample_email):
email = create_email(send_starts_at="2020-11-30",
send_after="2020-11-30T20:30:00",
expires="2020-12-20",
email_state=APPROVED)
member = create_member(email="*****@*****.**")
# counted
create_email_to_member(email_id=email.id,
created_at="2020-11-30T12:00:00")
# not counted
create_email_to_member(member_id=sample_member.id,
email_id=email.id,
created_at="2020-12-11T12:30:00")
create_email_to_member(member_id=member.id,
email_id=email.id,
created_at="2020-12-12T12:00:00")
count = dao_get_emails_sent_count(month=11, year=2020)
assert count == 1
def it_handles_error_from_extract_topics(self, app, db_session, mocker,
sample_magazine, sample_user):
mocker.patch('app.na_celery.upload_tasks.extract_topics',
side_effect=Exception('Unknown'))
mocker.patch('app.na_celery.upload_tasks.Storage')
mocker.patch('app.na_celery.upload_tasks.base64')
mock_logger = mocker.patch(
'app.na_celery.upload_tasks.current_app.logger.error')
mock_send_email = mocker.patch(
'app.na_celery.upload_tasks.send_smtp_email', return_value=200)
email = create_email(magazine_id=sample_magazine.id,
email_type=MAGAZINE)
upload_magazine(sample_magazine.id, 'pdf data')
assert mock_logger.called
assert 'Error extracting topics:' in mock_logger.call_args[0][0]
assert mock_send_email.called
assert '<div>Please review this email: {}/emails/{}</div>'.format(
app.config['FRONTEND_ADMIN_URL'],
str(email.id)) in mock_send_email.call_args[0][2]
def it_doesnt_create_a_magazine_email_if_no_magazine_id(self, db_session):
create_email(email_type=MAGAZINE, old_id=None)
assert Email.query.count() == 0
def it_gets_an_email_by_id(self, db, db_session, sample_email):
email = create_email(details='new event details')
fetched_email = dao_get_email_by_id(email.id)
assert fetched_email == email
