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

Source Code for Module omeroweb.webadmin.tests.unittests

  1  #!/usr/bin/env python 
  2  # encoding: 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   
 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 webadmin.controller.experimenter import BaseExperimenter 
 37  from webadmin.controller.group import BaseGroup 
 38  from webadmin_test_library import WebTest, WebAdminClientTest 
 39   
 40  from django.core.urlresolvers import reverse 
 41   
 42  # Testing client, URLs 
43 -class WebAdminUrlTest(WebAdminClientTest):
44
45 - def test_login(self):
46 params = { 47 'username': 'root', 48 'password': self.root_password, 49 'server':self.server_id, 50 'ssl':'on' 51 } 52 53 response = self.client.post(reverse(viewname="walogin"), params) 54 # Check that the response was a 302 (redirect) 55 self.failUnlessEqual(response.status_code, 302) 56 self.failUnlessEqual(response['Location'], reverse(viewname="waindex"))
57
58 - def test_urlsAsRoot(self):
59 self.client.login('root', self.root_password) 60 61 # response 200 62 response = self.client.get(reverse(viewname="waexperimenters")) 63 self.failUnlessEqual(response.status_code, 200) 64 65 # response 200 66 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["new"])) 67 self.failUnlessEqual(response.status_code, 200) 68 69 # response 302 70 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["create"])) 71 self.failUnlessEqual(response.status_code, 302) 72 self.failUnlessEqual(response['Location'], reverse(viewname="wamanageexperimenterid", args=["new"])) 73 74 # response 200 75 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["edit", "1"])) 76 self.failUnlessEqual(response.status_code, 200) 77 78 # response 302 79 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["save", "1"])) 80 self.failUnlessEqual(response.status_code, 302) 81 self.failUnlessEqual(response['Location'], reverse(viewname="wamanageexperimenterid", args=["edit", "1"])) 82 83 # response 200 84 response = self.client.get(reverse(viewname="wagroups")) 85 self.failUnlessEqual(response.status_code, 200) 86 87 # response 200 88 response = self.client.get(reverse(viewname="wamanagegroupid", args=["new"])) 89 self.failUnlessEqual(response.status_code, 200) 90 91 # response 302 92 response = self.client.get(reverse(viewname="wamanagegroupid", args=["create"])) 93 self.failUnlessEqual(response.status_code, 302) 94 self.failUnlessEqual(response['Location'], reverse(viewname="wamanagegroupid", args=["new"])) 95 96 # response 200 97 response = self.client.get(reverse(viewname="wamanagegroupid", args=["edit", "2"])) 98 self.failUnlessEqual(response.status_code, 200) 99 100 # response 302 101 response = self.client.get(reverse(viewname="wamanagegroupid", args=["save", "2"])) 102 self.failUnlessEqual(response.status_code, 302) 103 self.failUnlessEqual(response['Location'], reverse(viewname="wamanagegroupid", args=["edit", "2"])) 104 105 # response 200 106 response = self.client.get(reverse(viewname="wamanagechangepasswordid", args=["1"])) 107 self.failUnlessEqual(response.status_code, 200)
108 109
110 - def test_urlsAsUser(self):
111 conn = self.rootconn 112 uuid = conn._sessionUuid 113 114 # private group 115 params = { 116 "name":"webadmin_test_group_private %s" % uuid, 117 "description":"test group", 118 "owners": [0L], 119 "permissions":0 120 } 121 request = fakeRequest(method="post", params=params) 122 gid = _createGroup(request, conn) 123 124 params = { 125 "omename":"webadmin_test_user %s" % uuid, 126 "first_name":uuid, 127 "middle_name": uuid, 128 "last_name":uuid, 129 "email":"user_%s@domain.com" % uuid, 130 "institution":"Laboratory", 131 "active":True, 132 "default_group":gid, 133 "other_groups":[gid], 134 "password":"123", 135 "confirmation":"123" 136 } 137 request = fakeRequest(method="post", params=params) 138 eid = _createExperimenter(request, conn) 139 140 # TODO:Create experimenter 141 self.client.login("webadmin_test_user %s" % uuid, '123') 142 143 # response 200 144 response = self.client.get(reverse(viewname="wamyaccount")) 145 self.failUnlessEqual(response.status_code, 200) 146 147 response = self.client.get(reverse(viewname="wadrivespace")) 148 self.failUnlessEqual(response.status_code, 200) 149 150 response = self.client.get(reverse(viewname="wamyphoto")) 151 self.failUnlessEqual(response.status_code, 200) 152 153 response = self.client.get(reverse(viewname="wamanagechangepasswordid", args=["4"])) 154 self.failUnlessEqual(response.status_code, 200) 155 156 # response 404 157 response = self.client.get(reverse(viewname="waexperimenters")) 158 self.failUnlessEqual(response.status_code, 404) 159 160 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["new"])) 161 self.failUnlessEqual(response.status_code, 404) 162 163 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["create"])) 164 self.failUnlessEqual(response.status_code, 404) 165 166 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["edit", "1"])) 167 self.failUnlessEqual(response.status_code, 404) 168 169 response = self.client.get(reverse(viewname="wamanageexperimenterid", args=["save", "1"])) 170 self.failUnlessEqual(response.status_code, 404) 171 172 response = self.client.get(reverse(viewname="wagroups")) 173 self.failUnlessEqual(response.status_code, 404) 174 175 response = self.client.get(reverse(viewname="wamanagegroupid", args=["new"])) 176 self.failUnlessEqual(response.status_code, 404) 177 178 response = self.client.get(reverse(viewname="wamanagegroupid", args=["create"])) 179 self.failUnlessEqual(response.status_code, 404) 180 181 response = self.client.get(reverse(viewname="wamanagegroupid", args=["edit", "2"])) 182 self.failUnlessEqual(response.status_code, 404) 183 184 response = self.client.get(reverse(viewname="wamanagegroupid", args=["save", "2"])) 185 self.failUnlessEqual(response.status_code, 404)
186
187 -class WebAdminConfigTest(unittest.TestCase):
188
189 - def setUp (self):
190 c = omero.client(pmap=['--Ice.Config='+(os.environ.get("ICE_CONFIG"))]) 191 try: 192 self.root_password = c.ic.getProperties().getProperty('omero.rootpass') 193 self.omero_host = c.ic.getProperties().getProperty('omero.host') 194 self.omero_port = c.ic.getProperties().getProperty('omero.port') 195 finally: 196 c.__del__()
197
198 - def test_isServerOn(self):
199 from omeroweb.webadmin.webadmin_utils import _isServerOn 200 if not _isServerOn(self.omero_host, self.omero_port): 201 self.fail('Server is offline')
202
203 - def test_checkVersion(self):
204 from omeroweb.webadmin.webadmin_utils import _checkVersion 205 if not _checkVersion(self.omero_host, self.omero_port): 206 self.fail('Client version does not match server')
207 208 # Testing controllers, and forms
209 -class WebAdminTest(WebTest):
210
211 - def test_loginFromRequest(self):
212 params = { 213 'username': 'root', 214 'password': self.root_password, 215 'server':self.server_id, 216 'ssl':'on' 217 } 218 request = fakeRequest(method="post", path="/webadmin/login", params=params) 219 220 blitz = settings.SERVER_LIST.get(pk=request.REQUEST.get('server')) 221 request.session['server'] = blitz.id 222 request.session['host'] = blitz.host 223 request.session['port'] = blitz.port 224 request.session['username'] = request.REQUEST.get('username').encode('utf-8').strip() 225 request.session['password'] = request.REQUEST.get('password').encode('utf-8').strip() 226 request.session['ssl'] = (True, False)[request.REQUEST.get('ssl') is None] 227 228 conn = webgateway_views.getBlitzConnection(request, useragent="TEST.webadmin") 229 if conn is None: 230 self.fail('Cannot connect') 231 webgateway_views._session_logout(request, request.session.get('server')) 232 if conn.isConnected() and conn.keepAlive(): 233 self.fail('Connection was not closed')
234
235 - def test_loginFromForm(self):
236 params = { 237 'username': 'root', 238 'password': self.root_password, 239 'server':self.server_id, 240 'ssl':'on' 241 } 242 request = fakeRequest(method="post", params=params) 243 244 form = LoginForm(data=request.REQUEST.copy()) 245 if form.is_valid(): 246 247 blitz = settings.SERVER_LIST.get(pk=form.cleaned_data['server']) 248 request.session['server'] = blitz.id 249 request.session['host'] = blitz.host 250 request.session['port'] = blitz.port 251 request.session['username'] = form.cleaned_data['username'].strip() 252 request.session['password'] = form.cleaned_data['password'].strip() 253 request.session['ssl'] = form.cleaned_data['ssl'] 254 255 conn = webgateway_views.getBlitzConnection(request, useragent="TEST.webadmin") 256 if conn is None: 257 self.fail('Cannot connect') 258 webgateway_views._session_logout(request, request.session.get('server')) 259 if conn.isConnected() and conn.keepAlive(): 260 self.fail('Connection was not closed') 261 262 else: 263 errors = form.errors.as_text() 264 self.fail(errors)
265
266 - def test_loginFailure(self):
267 params = { 268 'username': 'notauser', 269 'password': 'nonsence', 270 'server':self.server_id 271 } 272 request = fakeRequest(method="post", params=params) 273 274 form = LoginForm(data=request.REQUEST.copy()) 275 if form.is_valid(): 276 blitz = settings.SERVER_LIST.get(pk=form.cleaned_data['server']) 277 request.session['server'] = blitz.id 278 request.session['host'] = blitz.host 279 request.session['port'] = blitz.port 280 request.session['username'] = form.cleaned_data['username'].strip() 281 request.session['password'] = form.cleaned_data['password'].strip() 282 request.session['ssl'] = form.cleaned_data['ssl'] 283 284 conn = webgateway_views.getBlitzConnection(request, useragent="TEST.webadmin") 285 if conn is not None: 286 self.fail('This user does not exist. Login failure error!') 287 webgateway_views._session_logout(request, request.session.get('server')) 288 289 else: 290 errors = form.errors.as_text() 291 self.fail(errors)
292 294 conn = self.rootconn 295 uuid = conn._sessionUuid 296 297 # private group 298 params = { 299 "name":u"русский_алфавит %s" % uuid, 300 "description":u"Frühstück-Śniadanie. Tschüß-Cześć", 301 "owners": [0L], 302 "permissions":0 303 } 304 request = fakeRequest(method="post", params=params) 305 gid = _createGroup(request, conn) 306 307 # check if group created 308 controller = BaseGroup(conn, gid) 309 perm = controller.getActualPermissions() 310 self.assertEquals(params['name'], controller.group.name) 311 self.assertEquals(params['description'], controller.group.description) 312 self.assertEquals(sorted(params['owners']), sorted(controller.owners)) 313 self.assertEquals(params['permissions'], perm) 314 self.assertEquals(False, controller.isReadOnly())
315
316 - def test_createGroups(self):
317 conn = self.rootconn 318 uuid = conn._sessionUuid 319 320 # private group 321 params = { 322 "name":"webadmin_test_group_private %s" % uuid, 323 "description":"test group", 324 "owners": [0L], 325 "permissions":0 326 } 327 request = fakeRequest(method="post", params=params) 328 gid = _createGroup(request, conn) 329 330 # check if group created 331 controller = BaseGroup(conn, gid) 332 perm = controller.getActualPermissions() 333 self.assertEquals(params['name'], controller.group.name) 334 self.assertEquals(params['description'], controller.group.description) 335 self.assertEquals(sorted(params['owners']), sorted(controller.owners)) 336 self.assertEquals(params['permissions'], perm) 337 self.assertEquals(False, controller.isReadOnly()) 338 339 # read-only group 340 params = { 341 "name":"webadmin_test_group_read-only %s" % uuid, 342 "description":"test group", 343 "owners": [0L], 344 "permissions":1, 345 "readonly":True 346 } 347 request = fakeRequest(method="post", params=params) 348 gid = _createGroup(request, conn) 349 350 # check if group created 351 controller = BaseGroup(conn, gid) 352 perm = controller.getActualPermissions() 353 self.assertEquals(params['name'], controller.group.name) 354 self.assertEquals(params['description'], controller.group.description) 355 self.assertEquals(sorted(params['owners']), sorted(controller.owners)) 356 self.assertEquals(params['permissions'], perm) 357 self.assertEquals(params['readonly'], controller.isReadOnly()) 358
359 - def test_updateGroups(self):
360 conn = self.rootconn 361 uuid = conn._sessionUuid 362 363 # private group 364 params = { 365 "name":"webadmin_test_group_private %s" % uuid, 366 "description":"test group", 367 "owners": [0L], 368 "permissions":0 369 } 370 request = fakeRequest(method="post", params=params) 371 gid = _createGroup(request, conn) 372 373 # create new user 374 params = { 375 "omename":"webadmin_test_owner %s" % uuid, 376 "first_name":uuid, 377 "middle_name": uuid, 378 "last_name":uuid, 379 "email":"owner_%s@domain.com" % uuid, 380 "institution":"Laboratory", 381 "active":True, 382 "default_group":gid, 383 "other_groups":[gid], 384 "password":"123", 385 "confirmation":"123" 386 } 387 request = fakeRequest(method="post", params=params) 388 eid = _createExperimenter(request, conn) 389 390 # upgrade group to collaborative 391 # read-only group and add new owner 392 params = { 393 "name":"webadmin_test_group_read-only %s" % uuid, 394 "description":"test group changed", 395 "owners": [0, eid], 396 "permissions":1, 397 "readonly":True 398 } 399 request = fakeRequest(method="post", params=params) 400 _updateGroup(request, conn, gid) 401 402 # check if updated 403 controller = BaseGroup(conn, gid) 404 perm = controller.getActualPermissions() 405 self.assertEquals(params['name'], controller.group.name) 406 self.assertEquals(params['description'], controller.group.description) 407 self.assertEquals(sorted(params['owners']), sorted(controller.owners)) 408 self.assertEquals(params['permissions'], perm) 409 self.assertEquals(params['readonly'], controller.isReadOnly()) 410
411 - def test_updateMembersOfGroup(self):
412 conn = self.rootconn 413 uuid = conn._sessionUuid 414 415 # create group 416 params = { 417 "name":"webadmin_test_group_private %s" % uuid, 418 "description":"test group", 419 "owners": [0L], 420 "permissions":0 421 } 422 request = fakeRequest(method="post", params=params) 423 gid = _createGroup(request, conn) 424 425 ###################################### 426 # default group - helper 427 params = { 428 "name":"webadmin_test_default %s" % uuid, 429 "description":"test group default", 430 "owners": [0L], 431 "permissions":0 432 } 433 request = fakeRequest(method="post", params=params) 434 default_gid = _createGroup(request, conn) 435 436 # create two new users 437 params = { 438 "omename":"webadmin_test_user1 %s" % uuid, 439 "first_name":uuid, 440 "middle_name": uuid, 441 "last_name":uuid, 442 "email":"user1_%s@domain.com" % uuid, 443 "institution":"Laboratory", 444 "active":True, 445 "default_group":default_gid, 446 "other_groups":[default_gid], 447 "password":"123", 448 "confirmation":"123" 449 } 450 request = fakeRequest(method="post", params=params) 451 eid1 = _createExperimenter(request, conn) 452 453 # create few new users 454 params = { 455 "omename":"webadmin_test_user2 %s" % uuid, 456 "first_name":uuid, 457 "middle_name": uuid, 458 "last_name":uuid, 459 "email":"user2_%s@domain.com" % uuid, 460 "institution":"Laboratory", 461 "active":True, 462 "default_group":default_gid, 463 "other_groups":[default_gid], 464 "password":"123", 465 "confirmation":"123" 466 } 467 request = fakeRequest(method="post", params=params) 468 eid2 = _createExperimenter(request, conn) 469 # make other users a member of the group 470 471 # add them to group 472 params = { 473 'available':[], 474 'members':[0,eid1,eid2] 475 } 476 request = fakeRequest(method="post", params=params) 477 478 controller = BaseGroup(conn, gid) 479 controller.containedExperimenters() 480 form = ContainedExperimentersForm(initial={'members':controller.members, 'available':controller.available}) 481 if not form.is_valid(): 482 #available = form.cleaned_data['available'] 483 available = request.POST.getlist('available') 484 #members = form.cleaned_data['members'] 485 members = request.POST.getlist('members') 486 controller.setMembersOfGroup(available, members) 487 488 # check if updated 489 controller = BaseGroup(conn, gid) 490 controller.containedExperimenters() 491 self.assertEquals(sorted(params['members']), sorted([e.id for e in controller.members])) 492 493 # remove them from the group 494 params = { 495 'available':[eid1,eid2], 496 'members':[0] 497 } 498 request = fakeRequest(method="post", params=params) 499 500 controller = BaseGroup(conn, gid) 501 controller.containedExperimenters() 502 form = ContainedExperimentersForm(initial={'members':controller.members, 'available':controller.available}) 503 if not form.is_valid(): 504 #available = form.cleaned_data['available'] 505 available = request.POST.getlist('available') 506 #members = form.cleaned_data['members'] 507 members = request.POST.getlist('members') 508 controller.setMembersOfGroup(available, members) 509 510 # check if updated 511 controller = BaseGroup(conn, gid) 512 controller.containedExperimenters() 513 self.assertEquals(sorted(params['members']), sorted([e.id for e in controller.members]))
514
515 - def test_createExperimenters(self):
516 conn = self.rootconn 517 uuid = conn._sessionUuid 518 519 # private group 520 params = { 521 "name":"webadmin_test_group_private %s" % uuid, 522 "description":"test group", 523 "owners": [0L], 524 "permissions":0 525 } 526 request = fakeRequest(method="post", params=params) 527 gid = _createGroup(request, conn) 528 529 params = { 530 "omename":"webadmin_test_user %s" % uuid, 531 "first_name":uuid, 532 "middle_name": uuid, 533 "last_name":uuid, 534 "email":"user_%s@domain.com" % uuid, 535 "institution":"Laboratory", 536 "active":True, 537 "default_group":gid, 538 "other_groups":[gid], 539 "password":"123", 540 "confirmation":"123" 541 } 542 request = fakeRequest(method="post", params=params) 543 eid = _createExperimenter(request, conn) 544 545 # check if experimenter created 546 controller = BaseExperimenter(conn, eid) 547 self.assertEquals(params['omename'], controller.experimenter.omeName) 548 self.assertEquals(params['first_name'], controller.experimenter.firstName) 549 self.assertEquals(params['middle_name'], controller.experimenter.middleName) 550 self.assertEquals(params['last_name'], controller.experimenter.lastName) 551 self.assertEquals(params['email'], controller.experimenter.email) 552 self.assertEquals(params['institution'], controller.experimenter.institution) 553 self.assert_(not controller.experimenter.isAdmin()) 554 self.assertEquals(params['active'], controller.experimenter.isActive()) 555 self.assertEquals(params['default_group'], controller.defaultGroup) 556 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups)) 557 558 params = { 559 "omename":"webadmin_test_admin %s" % uuid, 560 "first_name":uuid, 561 "middle_name": uuid, 562 "last_name":uuid, 563 "email":"admin_%s@domain.com" % uuid, 564 "institution":"Laboratory", 565 "administrator": True, 566 "active":True, 567 "default_group":gid, 568 "other_groups":[0,gid], 569 "password":"123", 570 "confirmation":"123" 571 } 572 request = fakeRequest(method="post", params=params) 573 eid = _createExperimenter(request, conn) 574 575 # check if experimenter created 576 controller = BaseExperimenter(conn, eid) 577 self.assertEquals(params['omename'], controller.experimenter.omeName) 578 self.assertEquals(params['first_name'], controller.experimenter.firstName) 579 self.assertEquals(params['middle_name'], controller.experimenter.middleName) 580 self.assertEquals(params['last_name'], controller.experimenter.lastName) 581 self.assertEquals(params['email'], controller.experimenter.email) 582 self.assertEquals(params['institution'], controller.experimenter.institution) 583 self.assertEquals(params['administrator'], controller.experimenter.isAdmin()) 584 self.assertEquals(params['active'], controller.experimenter.isActive()) 585 self.assertEquals(params['default_group'], controller.defaultGroup) 586 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups)) 587 588 params = { 589 "omename":"webadmin_test_off %s" % uuid, 590 "first_name":uuid, 591 "middle_name": uuid, 592 "last_name":uuid, 593 "email":"off_%s@domain.com" % uuid, 594 "institution":"Laboratory", 595 "default_group":gid, 596 "other_groups":[gid], 597 "password":"123", 598 "confirmation":"123" 599 } 600 request = fakeRequest(method="post", params=params) 601 eid = _createExperimenter(request, conn) 602 603 # check if experimenter created 604 controller = BaseExperimenter(conn, eid) 605 self.assertEquals(params['omename'], controller.experimenter.omeName) 606 self.assertEquals(params['first_name'], controller.experimenter.firstName) 607 self.assertEquals(params['middle_name'], controller.experimenter.middleName) 608 self.assertEquals(params['last_name'], controller.experimenter.lastName) 609 self.assertEquals(params['email'], controller.experimenter.email) 610 self.assertEquals(params['institution'], controller.experimenter.institution) 611 self.assert_(not controller.experimenter.isAdmin()) 612 self.assert_(not controller.experimenter.isActive()) 613 self.assertEquals(params['default_group'], controller.defaultGroup) 614 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups)) 615
616 - def test_updateExperimenter(self):
617 conn = self.rootconn 618 uuid = conn._sessionUuid 619 620 # private group 621 params = { 622 "name":"webadmin_test_group_private %s" % uuid, 623 "description":"test group", 624 "owners": [0L], 625 "permissions":0 626 } 627 628 request = fakeRequest(method="post", params=params) 629 gid = _createGroup(request, conn) 630 631 # default group - helper 632 params = { 633 "name":"webadmin_test_default %s" % uuid, 634 "description":"test group default", 635 "owners": [0L], 636 "permissions":0 637 } 638 request = fakeRequest(method="post", params=params) 639 default_gid = _createGroup(request, conn) 640 641 # create experimenter 642 params = { 643 "omename":"webadmin_test_user %s" % uuid, 644 "first_name":uuid, 645 "middle_name": uuid, 646 "last_name":uuid, 647 "email":"user_%s@domain.com" % uuid, 648 "institution":"Laboratory", 649 "active":True, 650 "default_group":gid, 651 "other_groups":[gid], 652 "password":"123", 653 "confirmation":"123" 654 } 655 request = fakeRequest(method="post", params=params) 656 eid = _createExperimenter(request, conn) 657 658 # add admin privilages and change default group 659 params = { 660 "omename":"webadmin_test_admin %s" % uuid, 661 "first_name":uuid, 662 "middle_name": uuid, 663 "last_name":uuid, 664 "email":"admin_%s@domain.com" % uuid, 665 "institution":"Laboratory", 666 "administrator": True, 667 "active":True, 668 "default_group":default_gid, 669 "other_groups":[0,gid,default_gid], 670 "password":"123", 671 "confirmation":"123" 672 } 673 request = fakeRequest(method="post", params=params) 674 _updateExperimenter(request, conn, eid) 675 676 # check if experimenter updated 677 controller = BaseExperimenter(conn, eid) 678 self.assertEquals(params['omename'], controller.experimenter.omeName) 679 self.assertEquals(params['first_name'], controller.experimenter.firstName) 680 self.assertEquals(params['middle_name'], controller.experimenter.middleName) 681 self.assertEquals(params['last_name'], controller.experimenter.lastName) 682 self.assertEquals(params['email'], controller.experimenter.email) 683 self.assertEquals(params['institution'], controller.experimenter.institution) 684 self.assertEquals(params['administrator'], controller.experimenter.isAdmin()) 685 self.assertEquals(params['active'], controller.experimenter.isActive()) 686 self.assertEquals(params['default_group'], controller.defaultGroup) 687 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups)) 688 689 # remove admin privilages and deactivate account 690 params = { 691 "omename":"webadmin_test_admin %s" % uuid, 692 "first_name":uuid, 693 "middle_name": uuid, 694 "last_name":uuid, 695 "email":"admin_%s@domain.com" % uuid, 696 "institution":"Laboratory", 697 "administrator": False, 698 "active":False, 699 "default_group":default_gid, 700 "other_groups":[gid,default_gid], 701 "password":"123", 702 "confirmation":"123" 703 } 704 request = fakeRequest(method="post", params=params) 705 _updateExperimenter(request, conn, eid) 706 707 # check if experimenter updated 708 controller = BaseExperimenter(conn, eid) 709 self.assertEquals(params['omename'], controller.experimenter.omeName) 710 self.assertEquals(params['first_name'], controller.experimenter.firstName) 711 self.assertEquals(params['middle_name'], controller.experimenter.middleName) 712 self.assertEquals(params['last_name'], controller.experimenter.lastName) 713 self.assertEquals(params['email'], controller.experimenter.email) 714 self.assertEquals(params['institution'], controller.experimenter.institution) 715 self.assert_(not controller.experimenter.isAdmin()) 716 self.assert_(not controller.experimenter.isActive()) 717 self.assertEquals(params['default_group'], controller.defaultGroup) 718 self.assertEquals(sorted(params['other_groups']), sorted(controller.otherGroups)) 719 720 try: 721 self.loginAsUser(params['omename'], params['password']) 722 self.fail('This user was deactivated. Login failure error!') 723 except: 724 pass 725
726 - def test_changePassword(self):
727 conn = self.rootconn 728 uuid = conn._sessionUuid 729 730 # private group 731 params = { 732 "name": uuid, 733 "description":"password test", 734 "owners": [0L], 735 "permissions":0 736 } 737 738 request = fakeRequest(method="post", params=params) 739 gid = _createGroup(request, conn) 740 741 # create experimenter 742 params = { 743 "omename":'password%s' % uuid, 744 "first_name":uuid, 745 "middle_name": uuid, 746 "last_name":uuid, 747 "email":"password_%s@domain.com" % uuid, 748 "institution":"Laboratory", 749 "active":True, 750 "default_group":gid, 751 "other_groups":[gid], 752 "password":"123", 753 "confirmation":"123" 754 } 755 request = fakeRequest(method="post", params=params) 756 eid = _createExperimenter(request, conn) 757 758 #change password as root 759 params_passwd = { 760 "password":"abc", 761 "confirmation":"abc", 762 "old_password":self.root_password 763 } 764 request = fakeRequest(method="post", params=params_passwd) 765 _changePassword(request, conn, eid) 766 767 # login as user and change my password 768 user_conn = self.loginAsUser(params['omename'], params_passwd['password']) 769 params_passwd = { 770 "old_password":"abc", 771 "password":"foo", 772 "confirmation":"foo" 773 } 774 request = fakeRequest(method="post", params=params_passwd) 775 _changePassword(request, user_conn) 776 777 self.loginAsUser(params['omename'], params_passwd['password'])
778 779 #################################### 780 # helpers 781
782 -def _changePassword(request, conn, eid=None):
783 password_form = ChangePassword(data=request.POST.copy()) 784 if password_form.is_valid(): 785 old_password = password_form.cleaned_data['old_password'] 786 password = password_form.cleaned_data['password'] 787 if conn.isAdmin(): 788 exp = conn.getObject("Experimenter", eid) 789 conn.changeUserPassword(exp.omeName, password, old_password) 790 else: 791 conn.changeMyPassword(password, old_password) 792 else: 793 raise Exception(password_form.errors.as_text())
794
795 -def _createGroup(request, conn):
796 #create group 797 controller = BaseGroup(conn) 798 name_check = conn.checkGroupName(request.REQUEST.get('name')) 799 form = GroupForm(initial={'experimenters':controller.experimenters}, data=request.POST.copy(), name_check=name_check) 800 if form.is_valid(): 801 name = form.cleaned_data['name'] 802 description = form.cleaned_data['description'] 803 owners = form.cleaned_data['owners'] 804 permissions = form.cleaned_data['permissions'] 805 readonly = toBoolean(form.cleaned_data['readonly']) 806 return controller.createGroup(name, owners, permissions, readonly, description) 807 else: 808 raise Exception(form.errors.as_text())
809
810 -def _updateGroup(request, conn, gid):
811 # update group 812 controller = BaseGroup(conn, gid) 813 name_check = conn.checkGroupName(request.REQUEST.get('name'), controller.group.name) 814 form = GroupForm(initial={'experimenters':controller.experimenters}, data=request.POST.copy(), name_check=name_check) 815 if form.is_valid(): 816 name = form.cleaned_data['name'] 817 description = form.cleaned_data['description'] 818 owners = form.cleaned_data['owners'] 819 permissions = form.cleaned_data['permissions'] 820 readonly = toBoolean(form.cleaned_data['readonly']) 821 controller.updateGroup(name, owners, permissions, readonly, description) 822 else: 823 raise Exception(form.errors.as_text())
824
825 -def _createExperimenter(request, conn):
826 # create experimenter 827 controller = BaseExperimenter(conn) 828 name_check = conn.checkOmeName(request.REQUEST.get('omename')) 829 email_check = conn.checkEmail(request.REQUEST.get('email')) 830 831 initial={'with_password':True} 832 833 exclude = list() 834 if len(request.REQUEST.getlist('other_groups')) > 0: 835 others = controller.getSelectedGroups(request.REQUEST.getlist('other_groups')) 836 initial['others'] = others 837 initial['default'] = [(g.id, g.name) for g in others] 838 exclude.extend([g.id for g in others]) 839 840 available = controller.otherGroupsInitialList(exclude) 841 initial['available'] = available 842 form = ExperimenterForm(initial=initial, data=request.REQUEST.copy(), name_check=name_check, email_check=email_check) 843 if form.is_valid(): 844 omename = form.cleaned_data['omename'] 845 firstName = form.cleaned_data['first_name'] 846 middleName = form.cleaned_data['middle_name'] 847 lastName = form.cleaned_data['last_name'] 848 email = form.cleaned_data['email'] 849 institution = form.cleaned_data['institution'] 850 admin = toBoolean(form.cleaned_data['administrator']) 851 active = toBoolean(form.cleaned_data['active']) 852 defaultGroup = form.cleaned_data['default_group'] 853 otherGroups = form.cleaned_data['other_groups'] 854 password = form.cleaned_data['password'] 855 return controller.createExperimenter(omename, firstName, lastName, email, admin, active, defaultGroup, otherGroups, password, middleName, institution) 856 else: 857 raise Exception(form.errors.as_text())
858
859 -def _updateExperimenter(request, conn, eid):
860 # update experimenter 861 controller = BaseExperimenter(conn, eid) 862 name_check = conn.checkOmeName(request.REQUEST.get('omename'), controller.experimenter.omeName) 863 email_check = conn.checkEmail(request.REQUEST.get('email'), controller.experimenter.email) 864 865 initial={'active':True} 866 exclude = list() 867 868 if len(request.REQUEST.getlist('other_groups')) > 0: 869 others = controller.getSelectedGroups(request.REQUEST.getlist('other_groups')) 870 initial['others'] = others 871 initial['default'] = [(g.id, g.name) for g in others] 872 exclude.extend([g.id for g in others]) 873 874 available = controller.otherGroupsInitialList(exclude) 875 initial['available'] = available 876 877 form = ExperimenterForm(initial=initial, data=request.POST.copy(), name_check=name_check, email_check=email_check) 878 879 if form.is_valid(): 880 omename = form.cleaned_data['omename'] 881 firstName = form.cleaned_data['first_name'] 882 middleName = form.cleaned_data['middle_name'] 883 lastName = form.cleaned_data['last_name'] 884 email = form.cleaned_data['email'] 885 institution = form.cleaned_data['institution'] 886 admin = toBoolean(form.cleaned_data['administrator']) 887 active = toBoolean(form.cleaned_data['active']) 888 defaultGroup = form.cleaned_data['default_group'] 889 otherGroups = form.cleaned_data['other_groups'] 890 controller.updateExperimenter(omename, firstName, lastName, email, admin, active, defaultGroup, otherGroups, middleName, institution) 891 else: 892 raise Exception(form.errors.as_text())
893