class TestBasicManagement(unittest.TestCase):
"""Tests the basic conference management functions
"""
def setUp( self ):
self._creator=Avatar()
self._creator.setId("creator")
self._conf=Conference(self._creator)
self._conf.setTimezone('UTC')
confTZ = self._conf.getTimezone()
sd = timezone(confTZ).localize(datetime(2000, 1, 1))
sdUTC = sd.astimezone(timezone('UTC'))
ed = timezone(confTZ).localize(datetime(2020, 1, 1))
edUTC = ed.astimezone(timezone('UTC'))
self._conf.setDates(sdUTC,edUTC)
def testAddRemoveSessions(self):
s1,s2=Session(),Session()
self._conf.addSession(s1)
self._conf.addSession(s2)
self.assert_(s1 in self._conf.getSessionList())
self.assert_(s1==self._conf.getSessionById(s1.getId()))
self.assert_(s2 in self._conf.getSessionList())
self.assert_(s2==self._conf.getSessionById(s2.getId()))
self._conf.removeSession(s1)
self.assert_(s1 not in self._conf.getSessionList())
self.assert_(None==self._conf.getSessionById(s1.getId()))
self.assert_(s2 in self._conf.getSessionList())
self.assert_(s2==self._conf.getSessionById(s2.getId()))
c1,c2,c3=Contribution(),Contribution(),Contribution()
self._conf.addSession(s1)
s1.addContribution(c1)
s1.addContribution(c2)
s2.addContribution(c3)
self.assert_(s1 in self._conf.getSessionList())
self.assert_(s1==self._conf.getSessionById(s1.getId()))
self.assert_(s2 in self._conf.getSessionList())
self.assert_(s2==self._conf.getSessionById(s2.getId()))
self.assert_(c1 in self._conf.getContributionList())
self.assert_(c2 in self._conf.getContributionList())
self.assert_(c3 in self._conf.getContributionList())
self.assert_(c1 in s1.getContributionList())
self.assert_(c2 in s1.getContributionList())
self.assert_(c3 in s2.getContributionList())
self._conf.removeSession(s1)
self.assert_(s1 not in self._conf.getSessionList())
self.assert_(s2 in self._conf.getSessionList())
self.assert_(c1 in self._conf.getContributionList())
self.assert_(c2 in self._conf.getContributionList())
self.assert_(c3 in self._conf.getContributionList())
self.assert_(c1 not in s1.getContributionList())
self.assert_(c1.getSession()==None)
self.assert_(c2.getSession()==None)
self.assert_(c2 not in s1.getContributionList())
self.assert_(c3 in s2.getContributionList())
class TestBasicManagement(unittest.TestCase):
"""Tests the basic conference management functions
"""
def setUp(self):
self._creator = Avatar()
self._creator.setId("creator")
self._conf = Conference(self._creator)
self._conf.setTimezone('UTC')
confTZ = self._conf.getTimezone()
sd = timezone(confTZ).localize(datetime(2000, 1, 1))
sdUTC = sd.astimezone(timezone('UTC'))
ed = timezone(confTZ).localize(datetime(2020, 1, 1))
edUTC = ed.astimezone(timezone('UTC'))
self._conf.setDates(sdUTC, edUTC)
def testAddRemoveSessions(self):
s1, s2 = Session(), Session()
self._conf.addSession(s1)
self._conf.addSession(s2)
self.assert_(s1 in self._conf.getSessionList())
self.assert_(s1 == self._conf.getSessionById(s1.getId()))
self.assert_(s2 in self._conf.getSessionList())
self.assert_(s2 == self._conf.getSessionById(s2.getId()))
self._conf.removeSession(s1)
self.assert_(s1 not in self._conf.getSessionList())
self.assert_(None == self._conf.getSessionById(s1.getId()))
self.assert_(s2 in self._conf.getSessionList())
self.assert_(s2 == self._conf.getSessionById(s2.getId()))
c1, c2, c3 = Contribution(), Contribution(), Contribution()
self._conf.addSession(s1)
s1.addContribution(c1)
s1.addContribution(c2)
s2.addContribution(c3)
self.assert_(s1 in self._conf.getSessionList())
self.assert_(s1 == self._conf.getSessionById(s1.getId()))
self.assert_(s2 in self._conf.getSessionList())
self.assert_(s2 == self._conf.getSessionById(s2.getId()))
self.assert_(c1 in self._conf.getContributionList())
self.assert_(c2 in self._conf.getContributionList())
self.assert_(c3 in self._conf.getContributionList())
self.assert_(c1 in s1.getContributionList())
self.assert_(c2 in s1.getContributionList())
self.assert_(c3 in s2.getContributionList())
self._conf.removeSession(s1)
self.assert_(s1 not in self._conf.getSessionList())
self.assert_(s2 in self._conf.getSessionList())
self.assert_(c1 in self._conf.getContributionList())
self.assert_(c2 in self._conf.getContributionList())
self.assert_(c3 in self._conf.getContributionList())
self.assert_(c1 not in s1.getContributionList())
self.assert_(c1.getSession() == None)
self.assert_(c2.getSession() == None)
self.assert_(c2 not in s1.getContributionList())
self.assert_(c3 in s2.getContributionList())
class TestContributionSubmitterIndex(unittest.TestCase):
"""
"""
def setUp( self ):
self._creator = Avatar()
self._creator.setId("creator")
self._categ = Category()
self._conf=Conference(self._creator)
self._conf.setId('a')
self._conf.setTimezone('UTC')
self._categ._addConference(self._conf)
def testBasic(self):
c1,c2=Contribution(),Contribution()
av1,av2=Avatar(),Avatar()
av1.setId("1")
av2.setId("2")
self.assert_(len(self._conf.getContribsForSubmitter(av1))==0)
self.assert_(len(self._conf.getContribsForSubmitter(av2))==0)
self._conf.addContribution(c1)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==0)
self.assert_(len(self._conf.getContribsForSubmitter(av2))==0)
c1.grantSubmission(av1)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2))==0)
c2.grantSubmission(av2)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2))==0)
self._conf.addContribution(c2)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2))==1)
self.assert_(c2 in self._conf.getContribsForSubmitter(av2))
c1.grantSubmission(av2)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2))==2)
self.assert_(c1 in self._conf.getContribsForSubmitter(av2))
self.assert_(c2 in self._conf.getContribsForSubmitter(av2))
c1.revokeSubmission(av2)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2))==1)
self.assert_(c1 not in self._conf.getContribsForSubmitter(av2))
self.assert_(c2 in self._conf.getContribsForSubmitter(av2))
self._conf.removeContribution(c2)
self.assert_(len(self._conf.getContribsForSubmitter(av1))==1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2))==0)
self.assert_(c1 not in self._conf.getContribsForSubmitter(av2))
self.assert_(c2 not in self._conf.getContribsForSubmitter(av2))
class TestSchedule(unittest.TestCase):
"""Tests the schedule management functions
"""
def setUp(self):
a = Avatar()
a.setId("creator")
self._conf = Conference(a)
self._conf.setTimezone('UTC')
sd = datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
ed = datetime(2004, 01, 05, 10, 00, tzinfo=timezone('UTC'))
self._conf.setDates(datetime(2000, 01, 01, tzinfo=timezone('UTC')),
datetime(2020, 01, 01, tzinfo=timezone('UTC')))
class TestSchedule(unittest.TestCase):
"""Tests the schedule management functions
"""
def setUp( self ):
a = Avatar()
a.setId("creator")
self._conf=Conference(a)
self._conf.setTimezone('UTC')
sd=datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
ed=datetime(2004, 01, 05, 10, 00, tzinfo=timezone('UTC'))
self._conf.setDates(datetime(2000, 01, 01, tzinfo=timezone('UTC')),datetime(2020, 01, 01, tzinfo=timezone('UTC')))
class TestContributionSubmitterIndex(unittest.TestCase):
"""
"""
def setUp(self):
self._creator = Avatar()
self._creator.setId("creator")
self._categ = Category()
self._conf = Conference(self._creator)
self._conf.setId('a')
self._conf.setTimezone('UTC')
self._categ._addConference(self._conf)
def testBasic(self):
c1, c2 = Contribution(), Contribution()
av1, av2 = Avatar(), Avatar()
av1.setId("1")
av2.setId("2")
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 0)
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 0)
self._conf.addContribution(c1)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 0)
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 0)
c1.grantSubmission(av1)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 0)
c2.grantSubmission(av2)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 0)
self._conf.addContribution(c2)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 1)
self.assert_(c2 in self._conf.getContribsForSubmitter(av2))
c1.grantSubmission(av2)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 2)
self.assert_(c1 in self._conf.getContribsForSubmitter(av2))
self.assert_(c2 in self._conf.getContribsForSubmitter(av2))
c1.revokeSubmission(av2)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 1)
self.assert_(c1 not in self._conf.getContribsForSubmitter(av2))
self.assert_(c2 in self._conf.getContribsForSubmitter(av2))
self._conf.removeContribution(c2)
self.assert_(len(self._conf.getContribsForSubmitter(av1)) == 1)
self.assert_(c1 in self._conf.getContribsForSubmitter(av1))
self.assert_(len(self._conf.getContribsForSubmitter(av2)) == 0)
self.assert_(c1 not in self._conf.getContribsForSubmitter(av2))
self.assert_(c2 not in self._conf.getContribsForSubmitter(av2))
class TestModifyConferenceDates(unittest.TestCase):
"""Tests different scenarios which can occur when modifying conference start
and end dates
"""
def setUp(self):
a = Avatar()
a.setId("creator")
self._conf=Conference(a)
self._conf.setTimezone('UTC')
sd=datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
ed=datetime(2004, 01, 05, 10, 00, tzinfo=timezone('UTC'))
self._conf.setDates(sd,ed)
def testSessions(self):
s1=Session()
s1.setDates(datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC')),datetime(2004, 01, 01, 12, 00, tzinfo=timezone('UTC')))
class TestModifyConferenceDates(unittest.TestCase):
"""Tests different scenarios which can occur when modifying conference start
and end dates
"""
def setUp(self):
a = Avatar()
a.setId("creator")
self._conf = Conference(a)
self._conf.setTimezone('UTC')
sd = datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
ed = datetime(2004, 01, 05, 10, 00, tzinfo=timezone('UTC'))
self._conf.setDates(sd, ed)
def testSessions(self):
s1 = Session()
s1.setDates(datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC')),
datetime(2004, 01, 01, 12, 00, tzinfo=timezone('UTC')))
class _Needs_Rewriting_TestTimeSchedule(unittest.TestCase):
"""Tests the basic schedule management functions
"""
def setUp( self ):
a = Avatar()
a.setId("creator")
self._conf = Conference( a )
self._conf.setId('a')
category=Category()
category.setId('1')
self._conf.addOwner(category)
catDateIdx = indexes.IndexesHolder().getIndex('categoryDate')
catDateIdx.indexConf(self._conf)
self._conf.setTimezone('UTC')
#TODO We need somehow to link schOwner with self._conf (Same thing for the following test
# def testBasicAddAndRemove( self ):
# from MaKaC.schedule import TimeSchedule
# sDateSch,eDateSch=datetime(2004,1,1,10,0, tzinfo=timezone('UTC')),datetime(2004,1,1,12,0, tzinfo=timezone('UTC'))
# schOwner=_ScheduleOwnerWrapper(sDateSch,eDateSch)
# sch=TimeSchedule(schOwner)
# self._conf.addOwner(sch)
# entry1=IndTimeSchEntry()
# entry1.setDuration(0,25)
# entry2=IndTimeSchEntry()
# entry2.setDuration(0,30)
# entry3=IndTimeSchEntry()
# self.assert_(not entry1.isScheduled())
# self.assert_(not entry2.isScheduled())
# self.assert_(not entry3.isScheduled())
# sch.addEntry(entry1)
# sch.addEntry(entry2)
# sch.addEntry(entry3)
# self.assert_(entry1.isScheduled())
# self.assert_(entry2.isScheduled())
# self.assert_(entry3.isScheduled())
# self.assert_(entry1==sch.getEntries()[0])
# self.assert_(entry2==sch.getEntries()[1])
# self.assert_(entry3==sch.getEntries()[2])
# self.assert_(entry1.getStartDate()==datetime(2004,1,1,10,0, tzinfo=timezone('UTC')))
# self.assert_(entry1.getDuration()==timedelta(minutes=25))
# self.assert_(entry2.getStartDate()==datetime(2004,1,1,10,25, tzinfo=timezone('UTC')))
# self.assert_(entry2.getDuration()==timedelta(minutes=30))
# self.assert_(entry3.getStartDate()==datetime(2004,1,1,10,55, tzinfo=timezone('UTC')))
# self.assert_(entry3.getDuration()==timedelta(minutes=5))
# sch.removeEntry(entry1)
# self.assert_(not entry1.isScheduled())
# self.assert_(entry2.isScheduled())
# self.assert_(entry3.isScheduled())
# self.assert_(entry1 not in sch.getEntries())
# self.assert_(entry2==sch.getEntries()[0])
# self.assert_(entry3==sch.getEntries()[1])
# self.assert_(entry1.getDuration()==timedelta(minutes=25))
# self.assert_(entry2.getStartDate()==datetime(2004,1,1,10,25, tzinfo=timezone('UTC')))
# self.assert_(entry2.getDuration()==timedelta(minutes=30))
# self.assert_(entry3.getStartDate()==datetime(2004,1,1,10,55, tzinfo=timezone('UTC')))
# self.assert_(entry3.getDuration()==timedelta(minutes=5))
# def testCompact(self):
# from MaKaC.schedule import TimeSchedule
# sDateSch=datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
# eDateSch=datetime(2004, 01, 01, 12, 00, tzinfo=timezone('UTC'))
# schOwner=_ScheduleOwnerWrapper(sDateSch,eDateSch)
# sch=TimeSchedule(schOwner)
# from MaKaC.schedule import TimeSchEntry
# entry1,entry2=IndTimeSchEntry(),IndTimeSchEntry()
# entry3=IndTimeSchEntry()
# entry1.setDuration(0,25)
# entry2.setDuration(0,25)
# entry3.setDuration(0,30)
# sch.addEntry(entry1)
# self.assert_(entry1.getStartDate()==datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC')))
# sch.addEntry(entry2)
# self.assert_(entry2.getStartDate()==datetime(2004, 01, 01, 10, 25, tzinfo=timezone('UTC')))
# sch.addEntry(entry3)
# self.assert_(entry3.getStartDate()==datetime(2004, 01, 01, 10, 50, tzinfo=timezone('UTC')))
# entry1.setStartDate(datetime(2004, 01, 01, 11, 00, tzinfo=timezone('UTC')))
# entry2.setStartDate(datetime(2004, 01, 01, 11, 15, tzinfo=timezone('UTC')))
# entry3.setStartDate(datetime(2004, 01, 01, 11, 25, tzinfo=timezone('UTC')))
# self.assert_(entry1.getStartDate()==datetime(2004, 01, 01, 11, 00, tzinfo=timezone('UTC')))
# self.assert_(entry2.getStartDate()==datetime(2004, 01, 01, 11, 15, tzinfo=timezone('UTC')))
# self.assert_(entry3.getStartDate()==datetime(2004, 01, 01, 11, 25, tzinfo=timezone('UTC')))
# sch.compact()
# self.assert_(entry1.getStartDate()==datetime(2004 ,01, 01, 10, 00, tzinfo=timezone('UTC')))
# self.assert_(entry1.getDuration()==timedelta(minutes=25))
# self.assert_(entry2.getStartDate()==datetime(2004, 01, 01, 10, 25, tzinfo=timezone('UTC')))
# self.assert_(entry2.getDuration()==timedelta(minutes=25))
# self.assert_(entry3.getStartDate()==datetime(2004, 01, 01, 10, 50, tzinfo=timezone('UTC')))
# self.assert_(entry3.getDuration()==timedelta(minutes=30))
def testStartEndDates(self):
from MaKaC.schedule import TimeSchedule
sDateSch,eDateSch=datetime(2004,1,1,10,0, tzinfo=timezone('UTC')),datetime(2004,1,1,12,0, tzinfo=timezone('UTC'))
schOwner=_ScheduleOwnerWrapper(sDateSch,eDateSch)
sch=TimeSchedule(schOwner)
self.assert_(sch.getStartDate()==schOwner.getStartDate())
self.assert_(sch.getEndDate()==schOwner.getEndDate())
schOwner.setStartDate(datetime(2004, 01, 02, 10, 00, tzinfo=timezone('UTC')))
class TestPosterSchedule(unittest.TestCase):
"""Tests the schedule for posters like schedules management functions
"""
def setUp( self ):
a=Avatar()
a.setId("creator")
self._conf=Conference(a)
self._conf.setTimezone('UTC')
self._conf.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self._conf.setEndDate(datetime(2004,1,1,13,0,tzinfo=timezone('UTC')))
self._session=Session()
self._session.setStartDate(datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
self._session.setEndDate(datetime(2004,1,1,13,0,tzinfo=timezone('UTC')))
self._conf.addSession(self._session)
self._slot1=SessionSlot(self._session)
self._slot1.setStartDate(datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
self._slot1.setDuration(hours=1)
self._session.addSlot(self._slot1)
self._session.setScheduleType("poster")
self._session.setContribDuration(1,0)
def testBasic(self):
#tests the basic adding of entries to a poster like timetable
p1,p2,p3=Contribution(),Contribution(),Contribution()
self._session.addContribution(p1)
self._session.addContribution(p2)
self._session.addContribution(p3)
self._slot1.getSchedule().addEntry(p1.getSchEntry())
self._slot1.getSchedule().addEntry(p2.getSchEntry())
self._slot1.getSchedule().addEntry(p3.getSchEntry())
self.assert_(p1.getDuration()==self._session.getContribDuration())
self.assert_(p2.getDuration()==self._session.getContribDuration())
self.assert_(p3.getDuration()==self._session.getContribDuration())
self.assert_(p1.getStartDate()==self._slot1.getStartDate())
self.assert_(p2.getStartDate()==self._slot1.getStartDate())
self.assert_(p3.getStartDate()==self._slot1.getStartDate())
self.assert_(p1.getSchEntry()==self._slot1.getSchedule().getEntries()[0])
self.assert_(p2.getSchEntry()==self._slot1.getSchedule().getEntries()[1])
self.assert_(p3.getSchEntry()==self._slot1.getSchedule().getEntries()[2])
self._session.removeContribution(p2)
self.assert_(p1.getDuration()==self._session.getContribDuration())
self.assert_(p3.getDuration()==self._session.getContribDuration())
self.assert_(p1.getStartDate()==self._slot1.getStartDate())
self.assert_(p3.getStartDate()==self._slot1.getStartDate())
self.assert_(p1.getSchEntry()==self._slot1.getSchedule().getEntries()[0])
self.assert_(p3.getSchEntry()==self._slot1.getSchedule().getEntries()[1])
def testStartDateNotChanging(self):
#tests that changing the start date of an entry scheduled within a
# poster schedule has no effect
p1=Contribution()
self._session.addContribution(p1)
self._slot1.getSchedule().addEntry(p1.getSchEntry())
self.assert_(p1.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
p1.setStartDate(datetime(2004,1,1,11,25,tzinfo=timezone('UTC')))
self.assert_(p1.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
def testChangeSlotStartDate(self):
#checks that changing the start date of a slot changes all the entries'
p1,p2=Contribution(),Contribution()
self._session.addContribution(p1)
self._session.addContribution(p2)
self._slot1.getSchedule().addEntry(p1.getSchEntry())
self._slot1.getSchedule().addEntry(p2.getSchEntry())
self.assert_(p1.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
self.assert_(p2.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
self._slot1.setStartDate(datetime(2004,1,1,11,25,tzinfo=timezone('UTC')))
class TestSchedule(unittest.TestCase):
"""Tests the schedule management functions
"""
def setUp( self ):
from MaKaC.user import Avatar
a = Avatar()
a.setId("creator")
from MaKaC.conference import Conference
self._conf = Conference( a )
self._conf.setTimezone('UTC')
def testTypeSetUp(self):
#test setting up the schedule type of a session works correctly
self._conf.setDates(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')),datetime(2004,1,5,10,0,tzinfo=timezone('UTC')))
session=Session()
session.setStartDate(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
session.setDuration(hours=10,minutes=0)
self._conf.addSession(session)
slot1=SessionSlot(session)
session.addSlot(slot1)
c1,c2,c3=Contribution(),Contribution(),Contribution()
session.addContribution(c1)
session.addContribution(c2)
session.addContribution(c3)
slot1.getSchedule().addEntry(c1.getSchEntry())
slot1.getSchedule().addEntry(c2.getSchEntry())
slot1.getSchedule().addEntry(c3.getSchEntry())
self.assert_(c1.getSchEntry()==slot1.getSchedule().getEntries()[0])
self.assert_(c2.getSchEntry()==slot1.getSchedule().getEntries()[1])
self.assert_(c3.getSchEntry()==slot1.getSchedule().getEntries()[2])
self.assert_(session.getScheduleType()=="standard")
self.assert_(slot1.getSchedule().__class__==conference.SlotSchedule)
session.setScheduleType("poster")
self.assert_(session.getScheduleType()=="poster")
self.assert_(slot1.getSchedule().__class__==conference.PosterSlotSchedule)
self.assert_(len(slot1.getSchedule().getEntries())==0)
def testSessionDates(self):
from MaKaC.conference import Session,SessionSlot, Conference
self._conf.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self._conf.setEndDate(datetime(2004,1,1,15,0,tzinfo=timezone('UTC')))
session1=Session()
session1.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
session1.setEndDate(datetime(2004,1,1,15,0,tzinfo=timezone('UTC')))
self._conf.addSession(session1)
slot1=SessionSlot(session1)
slot1.setDuration(hours=2,minutes=0)
slot1.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
session1.addSlot(slot1)
# ------- SESSIONS -------
# Session start date can not be bigger than the first slot start date
self.assertRaises(MaKaCError, session1.setStartDate, datetime(2004,1,1,12,0,tzinfo=timezone('UTC')))
# Session end date can not be prior than the last slot end date
self.assertRaises(MaKaCError, session1.setEndDate, datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
# Session duration must be bigger than zero.
self.assertRaises(MaKaCError, session1.setDuration, 0,0)
# Session start date can not be prior than the conference end date
#self.assertRaises(MaKaCError, session1.setStartDate, datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
# Session end date can not be bigger than the conference end date
#self.assertRaises(MaKaCError, session1.setEndDate, datetime(2004,1,1,15,1,tzinfo=timezone('UTC')))
# Session end date can not be bigger than the conference end date
#self.assertRaises(MaKaCError, session1.setDuration, 6,1)
# ------- SESSION SLOTS -------
self._conf.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self._conf.setEndDate(datetime(2004,1,1,15,0,tzinfo=timezone('UTC')))
session1.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
session1.setEndDate(datetime(2004,1,1,15,0,tzinfo=timezone('UTC')))
# Session slot duration must be bigger than zero.
self.assertRaises(MaKaCError, slot1.setDuration, 0,0,0)
# Forbid to create a slot alogn several days
self._conf.setEndDate(datetime(2005,1,1,15,0,tzinfo=timezone('UTC')))
self.assertRaises(MaKaCError, slot1.setDuration, 1,0,1)
# Slot start date has to be between the session ones
#self.assertRaises(MaKaCError, slot1.setStartDate, datetime(2004,1,1,9,59,tzinfo=timezone('UTC')))
# Slot end date has to be between the session ones
#self.assertRaises(MaKaCError, slot1.setDuration, 0,5,1)
# If the duration is modified and any of the slot entries is affected then an excetpion is raised
c1,c2,c3=Contribution(),Contribution(),Contribution()
session1.addContribution(c1)
session1.addContribution(c2)
session1.addContribution(c3)
c1.setDuration(0,30)
c2.setDuration(0,30)
c3.setDuration(0,30)
from MaKaC.schedule import BreakTimeSchEntry
b1=BreakTimeSchEntry()
slot1.getSchedule().addEntry(c1.getSchEntry())
slot1.getSchedule().addEntry(c2.getSchEntry())
slot1.getSchedule().addEntry(c3.getSchEntry())
self.assertRaises(MaKaCError, slot1.setDuration, 0,1,29)
# Check that the duration of the entries do not overpass the slot duration
slot1.setDuration(hours=1,minutes=30)
#self.assertRaises(MaKaCError,c3.setDuration,0,31)
c3.setDuration(0,30)
slot1.setDuration(hours=2,minutes=0)
slot1.getSchedule().addEntry(b1)
#self.assertRaises(MaKaCError,b1.setDuration,0,31)
#Check that entries start date is not less than owner start date
#self.assertRaises(MaKaCError,c1.setStartDate,datetime(2004,1,1,9,59,tzinfo=timezone('UTC')))
#self.assertRaises(MaKaCError,b1.setStartDate,datetime(2004,1,1,9,59,tzinfo=timezone('UTC')))
#Move all the entries
slot3=SessionSlot(session1)
slot3.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
slot3.setDuration(hours=3,minutes=0)
session1.addSlot(slot3)
c4,c5=Contribution(),Contribution()
session1.addContribution(c4)
session1.addContribution(c5)
c4.setTitle("campeon")
c5.setTitle("campeonisimo")
c4.setStartDate(datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
c4.setDuration(0,30)
c5.setDuration(0,30)
b2=BreakTimeSchEntry()
b2.setDuration(0,30)
b2.setTitle("breaaaaaaak")
slot3.getSchedule().addEntry(c4.getSchEntry())
slot3.getSchedule().addEntry(c5.getSchEntry())
slot3.getSchedule().addEntry(b2)
self.assert_(c4.getStartDate() == datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
slot3.setStartDate(datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
#self.assert_(c4.getStartDate() == datetime(2004,1,1,12,0,tzinfo=timezone('UTC')))
# ------- CONFERENCE -------
# Conference should not start after a entry
#self.assertRaises(MaKaCError,self._conf.setStartDate,datetime(2004,1,1,10,1,tzinfo=timezone('UTC')))
# Conference should not finish before a entry
#self.assertRaises(MaKaCError,self._conf.setEndDate,datetime(2004,1,1,14,59,tzinfo=timezone('UTC')))
# Conference should not start after a entry (TIME)
#self.assertRaises(MaKaCError,self._conf.setStartTime,10,1)
# Conference should not finish before a entry (TIME)
self._conf.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self._conf.setEndDate(datetime(2005,1,1,18,0,tzinfo=timezone('UTC')))
session2=Session()
self._conf.addSession(session2)
session2.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
session2.setEndDate(datetime(2005,1,1,18,0,tzinfo=timezone('UTC')))
slot2=SessionSlot(session2)
slot2.setDuration(hours=2,minutes=0)
slot2.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
session2.addSlot(slot2)
#self.assertRaises(MaKaCError,self._conf.setEndTime,17,59)
def testSlots(self):
self._conf.setDates(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')),datetime(2004,1,5,10,0,tzinfo=timezone('UTC')))
session1=Session()
session1.setStartDate(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
session1.setDuration(hours=10,minutes=0)
self._conf.addSession(session1)
slot1=SessionSlot(session1)
slot1.setDuration(hours=2,minutes=0)
session1.addSlot(slot1)
self.assert_(slot1.getSessionSchEntry() in session1.getSchedule().getEntries())
self.assert_(slot1.getStartDate()==session1.getStartDate())
self.assert_(slot1.getDuration().seconds==7200)
slot2=SessionSlot(session1)
slot2.setDuration(hours=2,minutes=0)
session1.addSlot(slot2)
self.assert_(slot1.getSessionSchEntry()==session1.getSchedule().getEntries()[0])
self.assert_(slot1.getStartDate()==session1.getStartDate())
self.assert_(slot1.getDuration().seconds==7200)
self.assert_(slot2.getSessionSchEntry()==session1.getSchedule().getEntries()[1])
self.assert_(slot2.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
self.assert_(slot2.getDuration().seconds==7200)
slot2.setStartDate(datetime(2004,1,1,15,0,tzinfo=timezone('UTC')))
self.assert_(slot1.getSessionSchEntry()==session1.getSchedule().getEntries()[0])
self.assert_(slot1.getStartDate()==session1.getStartDate())
self.assert_(slot1.getDuration().seconds==7200)
self.assert_(slot2.getSessionSchEntry()==session1.getSchedule().getEntries()[1])
self.assert_(slot2.getStartDate()==datetime(2004,1,1,15,0,tzinfo=timezone('UTC')))
self.assert_(slot2.getDuration().seconds==7200)
slot1.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
slot2.setStartDate(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
self.assert_(slot2.getStartDate()==datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
#slot1.setStartDate(datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
#slot2.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self.assert_(slot1.getSessionSchEntry()==session1.getSchedule().getEntries()[1])
self.assert_(slot1.getDuration().seconds==7200)
self.assert_(slot2.getSessionSchEntry()==session1.getSchedule().getEntries()[0])
self.assert_(slot2.getStartDate()==datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
self.assert_(slot2.getDuration().seconds==7200)
def testContributions(self):
self._conf.setDates(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')),datetime(2004,1,5,10,0,tzinfo=timezone('UTC')))
from MaKaC.conference import Session,Contribution,SessionSlot
self._conf.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self._conf.setEndDate(datetime(2005,1,1,10,0,tzinfo=timezone('UTC')))
session1=Session()
self._conf.addSession(session1)
session1.setStartDate(datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
session1.setDuration(hours=5,minutes=0)
slot1=SessionSlot(session1)
slot1.setDuration(hours=2,minutes=0)
session1.addSlot(slot1)
slot2=SessionSlot(session1)
slot2.setDuration(hours=2,minutes=0)
session1.addSlot(slot2)
self.assert_(slot2.getStartDate()==datetime(2004,1,1,12,0,tzinfo=timezone('UTC')))
c1,c2,c3=Contribution(),Contribution(),Contribution()
session1.addContribution(c1)
session1.addContribution(c2)
session1.addContribution(c3)
c1.setDuration(0,30)
c2.setDuration(0,30)
c3.setDuration(0,30)
from MaKaC.errors import MaKaCError
#self.assertRaises(MaKaCError,slot1.getSchedule().addEntry,c1.getSchEntry())
slot1.getSchedule().addEntry(c1.getSchEntry())
slot1.getSchedule().addEntry(c2.getSchEntry())
slot1.getSchedule().addEntry(c3.getSchEntry())
self.assert_(c1.getStartDate()==datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
self.assert_(c2.getStartDate()==datetime(2004,1,1,10,30,tzinfo=timezone('UTC')))
self.assert_(c3.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
#slot2.getSchedule().addEntry(c1.getSchEntry())
#self.assert_(c1.getStartDate()==datetime(2004,1,1,12,0,tzinfo=timezone('UTC')))
#self.assert_(c2.getStartDate()==datetime(2004,1,1,10,30,tzinfo=timezone('UTC')))
#self.assert_(c3.getStartDate()==datetime(2004,1,1,11,0,tzinfo=timezone('UTC')))
from MaKaC.schedule import BreakTimeSchEntry
b1=BreakTimeSchEntry()
slot1.getSchedule().addEntry(b1)
self.assert_(b1 in slot1.getSchedule().getEntries())
#self.assert_(b1.getStartDate()==datetime(2004,1,1,10,0,tzinfo=timezone('UTC')))
def testMoveScheduledContribToSession(self):
#tests that moving scheduled contributions at conference level into a
# session works correctly: removes them from the conference schedule
# and includes them into the selected session
self._conf.setDates(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')),datetime(2004,1,5,10,0,tzinfo=timezone('UTC')))
session1=Session()
session1.setStartDate(datetime(2004,1,1,9,0,tzinfo=timezone('UTC')))
session1.setDuration(hours=1,minutes=0)
self._conf.addSession(session1)
c1,c2=Contribution(),Contribution()
self._conf.addContribution(c1)
self._conf.addContribution(c2)
self._conf.getSchedule().addEntry(c1.getSchEntry())
self._conf.getSchedule().addEntry(c2.getSchEntry())
self.assert_(c1.isScheduled())
self.assert_(c2.isScheduled())
session1.addContribution(c1)
self.assert_(not c1.isScheduled())
self.assert_(c2.isScheduled())
class TestAuthorIndex(unittest.TestCase):
"""Tests the author index
"""
def setUp( self ):
self._creator = Avatar()
self._creator.setId("creator")
self._categ = Category()
self._conf=Conference(self._creator)
self._conf.setId('a')
self._conf.setTimezone('UTC')
self._categ._addConference(self._conf)
def testBasicIndexing(self):
#Tests adding a contribution with some authors already on it
c1=Contribution()
self._conf.addContribution(c1)
auth1,auth2=ContributionParticipation(),ContributionParticipation()
auth1.setFirstName("hector")
auth1.setFamilyName("sanchez sanmartin")
auth1.setEmail("*****@*****.**")
auth2.setFirstName("jose benito")
auth2.setFamilyName("gonzalez lopez")
auth2.setEmail("*****@*****.**")
c1.addPrimaryAuthor(auth1)
c1.addPrimaryAuthor(auth2)
idx=self._conf.getAuthorIndex()
self.assert_(auth1 in idx.getParticipations()[1])
self.assert_(len(idx.getParticipations()[1])==1)
self.assert_(auth2 in idx.getParticipations()[0])
self.assert_(len(idx.getParticipations()[0])==1)
c2=Contribution()
self._conf.addContribution(c2)
auth3,auth4=ContributionParticipation(),ContributionParticipation()
auth3.setFirstName("hector")
auth3.setFamilyName("sanchez sanmartin")
auth3.setEmail("*****@*****.**")
auth4.setFirstName("jose benito")
auth4.setFamilyName("gonzalez lopez2")
auth4.setEmail("*****@*****.**")
c2.addPrimaryAuthor(auth3)
c2.addPrimaryAuthor(auth4)
#Tests removing a contribution from a conference updates the author
# index correctly
#self.assert_(auth3 in idx.getParticipations()[2])
#self.assert_(len(idx.getParticipations()[2])==2)
#self.assert_(auth4 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#self._conf.removeContribution(c2)
#self.assert_(auth1 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#self.assert_(auth2 in idx.getParticipations()[0])
#self.assert_(len(idx.getParticipations()[0])==1)
#Tests adding additional authors to a contribution which is already
# included in a conference updates the author index correctly
#auth5=ContributionParticipation()
#auth5.setFirstName("jean-yves")
#auth5.setFamilyName("le meur")
#auth5.setEmail("*****@*****.**")
#c1.addPrimaryAuthor(auth5)
#self.assert_(auth1 in idx.getParticipations()[2])
#self.assert_(len(idx.getParticipations()[2])==1)
#self.assert_(auth2 in idx.getParticipations()[0])
#self.assert_(len(idx.getParticipations()[0])==1)
#self.assert_(auth5 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#Tests removing authors from a contribution which is already
# included in a conference updates the author index correctly
#c1.removePrimaryAuthor(auth5)
#self.assert_(auth1 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#self.assert_(auth2 in idx.getParticipations()[0])
#self.assert_(len(idx.getParticipations()[0])==1)
def testChangesInAuthorData(self):
#Checks that changes in the author data updates the author index
# correctly
c1=Contribution()
self._conf.addContribution(c1)
auth1,auth2=ContributionParticipation(),ContributionParticipation()
auth1.setFirstName("zFN")
auth1.setFamilyName("zSN")
auth1.setEmail("zM")
auth2.setFirstName("AFN")
auth2.setFamilyName("ASN")
auth2.setEmail("aM")
c1.addPrimaryAuthor(auth1)
c1.addPrimaryAuthor(auth2)
idx=self._conf.getAuthorIndex()
self.assert_(auth1 in idx.getParticipations()[1])
self.assert_(len(idx.getParticipations()[1])==1)
self.assert_(auth2 in idx.getParticipations()[0])
self.assert_(len(idx.getParticipations()[0])==1)
auth2.setFamilyName("ZZSN")
self.assert_(auth1 in idx.getParticipations()[0])
self.assert_(len(idx.getParticipations()[0])==1)
self.assert_(auth2 in idx.getParticipations()[1])
self.assert_(len(idx.getParticipations()[1])==1)
class TestAuthorSearch(unittest.TestCase):
"""Tests the author search
"""
def setUp(self):
self._creator = Avatar()
self._creator.setId("creator")
self._conf = Conference(self._creator)
self._conf.setTimezone('UTC')
def testBasicSearch(self):
c1 = Contribution()
self._conf.addContribution(c1)
auth1, auth2 = ContributionParticipation(), ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
auth2.setFamilyName("b")
auth2.setFirstName("b")
c1.addPrimaryAuthor(auth1)
c1.addPrimaryAuthor(auth2)
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("a")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
self.assert_(c1 in self._conf.getContribsMatchingAuth("B"))
self.assert_(len(self._conf.getContribsMatchingAuth("B")) == 1)
auth3 = ContributionParticipation()
auth3.setFamilyName("c")
auth3.setFirstName("c")
c1.addCoAuthor(auth3)
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("c")) == 0)
def testAddAuthor(self):
c1 = Contribution()
self._conf.addContribution(c1)
auth1, auth2 = ContributionParticipation(), ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
auth2.setFamilyName("b")
auth2.setFirstName("b")
c1.addPrimaryAuthor(auth1)
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("a")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
c1.addPrimaryAuthor(auth2)
self.assert_(len(self._conf.getContribsMatchingAuth("b")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("b"))
c1.removePrimaryAuthor(auth1)
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("a")) == 0)
self.assert_(c1 not in self._conf.getContribsMatchingAuth("a"))
self.assert_(len(self._conf.getContribsMatchingAuth("b")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("b"))
def testWithdrawnContrib(self):
#Withdrawn contributions authors must be searchable
c1 = Contribution()
self._conf.addContribution(c1)
auth1 = ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
c1.addPrimaryAuthor(auth1)
c1.withdraw(self._creator, "ll")
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("a")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
auth2 = ContributionParticipation()
auth2.setFamilyName("b")
auth2.setFirstName("b")
c1.addPrimaryAuthor(auth2)
#self._conf.getContribsMatchingAuth("b")
#self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
#self.assert_(len(self._conf.getContribsMatchingAuth("b"))==1)
#self.assert_(c1 in self._conf.getContribsMatchingAuth("b"))
def testAuthorsWithSameName(self):
#one contribution could have 2 authors with the same name
c1 = Contribution()
self._conf.addContribution(c1)
auth1 = ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
c1.addPrimaryAuthor(auth1)
auth2 = ContributionParticipation()
auth2.setFamilyName("a")
auth2.setFirstName("a")
c1.addPrimaryAuthor(auth2)
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("a")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
c1.removePrimaryAuthor(auth1)
self.assert_(len(self._conf.getContribsMatchingAuth("")) == 1)
self.assert_(len(self._conf.getContribsMatchingAuth("a")) == 1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
class TestAuthorIndex(unittest.TestCase):
"""Tests the author index
"""
def setUp(self):
self._creator = Avatar()
self._creator.setId("creator")
self._categ = Category()
self._conf = Conference(self._creator)
self._conf.setId('a')
self._conf.setTimezone('UTC')
self._categ._addConference(self._conf)
def testBasicIndexing(self):
#Tests adding a contribution with some authors already on it
c1 = Contribution()
self._conf.addContribution(c1)
auth1, auth2 = ContributionParticipation(), ContributionParticipation()
auth1.setFirstName("hector")
auth1.setFamilyName("sanchez sanmartin")
auth1.setEmail("*****@*****.**")
auth2.setFirstName("jose benito")
auth2.setFamilyName("gonzalez lopez")
auth2.setEmail("*****@*****.**")
c1.addPrimaryAuthor(auth1)
c1.addPrimaryAuthor(auth2)
idx = self._conf.getAuthorIndex()
self.assert_(auth1 in idx.getParticipations()[1])
self.assert_(len(idx.getParticipations()[1]) == 1)
self.assert_(auth2 in idx.getParticipations()[0])
self.assert_(len(idx.getParticipations()[0]) == 1)
c2 = Contribution()
self._conf.addContribution(c2)
auth3, auth4 = ContributionParticipation(), ContributionParticipation()
auth3.setFirstName("hector")
auth3.setFamilyName("sanchez sanmartin")
auth3.setEmail("*****@*****.**")
auth4.setFirstName("jose benito")
auth4.setFamilyName("gonzalez lopez2")
auth4.setEmail("*****@*****.**")
c2.addPrimaryAuthor(auth3)
c2.addPrimaryAuthor(auth4)
#Tests removing a contribution from a conference updates the author
# index correctly
#self.assert_(auth3 in idx.getParticipations()[2])
#self.assert_(len(idx.getParticipations()[2])==2)
#self.assert_(auth4 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#self._conf.removeContribution(c2)
#self.assert_(auth1 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#self.assert_(auth2 in idx.getParticipations()[0])
#self.assert_(len(idx.getParticipations()[0])==1)
#Tests adding additional authors to a contribution which is already
# included in a conference updates the author index correctly
#auth5=ContributionParticipation()
#auth5.setFirstName("jean-yves")
#auth5.setFamilyName("le meur")
#auth5.setEmail("*****@*****.**")
#c1.addPrimaryAuthor(auth5)
#self.assert_(auth1 in idx.getParticipations()[2])
#self.assert_(len(idx.getParticipations()[2])==1)
#self.assert_(auth2 in idx.getParticipations()[0])
#self.assert_(len(idx.getParticipations()[0])==1)
#self.assert_(auth5 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#Tests removing authors from a contribution which is already
# included in a conference updates the author index correctly
#c1.removePrimaryAuthor(auth5)
#self.assert_(auth1 in idx.getParticipations()[1])
#self.assert_(len(idx.getParticipations()[1])==1)
#self.assert_(auth2 in idx.getParticipations()[0])
#self.assert_(len(idx.getParticipations()[0])==1)
def testChangesInAuthorData(self):
#Checks that changes in the author data updates the author index
# correctly
c1 = Contribution()
self._conf.addContribution(c1)
auth1, auth2 = ContributionParticipation(), ContributionParticipation()
auth1.setFirstName("zFN")
auth1.setFamilyName("zSN")
auth1.setEmail("zM")
auth2.setFirstName("AFN")
auth2.setFamilyName("ASN")
auth2.setEmail("aM")
c1.addPrimaryAuthor(auth1)
c1.addPrimaryAuthor(auth2)
idx = self._conf.getAuthorIndex()
self.assert_(auth1 in idx.getParticipations()[1])
self.assert_(len(idx.getParticipations()[1]) == 1)
self.assert_(auth2 in idx.getParticipations()[0])
self.assert_(len(idx.getParticipations()[0]) == 1)
auth2.setFamilyName("ZZSN")
self.assert_(auth1 in idx.getParticipations()[0])
self.assert_(len(idx.getParticipations()[0]) == 1)
self.assert_(auth2 in idx.getParticipations()[1])
self.assert_(len(idx.getParticipations()[1]) == 1)
class TestWithdrawal(unittest.TestCase):
"""Tests different scenarios concerning the contribution withdrawal
"""
def setUp( self ):
self._creator=Avatar()
self._creator.setId("creator")
self._conf=Conference(self._creator)
self._conf.setTimezone('UTC')
sd=datetime(2004, 01, 01, 10, 00, tzinfo=timezone("UTC"))
ed=datetime(2004, 01, 05, 10, 00, tzinfo=timezone("UTC"))
self._conf.setDates(sd,ed)
def testBasicWithdrawal(self):
c1,c2=Contribution(),Contribution()
auth1,auth2=ContributionParticipation(),ContributionParticipation()
self._conf.addContribution(c1)
self._conf.addContribution(c2)
auth1.setFirstName("a")
auth1.setFamilyName("a")
auth1.setEmail("a")
auth2.setFirstName("b")
auth2.setFamilyName("b")
auth2.setEmail("b")
c1.addPrimaryAuthor(auth1)
c2.addPrimaryAuthor(auth2)
s1=Session()
sd=datetime(2004, 01, 01, 12, 00, tzinfo=timezone("UTC"))
ed=datetime(2004, 01, 01, 19, 00, tzinfo=timezone("UTC"))
s1.setDates(sd,ed)
slot1=SessionSlot(s1)
self._conf.addSession(s1)
s1.addSlot(slot1)
s1.addContribution(c1)
s1.addContribution(c2)
slot1.getSchedule().addEntry(c1.getSchEntry())
slot1.getSchedule().addEntry(c2.getSchEntry())
self.assert_(c1.isScheduled())
self.assert_(c2.isScheduled())
authIdx=self._conf.getAuthorIndex()
self.assert_(auth1 in authIdx.getParticipations()[0])
self.assert_(auth2 in authIdx.getParticipations()[1])
c1.withdraw(self._creator,"test")
self.assert_(not c1.isScheduled())
self.assert_(c2.isScheduled())
self.assert_(auth1 not in authIdx.getParticipations()[0])
self.assert_(auth2 in authIdx.getParticipations()[0])
auth1.setFirstName("aa")
self.assert_(auth1 not in authIdx.getParticipations()[0])
self.assert_(auth2 in authIdx.getParticipations()[0])
auth3,auth4=ContributionParticipation(),ContributionParticipation()
auth3.setFirstName("c")
auth3.setFamilyName("c")
auth3.setEmail("c")
auth4.setFirstName("d")
auth4.setFamilyName("d")
auth4.setEmail("d")
c1.addPrimaryAuthor(auth3)
c2.addPrimaryAuthor(auth4)
self.assert_(auth2 in authIdx.getParticipations()[0])
self.assert_(auth4 in authIdx.getParticipations()[1])
self.assertRaises(MaKaCError,slot1.getSchedule().addEntry,c1.getSchEntry())
class TestAuthorSearch(unittest.TestCase):
"""Tests the author search
"""
def setUp( self ):
self._creator = Avatar()
self._creator.setId("creator")
self._conf=Conference(self._creator)
self._conf.setTimezone('UTC')
def testBasicSearch(self):
c1=Contribution()
self._conf.addContribution(c1)
auth1,auth2=ContributionParticipation(),ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
auth2.setFamilyName("b")
auth2.setFirstName("b")
c1.addPrimaryAuthor(auth1)
c1.addPrimaryAuthor(auth2)
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("a"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
self.assert_(c1 in self._conf.getContribsMatchingAuth("B"))
self.assert_(len(self._conf.getContribsMatchingAuth("B"))==1)
auth3=ContributionParticipation()
auth3.setFamilyName("c")
auth3.setFirstName("c")
c1.addCoAuthor(auth3)
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("c"))==0)
def testAddAuthor(self):
c1=Contribution()
self._conf.addContribution(c1)
auth1,auth2=ContributionParticipation(),ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
auth2.setFamilyName("b")
auth2.setFirstName("b")
c1.addPrimaryAuthor(auth1)
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("a"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
c1.addPrimaryAuthor(auth2)
self.assert_(len(self._conf.getContribsMatchingAuth("b"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("b"))
c1.removePrimaryAuthor(auth1)
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("a"))==0)
self.assert_(c1 not in self._conf.getContribsMatchingAuth("a"))
self.assert_(len(self._conf.getContribsMatchingAuth("b"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("b"))
def testWithdrawnContrib(self):
#Withdrawn contributions authors must be searchable
c1=Contribution()
self._conf.addContribution(c1)
auth1=ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
c1.addPrimaryAuthor(auth1)
c1.withdraw(self._creator,"ll")
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("a"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
auth2=ContributionParticipation()
auth2.setFamilyName("b")
auth2.setFirstName("b")
c1.addPrimaryAuthor(auth2)
#self._conf.getContribsMatchingAuth("b")
#self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
#self.assert_(len(self._conf.getContribsMatchingAuth("b"))==1)
#self.assert_(c1 in self._conf.getContribsMatchingAuth("b"))
def testAuthorsWithSameName(self):
#one contribution could have 2 authors with the same name
c1=Contribution()
self._conf.addContribution(c1)
auth1=ContributionParticipation()
auth1.setFamilyName("a")
auth1.setFirstName("a")
c1.addPrimaryAuthor(auth1)
auth2=ContributionParticipation()
auth2.setFamilyName("a")
auth2.setFirstName("a")
c1.addPrimaryAuthor(auth2)
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("a"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
c1.removePrimaryAuthor(auth1)
self.assert_(len(self._conf.getContribsMatchingAuth(""))==1)
self.assert_(len(self._conf.getContribsMatchingAuth("a"))==1)
self.assert_(c1 in self._conf.getContribsMatchingAuth("a"))
class _Needs_Rewriting_TestTimeSchedule(unittest.TestCase):
"""Tests the basic schedule management functions
"""
def setUp(self):
a = Avatar()
a.setId("creator")
self._conf = Conference(a)
self._conf.setId('a')
category = Category()
category.setId('1')
self._conf.addOwner(category)
catDateIdx = indexes.IndexesHolder().getIndex('categoryDate')
catDateIdx.indexConf(self._conf)
self._conf.setTimezone('UTC')
#TODO We need somehow to link schOwner with self._conf (Same thing for the following test
# def testBasicAddAndRemove( self ):
# from MaKaC.schedule import TimeSchedule
# sDateSch,eDateSch=datetime(2004,1,1,10,0, tzinfo=timezone('UTC')),datetime(2004,1,1,12,0, tzinfo=timezone('UTC'))
# schOwner=_ScheduleOwnerWrapper(sDateSch,eDateSch)
# sch=TimeSchedule(schOwner)
# self._conf.addOwner(sch)
# entry1=IndTimeSchEntry()
# entry1.setDuration(0,25)
# entry2=IndTimeSchEntry()
# entry2.setDuration(0,30)
# entry3=IndTimeSchEntry()
# self.assert_(not entry1.isScheduled())
# self.assert_(not entry2.isScheduled())
# self.assert_(not entry3.isScheduled())
# sch.addEntry(entry1)
# sch.addEntry(entry2)
# sch.addEntry(entry3)
# self.assert_(entry1.isScheduled())
# self.assert_(entry2.isScheduled())
# self.assert_(entry3.isScheduled())
# self.assert_(entry1==sch.getEntries()[0])
# self.assert_(entry2==sch.getEntries()[1])
# self.assert_(entry3==sch.getEntries()[2])
# self.assert_(entry1.getStartDate()==datetime(2004,1,1,10,0, tzinfo=timezone('UTC')))
# self.assert_(entry1.getDuration()==timedelta(minutes=25))
# self.assert_(entry2.getStartDate()==datetime(2004,1,1,10,25, tzinfo=timezone('UTC')))
# self.assert_(entry2.getDuration()==timedelta(minutes=30))
# self.assert_(entry3.getStartDate()==datetime(2004,1,1,10,55, tzinfo=timezone('UTC')))
# self.assert_(entry3.getDuration()==timedelta(minutes=5))
# sch.removeEntry(entry1)
# self.assert_(not entry1.isScheduled())
# self.assert_(entry2.isScheduled())
# self.assert_(entry3.isScheduled())
# self.assert_(entry1 not in sch.getEntries())
# self.assert_(entry2==sch.getEntries()[0])
# self.assert_(entry3==sch.getEntries()[1])
# self.assert_(entry1.getDuration()==timedelta(minutes=25))
# self.assert_(entry2.getStartDate()==datetime(2004,1,1,10,25, tzinfo=timezone('UTC')))
# self.assert_(entry2.getDuration()==timedelta(minutes=30))
# self.assert_(entry3.getStartDate()==datetime(2004,1,1,10,55, tzinfo=timezone('UTC')))
# self.assert_(entry3.getDuration()==timedelta(minutes=5))
# def testCompact(self):
# from MaKaC.schedule import TimeSchedule
# sDateSch=datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
# eDateSch=datetime(2004, 01, 01, 12, 00, tzinfo=timezone('UTC'))
# schOwner=_ScheduleOwnerWrapper(sDateSch,eDateSch)
# sch=TimeSchedule(schOwner)
# from MaKaC.schedule import TimeSchEntry
# entry1,entry2=IndTimeSchEntry(),IndTimeSchEntry()
# entry3=IndTimeSchEntry()
# entry1.setDuration(0,25)
# entry2.setDuration(0,25)
# entry3.setDuration(0,30)
# sch.addEntry(entry1)
# self.assert_(entry1.getStartDate()==datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC')))
# sch.addEntry(entry2)
# self.assert_(entry2.getStartDate()==datetime(2004, 01, 01, 10, 25, tzinfo=timezone('UTC')))
# sch.addEntry(entry3)
# self.assert_(entry3.getStartDate()==datetime(2004, 01, 01, 10, 50, tzinfo=timezone('UTC')))
# entry1.setStartDate(datetime(2004, 01, 01, 11, 00, tzinfo=timezone('UTC')))
# entry2.setStartDate(datetime(2004, 01, 01, 11, 15, tzinfo=timezone('UTC')))
# entry3.setStartDate(datetime(2004, 01, 01, 11, 25, tzinfo=timezone('UTC')))
# self.assert_(entry1.getStartDate()==datetime(2004, 01, 01, 11, 00, tzinfo=timezone('UTC')))
# self.assert_(entry2.getStartDate()==datetime(2004, 01, 01, 11, 15, tzinfo=timezone('UTC')))
# self.assert_(entry3.getStartDate()==datetime(2004, 01, 01, 11, 25, tzinfo=timezone('UTC')))
# sch.compact()
# self.assert_(entry1.getStartDate()==datetime(2004 ,01, 01, 10, 00, tzinfo=timezone('UTC')))
# self.assert_(entry1.getDuration()==timedelta(minutes=25))
# self.assert_(entry2.getStartDate()==datetime(2004, 01, 01, 10, 25, tzinfo=timezone('UTC')))
# self.assert_(entry2.getDuration()==timedelta(minutes=25))
# self.assert_(entry3.getStartDate()==datetime(2004, 01, 01, 10, 50, tzinfo=timezone('UTC')))
# self.assert_(entry3.getDuration()==timedelta(minutes=30))
def testStartEndDates(self):
from MaKaC.schedule import TimeSchedule
sDateSch, eDateSch = datetime(2004,
1,
1,
10,
0,
tzinfo=timezone('UTC')), datetime(
2004,
1,
1,
12,
0,
tzinfo=timezone('UTC'))
schOwner = _ScheduleOwnerWrapper(sDateSch, eDateSch)
sch = TimeSchedule(schOwner)
self.assert_(sch.getStartDate() == schOwner.getStartDate())
self.assert_(sch.getEndDate() == schOwner.getEndDate())
schOwner.setStartDate(
datetime(2004, 01, 02, 10, 00, tzinfo=timezone('UTC')))
class TestContributionList(unittest.TestCase):
"""Tests the contribution list functions
"""
def setUp( self ):
from MaKaC.user import Avatar
a = Avatar()
a.setId("creator")
from MaKaC.conference import Conference
self._conf=Conference(a)
self._conf.setTimezone('UTC')
self._conf.setDates(datetime(2000,1,1,tzinfo=timezone('UTC')),datetime(2020,1,1,tzinfo=timezone('UTC')))
def testSorting( self ):
from MaKaC.conference import Contribution, ContributionType, Session, Track
from MaKaC.webinterface.common import contribFilters
from MaKaC.common.filters import SimpleFilter
contrib1 = Contribution()
contrib2 = Contribution()
contrib3 = Contribution()
self._conf.addContribution( contrib1 )
self._conf.addContribution( contrib2 )
self._conf.addContribution( contrib3 )
# Sorting by ID
sortingCrit = contribFilters.SortingCriteria( ["number"] )
f = SimpleFilter( None, sortingCrit )
contribList = f.apply(self._conf.getContributionList())
self.assert_( len(contribList) == 3 )
self.assert_( contribList[0] == contrib1 )
self.assert_( contribList[1] == contrib2 )
self.assert_( contribList[2] == contrib3 )
#Sorting by Date
contrib1.setStartDate(datetime(2004, 5, 1, 10, 30,tzinfo=timezone('UTC')))
contrib2.setStartDate(datetime(2003, 5, 1, 10, 30,tzinfo=timezone('UTC')))
sortingCrit = contribFilters.SortingCriteria( ["date"] )
f = SimpleFilter( None, sortingCrit )
contribList = f.apply(self._conf.getContributionList())
self.assert_( len(contribList) == 3 )
self.assert_( contribList[0] == contrib2 )
self.assert_( contribList[1] == contrib1 )
self.assert_( contribList[2] == contrib3 )
# Sorting by Contribution Type
contribType1 = ContributionType("oral presentation", "no description", self._conf)
contribType2 = ContributionType("poster", "no description", self._conf)
contrib1.setType(contribType1)
contrib2.setType(contribType2)
sortingCrit = contribFilters.SortingCriteria( ["type"] )
f = SimpleFilter( None, sortingCrit )
contribList = f.apply(self._conf.getContributionList())
self.assert_( len(contribList) == 3 )
self.assert_( contribList[0] == contrib1 )
self.assert_( contribList[1] == contrib2 )
self.assert_( contribList[2] == contrib3 )
# Sorting by Session
session1 = Session()
self._conf.addSession(session1)
session2 = Session()
self._conf.addSession(session2)
contrib1.setSession(session1)
contrib2.setSession(session2)
sortingCrit = contribFilters.SortingCriteria( ["session"] )
f = SimpleFilter( None, sortingCrit )
contribList = f.apply(self._conf.getContributionList())
self.assert_( len(contribList) == 3 )
self.assert_(contrib1 in contribList)
self.assert_(contrib2 in contribList)
self.assert_(contrib3 in contribList)
# Sorting by Track
track1 = Track()
track1.setTitle("3")
track1.setConference(self._conf)
track2 = Track()
track2.setTitle("1")
track2.setConference(self._conf)
contrib1.setTrack(track1)
contrib2.setTrack(track2)
sortingCrit = contribFilters.SortingCriteria( ["track"] )
f = SimpleFilter( None, sortingCrit )
contribList = f.apply(self._conf.getContributionList())
self.assert_( len(contribList) == 3 )
self.assert_( contribList[0] == contrib2 )
self.assert_( contribList[1] == contrib1 )
self.assert_( contribList[2] == contrib3 )
