def setManager(self, manager):
# Set up the first schedule.
schedule1 = Schedule()
interval11 = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150827T000000"), 5, 10, 2,
RepetitiveInterval.RepeatUnit.DAY)
interval12 = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150827T000000"), 6, 8, 1,
RepetitiveInterval.RepeatUnit.DAY)
interval13 = RepetitiveInterval(
Schedule.fromIsoString("20150827T000000"),
Schedule.fromIsoString("20150827T000000"), 7, 8)
schedule1.addWhiteInterval(interval11)
schedule1.addWhiteInterval(interval12)
schedule1.addBlackInterval(interval13)
# Set up the second schedule.
schedule2 = Schedule()
interval21 = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150827T000000"), 9, 12, 1,
RepetitiveInterval.RepeatUnit.DAY)
interval22 = RepetitiveInterval(
Schedule.fromIsoString("20150827T000000"),
Schedule.fromIsoString("20150827T000000"), 6, 8)
interval23 = RepetitiveInterval(
Schedule.fromIsoString("20150827T000000"),
Schedule.fromIsoString("20150827T000000"), 2, 4)
schedule2.addWhiteInterval(interval21)
schedule2.addWhiteInterval(interval22)
schedule2.addBlackInterval(interval23)
# Add them to the group manager database.
manager.addSchedule("schedule1", schedule1)
manager.addSchedule("schedule2", schedule2)
# Make some adaptions to certificate.
dataBlob = self.certificate.wireEncode()
memberA = Data()
memberA.wireDecode(dataBlob, TlvWireFormat.get())
memberA.setName(Name("/ndn/memberA/KEY/ksk-123/ID-CERT/123"))
memberB = Data()
memberB.wireDecode(dataBlob, TlvWireFormat.get())
memberB.setName(Name("/ndn/memberB/KEY/ksk-123/ID-CERT/123"))
memberC = Data()
memberC.wireDecode(dataBlob, TlvWireFormat.get())
memberC.setName(Name("/ndn/memberC/KEY/ksk-123/ID-CERT/123"))
# Add the members to the database.
manager.addMember("schedule1", memberA)
manager.addMember("schedule1", memberB)
manager.addMember("schedule2", memberC)
def test_cover_time_point(self):
################################ With the repeat unit DAY.
repetitiveInterval1 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20150925T000000"),
5, 10, 2, RepetitiveInterval.RepeatUnit.DAY)
timePoint1 = fromIsoString("20150825T050000")
result = repetitiveInterval1.getInterval(timePoint1)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150825T100000")
timePoint2 = fromIsoString("20150902T060000")
result = repetitiveInterval1.getInterval(timePoint2)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150902T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150902T100000")
timePoint3 = fromIsoString("20150929T040000")
result = repetitiveInterval1.getInterval(timePoint3)
self.assertEqual(result.isPositive, False)
################################ With the repeat unit MONTH.
repetitiveInterval2 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20160825T000000"),
5, 10, 2, RepetitiveInterval.RepeatUnit.MONTH)
timePoint4 = fromIsoString("20150825T050000")
result = repetitiveInterval2.getInterval(timePoint4)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150825T100000")
timePoint5 = fromIsoString("20151025T060000")
result = repetitiveInterval2.getInterval(timePoint5)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20151025T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20151025T100000")
timePoint6 = fromIsoString("20151226T050000")
result = repetitiveInterval2.getInterval(timePoint6)
self.assertEqual(result.isPositive, False)
timePoint7 = fromIsoString("20151225T040000")
result = repetitiveInterval2.getInterval(timePoint7)
self.assertEqual(result.isPositive, False)
################################ With the repeat unit YEAR.
repetitiveInterval3 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20300825T000000"),
5, 10, 3, RepetitiveInterval.RepeatUnit.YEAR)
timePoint8 = fromIsoString("20150825T050000")
result = repetitiveInterval3.getInterval(timePoint8)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150825T100000")
timePoint9 = fromIsoString("20180825T060000")
result = repetitiveInterval3.getInterval(timePoint9)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20180825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20180825T100000")
timePoint10 = fromIsoString("20180826T050000")
result = repetitiveInterval3.getInterval(timePoint10)
self.assertEqual(result.isPositive, False)
timePoint11 = fromIsoString("20210825T040000")
result = repetitiveInterval3.getInterval(timePoint11)
self.assertEqual(result.isPositive, False)
timePoint12 = fromIsoString("20300825T040000")
result = repetitiveInterval3.getInterval(timePoint12)
self.assertEqual(result.isPositive, False)
def test_construction(self):
repetitiveInterval1 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20150825T000000"),
5, 10)
self.assertEqual(toIsoString(repetitiveInterval1.getStartDate()),
"20150825T000000")
self.assertEqual(toIsoString(repetitiveInterval1.getEndDate()),
"20150825T000000")
self.assertEqual(repetitiveInterval1.getIntervalStartHour(), 5)
self.assertEqual(repetitiveInterval1.getIntervalEndHour(), 10)
repetitiveInterval2 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20150827T000000"),
5, 10, 1, RepetitiveInterval.RepeatUnit.DAY)
self.assertEqual(repetitiveInterval2.getNRepeats(), 1)
self.assertEqual(repetitiveInterval2.getRepeatUnit(),
RepetitiveInterval.RepeatUnit.DAY)
repetitiveInterval3 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20151227T000000"),
5, 10, 2, RepetitiveInterval.RepeatUnit.MONTH)
self.assertEqual(repetitiveInterval3.getNRepeats(), 2)
self.assertEqual(repetitiveInterval3.getRepeatUnit(),
RepetitiveInterval.RepeatUnit.MONTH)
repetitiveInterval4 = RepetitiveInterval(
fromIsoString("20150825T000000"), fromIsoString("20301227T000000"),
5, 10, 5, RepetitiveInterval.RepeatUnit.YEAR)
self.assertEqual(repetitiveInterval4.getNRepeats(), 5)
self.assertEqual(repetitiveInterval4.getRepeatUnit(),
RepetitiveInterval.RepeatUnit.YEAR)
repetitiveInterval5 = RepetitiveInterval()
self.assertEqual(repetitiveInterval5.getNRepeats(), 0)
self.assertEqual(repetitiveInterval5.getRepeatUnit(),
RepetitiveInterval.RepeatUnit.NONE)
def test_calculate_interval_without_black(self):
schedule = Schedule()
interval1 = RepetitiveInterval(fromIsoString("20150825T000000"),
fromIsoString("20150827T000000"), 5, 10,
2, RepetitiveInterval.RepeatUnit.DAY)
interval2 = RepetitiveInterval(fromIsoString("20150825T000000"),
fromIsoString("20150827T000000"), 6, 8,
1, RepetitiveInterval.RepeatUnit.DAY)
interval3 = RepetitiveInterval(fromIsoString("20150825T000000"),
fromIsoString("20150825T000000"), 4, 7)
schedule.addWhiteInterval(interval1)
schedule.addWhiteInterval(interval2)
schedule.addWhiteInterval(interval3)
# timePoint1 --> positive 8.25 4-10
timePoint1 = fromIsoString("20150825T063000")
result = schedule.getCoveringInterval(timePoint1)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150825T040000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150825T100000")
# timePoint2 --> positive 8.26 6-8
timePoint2 = fromIsoString("20150826T073000")
result = schedule.getCoveringInterval(timePoint2)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150826T060000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150826T080000")
# timePoint3 --> positive 8.27 5-10
timePoint3 = fromIsoString("20150827T053000")
result = schedule.getCoveringInterval(timePoint3)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150827T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150827T100000")
# timePoint4 --> negative 8.25 10-24
timePoint4 = fromIsoString("20150825T113000")
result = schedule.getCoveringInterval(timePoint4)
self.assertEqual(result.isPositive, False)
self.assertEqual(result.interval.isEmpty(), False)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150825T100000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150826T000000")
# timePoint5 --> negative 8.25 0-4
timePoint5 = fromIsoString("20150825T013000")
result = schedule.getCoveringInterval(timePoint5)
self.assertEqual(result.isPositive, False)
self.assertEqual(result.interval.isEmpty(), False)
self.assertEqual(toIsoString(result.interval.getStartTime()),
"20150825T000000")
self.assertEqual(toIsoString(result.interval.getEndTime()),
"20150825T040000")
def test_database_functions(self):
scheduleBlob = Blob(SCHEDULE, False)
# Create a schedule.
schedule = Schedule()
schedule.wireDecode(scheduleBlob)
# Create a member.
params = RsaKeyParams()
decryptKey = RsaAlgorithm.generateKey(params)
encryptKey = RsaAlgorithm.deriveEncryptKey(decryptKey.getKeyBits())
keyBlob = encryptKey.getKeyBits()
name1 = Name("/ndn/BoyA/ksk-123")
name2 = Name("/ndn/BoyB/ksk-1233")
name3 = Name("/ndn/GirlC/ksk-123")
name4 = Name("/ndn/GirlD/ksk-123")
name5 = Name("/ndn/Hello/ksk-123")
# Add schedules into the database.
self.database.addSchedule("work-time", schedule)
self.database.addSchedule("rest-time", schedule)
self.database.addSchedule("play-time", schedule)
self.database.addSchedule("boelter-time", schedule)
# Throw an exception when adding a schedule with an existing name.
with self.assertRaises(GroupManagerDb.Error):
self.database.addSchedule("boelter-time", schedule)
# Add members into the database.
self.database.addMember("work-time", name1, keyBlob)
self.database.addMember("rest-time", name2, keyBlob)
self.database.addMember("play-time", name3, keyBlob)
self.database.addMember("play-time", name4, keyBlob)
# Throw an exception when adding a member with a non-existing schedule name.
with self.assertRaises(GroupManagerDb.Error):
self.database.addMember("false-time", name5, keyBlob)
self.database.addMember("boelter-time", name5, keyBlob)
# Throw an exception when adding a member having an existing identity.
with self.assertRaises(GroupManagerDb.Error):
self.database.addMember("work-time", name5, keyBlob)
# Test has functions.
self.assertEqual(True, self.database.hasSchedule("work-time"))
self.assertEqual(True, self.database.hasSchedule("rest-time"))
self.assertEqual(True, self.database.hasSchedule("play-time"))
self.assertEqual(False, self.database.hasSchedule("sleep-time"))
self.assertEqual(False, self.database.hasSchedule(""))
self.assertEqual(True, self.database.hasMember(Name("/ndn/BoyA")))
self.assertEqual(True, self.database.hasMember(Name("/ndn/BoyB")))
self.assertEqual(False, self.database.hasMember(Name("/ndn/BoyC")))
# Get a schedule.
scheduleResult = self.database.getSchedule("work-time")
self.assertTrue(scheduleResult.wireEncode().equals(scheduleBlob))
scheduleResult = self.database.getSchedule("play-time")
self.assertTrue(scheduleResult.wireEncode().equals(scheduleBlob))
# Throw an exception when when there is no such schedule in the database.
with self.assertRaises(GroupManagerDb.Error):
self.database.getSchedule("work-time-11")
# List all schedule names.
names = self.database.listAllScheduleNames()
self.assertTrue("work-time" in names)
self.assertTrue("play-time" in names)
self.assertTrue("rest-time" in names)
self.assertTrue(not ("sleep-time" in names))
# List members of a schedule.
memberMap = self.database.getScheduleMembers("play-time")
self.assertTrue(len(memberMap) != 0)
# When there's no such schedule, the return map's size should be 0.
self.assertEquals(0, len(self.database.getScheduleMembers("sleep-time")))
# List all members.
members = self.database.listAllMembers()
self.assertTrue(Name("/ndn/GirlC") in members)
self.assertTrue(Name("/ndn/GirlD") in members)
self.assertTrue(Name("/ndn/BoyA") in members)
self.assertTrue(Name("/ndn/BoyB") in members)
# Rename a schedule.
self.assertEqual(True, self.database.hasSchedule("boelter-time"))
self.database.renameSchedule("boelter-time", "rieber-time")
self.assertEqual(False, self.database.hasSchedule("boelter-time"))
self.assertEqual(True, self.database.hasSchedule("rieber-time"))
self.assertEqual("rieber-time", self.database.getMemberSchedule(Name("/ndn/Hello")))
# Update a schedule.
newSchedule = Schedule()
newSchedule.wireDecode(scheduleBlob)
repetitiveInterval = RepetitiveInterval(
Schedule.fromIsoString("20150825T000000"),
Schedule.fromIsoString("20150921T000000"), 2, 10,
5, RepetitiveInterval.RepeatUnit.DAY)
newSchedule.addWhiteInterval(repetitiveInterval)
self.database.updateSchedule("rieber-time", newSchedule)
scheduleResult = self.database.getSchedule("rieber-time")
self.assertTrue(not scheduleResult.wireEncode().equals(scheduleBlob))
self.assertTrue(scheduleResult.wireEncode().equals(newSchedule.wireEncode()))
# Add a new schedule when updating a non-existing schedule.
self.assertEquals(False, self.database.hasSchedule("ralphs-time"))
self.database.updateSchedule("ralphs-time", newSchedule)
self.assertEquals(True, self.database.hasSchedule("ralphs-time"))
# Update the schedule of a member.
self.database.updateMemberSchedule(Name("/ndn/Hello"), "play-time")
self.assertEqual("play-time", self.database.getMemberSchedule(Name("/ndn/Hello")))
# Delete a member.
self.assertEqual(True, self.database.hasMember(Name("/ndn/Hello")))
self.database.deleteMember(Name("/ndn/Hello"))
self.assertEqual(False, self.database.hasMember(Name("/ndn/Hello")))
# Delete a non-existing member.
try:
self.database.deleteMember(Name("/ndn/notExisting"))
except Exception as ex:
self.fail("Unexpected error deleting a non-existing member: " + repr(ex))
# Delete a schedule. All the members using this schedule should be deleted.
self.database.deleteSchedule("play-time")
self.assertEqual(False, self.database.hasSchedule("play-time"))
self.assertEqual(False, self.database.hasMember(Name("/ndn/GirlC")))
self.assertEqual(False, self.database.hasMember(Name("/ndn/GirlD")))
# Delete a non-existing schedule.
try:
self.database.deleteSchedule("not-existing-time")
except Exception as ex:
self.fail("Unexpected error deleting a non-existing schedule: " + repr(ex))
def test_cover_time_point(self):
################################ With the repeat unit DAY.
repetitiveInterval1 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20150925T000000"), 5, 10, 2,
RepetitiveInterval.RepeatUnit.DAY)
timePoint1 = fromIsoString("20150825T050000")
result = repetitiveInterval1.getInterval(timePoint1)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()), "20150825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()), "20150825T100000")
timePoint2 = fromIsoString("20150902T060000")
result = repetitiveInterval1.getInterval(timePoint2)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()), "20150902T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()), "20150902T100000")
timePoint3 = fromIsoString("20150929T040000")
result = repetitiveInterval1.getInterval(timePoint3)
self.assertEqual(result.isPositive, False)
################################ With the repeat unit MONTH.
repetitiveInterval2 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20160825T000000"), 5, 10, 2,
RepetitiveInterval.RepeatUnit.MONTH)
timePoint4 = fromIsoString("20150825T050000")
result = repetitiveInterval2.getInterval(timePoint4)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()), "20150825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()), "20150825T100000")
timePoint5 = fromIsoString("20151025T060000")
result = repetitiveInterval2.getInterval(timePoint5)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()), "20151025T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()), "20151025T100000")
timePoint6 = fromIsoString("20151226T050000")
result = repetitiveInterval2.getInterval(timePoint6)
self.assertEqual(result.isPositive, False)
timePoint7 = fromIsoString("20151225T040000")
result = repetitiveInterval2.getInterval(timePoint7)
self.assertEqual(result.isPositive, False)
################################ With the repeat unit YEAR.
repetitiveInterval3 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20300825T000000"), 5, 10, 3,
RepetitiveInterval.RepeatUnit.YEAR)
timePoint8 = fromIsoString("20150825T050000")
result = repetitiveInterval3.getInterval(timePoint8)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()), "20150825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()), "20150825T100000")
timePoint9 = fromIsoString("20180825T060000")
result = repetitiveInterval3.getInterval(timePoint9)
self.assertEqual(result.isPositive, True)
self.assertEqual(toIsoString(result.interval.getStartTime()), "20180825T050000")
self.assertEqual(toIsoString(result.interval.getEndTime()), "20180825T100000")
timePoint10 = fromIsoString("20180826T050000")
result = repetitiveInterval3.getInterval(timePoint10)
self.assertEqual(result.isPositive, False)
timePoint11 = fromIsoString("20210825T040000")
result = repetitiveInterval3.getInterval(timePoint11)
self.assertEqual(result.isPositive, False)
timePoint12 = fromIsoString("20300825T040000")
result = repetitiveInterval3.getInterval(timePoint12)
self.assertEqual(result.isPositive, False)
def test_construction(self):
repetitiveInterval1 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20150825T000000"), 5, 10)
self.assertEqual(toIsoString(repetitiveInterval1.getStartDate()), "20150825T000000")
self.assertEqual(toIsoString(repetitiveInterval1.getEndDate()), "20150825T000000")
self.assertEqual(repetitiveInterval1.getIntervalStartHour(), 5)
self.assertEqual(repetitiveInterval1.getIntervalEndHour(), 10)
repetitiveInterval2 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20150827T000000"), 5, 10, 1,
RepetitiveInterval.RepeatUnit.DAY)
self.assertEqual(repetitiveInterval2.getNRepeats(), 1)
self.assertEqual(
repetitiveInterval2.getRepeatUnit(), RepetitiveInterval.RepeatUnit.DAY)
repetitiveInterval3 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20151227T000000"), 5, 10, 2,
RepetitiveInterval.RepeatUnit.MONTH)
self.assertEqual(repetitiveInterval3.getNRepeats(), 2)
self.assertEqual(
repetitiveInterval3.getRepeatUnit(), RepetitiveInterval.RepeatUnit.MONTH)
repetitiveInterval4 = RepetitiveInterval(
fromIsoString("20150825T000000"),
fromIsoString("20301227T000000"), 5, 10, 5,
RepetitiveInterval.RepeatUnit.YEAR)
self.assertEqual(repetitiveInterval4.getNRepeats(), 5)
self.assertEqual(
repetitiveInterval4.getRepeatUnit(), RepetitiveInterval.RepeatUnit.YEAR)
repetitiveInterval5 = RepetitiveInterval()
self.assertEqual(repetitiveInterval5.getNRepeats(), 0)
self.assertEqual(
repetitiveInterval5.getRepeatUnit(), RepetitiveInterval.RepeatUnit.NONE)
