Package omeroweb :: Package webadmin :: Package tests :: Module test_webadmin
[hide private]
[frames] | no frames]

Source Code for Module omeroweb.webadmin.tests.test_webadmin

  1  #!/usr/bin/env python 
  2  # -*- coding: utf-8 -*- 
  3  #  
  4  #  
  5  # Copyright (c) 2008 University of Dundee.  
  6  #  
  7  # This program is free software: you can redistribute it and/or modify 
  8  # it under the terms of the GNU Affero General Public License as 
  9  # published by the Free Software Foundation, either version 3 of the 
 10  # License, or (at your option) any later version. 
 11  #  
 12  # This program is distributed in the hope that it will be useful, 
 13  # but WITHOUT ANY WARRANTY; without even the implied warranty of 
 14  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 15  # GNU Affero General Public License for more details. 
 16  #  
 17  # You should have received a copy of the GNU Affero General Public License 
 18  # along with this program.  If not, see <http://www.gnu.org/licenses/>. 
 19  # 
 20   
 21   
 22  import unittest, time, os, datetime 
 23  import tempfile 
 24  import pytest 
 25  import omero 
 26   
 27  from django.conf import settings 
 28  from request_factory import fakeRequest 
 29   
 30  from webgateway import views as webgateway_views 
 31  from webadmin import views as webadmin_views 
 32  from webadmin.webadmin_utils import toBoolean 
 33  from webadmin.forms import LoginForm, GroupForm, ExperimenterForm, \ 
 34                  ContainedExperimentersForm, ChangePassword 
 35   
 36  from connector import Server, Connector 
 37  from webadmin.views import getActualPermissions, setActualPermissions, \ 
 38                          otherGroupsInitialList, prepare_experimenter, \ 
 39                          getSelectedExperimenters, getSelectedGroups, \ 
 40                          mergeLists 
 41  from django.core.urlresolvers import reverse 
 42   
 43  # Test model 
44 -class ServerModelTest (unittest.TestCase):
45
46 - def setUp(self):
47 Server.reset()
48
49 - def test_constructor(self):
50 # Create object with alias 51 Server(host=u'example.com', port=4064, server=u'ome') 52 53 # Create object without alias 54 Server(host=u'example2.com', port=4065) 55 56 # without any params 57 try: 58 Server() 59 except Exception, x: 60 pass 61 else: 62 self.fail('Error:Parameters required')
63
64 - def test_get_and_find(self):
65 SERVER_LIST = [[u'example1.com', 4064, u'omero1'], [u'example2.com', 4064, u'omero2'], [u'example3.com', 4064], [u'example4.com', 4064]] 66 for s in SERVER_LIST: 67 server = (len(s) > 2) and s[2] or None 68 Server(host=s[0], port=s[1], server=server) 69 70 s1 = Server.get(1) 71 self.assertEquals(s1.host, u'example1.com') 72 self.assertEquals(s1.port, 4064) 73 self.assertEquals(s1.server, u'omero1') 74 75 s2 = Server.find('example2.com')[0] 76 self.assertEquals(s2.host, u'example2.com') 77 self.assertEquals(s2.port, 4064) 78 self.assertEquals(s2.server, u'omero2')
79
80 - def test_load_server_list(self):
81 SERVER_LIST = [[u'example1.com', 4064, u'omero1'], [u'example2.com', 4064, u'omero2'], [u'example3.com', 4064], [u'example4.com', 4064]] 82 for s in SERVER_LIST: 83 server = (len(s) > 2) and s[2] or None 84 Server(host=s[0], port=s[1], server=server) 85 Server.freeze() 86 87 try: 88 Server(host=u'example5.com', port=4064) 89 except Exception, x: 90 pass 91 else: 92 self.fail('Error:No more instances allowed') 93 94 Server(host=u'example1.com', port=4064)
95 96
97 -class WebTest(unittest.TestCase):
98
99 - def setUp (self):
100 c = omero.client(pmap=['--Ice.Config='+(os.environ.get("ICE_CONFIG"))]) 101 try: 102 self.root_password = c.ic.getProperties().getProperty('omero.rootpass') 103 self.omero_host = c.ic.getProperties().getProperty('omero.host') 104 self.omero_port = c.ic.getProperties().getProperty('omero.port') 105 Server.reset() 106 Server(host=self.omero_host, port=self.omero_port) 107 finally: 108 c.__del__() 109 110 self.server_id = 1 111 connector = Connector(self.server_id, True) 112 self.rootconn = connector.create_connection('TEST.webadmin', 'root', self.root_password) 113 if self.rootconn is None or not self.rootconn.isConnected() or not self.rootconn.keepAlive(): 114 raise Exception("Cannot connect")
115
116 - def tearDown(self):
117 try: 118 self.rootconn.seppuku() 119 except Exception,e: 120 self.fail(e)
121
122 - def loginAsUser(self, username, password):
123 blitz = Server.get(pk=self.server_id) 124 if blitz is not None: 125 connector = Connector(self.server_id, True) 126 conn = connector.create_connection('TEST.webadmin', username, password) 127 if conn is None or not conn.isConnected() or not conn.keepAlive(): 128 raise Exception("Cannot connect") 129 return conn 130 else: 131 raise Exception("'%s' is not on omero.web.server_list" % omero_host)
132 133
134 -class WebAdminConfigTest(unittest.TestCase):
135
136 - def setUp (self):
137 c = omero.client(pmap=['--Ice.Config='+(os.environ.get("ICE_CONFIG"))]) 138 try: 139 self.root_password = c.ic.getProperties().getProperty('omero.rootpass') 140 self.omero_host = c.ic.getProperties().getProperty('omero.host') 141 self.omero_port = c.ic.getProperties().getProperty('omero.port') 142 Server.reset() 143 Server(host=self.omero_host, port=self.omero_port) 144 finally: 145 c.__del__()
146
147 - def test_isServerOn(self):
148 connector = Connector(1, True) 149 if not connector.is_server_up('omero-webadmin-test'): 150 self.fail('Server is offline')
151
152 - def test_checkVersion(self):
153 connector = Connector(1, True) 154 if not connector.check_version('omero-webadmin-test'): 155 self.fail('Client version does not match server')
156 157 # Testing controllers, and forms
158 -class WebAdminTest(WebTest):
159
160 - def test_loginFromRequest(self):
161 params = { 162 'username': 'root', 163 'password': self.root_password, 164 'server':self.server_id, 165 'ssl':'on' 166 } 167 request = fakeRequest(method="post", path="/webadmin/login", params=params) 168 169 server_id = request.REQUEST.get('server') 170 username = request.REQUEST.get('username') 171 password = request.REQUEST.get('password') 172 is_secure = toBoolean(request.REQUEST.get('ssl')) 173 174 connector = Connector(server_id, is_secure) 175 conn = connector.create_connection('TEST.webadmin', username, password) 176 if conn is None: 177 self.fail('Cannot connect') 178 179 conn.seppuku() 180 if conn.isConnected() and conn.keepAlive(): 181 self.fail('Connection was not closed')
182
183 - def test_loginFromForm(self):
184 params = { 185 'username': 'root', 186 'password': self.root_password, 187 'server':self.server_id, 188 'ssl':'on' 189 } 190 request = fakeRequest(method="post", params=params) 191 192 server_id = request.REQUEST.get('server') 193 form = LoginForm(data=request.REQUEST.copy()) 194 if form.is_valid(): 195 username = form.cleaned_data['username'] 196 password = form.cleaned_data['password'] 197 server_id = form.cleaned_data['server'] 198 is_secure = toBoolean(form.cleaned_data['ssl']) 199 200 connector = Connector(server_id, is_secure) 201 conn = connector.create_connection('OMERO.web', username, password) 202 if conn is None: 203 self.fail('Cannot connect') 204 205 conn.seppuku() 206 if conn.isConnected() and conn.keepAlive(): 207 self.fail('Connection was not closed') 208 209 else: 210 errors = form.errors.as_text() 211 self.fail(errors)
212
213 - def test_loginFailure(self):
214 params = { 215 'username': 'notauser', 216 'password': 'nonsence', 217 'server':self.server_id 218 } 219 request = fakeRequest(method="post", params=params) 220 221 server_id = request.REQUEST.get('server') 222 form = LoginForm(data=request.REQUEST.copy()) 223 if form.is_valid(): 224 username = form.cleaned_data['username'] 225 password = form.cleaned_data['password'] 226 server_id = form.cleaned_data['server'] 227 is_secure = toBoolean(form.cleaned_data['ssl']) 228 229 connector = Connector(server_id, is_secure) 230 conn = connector.create_connection('OMERO.web', username, password) 231 if conn is not None: 232 self.fail('This user does not exist. Login failure error!') 233 234 else: 235 errors = form.errors.as_text() 236 self.fail(errors)
237 239 conn = self.rootconn 240 uuid = conn._sessionUuid 241 242 # private group 243 params = { 244 "name":u"русский_алфавит %s" % uuid, 245 "description":u"Frühstück-Śniadanie. Tschüß-Cześć", 246 "owners": [0L], 247 "members": [0L], 248 "permissions":0 249 } 250 request = fakeRequest(method="post", params=params) 251 gid = _createGroup(request, conn) 252 253 # check if group created 254 group = conn.getObject("ExperimenterGroup", gid) 255 ownerIds = [e.id for e in group.getOwners()] 256 membersIds = [e.id for e in group.getMembers()] 257 permissions = getActualPermissions(group) 258 self.assertEquals(params['name'], group.name) 259 self.assertEquals(params['description'], group.description) 260 self.assertEquals(sorted(params['owners']), sorted(ownerIds)) 261 self.assertEquals(sorted(params['members']), sorted(membersIds)) 262 self.assertEquals(params['permissions'], permissions)
263
264 - def test_createGroups(self):
265 conn = self.rootconn 266 uuid = conn._sessionUuid 267 268 # private group 269 params = { 270 "name":"webadmin_test_group_private %s" % uuid, 271 "description":"test group", 272 "permissions":0 273 } 274 request = fakeRequest(method="post", params=params) 275 gid = _createGroup(request, conn) 276 277 # check if group created 278 group = conn.getObject("ExperimenterGroup", gid) 279 permissions = getActualPermissions(group) 280 self.assertEquals(params['name'], group.name) 281 self.assertEquals(params['description'], group.description) 282 self.assertEquals(params['permissions'], permissions) 283 284 # collaborative read-only group 285 params = { 286 "name":"webadmin_test_group_read-only %s" % uuid, 287 "description":"test group", 288 "permissions":1 289 } 290 request = fakeRequest(method="post", params=params) 291 gid = _createGroup(request, conn) 292 293 # check if group created 294 group = conn.getObject("ExperimenterGroup", gid) 295 permissions = getActualPermissions(group) 296 self.assertEquals(params['name'], group.name) 297 self.assertEquals(params['description'], group.description) 298 self.assertEquals(params['permissions'], permissions) 299 300 # collaborative read-annotate group 301 params = { 302 "name":"webadmin_test_group_read-ann %s" % uuid, 303 "description":"test group", 304 "permissions":2 305 } 306 request = fakeRequest(method="post", params=params) 307 gid = _createGroup(request, conn) 308 309 # check if group created 310 group = conn.getObject("ExperimenterGroup", gid) 311 permissions = getActualPermissions(group) 312 self.assertEquals(params['name'], group.name) 313 self.assertEquals(params['description'], group.description) 314 self.assertEquals(params['permissions'], permissions) 315
316 - def test_badCreateGroup(self):
317 conn = self.rootconn 318 uuid = conn._sessionUuid 319 320 # empty fields 321 params = {} 322 request = fakeRequest(method="post", params=params) 323 try: 324 gid = _createGroup(request, conn) 325 except Exception, e: 326 pass 327 else: 328 self.fail("Can't create group with no parameters")
329
330 - def test_updateGroups(self):
331 conn = self.rootconn 332 uuid = conn._sessionUuid 333 334 # default group - helper 335 params = { 336 "name":"webadmin_test_default %s" % uuid, 337 "description":"test group default", 338 "owners": [0L], 339 "permissions":0 340 } 341 request = fakeRequest(method="post", params=params) 342 default_gid = _createGroup(request, conn) 343 344 # create new user 345 params = { 346 "omename":"webadmin_test_owner %s" % uuid, 347 "first_name":uuid, 348 "middle_name": uuid, 349 "last_name":uuid, 350 "email":"owner_%s@domain.com" % uuid, 351 "institution":"Laboratory", 352 "active":True, 353 "default_group":default_gid, 354 "other_groups":[default_gid], 355 "password":"123", 356 "confirmation":"123" 357 } 358 request = fakeRequest(method="post", params=params) 359 eid = _createExperimenter(request, conn) 360 361 # create new user2 362 params = { 363 "omename":"webadmin_test_member %s" % uuid, 364 "first_name":uuid, 365 "middle_name": uuid, 366 "last_name":uuid, 367 "email":"member_%s@domain.com" % uuid, 368 "institution":"Laboratory", 369 "active":True, 370 "default_group":default_gid, 371 "other_groups":[default_gid], 372 "password":"123", 373 "confirmation":"123" 374 } 375 request = fakeRequest(method="post", params=params) 376 eid2 = _createExperimenter(request, conn) 377 378 # create private group 379 params = { 380 "name":"webadmin_test_group_private %s" % uuid, 381 "description":"test group", 382 "permissions":0 383 } 384 request = fakeRequest(method="post", params=params) 385 gid = _createGroup(request, conn) 386 387 # check if group created 388 group = conn.getObject("ExperimenterGroup", gid) 389 permissions = getActualPermissions(group) 390 self.assertEquals(params['name'], group.name) 391 self.assertEquals(params['description'], group.description) 392 self.assertEquals(params['permissions'], permissions) 393 394 # upgrade group to collaborative 395 # read-only group and add new owner and members 396 params = { 397 "name":"webadmin_test_group_read-only %s" % uuid, 398 "description":"test group changed", 399 "owners": [eid], 400 "members": [eid2], 401 "permissions":1 402 } 403 request = fakeRequest(method="post", params=params) 404 _updateGroup(request, conn, gid) 405 406 # check if group updated 407 group = conn.getObject("ExperimenterGroup", gid) 408 ownerIds = [e.id for e in group.getOwners()] 409 memberIds = [e.id for e in group.getMembers()] 410 permissions = getActualPermissions(group) 411 self.assertEquals(params['name'], group.name) 412 self.assertEquals(params['description'], group.description) 413 self.assertEquals(params['owners'], sorted(ownerIds)) 414 self.assertEquals(sorted(mergeLists(params['owners'], params['members'])), sorted(memberIds)) 415 self.assertEquals(params['permissions'], permissions) 416 417 # upgrade group to collaborative 418 # read-ann group and change owners and members 419 params = { 420 "name":"webadmin_test_group_read-only %s" % uuid, 421 "description":"test group changed", 422 "owners": [eid2], 423 "members": [0,eid], 424 "permissions":1 425 } 426 request = fakeRequest(method="post", params=params) 427 _updateGroup(request, conn, gid) 428 429 # check if group updated 430 group = conn.getObject("ExperimenterGroup", gid) 431 ownerIds = [e.id for e in group.getOwners()] 432 memberIds = [e.id for e in group.getMembers()] 433 permissions = getActualPermissions(group) 434 self.assertEquals(params['name'], group.name) 435 self.assertEquals(params['description'], group.description) 436 self.assertEquals(params['owners'], sorted(ownerIds)) 437 self.assertEquals(sorted(mergeLists(params['owners'], params['members'])), sorted(memberIds)) 438 self.assertEquals(params['permissions'], permissions)
439 440
441 - def test_badUpdateGroup(self):
442 conn = self.rootconn 443 uuid = conn._sessionUuid 444 445 # create group 446 params = { 447 "name":"webadmin_test_group_private %s" % uuid, 448 "description":"test group", 449 "owners": [0L], 450 "permissions":0 451 } 452 request = fakeRequest(method="post", params=params) 453 gid = _createGroup(request, conn) 454 455 # create new users 456 params2 = { 457 "omename":"webadmin_test_user1 %s" % uuid, 458 "first_name":uuid, 459 "middle_name": uuid, 460 "last_name":uuid, 461 "email":"user1_%s@domain.com" % uuid, 462 "institution":"Laboratory", 463 "active":True, 464 "default_group":gid, 465 "other_groups":[gid], 466 "password":"123", 467 "confirmation":"123" 468 } 469 request = fakeRequest(method="post", params=params2) 470 eid = _createExperimenter(request, conn) 471 472 # check if group updated 473 group = conn.getObject("ExperimenterGroup", gid) 474 ownerIds = [e.id for e in group.getOwners()] 475 memberIds = [e.id for e in group.getMembers()] 476 self.assertEquals(params['owners'], sorted(ownerIds)) 477 self.assertEquals(sorted(mergeLists(params['owners'], [eid])), sorted(memberIds)) 478 479 # remove user from the group 480 params["members"] = [0] 481 request = fakeRequest(method="post", params=params) 482 483 try: 484 _updateGroup(request, conn, gid) 485 self.fail("Can't remove user from the group members if this it's hs default group") 486 except omero.ValidationException, ve: 487 pass 488 489 # check if group updated 490 group = conn.getObject("ExperimenterGroup", gid) 491 memberIds = [e.id for e in group.getMembers()] 492 if eid not in memberIds: 493 self.fail("Can't remove user from the group members if this it's hs default group")
494
495 - def test_createExperimenters(self):
496 conn = self.rootconn 497 uuid = conn._sessionUuid 498 499 # private group 500 params = { 501 "name":"webadmin_test_group_private %s" % uuid, 502 "description":"test group", 503 "permissions":0 504 } 505 request = fakeRequest(method="post", params=params) 506 gid = _createGroup(request, conn) 507 508 params = { 509 "omename":"webadmin_test_user %s" % uuid, 510 "first_name":uuid, 511 "middle_name": uuid, 512 "last_name":uuid, 513 "email":"user_%s@domain.com" % uuid, 514 "institution":"Laboratory", 515 "active":True, 516 "default_group":gid, 517 "other_groups":[gid], 518 "password":"123", 519 "confirmation":"123" 520 } 521 request = fakeRequest(method="post", params=params) 522 eid = _createExperimenter(request, conn) 523 524 # check if experimenter created 525 experimenter = conn.getObject("Experimenter", eid) 526 otherGroupIds = [g.id for g in experimenter.getOtherGroups()] 527 self.assertEquals(params['omename'], experimenter.omeName) 528 self.assertEquals(params['first_name'], experimenter.firstName) 529 self.assertEquals(params['middle_name'], experimenter.middleName) 530 self.assertEquals(params['last_name'], experimenter.lastName) 531 self.assertEquals(params['email'], experimenter.email) 532 self.assertEquals(params['institution'], experimenter.institution) 533 self.assert_(not experimenter.isAdmin()) 534 self.assertEquals(params['active'], experimenter.isActive()) 535 self.assertEquals(params['default_group'], experimenter.getDefaultGroup().id) 536 self.assertEquals(sorted(params['other_groups']), sorted(otherGroupIds)) 537 538 params = { 539 "omename":"webadmin_test_admin %s" % uuid, 540 "first_name":uuid, 541 "middle_name": uuid, 542 "last_name":uuid, 543 "email":"admin_%s@domain.com" % uuid, 544 "institution":"Laboratory", 545 "administrator": True, 546 "active":True, 547 "default_group":gid, 548 "other_groups":[0,gid], 549 "password":"123", 550 "confirmation":"123" 551 } 552 request = fakeRequest(method="post", params=params) 553 eid = _createExperimenter(request, conn) 554 555 # check if experimenter created 556 experimenter = conn.getObject("Experimenter", eid) 557 otherGroupIds = [g.id for g in experimenter.getOtherGroups()] 558 self.assertEquals(params['omename'], experimenter.omeName) 559 self.assertEquals(params['first_name'], experimenter.firstName) 560 self.assertEquals(params['middle_name'], experimenter.middleName) 561 self.assertEquals(params['last_name'], experimenter.lastName) 562 self.assertEquals(params['email'], experimenter.email) 563 self.assertEquals(params['institution'], experimenter.institution) 564 self.assertEquals(params['administrator'], experimenter.isAdmin()) 565 self.assertEquals(params['active'], experimenter.isActive()) 566 self.assertEquals(params['default_group'], experimenter.getDefaultGroup().id) 567 self.assertEquals(sorted(params['other_groups']), sorted(otherGroupIds)) 568 569 params = { 570 "omename":"webadmin_test_off %s" % uuid, 571 "first_name":uuid, 572 "middle_name": uuid, 573 "last_name":uuid, 574 "email":"off_%s@domain.com" % uuid, 575 "institution":"Laboratory", 576 "default_group":gid, 577 "other_groups":[gid], 578 "password":"123", 579 "confirmation":"123" 580 } 581 request = fakeRequest(method="post", params=params) 582 eid = _createExperimenter(request, conn) 583 584 # check if experimenter created 585 experimenter = conn.getObject("Experimenter", eid) 586 otherGroupIds = [g.id for g in experimenter.getOtherGroups()] 587 self.assertEquals(params['omename'], experimenter.omeName) 588 self.assertEquals(params['first_name'], experimenter.firstName) 589 self.assertEquals(params['middle_name'], experimenter.middleName) 590 self.assertEquals(params['last_name'], experimenter.lastName) 591 self.assertEquals(params['email'], experimenter.email) 592 self.assertEquals(params['institution'], experimenter.institution) 593 self.assert_(not experimenter.isAdmin()) 594 self.assert_(not experimenter.isActive()) 595 self.assertEquals(params['default_group'], experimenter.getDefaultGroup().id) 596 self.assertEquals(sorted(params['other_groups']), sorted(otherGroupIds))
597
598 - def test_badCreateExperimenters(self):
599 conn = self.rootconn 600 uuid = conn._sessionUuid 601 602 # empty fields 603 params = {} 604 request = fakeRequest(method="post", params=params) 605 try: 606 eid = _createExperimenter(request, conn) 607 except Exception, e: 608 pass 609 else: 610 self.fail("Can't create user with no parameters")
611
612 - def test_updateExperimenter(self):
613 conn = self.rootconn 614 uuid = conn._sessionUuid 615 616 # private group 617 params = { 618 "name":"webadmin_test_group_private %s" % uuid, 619 "description":"test group", 620 "permissions":0 621 } 622 623 request = fakeRequest(method="post", params=params) 624 gid = _createGroup(request, conn) 625 626 # default group - helper 627 params = { 628 "name":"webadmin_test_default %s" % uuid, 629 "description":"test group default", 630 "permissions":0 631 } 632 request = fakeRequest(method="post", params=params) 633 default_gid = _createGroup(request, conn) 634 635 # create experimenter 636 params = { 637 "omename":"webadmin_test_user %s" % uuid, 638 "first_name":uuid, 639 "middle_name": uuid, 640 "last_name":uuid, 641 "email":"user_%s@domain.com" % uuid, 642 "institution":"Laboratory", 643 "active":True, 644 "administrator":False, 645 "default_group":gid, 646 "other_groups":[gid], 647 "password":"123", 648 "confirmation":"123" 649 } 650 request = fakeRequest(method="post", params=params) 651 eid = _createExperimenter(request, conn) 652 653 # add admin privilages and change default group 654 params = { 655 "omename":"webadmin_test_admin %s" % uuid, 656 "first_name":uuid, 657 "middle_name": uuid, 658 "last_name":uuid, 659 "email":"admin_%s@domain.com" % uuid, 660 "institution":"Laboratory", 661 "administrator": True, 662 "active":True, 663 "default_group":default_gid, 664 "other_groups":[0,gid,default_gid], 665 "password":"123", 666 "confirmation":"123" 667 } 668 request = fakeRequest(method="post", params=params) 669 _updateExperimenter(request, conn, eid) 670 671 # check if experimenter updated 672 experimenter = conn.getObject("Experimenter", eid) 673 otherGroupIds = [g.id for g in experimenter.getOtherGroups()] 674 self.assertEquals(params['omename'], experimenter.omeName) 675 self.assertEquals(params['first_name'], experimenter.firstName) 676 self.assertEquals(params['middle_name'], experimenter.middleName) 677 self.assertEquals(params['last_name'], experimenter.lastName) 678 self.assertEquals(params['email'], experimenter.email) 679 self.assertEquals(params['institution'], experimenter.institution) 680 self.assert_(experimenter.isAdmin()) 681 self.assert_(experimenter.isActive()) 682 self.assertEquals(params['default_group'], experimenter.getDefaultGroup().id) 683 self.assertEquals(sorted(params['other_groups']), sorted(otherGroupIds)) 684 685 # remove admin privilages and deactivate account 686 params = { 687 "omename":"webadmin_test_admin %s" % uuid, 688 "first_name":uuid, 689 "middle_name": uuid, 690 "last_name":uuid, 691 "email":"admin_%s@domain.com" % uuid, 692 "institution":"Laboratory", 693 "administrator": False, 694 "active":False, 695 "default_group":default_gid, 696 "other_groups":[gid,default_gid], 697 "password":"123", 698 "confirmation":"123" 699 } 700 request = fakeRequest(method="post", params=params) 701 _updateExperimenter(request, conn, eid) 702 703 # check if experimenter updated 704 experimenter = conn.getObject("Experimenter", eid) 705 otherGroupIds = [g.id for g in experimenter.getOtherGroups()] 706 self.assertEquals(params['omename'], experimenter.omeName) 707 self.assertEquals(params['first_name'], experimenter.firstName) 708 self.assertEquals(params['middle_name'], experimenter.middleName) 709 self.assertEquals(params['last_name'], experimenter.lastName) 710 self.assertEquals(params['email'], experimenter.email) 711 self.assertEquals(params['institution'], experimenter.institution) 712 self.assert_(not experimenter.isAdmin()) 713 self.assert_(not experimenter.isActive()) 714 self.assertEquals(params['default_group'], experimenter.getDefaultGroup().id) 715 self.assertEquals(sorted(params['other_groups']), sorted(otherGroupIds)) 716 717 718 try: 719 self.loginAsUser(params['omename'], params['password']) 720 self.fail('This user was deactivated. Login failure error!') 721 except: 722 pass
723
724 - def test_changePassword(self):
725 conn = self.rootconn 726 uuid = conn._sessionUuid 727 728 # private group 729 params = { 730 "name": uuid, 731 "description":"password test", 732 "permissions":0 733 } 734 735 request = fakeRequest(method="post", params=params) 736 gid = _createGroup(request, conn) 737 738 # create experimenter 739 params = { 740 "omename":'password%s' % uuid, 741 "first_name":uuid, 742 "middle_name": uuid, 743 "last_name":uuid, 744 "email":"password_%s@domain.com" % uuid, 745 "institution":"Laboratory", 746 "administrator": False, 747 "active":True, 748 "default_group":gid, 749 "other_groups":[gid], 750 "password":"123", 751 "confirmation":"123" 752 } 753 request = fakeRequest(method="post", params=params) 754 eid = _createExperimenter(request, conn) 755 756 #change password as root 757 params_passwd = { 758 "password":"abc", 759 "confirmation":"abc", 760 "old_password":self.root_password 761 } 762 request = fakeRequest(method="post", params=params_passwd) 763 _changePassword(request, conn, eid) 764 765 # login as user and change my password 766 user_conn = self.loginAsUser(params['omename'], params_passwd['password']) 767 params_passwd = { 768 "old_password":"abc", 769 "password":"foo", 770 "confirmation":"foo" 771 } 772 request = fakeRequest(method="post", params=params_passwd) 773 _changePassword(request, user_conn) 774 775 self.loginAsUser(params['omename'], params_passwd['password'])
776
777 - def test_badChangePassword(self):
778 conn = self.rootconn 779 uuid = conn._sessionUuid 780 781 # private group 782 params = { 783 "name": uuid, 784 "description":"password test", 785 "permissions":0 786 } 787 788 request = fakeRequest(method="post", params=params) 789 gid = _createGroup(request, conn) 790 791 # create experimenter 792 params = { 793 "omename":'password%s' % uuid, 794 "first_name":uuid, 795 "middle_name": uuid, 796 "last_name":uuid, 797 "email":"password_%s@domain.com" % uuid, 798 "institution":"Laboratory", 799 "administrator": False, 800 "active":True, 801 "default_group":gid, 802 "other_groups":[gid], 803 "password":"123", 804 "confirmation":"123" 805 } 806 request = fakeRequest(method="post", params=params) 807 eid = _createExperimenter(request, conn) 808 809 # login as user and change my password 810 user_conn = self.loginAsUser(params['omename'], params['password']) 811 params_passwd = {} 812 request = fakeRequest(method="post", params=params_passwd) 813 try: 814 _changePassword(request, user_conn) 815 except: 816 pass 817 else: 818 self.fail("Can't change password with no parameters") 819 820 self.loginAsUser(params['omename'], params['password'])
821 822 #################################### 823 # helpers 824
825 -def _changePassword(request, conn, eid=None):
826 password_form = ChangePassword(data=request.POST.copy()) 827 if password_form.is_valid(): 828 old_password = password_form.cleaned_data['old_password'] 829 password = password_form.cleaned_data['password'] 830 if conn.isAdmin(): 831 exp = conn.getObject("Experimenter", eid) 832 conn.changeUserPassword(exp.omeName, password, old_password) 833 else: 834 conn.changeMyPassword(password, old_password) 835 else: 836 raise Exception(password_form.errors.as_text())
837
838 -def _createGroup(request, conn):
839 #create group 840 experimenters = list(conn.getObjects("Experimenter")) 841 name_check = conn.checkGroupName(request.REQUEST.get('name')) 842 form = GroupForm(initial={'experimenters':experimenters}, data=request.POST.copy(), name_check=name_check) 843 if form.is_valid(): 844 name = form.cleaned_data['name'] 845 description = form.cleaned_data['description'] 846 owners = form.cleaned_data['owners'] 847 members = form.cleaned_data['members'] 848 permissions = form.cleaned_data['permissions'] 849 850 perm = setActualPermissions(permissions) 851 listOfOwners = getSelectedExperimenters(conn, owners) 852 gid = conn.createGroup(name, perm, listOfOwners, description) 853 new_members = getSelectedExperimenters(conn, mergeLists(members,owners)) 854 group = conn.getObject("ExperimenterGroup", gid) 855 conn.setMembersOfGroup(group, new_members) 856 return gid 857 else: 858 raise Exception(form.errors.as_text())
859
860 -def _updateGroup(request, conn, gid):
861 # update group 862 experimenters = list(conn.getObjects("Experimenter")) 863 group = conn.getObject("ExperimenterGroup", gid) 864 name_check = conn.checkGroupName(request.REQUEST.get('name'), group.name) 865 form = GroupForm(initial={'experimenters':experimenters}, data=request.POST.copy(), name_check=name_check) 866 if form.is_valid(): 867 name = form.cleaned_data['name'] 868 description = form.cleaned_data['description'] 869 owners = form.cleaned_data['owners'] 870 permissions = form.cleaned_data['permissions'] 871 members = form.cleaned_data['members'] 872 873 listOfOwners = getSelectedExperimenters(conn, owners) 874 if permissions != int(permissions): 875 perm = setActualPermissions(permissions) 876 else: 877 perm = None 878 conn.updateGroup(group, name, perm, listOfOwners, description) 879 880 new_members = getSelectedExperimenters(conn, mergeLists(members,owners)) 881 conn.setMembersOfGroup(group, new_members) 882 else: 883 raise Exception(form.errors.as_text())
884
885 -def _createExperimenter(request, conn):
886 # create experimenter 887 groups = list(conn.getObjects("ExperimenterGroup")) 888 groups.sort(key=lambda x: x.getName().lower()) 889 890 name_check = conn.checkOmeName(request.REQUEST.get('omename')) 891 email_check = conn.checkEmail(request.REQUEST.get('email')) 892 893 initial={'with_password':True, 'groups':otherGroupsInitialList(groups)} 894 form = ExperimenterForm(initial=initial, data=request.REQUEST.copy(), name_check=name_check, email_check=email_check) 895 if form.is_valid(): 896 omename = form.cleaned_data['omename'] 897 firstName = form.cleaned_data['first_name'] 898 middleName = form.cleaned_data['middle_name'] 899 lastName = form.cleaned_data['last_name'] 900 email = form.cleaned_data['email'] 901 institution = form.cleaned_data['institution'] 902 admin = toBoolean(form.cleaned_data['administrator']) 903 active = toBoolean(form.cleaned_data['active']) 904 defaultGroup = form.cleaned_data['default_group'] 905 otherGroups = form.cleaned_data['other_groups'] 906 password = form.cleaned_data['password'] 907 908 # default group 909 for g in groups: 910 if long(defaultGroup) == g.id: 911 dGroup = g 912 break 913 914 listOfOtherGroups = set() 915 # rest of groups 916 for g in groups: 917 for og in otherGroups: 918 # remove defaultGroup from otherGroups if contains 919 if long(og) == long(dGroup.id): 920 pass 921 elif long(og) == g.id: 922 listOfOtherGroups.add(g) 923 924 return conn.createExperimenter(omename, firstName, lastName, email, admin, active, dGroup, listOfOtherGroups, password, middleName, institution) 925 else: 926 raise Exception(form.errors.as_text())
927
928 -def _updateExperimenter(request, conn, eid):
929 groups = list(conn.getObjects("ExperimenterGroup")) 930 groups.sort(key=lambda x: x.getName().lower()) 931 932 experimenter, defaultGroup, otherGroups, isLdapUser, hasAvatar = prepare_experimenter(conn, eid) 933 934 name_check = conn.checkOmeName(request.REQUEST.get('omename'), experimenter.omeName) 935 email_check = conn.checkEmail(request.REQUEST.get('email'), experimenter.email) 936 initial={'active':True, 'groups':otherGroupsInitialList(groups)} 937 938 form = ExperimenterForm(initial=initial, data=request.POST.copy(), name_check=name_check, email_check=email_check) 939 940 if form.is_valid(): 941 omename = form.cleaned_data['omename'] 942 firstName = form.cleaned_data['first_name'] 943 middleName = form.cleaned_data['middle_name'] 944 lastName = form.cleaned_data['last_name'] 945 email = form.cleaned_data['email'] 946 institution = form.cleaned_data['institution'] 947 admin = toBoolean(form.cleaned_data['administrator']) 948 active = toBoolean(form.cleaned_data['active']) 949 defaultGroup = form.cleaned_data['default_group'] 950 otherGroups = form.cleaned_data['other_groups'] 951 952 # default group 953 for g in groups: 954 if long(defaultGroup) == g.id: 955 dGroup = g 956 break 957 958 listOfOtherGroups = set() 959 # rest of groups 960 for g in groups: 961 for og in otherGroups: 962 # remove defaultGroup from otherGroups if contains 963 if long(og) == long(dGroup.id): 964 pass 965 elif long(og) == g.id: 966 listOfOtherGroups.add(g) 967 968 conn.updateExperimenter(experimenter, omename, firstName, lastName, email, admin, active, dGroup, listOfOtherGroups, middleName, institution) 969 else: 970 raise Exception(form.errors.as_text())
971