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 testRemoveTC( self ):
from MaKaC.user import Avatar
tc1 = Avatar()
tc1.setId( "tc1" )
tc2 = Avatar()
tc2.setId( "tc2" )
self._track1.addCoordinator( tc1 )
self._track1.addCoordinator( tc2 )
self._track1.removeCoordinator( tc1 )
self.assert_( tc1 not in self._track1.getCoordinatorList() )
self.assert_( tc2 in self._track1.getCoordinatorList() )
self.assert_( self._track1 not in self._conf.getCoordinatedTracks( tc1 ) )
self.assert_( self._track1 in self._conf.getCoordinatedTracks( tc2 ) )
def testUnindexingSeveralCoordinators( self ):
from MaKaC.user import Avatar
av1 = Avatar()
av1.setId( "1" ) #the index needs the avatar to be uniquely identified
av2 = Avatar()
av2.setId( "2" ) #the index needs the avatar to be uniquely identified
from MaKaC.conference import Track
t1 = Track()
t1.setId( "1" )
self._idx.indexCoordinator( av1 , t1 )
self._idx.indexCoordinator( av2 , t1 )
self._idx.unindexCoordinator( av1, t1 )
self.assert_( t1 not in self._idx.getTracks( av1 ) )
self.assert_( t1 in self._idx.getTracks( av2 ) )
def testIndexingSeveralCoordinators( self ):
#adding 2 coordinators for the same track
from MaKaC.user import Avatar
av1 = Avatar()
av1.setId( "1" ) #the index needs the avatar to be uniquely identified
av2 = Avatar()
av2.setId( "2" ) #the index needs the avatar to be uniquely identified
from MaKaC.conference import Track
t = Track()
t.setId( "1" )
self._idx.indexCoordinator( av1 , t )
self._idx.indexCoordinator( av2 , t )
self.assert_( t in self._idx.getTracks( av1 ) )
self.assert_( t in self._idx.getTracks( av2 ) )
def setUp(self):
super(TestAuthentication, self).setUp()
with self._context("database"):
# Create few users and groups
gh = GroupHolder()
ah = AvatarHolder()
self._authMgr = AuthenticatorMgr()
for i in xrange(1, 3):
group = Group()
group.setName("fake-group-%d" % i)
group.setDescription("fake")
group.setEmail("*****@*****.**" % i)
group.setId("fake-group-%d" % i)
avatar = Avatar()
avatar.setName("fake-%d" % i)
avatar.setSurName("fake")
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**" % i)
avatar.setId("fake-%d" % i)
avatar.activateAccount()
group.addMember(avatar)
ah.add(avatar)
gh.add(group)
identity = self._authMgr.createIdentity(
LoginInfo("fake-%d" % i, "fake-%d" % i), avatar, "Local")
self._authMgr.add(identity)
def testAccContrib(self):
#tests that when a contribution comes from an accepted abstract the
# abstract submitters are also granted with submission privileges
# for the contribution
av1=Avatar()
av1.setId("1")
av2=Avatar()
av2.setId("2")
abs=self._conf.getAbstractMgr().newAbstract(av1)
abs.accept(self._creator,None,None)
c=abs.getContribution()
self.assert_(c.canUserSubmit(av1))
self.assert_(not c.canUserSubmit(av2))
c.grantSubmission(av2)
self.assert_(c.canUserSubmit(av1))
self.assert_(c.canUserSubmit(av2))
def setUp( self ):
a = Avatar()
a.setId("creator")
self._categ = Category()
self._conf = Conference( a )
self._conf.setId('a')
self._conf.setDates(datetime(2000, 01, 01, tzinfo=timezone("UTC")),datetime(2020, 01, 01, tzinfo=timezone("UTC")))
def create_dummy_user():
"""
Creates a dummy user for testing purposes
"""
avatar = Avatar()
avatar.setName("fake")
avatar.setSurName("fake")
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**")
# registering user
ah = AvatarHolder()
ah.add(avatar)
# setting up the login info
li = LoginInfo("dummyuser", "dummyuser")
ih = AuthenticatorMgr()
userid = ih.createIdentity(li, avatar, "Local")
ih.add(userid)
# activate the account
avatar.activateAccount()
# since the DB is empty, we have to add dummy user as admin
minfo = HelperMaKaCInfo.getMaKaCInfoInstance()
al = minfo.getAdminList()
al.grant(avatar)
dc = DefaultConference()
HelperMaKaCInfo.getMaKaCInfoInstance().setDefaultConference(dc)
return avatar
def _run(self, args):
avatar = Avatar()
name = raw_input("New administrator name: ").strip()
surname = raw_input("New administrator surname: ").strip()
organization = raw_input("New administrator organization: ").strip()
email = raw_input("New administrator email: ").strip()
login = raw_input("New administrator login: "******"New administrator password: "******"Retype administrator password: "******"Sorry, passwords do not match")
avatar.setName(name)
avatar.setSurName(surname)
avatar.setOrganisation(organization)
avatar.setLang("en_GB")
avatar.setEmail(email)
self.printUserInfo(avatar)
if console.yesno(
"Are you sure to create and grant administrator privileges to this user?"
):
avatar.activateAccount()
loginInfo = LoginInfo(login, password)
authMgr = AuthenticatorMgr()
userid = authMgr.createIdentity(loginInfo, avatar, "Local")
authMgr.add(userid)
adminList = info.HelperMaKaCInfo.getMaKaCInfoInstance(
).getAdminList()
AvatarHolder().add(avatar)
adminList.grant(avatar)
print "New administrator created successfully with id: %s" % avatar.getId(
)
def setUp( self ):
self._creator=Avatar()
self._creator.setId("creator")
self._conf=Conference(self._creator)
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 testArchiveConferenceFile(self):
"""Makes sure a file wich is attached to a conference gets stored in
the right path: basePath/year/C0/0/test.txt
"""
with self._context('database'):
#first we create a dummy user which will be the conf creator
from MaKaC.user import Avatar
av = Avatar()
#Now we create a dummy conference and set its id to 0
from MaKaC.conference import Conference
c = Conference(av)
c.setId("0")
#Now we create the material (id=0) and attach it to the conference
from MaKaC.conference import Material
m = Material()
c.addMaterial(m)
#Now we create a dummy file and attach it to the material
filePath = os.path.join(os.getcwd(), "test.txt")
fh = open(filePath, "w")
fh.write("hola")
fh.close()
from MaKaC.conference import LocalFile
f = LocalFile()
f.setFilePath(filePath)
f.setFileName("test.txt")
m.addResource(f)
def setUp(self):
super(TestAbstractSubmission, self).setUp()
self._startDBReq()
# Create few users
ah = AvatarHolder()
# Create dummy avatars in obj._avatarN
self._avatars = []
for i in xrange(1, 5):
avatar = Avatar()
avatar.setName("fake-%d" % i)
avatar.setSurName("fake")
avatar.setOrganisation("fake")
avatar.setLang("en_GB")
avatar.setEmail("*****@*****.**" % i)
avatar.setId("fake-%d" % i)
ah.add(avatar)
self._avatars.append(avatar)
setattr(self, '_avatar%d' % i, avatar)
# Create a conference
category = conference.CategoryManager().getById('0')
self._conf = category.newConference(self._avatar1)
self._conf.setTimezone('UTC')
sd = datetime(2011, 11, 1, 10, 0, tzinfo=timezone('UTC'))
ed = datetime(2011, 11, 1, 18, 0, tzinfo=timezone('UTC'))
self._conf.setDates(sd, ed)
ch = ConferenceHolder()
ch.add(self._conf)
self._stopDBReq()
def testTplConditions(self):
#test adding and removing conditions to templates
from MaKaC.review import NotificationTemplate
tpl1 = NotificationTemplate()
tpl2 = NotificationTemplate()
absMgr = self._conf.getAbstractMgr()
absMgr.addNotificationTpl(tpl1)
absMgr.addNotificationTpl(tpl2)
from MaKaC.review import NotifTplCondAccepted, NotifTplCondRejected
cond1 = NotifTplCondAccepted(contribType=self._contribTypeOral)
cond2 = NotifTplCondRejected()
tpl1.addCondition(cond1)
tpl2.addCondition(cond2)
from MaKaC.user import Avatar
submitter = Avatar()
submitter.setId("submitter")
abs1 = absMgr.newAbstract(submitter)
tplRes = absMgr.getNotifTplForAbstract(abs1)
self.assert_(tplRes is None)
abs1.accept(submitter, self._track1, self._contribTypeOral)
self.assert_(absMgr.getNotifTplForAbstract(abs1) == tpl1)
abs2 = absMgr.newAbstract(submitter)
abs2.accept(submitter, self._track1, self._contribTypePoster)
self.assert_(not absMgr.getNotifTplForAbstract(abs2))
abs3 = absMgr.newAbstract(submitter)
abs3.reject(submitter)
self.assert_(absMgr.getNotifTplForAbstract(abs3) == tpl2)
def testTplCondAccAnyTrack(self):
#test different possibilities when a condition has been stablished for
# a notif tpl on any track
from MaKaC.review import NotificationTemplate
tpl1 = NotificationTemplate()
absMgr = self._conf.getAbstractMgr()
absMgr.addNotificationTpl(tpl1)
from MaKaC.review import NotifTplCondAccepted
cond1 = NotifTplCondAccepted(contribType=self._contribTypeOral)
tpl1.addCondition(cond1)
from MaKaC.user import Avatar
submitter = Avatar()
submitter.setId("submitter")
abs1 = absMgr.newAbstract(submitter)
abs1.accept(submitter, self._track1, self._contribTypeOral)
self.assert_(absMgr.getNotifTplForAbstract(abs1) == tpl1)
abs2 = absMgr.newAbstract(submitter)
abs2.accept(submitter, self._track1, self._contribTypePoster)
self.assert_(absMgr.getNotifTplForAbstract(abs2) is None)
abs3 = absMgr.newAbstract(submitter)
abs3.accept(submitter, self._track2, self._contribTypeOral)
self.assert_(absMgr.getNotifTplForAbstract(abs3) == tpl1)
abs4 = absMgr.newAbstract(submitter)
abs4.accept(submitter, None, self._contribTypeOral)
self.assert_(absMgr.getNotifTplForAbstract(abs4) == tpl1)
def testAddTC( self ):
from MaKaC.user import Avatar
tc1 = Avatar()
tc1.setId( "tc1" )
self._track1.addCoordinator( tc1 )
self.assert_( len(self._track1.getCoordinatorList()) == 1 )
self.assert_( tc1 in self._track1.getCoordinatorList() )
self.assert_( self._track1 in self._conf.getCoordinatedTracks( tc1 ) )
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 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 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 setUp( self ):
from MaKaC.user import Avatar
cr = Avatar()
cr.setId( "creator" )
from MaKaC.conference import Conference, Track
self._conf = Conference( cr )
self._track1 = Track()
self._track1.setId( "1" )
self._conf.addTrack( self._track1 )
def setUp(self):
super(TestTasks, self).setUp()
self._startDBReq()
PluginsHolder().updateAllPluginInfo()
PluginsHolder().getPluginType('calendaring').setActive(True)
PluginsHolder().getPluginType('calendaring').getPlugin(
'outlook').setActive(True)
# Create two dummy users
ah = AvatarHolder()
self._avatar1 = Avatar()
self._avatar1.setName("fake-1")
self._avatar1.setSurName("fake1")
self._avatar1.setOrganisation("fake1")
self._avatar1.setEmail("*****@*****.**")
ah.add(self._avatar1)
self._avatar2 = Avatar()
self._avatar2.setName("fake-2")
self._avatar2.setSurName("fake2")
self._avatar2.setOrganisation("fake2")
self._avatar2.setEmail("*****@*****.**")
ah.add(self._avatar2)
# Create two dummy conferences
category = conf.CategoryManager().getById('0')
ch = ConferenceHolder()
self._conf1 = category.newConference(self._avatar1)
self._conf1.setTimezone('UTC')
sd1 = datetime(2012, 12, 1, 10, 0, tzinfo=timezone('UTC'))
ed1 = datetime(2012, 12, 1, 18, 0, tzinfo=timezone('UTC'))
self._conf1.setDates(sd1, ed1)
ch.add(self._conf1)
self._conf2 = category.newConference(self._avatar2)
self._conf2.setTimezone('UTC')
sd2 = datetime(2012, 12, 10, 11, 0, tzinfo=timezone('UTC'))
ed2 = datetime(2012, 12, 11, 13, 0, tzinfo=timezone('UTC'))
self._conf2.setDates(sd2, ed2)
ch.add(self._conf2)
self._stopDBReq()
def setUp(self):
a = Avatar()
a.setId("creator")
self._conf = ConferenceFacade(a)
self._conf.setId('a')
self._conf.setTimezone('UTC')
self._conf.setDates(
datetime(2009, 9, 21, 16, 0, 0, tzinfo=timezone("UTC")),
datetime(2009, 9, 21, 19, 0, 0, tzinfo=timezone("UTC")))
def testSimpleIndexing( self ):
#adding a simple object to the index
from MaKaC.user import Avatar
av = Avatar()
av.setId( "1" ) #the index needs the avatar to be uniquely identified
from MaKaC.conference import Track
t = Track()
t.setId( "1" )
self._idx.indexCoordinator( av , t )
self.assert_( len(self._idx.getTracks( av )) == 1 )
self.assert_( t in self._idx.getTracks( av ) )
def setUp(self):
from MaKaC.user import Avatar
av = Avatar()
from MaKaC.conference import Conference
self._conf = Conference(av)
self._track1 = self._conf.newTrack()
self._track2 = self._conf.newTrack()
self._track3 = self._conf.newTrack()
absMgr = self._conf.getAbstractMgr()
self._contribTypeOral = "oral"
self._contribTypePoster = "poster"
def setUp(self):
super(TestAbstractJudgements, self).setUp()
self._startDBReq()
# Get dummy user and create another one
ah = AvatarHolder()
avatar1 = ah.getById(0)
avatar2 = Avatar()
avatar2.setName("fake-2")
avatar2.setSurName("fake")
avatar2.setOrganisation("fake")
avatar2.setLang("en_GB")
avatar2.setEmail("*****@*****.**")
avatar2.setId("fake-2")
ah.add(avatar2)
setattr(self, '_avatar1', avatar1)
setattr(self, '_avatar2', avatar2)
# Create a conference
category = conference.CategoryManager().getById('0')
self._conf = category.newConference(self._avatar1)
self._conf.setTimezone('UTC')
sd = datetime(2011, 11, 1, 10, 0, tzinfo=timezone('UTC'))
ed = datetime(2011, 11, 1, 18, 0, tzinfo=timezone('UTC'))
self._conf.setDates(sd, ed)
ch = ConferenceHolder()
ch.add(self._conf)
self._ctOral = conference.ContributionType("oral", "", self._conf)
self._conf.addContribType(self._ctOral)
self._track1 = self._conf.newTrack()
self._track2 = self._conf.newTrack()
self._track3 = self._conf.newTrack()
self._abstract1 = self._conf.getAbstractMgr().newAbstract(
self._avatar1)
self._abstract2 = self._conf.getAbstractMgr().newAbstract(
self._avatar1)
self._abstract3 = self._conf.getAbstractMgr().newAbstract(
self._avatar1)
self._abstract4 = self._conf.getAbstractMgr().newAbstract(
self._avatar1)
self._abstract5 = self._conf.getAbstractMgr().newAbstract(
self._avatar1)
self._abstract1.setTracks([self._track1, self._track2, self._track3])
self._abstract2.setTracks([self._track1, self._track2])
self._abstract3.setTracks([self._track1])
self._abstract4.setTracks([self._track2, self._track3])
self._abstract5.setTracks([self._track3])
self._stopDBReq()
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')
def testSimpleUnidexing( self ):
#check that unindexing works properly
from MaKaC.user import Avatar
av = Avatar()
av.setId( "1" ) #the index needs the avatar to be uniquely identified
from MaKaC.conference import Track
t = Track()
t.setId( "1" )
self._idx.indexCoordinator( av , t )
self._idx.unindexCoordinator( av, t )
self.assert_( len(self._idx.getTracks( av )) == 0 )
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 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 setUp(self):
super(TestProtection, self).setUp()
self._startDBReq()
# Create a user
ah = AvatarHolder()
self._avatar = Avatar()
self._avatar.setName("fake")
self._avatar.setSurName("fake")
self._avatar.setOrganisation("fake")
self._avatar.setLang("en_GB")
self._avatar.setEmail("*****@*****.**")
self._avatar.setId("fake")
ah.add(self._avatar)
# Create a conference
category = conference.CategoryManager().getById('0')
self._conf = category.newConference(self._avatar)
self._conf.setTimezone('UTC')
sd = datetime(2011, 11, 1, 10, 0, tzinfo=timezone('UTC'))
ed = datetime(2011, 11, 1, 18, 0, tzinfo=timezone('UTC'))
self._conf.setDates(sd, ed)
ch = ConferenceHolder()
ch.add(self._conf)
self._contrib1 = conference.Contribution()
self._conf.addContribution(self._contrib1)
self._session1 = conference.Session()
self._conf.addSession(self._session1)
self._session2 = conference.Session()
self._conf.addSession(self._session2)
self._contrib2 = conference.Contribution()
self._session1.addContribution(self._contrib2)
#Now we create the material (id=0) and attach it to the contrib
self._material = conference.Material()
self._contrib1.addMaterial(self._material)
#Now we create a dummy file and attach it to the material
filePath = os.path.join(os.getcwd(), "test.txt")
fh = open(filePath, "w")
fh.write("hola")
fh.close()
self._resource = conference.LocalFile()
self._resource.setFilePath(filePath)
self._resource.setFileName("test.txt")
self._material.addResource(self._resource)
self._stopDBReq()
def testIndexingSeveralTracks( self ):
#adding 1 coordinator for 2 tracks
from MaKaC.user import Avatar
av1 = Avatar()
av1.setId( "1" ) #the index needs the avatar to be uniquely identified
from MaKaC.conference import Track
t1 = Track()
t1.setId( "1" )
t2 = Track()
t2.setId( "2" )
self._idx.indexCoordinator( av1 , t1 )
self._idx.indexCoordinator( av1 , t2 )
self.assert_( t1 in self._idx.getTracks( av1 ) )
self.assert_( t2 in self._idx.getTracks( av1 ) )