def setUp(self): av = user.Avatar() self._conf = conference.Conference(av) self._track1 = self._conf.newTrack() self._track2 = self._conf.newTrack() self._track3 = self._conf.newTrack() submitter = user.Avatar() submitter.setId("submitter") self._abstract = self._conf.getAbstractMgr().newAbstract(submitter)
def setUp(self): av = user.Avatar() self._conf = conference.Conference(av) 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() submitter = user.Avatar() submitter.setId("submitter") self._abstract = self._conf.getAbstractMgr().newAbstract(submitter)
def testCannotAccWithdrawn(self): #tests that a withdrawn abstract cannot be accepted self._abstract.withdraw(None, "hola") cm = user.Avatar() cm.setId("cm") self.assertRaises(errors.MaKaCError, self._abstract.accept, cm, self._track1, self._ctOral)
def testNormal(self): #tests the normal flow of events of the withdrawal TC av = user.Avatar() self._abstract.withdraw(av, "hola") self.assert_( isinstance(self._abstract.getCurrentStatus(), review.AbstractStatusWithdrawn))
def _process(self): from MaKaC.common.Configuration import Config from MaKaC.externUsers import ExtUserHolder from urllib import urlencode euh = ExtUserHolder() ah = user.AvatarHolder() newIdentityList = [] for id in self._identityList: newId = id for authId in Config.getInstance().getAuthenticatorList(): if id[:len(authId)] == authId: dict = euh.getById(authId).getById(id.split(':')[1]) av = user.Avatar(dict) newId = ah.add(av) identity = dict["identity"](dict["login"], av) try: dict["authenticator"].add(identity) except: pass av.activateAccount() newIdentityList.append("selectedPrincipals=%s" % newId) if self._addURL.find("?") != -1: targetURL = self._addURL + "&" + urlencode( self._params) + "&" + "&".join(newIdentityList) else: targetURL = self._addURL + "?" + urlencode( self._params) + "&" + "&".join(newIdentityList) self._redirect(targetURL)
def createUser(name, email, org, password): #has problem that if no email exists and 2 users with same name will clash #perhaps change getUser() to check for same name if no email exist. #problem being that more than one person can have same name. Email unique. dummy = user.Avatar() #sets the user properties if name == '': #if there is no username makes the email address appear in it's place dummy.setName(email) else: dummy.setName(name) dummy.setEmail(email) dummy.setOrganisation(org) ah.add(dummy) avatar = ah.getById(dummy.id) if email != '': #creates the identity and sets the password for chairs etc. id = user.LocalIdentity(name, password, avatar) else: #user with no email address - identity not created return avatar ih = user.AuthenticatorMgr() try: ih.add(id) except (UserError): pass avatar.activateAccount() return avatar
def create(self, li): # first, check if authentication is OK data = NiceChecker().check(li.getLogin(), li.getPassword()) if not data: return None if (data["ccid"] == '') and (data['email'] == ""): return None if not data: # cannot get user data return None # Search if user already exist, using email address import MaKaC.user as user ah = user.AvatarHolder() userList = ah.match({"email":data["mail"]}, forceWithoutExtAuth=True) if len(userList) == 0: # User doesn't exist, create it try: av = user.Avatar() av.setName(data.get('cn', "No name")) av.setSurName(data.get('sn', "No Surname")) av.setOrganisation(data.get('homeinstitute', "No institute")) av.setEmail(data['mail']) av.setTelephone(data.get('telephonenumber',"")) ah.add(av) except KeyError, e: raise MaKaCError( _("NICE account does not contain the mandatory data to create \ an Indico account. You can create an Indico \ account manually in order to use your NICE login")%(urlHandlers.UHUserRegistration.getURL()))
def testNormal(self): #tests the abstract recovery normal flow av = user.Avatar() self._abstract.withdraw(av) self._abstract.recover() self.assert_( isinstance(self._abstract.getCurrentStatus(), review.AbstractStatusSubmitted))
def testIdCollission(self): #checks that no collission with contributions can happen regarding # the ids contrib = conference.Contribution() self._conf.addContribution(contrib) res1 = user.Avatar() res1.setId("res1") abstract = self._conf.getAbstractMgr().newAbstract(res1) #accepting an abstract for a certain track self._abstract.accept(res1, self._track1, self._ctOral) self.assert_(contrib.getId() != abstract.getId())
def testAcceptForNonProposedTrack(self): #an abstract can be accepted for a track for which it is not proposed self._abstract.setTracks([self._track1, self._track2]) self.assert_(not self._track3.hasAbstract(self._abstract)) res1 = user.Avatar() res1.setId("res1") self._abstract.accept(res1, self._track3, self._ctOral) #check the status is changed to accept status = self._abstract.getCurrentStatus() self.assert_(isinstance(status, review.AbstractStatusAccepted)) #check the track self.assert_(status.getTrack() == self._track3) #check the track list contains the track for which it was accepted self.assert_(self._track3.hasAbstract(self._abstract))
def testTackJudgementClearing(self): #tests that after recovering an abstract which had some judgements # they are cleared. tc = user.Avatar() tc.setId("tc") self._abstract.proposeToAccept(tc, self._track1, "oral") self._abstract.proposeToAccept(tc, self._track3, "oral") self._abstract.withdraw(tc) self._abstract.recover() self.assert_(self._abstract.hasTrack(self._track1)) self.assert_(self._abstract.hasTrack(self._track3)) self.assert_(self._track1.hasAbstract(self._abstract)) self.assert_(self._track3.hasAbstract(self._abstract)) self.assert_(self._abstract.getNumJudgements() == 2)
def testAccepted(self): #tests that it is possible to withdraw an accepted abstract and that it # provokes the withdrawal of the associated contribution av = user.Avatar() self._abstract.accept(av, self._track1, self._ctOral) contrib = self._abstract.getContribution() self.assert_( not isinstance(contrib, conference.ContribStatusWithdrawn)) self._abstract.withdraw(av, "hola") absStatus = self._abstract.getCurrentStatus() contribStatus = contrib.getCurrentStatus() self.assert_(isinstance(absStatus, review.AbstractStatusWithdrawn)) self.assert_( isinstance(contribStatus, conference.ContribStatusWithdrawn))
def testAddAndRemoveSubCategories(self): #checks that the conference counter works fine when adding a new # sub-category croot=conference.Category() c1=conference.Category() c2=conference.Category() croot._addSubCategory(c2) creator=user.Avatar() conf0=conference.Conference(creator) conf0.setId("0") conf1=conference.Conference(creator) conf1.setId("1") c1._addConference(conf0) c1._addConference(conf1) self.assert_(croot.getNumConferences()==0) self.assert_(c1.getNumConferences()==2) self.assert_(c2.getNumConferences()==0) croot._addSubCategory(c1) self.assert_(croot.getNumConferences()==2) self.assert_(c1.getNumConferences()==2) self.assert_(c2.getNumConferences()==0) c1_1=conference.Category() c1._addSubCategory(c1_1) self.assert_(croot.getNumConferences()==2) self.assert_(c1.getNumConferences()==2) self.assert_(c1_1.getNumConferences()==2) self.assert_(c2.getNumConferences()==0) c1_1.move(c2) self.assert_(croot.getNumConferences()==2) self.assert_(c1.getNumConferences()==0) self.assert_(c1_1.getNumConferences()==2) self.assert_(c2.getNumConferences()==2) croot._removeSubCategory(c1) self.assert_(croot.getNumConferences()==2) self.assert_(c1.getNumConferences()==0) self.assert_(c1_1.getNumConferences()==2) self.assert_(c2.getNumConferences()==2) c2._removeSubCategory(c1_1) self.assert_(croot.getNumConferences()==0) self.assert_(c1.getNumConferences()==0) self.assert_(c1_1.getNumConferences()==2) self.assert_(c2.getNumConferences()==0)
def testSimpleSubmission(self): submitter = user.Avatar() submitter.setId("submitter") #creation of a new abstract a = self._conf.getAbstractMgr().newAbstract(submitter) #setting of abstract tracks a.setTracks([self._track1, self._track2]) #checking that the abstract is in the conference and its status is # submitted self.assert_(a in self._conf.getAbstractMgr().getAbstractList()) self.assert_( isinstance(a.getCurrentStatus(), review.AbstractStatusSubmitted)) #checking that the abstract tracks are correctly set up self.assert_(a.isProposedForTrack(self._track1)) self.assert_(a.isProposedForTrack(self._track2)) self.assert_(not a.isProposedForTrack(self._track3)) #checking that the abstract is included in the track abstract list self.assert_(a.isProposedForTrack(self._track1)) self.assert_(a.isProposedForTrack(self._track2)) self.assert_(not a.isProposedForTrack(self._track3)) #checking that the submitter is the abstract submitter self.assert_(a.isSubmitter(submitter))
def testSimpleReallocation(self): tc1 = user.Avatar() tc1.setId("tc1") self._abstract.proposeForOtherTracks( tc1, self._track1, "test", \ [self._track2, self._track3] ) self.assert_(self._abstract.hasTrack(self._track1)) self.assert_(self._abstract.hasTrack(self._track2)) self.assert_(self._abstract.hasTrack(self._track3)) self.assert_(self._abstract.getNumJudgements() == 1) t1jud = self._abstract.getTrackJudgement(self._track1) self.assert_(isinstance(t1jud, review.AbstractReallocation)) self.assert_(t1jud.getResponsible() == tc1) self.assert_(self._track2 in t1jud.getProposedTrackList()) self.assert_(self._track3 in t1jud.getProposedTrackList()) self.assert_(self._track1 not in t1jud.getProposedTrackList()) status = self._abstract.getCurrentStatus() self.assert_(isinstance(status, review.AbstractStatusUnderReview)) t2_tl = self._abstract.getReallocationTargetedList(self._track2) self.assert_(t1jud in t2_tl) t3_tl = self._abstract.getReallocationTargetedList(self._track3) self.assert_(t1jud in t3_tl) t1_tl = self._abstract.getReallocationTargetedList(self._track1) self.assert_(t1jud not in t1_tl)
def create(self, li): Logger.get('auth.ldap').info("create '%s'" % li.getLogin()) # first, check if authentication is OK data = LDAPChecker().check(li.getLogin(), li.getPassword()) if not data: return None # Search if user already exist, using email address import MaKaC.user as user ah = user.AvatarHolder() userList = ah.match({"email": data["mail"]}, forceWithoutExtAuth=True) if len(userList) == 0: # User doesn't exist, create it try: av = user.Avatar() name = data.get('cn') av.setName(name.split()[0]) av.setSurName(name.split()[-1]) av.setOrganisation(data.get('o', "")) av.setEmail(data['mail']) if 'postalAddress' in data: av.setAddress(fromLDAPmultiline(data.get('postalAddress'))) #av.setTelephone(data.get('telephonenumber',"")) ah.add(av) av.activateAccount() except KeyError: raise MaKaCError("LDAP account does not contain the mandatory" "data to create an Indico account.") else: # user founded av = userList[0] #now create the nice identity for the user na = LDAPAuthenticator() id = na.createIdentity(li, av) na.add(id) return av
def testBasicAddAndRemoveConferences(self): #creation of basic category structure over which perform the tests croot=conference.Category() c1=conference.Category() croot._addSubCategory(c1) c2=conference.Category() croot._addSubCategory(c2) c1_1=conference.Category() c1._addSubCategory(c1_1) #checks adding a conference increases the conference number of the # involved categories creator=user.Avatar() conf1=conference.Conference(creator) conf1.setId("0") c1_1._addConference(conf1) self.assert_(c1_1.getNumConferences()==1) self.assert_(c1.getNumConferences()==1) self.assert_(c2.getNumConferences()==0) self.assert_(croot.getNumConferences()==1) conf2=conference.Conference(creator) conf2.setId("1") c2._addConference(conf2) self.assert_(c1_1.getNumConferences()==1) self.assert_(c1.getNumConferences()==1) self.assert_(c2.getNumConferences()==1) self.assert_(croot.getNumConferences()==2) c1_1.removeConference(conf1) self.assert_(c1_1.getNumConferences()==0) self.assert_(c1.getNumConferences()==0) self.assert_(c2.getNumConferences()==1) self.assert_(croot.getNumConferences()==1) c2.removeConference(conf2) self.assert_(c1_1.getNumConferences()==0) self.assert_(c1.getNumConferences()==0) self.assert_(c2.getNumConferences()==0) self.assert_(croot.getNumConferences()==0)
def _process(self): save = False authManager = AuthenticatorMgr() minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance() self._params["msg"] = "" if self._save: save = True #check submited data if not self._params.get("name", ""): self._params["msg"] += _("You must enter a name.") + "<br>" save = False if not self._params.get("surName", ""): self._params["msg"] += _("You must enter a surname.") + "<br>" save = False if not self._params.get("organisation", ""): self._params["msg"] += _( "You must enter the name of your organisation.") + "<br>" save = False if not self._params.get("email", ""): self._params["msg"] += _( "You must enter an email address.") + "<br>" save = False if not self._params.get("login", ""): self._params["msg"] += _("You must enter a login.") + "<br>" save = False if not self._params.get("password", ""): self._params["msg"] += _( "You must define a password.") + "<br>" save = False if self._params.get("password", "") != self._params.get( "passwordBis", ""): self._params["msg"] += _( "You must enter the same password twice.") + "<br>" save = False if not authManager.isLoginAvailable(self._params.get("login", "")): self._params["msg"] += _( "Sorry, the login you requested is already in use. Please choose another one." ) + "<br>" save = False if not self._validMail(self._params.get("email", "")): self._params["msg"] += _( "You must enter a valid email address") save = False if save: #Data are OK, Now check if there is an existing user or create a new one ah = user.AvatarHolder() res = ah.match({"email": self._params["email"]}, exact=1, searchInAuthenticators=False) if res: #we find a user with the same email a = res[0] #check if the user have an identity: if a.getIdentityList(): self._redirect( urlHandlers.UHConfUserExistWithIdentity.getURL( self._conf, a)) return else: #create the identity to the user and send the comfirmation email li = user.LoginInfo(self._params["login"], self._params["password"]) id = authManager.createIdentity(li, a, "Local") authManager.add(id) DBMgr.getInstance().commit() if minfo.getModerateAccountCreation(): mail.sendAccountCreationModeration(a).send() else: mail.sendConfirmationRequest(a, self._conf).send() if minfo.getNotifyAccountCreation(): mail.sendAccountCreationNotification(a).send() else: a = user.Avatar() _UserUtils.setUserData(a, self._params) ah.add(a) li = user.LoginInfo(self._params["login"], self._params["password"]) id = authManager.createIdentity(li, a, "Local") authManager.add(id) DBMgr.getInstance().commit() if minfo.getModerateAccountCreation(): mail.sendAccountCreationModeration(a).send() else: mail.sendConfirmationRequest(a).send() if minfo.getNotifyAccountCreation(): mail.sendAccountCreationNotification(a).send() self._redirect(urlHandlers.UHConfUserCreated.getURL(self._conf, a)) else: p = conferences.WPConfUserCreation(self, self._conf, self._params) return p.display()
def setUp(self): self._creator = user.Avatar() self._conf = conference.Conference(self._creator)
def setUp(self): av = user.Avatar() self._conf = conference.Conference(av) self._track1 = self._conf.newTrack() self._track2 = self._conf.newTrack() self._track3 = self._conf.newTrack()
def runTests(host='localhost', port=FAKE_SERVICE_PORT, scenarios=[(2, 10)]): execTimes = [] agent = InvenioBatchUploaderAgent('test1', 'test1', 'test', 0, 'http://%s:%s' \ % (host, port)) ph = PluginsHolder() ph.reloadAllPlugins() ph.getPluginType('livesync').toggleActive() do = DummyObservable() do._notify('updateDBStructures', 'indico.ext.livesync', None, None, None) sm = SyncManager.getDBInstance() sm.registerNewAgent(agent) cm = CategoryManager() avatar = user.Avatar() avatar.setName( "fake" ) avatar.setSurName( "fake" ) avatar.setOrganisation( "fake" ) avatar.setLang( "en_GB" ) avatar.setEmail( "*****@*****.**" ) #registering user ah = user.AvatarHolder() ah.add(avatar) #setting up the login info li = user.LoginInfo("dummyuser", None) am = AuthenticatorMgr() userid = am.createIdentity( li, avatar, "Local" ) am.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 ) dummy = avatar ContextManager.destroy() HelperMaKaCInfo.getMaKaCInfoInstance().setDefaultConference(DefaultConference()) cm.getRoot() do._notify('requestStarted') home = cm.getById('0') # execute code for nconf in range(0, 1000): conf = home.newConference(dummy) conf.setTitle('Test Conference %s' % nconf) do._notify('requestFinished') time.sleep(1) # params won't be used task = LiveSyncUpdateTask(dateutil.rrule.MINUTELY) for scen in scenarios: print "Scenario %s workers, size = %s " % scen, # configure scenario InvenioBatchUploaderAgent.NUM_WORKERS = scen[0] InvenioBatchUploaderAgent.BATCH_SIZE = scen[1] ts = time.time() # just run it task.run() te = time.time() execTimes.append(te - ts) print "%s" % (te - ts) sm._track._pointers['test1'] = None for i in range(0, len(execTimes)): results[scenarios[i]] = execTimes[i]
def setUp(self): av = user.Avatar() self._conf = conference.Conference(av) self._tz = timezone('UTC') self._conf.setTimezone('UTC')
def _process(self): save = False ih = AuthenticatorMgr() minfo = info.HelperMaKaCInfo.getMaKaCInfoInstance() self._params["msg"] = "" if self._save: save = True #check submited data if not self._params.get("name", ""): self._params["msg"] += _("You must enter a name.") + "<br>" save = False if not self._params.get("surName", ""): self._params["msg"] += _("You must enter a surname.") + "<br>" save = False if not self._params.get("organisation", ""): self._params["msg"] += _( "You must enter the name of your organisation.") + "<br>" save = False if not self._params.get("email", ""): self._params["msg"] += _( "You must enter an email address.") + "<br>" save = False if not self._params.get("login", ""): self._params["msg"] += _("You must enter a login.") + "<br>" save = False if not self._params.get("password", ""): self._params["msg"] += _( "You must define a password.") + "<br>" save = False if self._params.get("password", "") != self._params.get( "passwordBis", ""): self._params["msg"] += _( "You must enter the same password twice.") + "<br>" save = False if not ih.isLoginFree(self._params.get("login", "")): self._params["msg"] += _( "Sorry, the login you requested is already in use. Please choose another one." ) + "<br>" save = False if not self._validMail(self._params.get("email", "")): self._params["msg"] += _( "You must enter a valid email address") save = False if save: #Data are OK, Now check if there is an existing user or create a new one ah = user.AvatarHolder() res = ah.match({"email": self._params["email"]}, exact=1, forceWithoutExtAuth=True) if res: #we find a user with the same email a = res[0] #check if the user have an identity: if a.getIdentityList(): self._redirect( urlHandlers.UHUserExistWithIdentity.getURL(a)) return else: #create the identity to the user and send the comfirmatio email _UserUtils.setUserData(a, self._params) li = user.LoginInfo(self._params["login"], self._params["password"]) id = ih.createIdentity(li, a, "Local") ih.add(id) DBMgr.getInstance().commit() if minfo.getModerateAccountCreation(): mail.sendAccountCreationModeration(a).send() else: mail.sendConfirmationRequest(a).send() if minfo.getNotifyAccountCreation(): mail.sendAccountCreationNotification(a).send() else: a = user.Avatar() _UserUtils.setUserData(a, self._params) ah.add(a) li = user.LoginInfo(self._params["login"], self._params["password"]) id = ih.createIdentity(li, a, "Local") ih.add(id) DBMgr.getInstance().commit() if minfo.getModerateAccountCreation(): mail.sendAccountCreationModeration(a).send() else: mail.sendConfirmationRequest(a).send() if minfo.getNotifyAccountCreation(): mail.sendAccountCreationNotification(a).send() self._redirect(urlHandlers.UHUserCreated.getURL(a)) else: cp = None if self._params.has_key("cpEmail"): ph = pendingQueues.PendingQueuesHolder() cp = ph.getFirstPending(self._params["cpEmail"]) if self._aw.getUser() and self._aw.getUser() in minfo.getAdminList( ).getList(): p = adminPages.WPUserCreation(self, self._params, cp) else: p = adminPages.WPUserCreationNonAdmin(self, self._params, cp) return p.display()
def testBasicAcceptation(self): self._abstract.setTitle("test_title") self._abstract.setField("content", "test_content") self._abstract.setContribType(self._ctPoster) auth1 = self._abstract.newPrimaryAuthor() auth1.setData(firstName="test1_fn", surName="test1_sn", email="test1_email", affiliation="test1_af", address="test1_add", telephone="test1_phone", fax="test1_fax", title="test1_title") self._abstract.addSpeaker(auth1) auth2 = self._abstract.newCoAuthor() auth2.setData(firstName="test2_fn", surName="test2_sn", email="test2_email", affiliation="test2_af", address="test2_add", telephone="test2_phone", fax="test2_fax", title="test2_title") #accepting an abstract for a certain track self._abstract.setTracks([self._track1, self._track2]) res1 = user.Avatar() res1.setId("res1") self._abstract.accept(res1, self._track1, self._ctOral) #check the status is changed to accept status = self._abstract.getCurrentStatus() self.assert_(isinstance(status, review.AbstractStatusAccepted)) #check the track self.assert_(status.getTrack() == self._track1) #check that a contribution has been created and has exactly the same # data contrib = status.getContribution() self.assert_(contrib.getId() == self._abstract.getId()) self.assert_(contrib.getConference() == self._conf) self.assert_(contrib.getAbstract() == self._abstract) self.assert_(contrib in self._conf.getContributionList()) self.assert_(contrib.getTrack() == status.getTrack()) self.assert_(contrib.getTitle() == "test_title") self.assert_(contrib.getDescription() == "test_content") self.assert_(contrib.getType() == self._ctOral) c_auth = contrib.getPrimaryAuthorList()[0] self.assert_(c_auth.getTitle() == auth1.getTitle()) self.assert_(c_auth.getFirstName() == auth1.getFirstName()) self.assert_(c_auth.getFamilyName() == auth1.getSurName()) self.assert_(c_auth.getEmail() == auth1.getEmail()) self.assert_(c_auth.getAffiliation() == auth1.getAffiliation()) self.assert_(c_auth.getAddress() == auth1.getAddress()) self.assert_(c_auth.getPhone() == auth1.getTelephone()) self.assert_(len(contrib.getSpeakerList()) == 1) self.assert_(contrib.isSpeaker(c_auth)) c_auth = contrib.getCoAuthorList()[0] self.assert_(c_auth.getTitle() == auth2.getTitle()) self.assert_(c_auth.getFirstName() == auth2.getFirstName()) self.assert_(c_auth.getFamilyName() == auth2.getSurName()) self.assert_(c_auth.getEmail() == auth2.getEmail()) self.assert_(c_auth.getAffiliation() == auth2.getAffiliation()) self.assert_(c_auth.getAddress() == auth2.getAddress()) self.assert_(c_auth.getPhone() == auth2.getTelephone())
def testCannotRejWithdrawn(self): #tests that a withdrawn abstract cannot be rejected self._abstract.withdraw(None, "hola") cm = user.Avatar() cm.setId("cm") self.assertRaises(errors.MaKaCError, self._abstract.reject, cm)