def test_filter_subscriptions_by_user_data(database):
preference = UserSubscriptionPreferences(
subscription=database.sub.key,
preference=database.prefs[0].key
)
preference.put()
user = User(
email='*****@*****.**',
subscription_preferences=[preference.key]
)
user.metadata = {"department": "a"}
user.put()
rule = Rule(name="department", value="a").put()
database.sub.rules = [rule]
database.sub.put()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.key.urlsafe()
user.metadata = {"department": "b"}
user.put()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert subscriptions == []
def test_filter_subscriptions_by_user_data_all(database):
database.sub.rule_logic = 'all'
rule1 = Rule(name="department", value="a").put()
rule2 = Rule(name="location", value="c").put()
database.sub.user_rules = [rule1, rule2]
database.sub.put()
preference = UserSubscriptionPreferences(subscription=database.sub.key,
preference=database.prefs[0].key)
preference.put()
user = User(email='*****@*****.**', subscription_preferences=[preference.key])
user.metadata = {"department": "a", "location": "b"}
user.put()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert subscriptions == []
user.metadata = {'department': 'a', 'location': 'c'}
user.put()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.key.urlsafe()
def test_remove_preferences_multiple_remove_on_opt_in(session, subscription):
preference_1 = subscription.datetime[0]
preference_2 = subscription.datetime[1]
user_pref_1 = UserSubscriptionPreferences(
preference=preference_1,
subscription=subscription,
)
user_pref_2 = UserSubscriptionPreferences(
preference=preference_2,
subscription=subscription,
)
session.add(user_pref_1)
session.add(user_pref_2)
user = User(email='*****@*****.**',
meta_data={'department': 'dept'},
subscription_preferences=[user_pref_1, user_pref_2])
session.add(user)
session.commit()
assert user.subscription_preferences == [user_pref_1, user_pref_2]
updated_preferences = {preference_1.id: False, preference_2.id: False}
removed = remove_preferences(user, updated_preferences, subscription.id)
assert removed == {user_pref_1.preference_id, user_pref_2.preference_id}
user = user = User.query.filter(User.id == user.id).one()
assert user.subscription_preferences == []
assert UserSubscriptionPreferences.query.all() == []
def test_send_batch_meeting_confirmation_email(database):
pref = UserSubscriptionPreferences(subscription=database.sub.key,
preference=database.prefs[0].key)
pref.put()
s3_url = 'https://s3-media2.fl.yelpcdn.com/assets/srv0/yelp_large_assets/'
user_a = User(email='*****@*****.**',
photo_url=s3_url +
'a315bcce34b3/assets/img/illustrations/mascots/hammy.png',
first_name='Hammy',
last_name='Yelp',
metadata={'department': 'Engineering'},
subscription_preferences=[pref.key])
user_b = User(first_name='Darwin',
last_name='Yelp',
email='*****@*****.**',
photo_url=s3_url +
'36a31704362e/assets/img/illustrations/mascots/darwin.png',
metadata={'department': 'Design'},
subscription_preferences=[pref.key])
user_c = User(first_name='Carmin',
last_name='Yelp',
email='*****@*****.**',
photo_url=s3_url +
'd71947670be7/assets/img/illustrations/mascots/carmen.png',
metadata={'department': 'Design'},
subscription_preferences=[pref.key])
user_a.put()
user_b.put()
user_c.put()
matches = [tuple((user_a, user_b, user_c, pref))]
send_batch_meeting_confirmation_email(matches, database.specs[0])
def test_get_meeting_participants(app, database):
pref = UserSubscriptionPreferences(subscription=database.sub.key,
preference=database.prefs[0].key)
pref.put()
user1 = User(email='*****@*****.**',
metadata={'department': 'dept'},
subscription_preferences=[pref.key])
user1.put()
user2 = User(email='*****@*****.**',
metadata={'department': 'dept'},
subscription_preferences=[pref.key])
user2.put()
meeting1 = Meeting(meeting_spec=database.specs[0].key,
cancelled=False).put()
MeetingParticipant(meeting=meeting1, user=user1.key).put()
MeetingParticipant(meeting=meeting1, user=user2.key).put()
with app.test_request_context('/v1/metrics/meeting_participants'):
participants = json.loads(meeting_participants())
assert participants == [{
'date': '2017-10-27T23:00:00',
'meeting': 'agx0ZXN0YmVkLXRlc3RyDQsSB01lZXRpbmcYCgw',
'meeting_title': 'Yelp Weekly',
'participant': '*****@*****.**',
'time': '04:00PM'
}, {
'date': '2017-10-27T23:00:00',
'meeting': 'agx0ZXN0YmVkLXRlc3RyDQsSB01lZXRpbmcYCgw',
'meeting_title': 'Yelp Weekly',
'participant': '*****@*****.**',
'time': '04:00PM'
}]
def get_users_from_spec(meeting_spec):
logging.info('Meeting subscription for spec:')
logging.info(meeting_spec.meeting_subscription)
logging.info('All Preferences')
logging.info(UserSubscriptionPreferences.query().fetch())
user_sub_preferences = UserSubscriptionPreferences.query(
UserSubscriptionPreferences.subscription ==
meeting_spec.meeting_subscription).fetch()
logging.info('User Preferences')
logging.info(user_sub_preferences)
users = []
for user_preference in user_sub_preferences:
if user_preference.preference:
logging.info('User Preference')
logging.info(user_preference.preference)
logging.info(user_preference.preference.get())
preference_dt = user_preference.preference.get().datetime
if preference_dt.hour == meeting_spec.datetime.hour and \
preference_dt.minute == meeting_spec.datetime.minute and \
preference_dt.weekday() == meeting_spec.datetime.weekday():
user = User.query(User.subscription_preferences ==
user_preference.key).get()
logging.info('user added: ')
logging.info(user)
users.append(user)
return users
def test_get_meeting_requests(app, database):
pref = UserSubscriptionPreferences(subscription=database.sub.key,
preference=database.prefs[0].key)
pref.put()
user = User(email='*****@*****.**',
metadata={'department': 'dept'},
subscription_preferences=[pref.key])
user.put()
MeetingRequest(user=user.key, meeting_spec=database.specs[0].key).put()
with app.test_request_context('/v1/metrics/meeting_requests'):
requests = json.loads(meeting_requests())
assert requests == [{'title': 'Yelp Weekly', 'user': '******'}]
def test_get_previous_meetings_multi_subscription(minimal_database):
pref_1 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1)).put()
subscription1 = MeetingSubscription(title='all engineering weekly', datetime=[pref_1]).put()
subscription2 = MeetingSubscription(title='all sales weekly', datetime=[pref_1]).put()
user_pref1 = UserSubscriptionPreferences(preference=pref_1, subscription=subscription1).put()
user_pref2 = UserSubscriptionPreferences(preference=pref_1, subscription=subscription2).put()
user1 = User(email='*****@*****.**', metadata={'department': 'dept'}, subscription_preferences=[user_pref1, user_pref2]).put()
user2 = User(email='*****@*****.**', metadata={'department': 'dept2'}, subscription_preferences=[user_pref1, user_pref2]).put()
meeting_spec1 = MeetingSpec(meeting_subscription=subscription1, datetime=pref_1.get().datetime).put()
meeting = Meeting(meeting_spec=meeting_spec1, cancelled=False).put()
MeetingParticipant(meeting=meeting, user=user2).put()
MeetingParticipant(meeting=meeting, user=user1).put()
assert get_previous_meetings(subscription1) == set([(user1.id(), user2.id())])
assert get_previous_meetings(subscription2) == set([])
def test_filter_subscriptions_by_user_data_none(database):
database.sub.put()
preference = UserSubscriptionPreferences(
subscription=database.sub.key,
preference=database.prefs[0].key,
)
preference.put()
user = User(email='*****@*****.**', subscription_preferences=[preference.key])
user.put()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.key.urlsafe()
def test_filter_subscriptions_by_user_data_without_rules(database):
database.sub.rule_logic = 'all'
database.sub.user_rules = []
database.sub.put()
preference = UserSubscriptionPreferences(subscription=database.sub.key,
preference=database.prefs[0].key)
preference.put()
user = User(email='*****@*****.**', subscription_preferences=[preference.key])
user.metadata = {"department": "a", "location": "b"}
user.put()
merged_preferences = merge_subscriptions_with_preferences(user)
with pytest.raises(AssertionError):
filter_subscriptions_by_user_data(merged_preferences, user)
def test_generate_group_meeting(session):
pref_1 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1))
subscription = MeetingSubscription(title='all engineering weekly', datetime=[pref_1])
user_pref = UserSubscriptionPreferences(preference=pref_1, subscription=subscription)
meeting_spec = MeetingSpec(meeting_subscription=subscription, datetime=pref_1.datetime)
session.add(pref_1)
session.add(subscription)
session.add(user_pref)
session.add(meeting_spec)
users = []
num_users = 21
for i in range(0, num_users):
user = User(email='{}@yelp.com'.format(i), meta_data={
'department': 'dept{}'.format(i)}, subscription_preferences=[user_pref])
session.add(user)
mr = MeetingRequest(user=user, meeting_spec=meeting_spec)
session.add(mr)
users.append(user)
session.commit()
matches, unmatched = generate_meetings(users, meeting_spec, prev_meeting_tuples=None, group_size=3)
assert(len(matches) == 7)
assert (len(unmatched) == 0)
matches, unmatched = generate_meetings(users, meeting_spec, prev_meeting_tuples=None, group_size=5)
assert(len(matches) == 4)
assert (len(unmatched) == 1)
def test_filter_subscriptions_by_user_data_all(database, session):
database.sub.rule_logic = 'all'
rule1 = Rule(name="department", value="a")
rule2 = Rule(name="location", value="c")
database.sub.user_rules = [rule1, rule2]
session.add(rule1)
session.add(rule2)
session.add(database.sub)
preference = UserSubscriptionPreferences(subscription=database.sub,
preference=database.prefs[0])
session.add(preference)
user = User(email='*****@*****.**', subscription_preferences=[preference])
user.meta_data = {"department": "a", "location": "b"}
session.add(user)
session.commit()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert subscriptions == []
user.meta_data = {'department': 'a', 'location': 'c'}
session.add(user)
session.commit()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.id
def test_get_user_weights(minimal_database):
pref_1 = SubscriptionDateTime(
datetime=datetime.now() -
timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1)).put()
subscription = MeetingSubscription(title='all engineering weekly',
datetime=[pref_1]).put()
user_pref = UserSubscriptionPreferences(preference=pref_1,
subscription=subscription).put()
user1 = User(email='*****@*****.**',
metadata={
'department': 'dept'
},
subscription_preferences=[user_pref]).put()
user2 = User(email='*****@*****.**',
metadata={
'department': 'dept2'
},
subscription_preferences=[user_pref]).put()
meeting_spec = MeetingSpec(meeting_subscription=subscription,
datetime=pref_1.get().datetime).put()
meeting = Meeting(meeting_spec=meeting_spec, cancelled=False).put()
MeetingParticipant(meeting=meeting, user=user2).put()
MeetingParticipant(meeting=meeting, user=user1).put()
previous_meetings_count = get_previous_meetings_counts(
[user1.get(), user2.get()], subscription)
assert (get_user_weights([user1.get(), user2.get()],
previous_meetings_count, 10, 5) == [[0, 5],
[5, 0]])
def test_get_previous_meetings_no_specs(database_no_specs):
pref_1 = SubscriptionDateTime(
datetime=datetime.now() -
timedelta(weeks=MEETING_COOLDOWN_WEEKS + 1)).put()
subscription = MeetingSubscription(title='all engineering weekly',
datetime=[pref_1]).put()
user_pref = UserSubscriptionPreferences(preference=pref_1,
subscription=subscription).put()
user1 = User(email='*****@*****.**',
metadata={
'department': 'dept'
},
subscription_preferences=[user_pref]).put()
user2 = User(email='*****@*****.**',
metadata={
'department': 'dept2'
},
subscription_preferences=[user_pref]).put()
meeting_spec = MeetingSpec(meeting_subscription=subscription,
datetime=pref_1.get().datetime).put()
meeting = Meeting(meeting_spec=meeting_spec, cancelled=False).put()
MeetingParticipant(meeting=meeting, user=user2).put()
MeetingParticipant(meeting=meeting, user=user1).put()
assert get_previous_meetings() == set([])
def test_generate_save_meetings(minimal_database, subscription):
pref_1 = SubscriptionDateTime(
datetime=datetime.now() -
timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1)).put()
subscription = MeetingSubscription(title='all engineering weekly',
datetime=[pref_1]).put()
user_pref = UserSubscriptionPreferences(preference=pref_1,
subscription=subscription).put()
user1 = User(email='*****@*****.**',
metadata={
'department': 'dept'
},
subscription_preferences=[user_pref]).put()
user2 = User(email='*****@*****.**',
metadata={
'department': 'dept2'
},
subscription_preferences=[user_pref]).put()
meeting_spec = MeetingSpec(meeting_subscription=subscription,
datetime=pref_1.get().datetime)
meeting_spec.put()
MeetingRequest(user=user1, meeting_spec=meeting_spec.key).put()
MeetingRequest(user=user2, meeting_spec=meeting_spec.key).put()
matches, unmatched = generate_meetings(
[user1.get(), user2.get()], meeting_spec)
save_meetings(matches, meeting_spec)
assert unmatched == []
participants = [
participant.user for participant in MeetingParticipant.query().fetch()
]
assert participants == [user1, user2]
def test_filter_subscriptions_by_user_data_any(database, session):
preference = UserSubscriptionPreferences(subscription=database.sub,
preference=database.prefs[0])
session.add(preference)
user = User(email='*****@*****.**', subscription_preferences=[preference])
user.meta_data = {"department": "a"}
session.add(user)
rule = Rule(name="department", value="a")
session.add(rule)
database.sub.user_rules = [rule]
database.sub.rule_logic = 'any'
session.add(database.sub)
session.commit()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.id
user.meta_data = {"department": "b"}
session.add(user)
session.commit()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert subscriptions == []
def _fake_user():
user_list = []
subscription = MeetingSubscription.query().get()
for user in FAKE_USER:
preferences = UserSubscriptionPreferences(
preference=subscription.datetime[0],
subscription=subscription.key,
).put()
user_entity = User(
first_name=user['first_name'],
last_name=user['last_name'],
email=user['email'],
photo_url=user['photo_url'],
metadata={
'department':
user['department'],
'office':
'USA: CA SF New Montgomery Office',
'company_profile_url':
'https://www.yelp.com/user_details?userid=nkN_do3fJ9xekchVC-v68A',
},
subscription_preferences=[preferences],
)
user_entity.put()
user_list.append(user_entity)
return user_list[0]
def test_filter_subscriptions_by_user_data_list(database, session):
preference = UserSubscriptionPreferences(subscription=database.sub,
preference=database.prefs[0])
session.add(preference)
user = User(email='*****@*****.**', subscription_preferences=[preference])
user.meta_data = {"role": ["pushmaster", "technical_lead"]}
session.add(user)
rule = Rule(name="role", value="pushmaster")
database.sub.user_rules = [rule]
database.sub.rule_logic = 'any'
session.add(rule)
session.add(database.sub)
session.commit()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.id
user.meta_data = {"role": "infra"}
session.add(user)
session.commit()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 0
def test_no_re_matches(session):
pref_1 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1))
subscription = MeetingSubscription(title='all engineering weekly', datetime=[pref_1])
user_pref = UserSubscriptionPreferences(preference=pref_1, subscription=subscription)
meeting_spec = MeetingSpec(meeting_subscription=subscription, datetime=pref_1.datetime)
session.add(pref_1)
session.add(subscription)
session.add(user_pref)
session.add(meeting_spec)
users = []
num_users = 20
for i in range(0, num_users):
user = User(email='{}@yelp.com'.format(i), meta_data={
'department': 'dept{}'.format(i)}, subscription_preferences=[user_pref])
session.add(user)
mr = MeetingRequest(user=user, meeting_spec=meeting_spec)
session.add(mr)
users.append(user)
session.commit()
previous_meetings = {pair for pair in itertools.combinations([user.id for user in users], 2)}
previous_meetings = previous_meetings - {(users[0].id, users[1].id)}
matches, unmatched = generate_meetings(users, meeting_spec, previous_meetings)
assert len(unmatched) == num_users - 2
assert [(match[0].id, match[1].id) for match in matches] == [(users[0].id, users[1].id)]
def test_generate_group_meetings(session):
pref_1 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1))
subscription = MeetingSubscription(title='all engineering weekly', datetime=[pref_1])
user_pref = UserSubscriptionPreferences(preference=pref_1, subscription=subscription)
user1 = User(email='*****@*****.**', meta_data={'department': 'dept'}, subscription_preferences=[user_pref])
user2 = User(email='*****@*****.**', meta_data={'department': 'dept2'}, subscription_preferences=[user_pref])
user3 = User(email='*****@*****.**', meta_data={'department': 'dept3'}, subscription_preferences=[user_pref])
meeting_spec = MeetingSpec(meeting_subscription=subscription, datetime=pref_1.datetime)
meeting = Meeting(meeting_spec=meeting_spec, cancelled=False)
mp1 = MeetingParticipant(meeting=meeting, user=user3)
mp2 = MeetingParticipant(meeting=meeting, user=user2)
mp3 = MeetingParticipant(meeting=meeting, user=user1)
session.add(pref_1)
session.add(subscription)
session.add(user_pref)
session.add(user1)
session.add(user2)
session.add(user3)
session.add(meeting_spec)
session.add(meeting)
session.add(mp1)
session.add(mp2)
session.add(mp3)
session.commit()
matched, unmatched = generate_group_meetings([user1, user2, user3], meeting_spec, 3, 10, 5)
assert {user for user in matched[0]} == {user1, user2, user3}
assert unmatched == []
def add_preferences(user, updated_preferences, subscription_id):
"""
Parameters
----------
user - db.User
preferences - {SubscriptionDateTime.id:Boolean}
subscription_id - int
Returns
-------
set(SubscriptionDateTime.id)
"""
added = set()
for datetime_id, active in updated_preferences.items():
if active:
preference = UserSubscriptionPreferences(
subscription_id=subscription_id,
preference_id=datetime_id,
)
db.session.add(preference)
user.subscription_preferences.append(preference)
db.session.add(user)
added.add(datetime_id)
db.session.commit()
return added
def test_generate_group_meetings():
pref_1 = SubscriptionDateTime(
datetime=datetime.now() -
timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1)).put()
subscription = MeetingSubscription(title='all engineering weekly',
datetime=[pref_1]).put()
user_pref = UserSubscriptionPreferences(preference=pref_1,
subscription=subscription).put()
user1 = User(email='*****@*****.**',
metadata={
'department': 'dept'
},
subscription_preferences=[user_pref]).put()
user2 = User(email='*****@*****.**',
metadata={
'department': 'dept2'
},
subscription_preferences=[user_pref]).put()
user3 = User(email='*****@*****.**',
metadata={
'department': 'dept3'
},
subscription_preferences=[user_pref]).put()
meeting_spec = MeetingSpec(meeting_subscription=subscription,
datetime=pref_1.get().datetime).put()
meeting = Meeting(meeting_spec=meeting_spec, cancelled=False).put()
MeetingParticipant(meeting=meeting, user=user3).put()
MeetingParticipant(meeting=meeting, user=user2).put()
MeetingParticipant(meeting=meeting, user=user1).put()
matched, unmatched = generate_group_meetings(
[user1.get(), user2.get(), user3.get()], meeting_spec.get(), 3, 10, 5)
assert {user.key for user in matched[0]} == {user1, user2, user3}
assert unmatched == []
def test_no_re_matches(minimal_database):
pref_1 = SubscriptionDateTime(
datetime=datetime.now() -
timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1)).put()
subscription = MeetingSubscription(title='all engineering weekly',
datetime=[pref_1]).put()
user_pref = UserSubscriptionPreferences(preference=pref_1,
subscription=subscription).put()
meeting_spec = MeetingSpec(meeting_subscription=subscription,
datetime=pref_1.get().datetime)
meeting_spec.put()
users = []
num_users = 20
for i in range(0, num_users):
user = User(email='{}@yelp.com'.format(i),
metadata={'department': 'dept{}'.format(i)},
subscription_preferences=[user_pref])
user.put()
MeetingRequest(user=user.key, meeting_spec=meeting_spec.key).put()
users.append(user)
previous_meetings = {
pair
for pair in itertools.combinations([user.key.id()
for user in users], 2)
}
previous_meetings = previous_meetings - {
(users[0].key.id(), users[1].key.id())
}
matches, unmatched = generate_meetings(users, meeting_spec,
previous_meetings)
assert len(unmatched) == num_users - 2
assert [(match[0].key.id(), match[1].key.id())
for match in matches] == [(users[0].key.id(), users[1].key.id())]
def test_get_previous_meetings(session):
pref_1 = SubscriptionDateTime(datetime=datetime.now() -
timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1))
subscription = MeetingSubscription(title='all engineering weekly',
datetime=[pref_1])
user_pref = UserSubscriptionPreferences(preference=pref_1,
subscription=subscription)
user1 = User(email='*****@*****.**',
meta_data={'department': 'dept'},
subscription_preferences=[user_pref])
user2 = User(email='*****@*****.**',
meta_data={'department': 'dept2'},
subscription_preferences=[user_pref])
meeting_spec = MeetingSpec(meeting_subscription=subscription,
datetime=pref_1.datetime)
meeting = Meeting(meeting_spec=meeting_spec, cancelled=False)
mp1 = MeetingParticipant(meeting=meeting, user=user2)
mp2 = MeetingParticipant(meeting=meeting, user=user1)
session.add(pref_1)
session.add(subscription)
session.add(user_pref)
session.add(user1)
session.add(user2)
session.add(meeting_spec)
session.add(meeting)
session.add(mp1)
session.add(mp2)
session.commit()
assert get_previous_meetings(subscription) == set([(user1.id, user2.id)])
def test_get_subscribers_null_sub_id(database, fake_user, session):
sub_pref = UserSubscriptionPreferences(user_id=fake_user.id, subscription_id=None)
session.add(sub_pref)
session.commit()
subscribed_users = get_subscribers()
assert len(subscribed_users) == 1
assert subscribed_users[database.sub.id] == ['*****@*****.**']
def test_remove_preferences_removes_on_opt_out(minimal_database, subscription):
preference = subscription.datetime[0]
user_pref = UserSubscriptionPreferences(
preference=preference,
subscription=subscription.key,
).put()
user = User(email='*****@*****.**',
metadata={'department': 'dept'},
subscription_preferences=[user_pref])
user.put()
assert user.subscription_preferences == [user_pref]
updated_preferences = {preference: False}
removed = remove_preferences(user, updated_preferences, subscription.key)
assert removed == {user_pref}
user = user.key.get()
assert user.subscription_preferences == []
assert UserSubscriptionPreferences.query().fetch() == []
def test_weekly_opt_in(minimal_database, subscription):
preference = subscription.datetime[0]
user_pref = UserSubscriptionPreferences(
preference=preference,
subscription=subscription.key,
).put()
user1 = User(email="*****@*****.**", metadata={'department': 'dept'}, subscription_preferences=[user_pref])
user1.put()
response = weekly_opt_in()
assert response == 'OK'
def test_previous_meeting_penalty(minimal_database):
pref_1 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 1)).put()
pref_2 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 2)).put()
pref_3 = SubscriptionDateTime(datetime=datetime.now() - timedelta(weeks=MEETING_COOLDOWN_WEEKS - 3)).put()
subscription = MeetingSubscription(title='all engineering weekly', datetime=[pref_1, pref_2, pref_3]).put()
user_pref1 = UserSubscriptionPreferences(preference=pref_1, subscription=subscription).put()
user_pref2 = UserSubscriptionPreferences(preference=pref_2, subscription=subscription).put()
user_pref3 = UserSubscriptionPreferences(preference=pref_3, subscription=subscription).put()
meeting_spec1 = MeetingSpec(meeting_subscription=subscription, datetime=pref_1.get().datetime)
meeting_spec1.put()
meeting_spec2 = MeetingSpec(meeting_subscription=subscription, datetime=pref_2.get().datetime)
meeting_spec2.put()
meeting_spec3 = MeetingSpec(meeting_subscription=subscription, datetime=pref_3.get().datetime)
meeting_spec3.put()
users = []
num_users = 20
for i in range(0, num_users):
user = User(email='{}@yelp.com'.format(i), metadata={
'department': 'dept{}'.format(i)}, subscription_preferences=[user_pref1, user_pref2, user_pref3])
user.put()
MeetingRequest(user=user.key, meeting_spec=meeting_spec1.key).put()
MeetingRequest(user=user.key, meeting_spec=meeting_spec2.key).put()
MeetingRequest(user=user.key, meeting_spec=meeting_spec3.key).put()
users.append(user)
meeting1 = Meeting(meeting_spec=meeting_spec1.key, cancelled=False).put()
MeetingParticipant(meeting=meeting1, user=users[1].key).put()
MeetingParticipant(meeting=meeting1, user=users[0].key).put()
meeting2 = Meeting(meeting_spec=meeting_spec2.key, cancelled=False).put()
MeetingParticipant(meeting=meeting2, user=users[1].key).put()
MeetingParticipant(meeting=meeting2, user=users[0].key).put()
meeting3 = Meeting(meeting_spec=meeting_spec3.key, cancelled=False).put()
MeetingParticipant(meeting=meeting3, user=users[1].key).put()
MeetingParticipant(meeting=meeting3, user=users[0].key).put()
for run in range(10):
matches, unmatched = generate_meetings(users, meeting_spec1, prev_meeting_tuples=None, group_size=3)
assert(len(matches) == 6)
assert (len(unmatched) == 2)
for matched_group in matches:
assert(not (users[0] in matched_group and users[1] in matched_group))
def test_is_valid_user_subscription_preference_valid(subscription):
preference = subscription.datetime[0]
user = User(email='*****@*****.**', meta_data={'department': 'dept'})
user_sub = UserSubscriptionPreferences(preference=preference,
subscription_id=subscription.id,
user=user)
subscription.user_rules = [Rule(name='department', value='dept')]
subscription.rule_logic = 'all'
result = is_valid_user_subscription_preference(user_sub, subscription)
assert result
def test_filter_subscriptions_by_user_data_none_when_rules_exist(database):
rule = Rule(name="department", value="b").put()
database.sub.user_rules = [rule]
database.sub.rule_logic = 'none'
database.sub.put()
preference = UserSubscriptionPreferences(
subscription=database.sub.key,
preference=database.prefs[0].key,
)
preference.put()
user = User(email='*****@*****.**',
subscription_preferences=[preference.key],
metadata={'department': 'a'})
user.put()
merged_preferences = merge_subscriptions_with_preferences(user)
subscriptions = filter_subscriptions_by_user_data(merged_preferences, user)
assert len(subscriptions) == 1
assert subscriptions[0]['id'] == database.sub.key.urlsafe()
