def test_svc_supported_activity_types(self):
''' check that only activities are only sent to services which support them '''
svcA, svcB = TestTools.create_mock_services()
recA = TestTools.create_mock_svc_record(svcA)
recB = TestTools.create_mock_svc_record(svcB)
svcA.SupportedActivities = [ActivityType.CrossCountrySkiing]
svcB.SupportedActivities = [ActivityType.Cycling]
actA = Activity()
actA.StartTime = datetime(1, 2, 3, 4, 5, 6, 7)
actA.ServiceDataCollection = TestTools.create_mock_servicedatacollection(
svcA, record=recA)
actA.Type = svcA.SupportedActivities[0]
actA.CalculateUID()
actA.UIDs = set([actA.UID])
actA.Record = ActivityRecord.FromActivity(actA)
actB = Activity()
actB.StartTime = datetime(5, 6, 7, 8, 9, 10, 11)
actB.ServiceDataCollection = TestTools.create_mock_servicedatacollection(
svcB, record=recB)
actB.Type = [x for x in svcB.SupportedActivities if x != actA.Type][0]
actB.CalculateUID()
actB.UIDs = set([actB.UID])
actB.Record = ActivityRecord.FromActivity(actB)
s = SynchronizationTask(None)
s._serviceConnections = [recA, recB]
s._activities = []
s._accumulateActivities(recA, [actA])
s._accumulateActivities(recB, [actB])
syncToA = s._determineRecipientServices(actA)
syncToB = s._determineRecipientServices(actB)
self.assertEqual(len(syncToA), 0)
self.assertEqual(len(syncToB), 0)
svcB.SupportedActivities = svcA.SupportedActivities
syncToA = s._determineRecipientServices(actA)
syncToB = s._determineRecipientServices(actB)
self.assertEqual(len(syncToA), 1)
self.assertEqual(len(syncToB), 0)
svcB.SupportedActivities = svcA.SupportedActivities = [
ActivityType.CrossCountrySkiing, ActivityType.Cycling
]
syncToA = s._determineRecipientServices(actA)
syncToB = s._determineRecipientServices(actB)
self.assertEqual(len(syncToA), 1)
self.assertEqual(len(syncToB), 1)
def test_eligibility_flowexception_none(self):
user = TestTools.create_mock_user()
svcA, svcB = TestTools.create_mock_services()
recA = TestTools.create_mock_svc_record(svcA)
recB = TestTools.create_mock_svc_record(svcB)
act = TestTools.create_blank_activity(svcA, record=recB)
act.Origin = recB
act.UIDs = set([act.UID])
act.Record = ActivityRecord.FromActivity(act)
User.SetFlowException(user,
recA,
recB,
flowToSource=False,
flowToTarget=False)
recipientServices = [recA]
s = SynchronizationTask(None)
s._excludedServices = {}
s.user = user
s._serviceConnections = [recA, recB]
eligible = s._determineEligibleRecipientServices(
act, recipientServices)
self.assertTrue(recA not in eligible)
self.assertTrue(recB not in eligible)
recipientServices = [recB]
act.Origin = recA
act.ServiceDataCollection = TestTools.create_mock_servicedatacollection(
svcA, record=recA)
eligible = s._determineEligibleRecipientServices(
act, recipientServices)
self.assertTrue(recA not in eligible)
self.assertTrue(recB not in eligible)
def test_eligibility_flowexception_shortcircuit(self):
user = TestTools.create_mock_user()
svcA, svcB = TestTools.create_mock_services()
svcC = TestTools.create_mock_service("mockC")
recA = TestTools.create_mock_svc_record(svcA)
recB = TestTools.create_mock_svc_record(svcB)
recC = TestTools.create_mock_svc_record(svcC)
act = TestTools.create_blank_activity(svcA, record=recA)
User.SetFlowException(user, recA, recC, flowToTarget=False)
# Behaviour with known origin and no override set
act.Origin = recA
act.UIDs = set([act.UID])
act.Record = ActivityRecord.FromActivity(act)
recipientServices = [recC, recB]
s = SynchronizationTask(None)
s._excludedServices = {}
s.user = user
s._serviceConnections = [recA, recB, recC]
eligible = s._determineEligibleRecipientServices(
act, recipientServices)
self.assertTrue(recA not in eligible)
self.assertTrue(recB in eligible)
self.assertTrue(recC not in eligible)
# Enable alternate routing
# FIXME: This setting doesn't seem to be used anywhere any more?? Test disabled at the end..
recB.SetConfiguration(
{"allow_activity_flow_exception_bypass_via_self": True},
no_save=True)
self.assertTrue(recB.GetConfiguration()
["allow_activity_flow_exception_bypass_via_self"])
# We should now be able to arrive at recC via recB
act.Origin = recA
act.UIDs = set([act.UID])
act.Record = ActivityRecord.FromActivity(act)
recipientServices = [recC, recB]
s._excludedServices = {}
s._serviceConnections = [recA, recB, recC]
eligible = s._determineEligibleRecipientServices(
act, recipientServices)
self.assertTrue(recA not in eligible)
self.assertTrue(recB in eligible)
def test_eligibility_config(self):
user = TestTools.create_mock_user()
svcA, svcB = TestTools.create_mock_services()
svcA.Configurable = True
svcA.RequiresConfiguration = lambda x: True
recA = TestTools.create_mock_svc_record(svcA)
recB = TestTools.create_mock_svc_record(svcB)
act = TestTools.create_blank_activity(svcA, record=recB)
recipientServices = [recA, recB]
s = SynchronizationTask(None)
s._excludedServices = {}
s.user = user
s._serviceConnections = recipientServices
act.UIDs = set([act.UID])
act.Record = ActivityRecord.FromActivity(act)
eligible = s._determineEligibleRecipientServices(
act, recipientServices)
self.assertTrue(recB in eligible)
self.assertTrue(recA not in eligible)
def test_eligibility_excluded(self):
user = TestTools.create_mock_user()
svcA, svcB = TestTools.create_mock_services()
recA = TestTools.create_mock_svc_record(svcA)
recB = TestTools.create_mock_svc_record(svcB)
act = TestTools.create_blank_activity(svcA, record=recB)
recipientServices = [recA, recB]
s = SynchronizationTask(None)
s._excludedServices = {
recA._id: UserException(UserExceptionType.Private)
}
s.user = user
s._serviceConnections = recipientServices
act.UIDs = set([act.UID])
act.Record = ActivityRecord.FromActivity(act)
eligible = s._determineEligibleRecipientServices(
act, recipientServices)
self.assertTrue(recB in eligible)
self.assertTrue(recA not in eligible)
