def it_creates_an_event_date_with_speaker(self, db, db_session,
sample_speaker):
create_event_date(speakers=[sample_speaker])
assert EventDate.query.count() == 1
event_date_from_db = EventDate.query.first()
assert event_date_from_db.speakers[0] == sample_speaker
def it_gets_events_in_year(self, db, db_session, sample_event_with_dates,
sample_event_type):
event_2 = create_event(
title='2018 event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2018-12-31T23:59:00')
])
create_event(
title='2017 event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2017-12-31T23:59:59')
])
create_event(
title='2019 event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2019-01-01T00:00:01')
])
events_from_db = dao_get_events_in_year(2018)
assert len(events_from_db) == 2
assert events_from_db[0] == sample_event_with_dates
assert events_from_db[1] == event_2
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_gets_event_dates_by_event_id(self, db_session, sample_event_date, sample_event_type):
event = create_event(event_type_id=sample_event_type.id)
create_event_date(event_id=event.id)
assert len(EventDate.query.all()) == 2
event_dates = dao_get_event_dates_by_event_id(sample_event_date.event_id)
assert len(event_dates) == 1
def it_gets_all_event_dates(self, db_session, sample_event_date):
create_event_date(event_datetime='2018-03-19 19:30', event_id=sample_event_date.event_id)
event_dates = dao_get_event_dates()
event_dates_json = [e.serialize() for e in event_dates]
assert EventDate.query.count() == 2
event_dates_from_db = EventDate.query.all()
event_dates_from_db_json = [e.serialize() for e in event_dates_from_db]
assert sorted([e.values() for e in event_dates_json]) == \
sorted([e.values() for e in event_dates_from_db_json])
def it_deletes_an_event_date_with_speaker(self, db, db_session,
sample_speaker):
event_date = create_event_date(speakers=[sample_speaker])
assert EventDate.query.count() == 1
dao_delete_event_date(event_date.id)
def sample_event_with_dates(db, sample_event_date_without_event):
another_event_date = create_event_date(event_datetime='2018-01-02 19:00')
return create_event(
title='test_title',
description='test description',
event_dates=[sample_event_date_without_event, another_event_date]
)
def it_deletes_an_event_date(self, db, db_session):
event_date = create_event_date()
assert EventDate.query.count() == 1
dao_delete_event_date(event_date.id)
assert EventDate.query.count() == 0
def it_creates_an_event_with_event_dates(self, db, db_session):
event_date = create_event_date()
event = create_event(event_dates=[event_date])
assert Event.query.count() == 1
event_from_db = Event.query.first()
assert event == event_from_db
assert event_from_db.event_dates[0] == event_date
def it_deletes_an_event_with_event_dates(self, db, db_session):
event_date = create_event_date()
event = create_event(event_dates=[event_date])
assert Event.query.count() == 1
dao_delete_event(event.id)
assert Event.query.count() == 0
def it_gets_past_year_events(self, db, db_session, sample_event_with_dates,
sample_event_type):
create_event(
title='way past last year event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2016-01-01T19:00:00')
])
create_event(
title='future event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2018-01-20T19:00:00')
])
events_from_db = dao_get_past_year_events()
assert Event.query.count() == 3
assert len(events_from_db) == 1
assert events_from_db[0] == sample_event_with_dates
def it_gets_limited_events(self, db, db_session, sample_event_with_dates,
sample_event_type):
event_2 = create_event(
title='2018 event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2018-12-31T23:59:00')
])
create_event(
title='beyond limit',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2017-12-31T23:59:59')
])
events_from_db = dao_get_limited_events(2)
assert len(events_from_db) == 2
assert events_from_db[0] == event_2
assert events_from_db[1] == sample_event_with_dates
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_updates_an_event_dao_with_new_event_date(self, db, db_session,
sample_event):
speaker = create_speaker(name='John Brown')
event_date = create_event_date(event_datetime='2018-01-20T19:00:00',
speakers=[speaker])
dao_update_event(sample_event.id, event_dates=[event_date])
event_from_db = Event.query.filter(Event.id == sample_event.id).first()
assert sample_event.event_dates[0] == event_from_db.event_dates[0]
event_date2 = create_event_date(event_datetime='2018-02-20T19:00:00',
speakers=[speaker])
dao_update_event(sample_event.id, event_dates=[event_date2])
event_dates = EventDate.query.all()
assert len(event_dates) == 1
def it_gets_all_future_events(self, db, db_session,
sample_event_with_dates, sample_event_type):
event = create_event(
title='future event',
event_type_id=sample_event_type.id,
event_dates=[
create_event_date(event_datetime='2018-01-20T19:00:00')
])
events_from_db = dao_get_future_events()
assert Event.query.count() == 2
assert len(events_from_db) == 1
assert events_from_db[0] == event
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_doesnt_update_duplicate_event_date(self, client, db_session,
sample_event_date):
event_date_1 = create_event_date(event_id=sample_event_date.event_id)
data = {
'event_datetime':
sample_event_date.event_datetime.strftime('%Y-%m-%d %H:%M')
}
response = client.post(url_for('event_date.update_event_date',
event_date_id=event_date_1.id),
data=json.dumps(data),
headers=[('Content-Type', 'application/json'),
create_authorization_header()])
assert response.status_code == 400
json_resp = json.loads(response.get_data(as_text=True))
assert json_resp['message'] == '{} already exists for {}'.format(
data['event_datetime'], sample_event_date.event_id)
def it_updates_an_event_dao_with_new_speaker(self, db, db_session):
speaker = create_speaker(name='John Brown')
event_date = create_event_date(event_datetime='2018-01-20T19:00:00',
speakers=[speaker])
event = create_event(event_dates=[event_date])
speaker2 = create_speaker(name='Jim Blue')
db_event_date = dao_get_event_date_by_id(event_date.id)
db_event_date.speakers = [speaker, speaker2]
dao_update_event(event.id, event_dates=[db_event_date])
event_from_db = Event.query.filter(Event.id == event.id).first()
assert event.event_dates[0] == event_from_db.event_dates[0]
event_dates = EventDate.query.all()
assert len(event_dates) == 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 sample_event_date_without_event(db):
return create_event_date()
def sample_event_date(db, sample_event):
return create_event_date(event_id=sample_event.id)
def it_creates_an_event_date(self, db, db_session):
event_date = create_event_date()
assert EventDate.query.count() == 1
event_date_from_db = EventDate.query.first()
assert event_date == event_date_from_db
