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)
def testEntries(self):
c1, c2 = Contribution(), Contribution()
b = BreakTimeSchEntry()
self._conf.addContribution(c1)
self._conf.addContribution(c2)
self._conf.getSchedule().addEntry(c1.getSchEntry())
self._conf.getSchedule().addEntry(b)
self._conf.getSchedule().addEntry(c2.getSchEntry())
#checks that modifying conference dates which does not affect to
# entries is allowed
self._conf.setStartDate(
datetime(2004, 01, 01, 9, 00, tzinfo=timezone('UTC')))
def testBasicAddAndRemove( self ):
contrib1 = Contribution()
contrib2 = Contribution()
contrib3 = Contribution()
self._conf.addContribution( contrib1 )
self.assert_( self._conf.getContributionById( contrib1.getId() ) == contrib1 )
self._conf.removeContribution( contrib2 )
self.assert_( self._conf.getContributionById( contrib1.getId() ) == contrib1 )
self._conf.removeContribution( contrib1 )
self.assert_( self._conf.getContributionById( contrib1.getId() ) == None )
self._conf.addContribution( contrib2 )
contrib2.delete()
self.assert_( self._conf.getContributionById( contrib2.getId() ) == None )
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())
def testContributions(self):
c1, c2 = Contribution(), Contribution()
self._conf.addContribution(c1)
self._conf.addContribution(c2)
sDate = datetime(2004, 01, 01, 10, 00, tzinfo=timezone('UTC'))
eDate = datetime(2004, 01, 01, 12, 00, tzinfo=timezone('UTC'))
self._conf.setStartDate(sDate)
self._conf.setEndDate(eDate)
c1.setDuration(0, 10)
c2.setDuration(0, 30)
self._conf.getSchedule().addEntry(c1.getSchEntry())
self._conf.getSchedule().addEntry(c2.getSchEntry())
self.assert_(c1.getSchEntry() in self._conf.getSchedule().getEntries())
self.assert_(c1.getStartDate() == datetime(
2004, 01, 01, 10, 00, tzinfo=timezone('UTC')))
def testSessionInclusion(self):
session1,session2=Session(),Session()
self._conf.addSession(session1)
self._conf.addSession(session2)
contrib1=Contribution()
self._conf.addContribution(contrib1)
contrib1.setTitle("debug")
contrib1.setSession(session1)
self.assert_(self._conf.hasContribution(contrib1))
self.assert_(session1.hasContribution(contrib1))
self.assert_(not session2.hasContribution(contrib1))
contrib1.setSession(session2)
self.assert_(self._conf.hasContribution(contrib1))
self.assert_(not session1.hasContribution(contrib1))
self.assert_(session2.hasContribution(contrib1))
contrib1.setSession(None)
self.assert_(self._conf.hasContribution(contrib1))
self.assert_(not session1.hasContribution(contrib1))
self.assert_(not session2.hasContribution(contrib1))
contrib1.setSession(session1)
self.assert_(self._conf.hasContribution(contrib1))
self.assert_(session1.hasContribution(contrib1))
self.assert_(not session2.hasContribution(contrib1))
self._conf.removeContribution(contrib1)
self.assert_(not self._conf.hasContribution(contrib1))
self.assert_(not session1.hasContribution(contrib1))
self.assert_(contrib1 not in session1.getContributionList())
self.assert_(not session2.hasContribution(contrib1))
self.assert_(contrib1 not in session2.getContributionList())
def testBasic(self):
c1=Contribution()
self._conf.addContribution(c1)
av1,av2=Avatar(),Avatar()
av1.setId("1")
av2.setId("2")
self.assert_(not c1.canUserSubmit(av1))
self.assert_(not c1.canUserSubmit(av2))
self.assert_(len(c1.getSubmitterList())==0)
c1.grantSubmission(av1)
self.assert_(c1.canUserSubmit(av1))
self.assert_(not c1.canUserSubmit(av2))
self.assert_(len(c1.getSubmitterList())==1)
self.assert_(av1 in c1.getSubmitterList())
self.assert_(av2 not in c1.getSubmitterList())
c1.revokeSubmission(av2)
self.assert_(c1.canUserSubmit(av1))
self.assert_(not c1.canUserSubmit(av2))
self.assert_(len(c1.getSubmitterList())==1)
self.assert_(av1 in c1.getSubmitterList())
self.assert_(av2 not in c1.getSubmitterList())
c1.revokeSubmission(av1)
self.assert_(not c1.canUserSubmit(av1))
self.assert_(not c1.canUserSubmit(av2))
self.assert_(len(c1.getSubmitterList())==0)
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)
def test( self ):
from MaKaC.conference import Contribution
contrib1 = Contribution()
self._conf.addContribution( contrib1 )
self._track1.addContribution( contrib1 )
self.assert_( self._track1.hasContribution( contrib1 ) )
self.assert_( contrib1.getTrack() == track1 )
self._track1.removeContribution( contrib1 )
self.assert_( not self._track1.hasContribution( contrib1 ) )
self.assert_( contrib1.getTrack() == None )
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))
def testTrackDefinition( self ):
#tests the definition of the track of a contribution
contrib1 = Contribution()
track1 = self._conf.newTrack()
track2 = self._conf.newTrack()
self._conf.addContribution( contrib1 )
contrib1.setTrack( track1 )
self.assert_( contrib1.getTrack() == track1 )
self.assert_( track1.hasContribution( contrib1 ) )
contrib1.setTrack( None )
self.assert_( contrib1.getTrack() == None )
self.assert_( not track1.hasContribution( contrib1 ) )
def testCustomIds(self):
#tests that adding a contribution with a custom id does not cause any
# trouble
contrib1 = Contribution()
self._conf.addContribution(contrib1,"test")
self.assert_(contrib1.getId()=="test")
self.assert_(self._conf.getContributionById("test")==contrib1)
contrib2 = Contribution()
self._conf.addContribution(contrib2)
self.assert_(contrib2.getId()=="0")
self.assert_(self._conf.getContributionById("0")==contrib2)
contrib3 = Contribution()
self._conf.addContribution(contrib3,"12")
self.assert_(contrib3.getId()=="12")
self.assert_(self._conf.getContributionById("12")==contrib3)
contrib4 = Contribution()
self._conf.addContribution(contrib4)
self.assert_(contrib4.getId()=="1")
self.assert_(self._conf.getContributionById("1")==contrib4)
contrib5 = Contribution()
self.assertRaises(MaKaCError,self._conf.addContribution,contrib5,"0")
self._conf.addContribution(contrib5,"2")
self.assert_(contrib5.getId()=="2")
self.assert_(self._conf.getContributionById("2")==contrib5)
contrib6 = Contribution()
self._conf.addContribution(contrib6)
self.assert_(contrib6.getId()=="3")
self.assert_(self._conf.getContributionById("3")==contrib6)
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())
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)
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"))
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"))
#c1.setStartDate(datetime(1999, 01, 01, 9, 00, tzinfo=timezone('UTC')))
#self.assertRaises(MaKaCError,self._conf.getSchedule().addEntry,c1.getSchEntry())
#b=BreakTimeSchEntry()
#b.setStartDate(datetime(2004, 01, 01, 9, 00, tzinfo=timezone('UTC')))
#self.assertRaises(MaKaCError,self._conf.getSchedule().addEntry,b)
pass
def testSetScheduleDifferentDates(self):
self._conf.setDates(
datetime(2004, 01, 03, 10, 00, tzinfo=timezone('UTC')),
datetime(2004, 01, 05, 10, 00, tzinfo=timezone('UTC')))
s = Session()
s.setDates(datetime(2004, 01, 04, 10, 00, tzinfo=timezone('UTC')),
datetime(2004, 01, 04, 12, 00, tzinfo=timezone('UTC')))
self._conf.addSession(s)
c = Contribution()
self._conf.addContribution(c)
c.setStartDate(datetime(2004, 01, 04, 13, 00, tzinfo=timezone('UTC')))
self._conf.getSchedule().addEntry(c.getSchEntry())
#checks that everything works fine when changing conference schdule
# dates to ones different from the conference
#self._conf.setScreenStartDate(datetime(2004, 01, 04, 10, 00, tzinfo=timezone('UTC')))
#self._conf.setScreenEndDate(datetime(2004, 01, 05, 12, 00, tzinfo=timezone('UTC')))
#self.assertRaises(MaKaCError,self._conf.setScreenStartDate,datetime(2004, 01, 04, 10, 01, tzinfo=timezone('UTC')))
#self.assertRaises(MaKaCError,self._conf.setScreenEndDate,datetime(2004, 01, 04, 13, 00, tzinfo=timezone('UTC')))
#self._conf.setScreenStartDate(datetime(2004, 01, 04, 10, 00, tzinfo=timezone('UTC')))
#self._conf.setScreenEndDate(datetime(2004, 01, 04, 14, 00, tzinfo=timezone('UTC')))
#self._conf.setScreenStartDate(datetime(2004, 01, 01, tzinfo=timezone('UTC')))
#self._conf.setScreenEndDate(datetime(2004, 01, 05, tzinfo=timezone('UTC')))
def setUp(self):
'''
Create a conference, 0
Add 2 contributions to this conference, 0 and 1
To contribution 0 - Add 2 speakers, person1 and person2
To contribution 1 - Add 1 speaker, person1
'''
super(TestElectronicAgreement, self).setUp()
self._startDBReq()
self.falseSession = FalseSession()
# Create few users
self._creator = Avatar({"name": "God", "email": "*****@*****.**"})
self._creator.setId("creator")
# Set God as admin
AdminList.getInstance().getList().append(self._creator)
self.person1 = Avatar({"name": "giuseppe", "email": "*****@*****.**"})
self.person1.setId("spk1")
self.person2 = Avatar({"name": "gabriele", "email": "*****@*****.**"})
self.person1.setId("spk2")
self.person3 = Avatar({"name": "lorenzo", "email": "*****@*****.**"})
self.person1.setId("spk3")
self.person4 = Avatar({"name": "silvio", "email": "*****@*****.**"})
self.person1.setId("spk4")
ah = AvatarHolder()
ah.add(self.person1)
ah.add(self.person2)
ah.add(self.person3)
ah.add(self.person4)
# Create a conference
category = conference.CategoryManager().getById('0')
self._conf = category.newConference(self._creator)
self._conf.setTimezone('UTC')
sd = datetime(2011, 06, 01, 10, 00, tzinfo=timezone("UTC"))
ed = datetime(2011, 06, 05, 10, 00, tzinfo=timezone("UTC"))
self._conf.setDates(
sd,
ed,
)
ch = ConferenceHolder()
ch.add(self._conf)
# Create contributions and add to the conference
c1, c2 = Contribution(), Contribution()
self.speaker1, self.speaker2 = ContributionParticipation(
), ContributionParticipation()
self.speaker1.setDataFromAvatar(self.person1)
self.speaker2.setDataFromAvatar(self.person2)
self._conf.addContribution(c2)
self._conf.addContribution(c1)
# Add speakers to contributions
c1.addPrimaryAuthor(self.speaker1)
c2.addPrimaryAuthor(self.speaker2)
c1.addSpeaker(self.speaker1)
c2.addSpeaker(self.speaker1)
c2.addSpeaker(self.speaker2)
self._conf.enableSessionSlots()
# Create session and schedule the contributions
s1 = Session()
sd = datetime(2011, 06, 02, 12, 00, tzinfo=timezone("UTC"))
ed = datetime(2011, 06, 02, 19, 00, tzinfo=timezone("UTC"))
s1.setDates(sd, ed)
slot1 = SessionSlot(s1)
self._conf.addSession(s1)
slot1.setValues({"sDate": sd})
s1.addSlot(slot1)
s1.addContribution(c1)
s1.addContribution(c2)
slot1.getSchedule().addEntry(c1.getSchEntry())
slot1.getSchedule().addEntry(c2.getSchEntry())
self.createAndAcceptBooking()
self._stopDBReq()
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 )
