auth/auth-service/src/test/java/org/onap/aaf/auth/service/facade/JU_AuthzFacadeImpl.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.auth.service.facade;
  23 import static org.junit.Assert.assertNull;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.mockito.Mockito.mock;
  26 import static org.mockito.MockitoAnnotations.initMocks;
  27
  28 import java.io.IOException;
  29 import java.util.Date;
  30
  31 import javax.servlet.ServletInputStream;
  32 import javax.servlet.ServletOutputStream;
  33 import javax.servlet.http.HttpServletRequest;
  34 import javax.servlet.http.HttpServletResponse;
  35
  36 import org.junit.Before;
  37 import org.junit.Test;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.onap.aaf.auth.dao.cached.CachedCertDAO;
  41 import org.onap.aaf.auth.dao.cached.CachedCredDAO;
  42 import org.onap.aaf.auth.dao.cached.CachedNSDAO;
  43 import org.onap.aaf.auth.dao.cached.CachedPermDAO;
  44 import org.onap.aaf.auth.dao.cached.CachedRoleDAO;
  45 import org.onap.aaf.auth.dao.cached.CachedUserRoleDAO;
  46 import org.onap.aaf.auth.dao.cass.ApprovalDAO;
  47 import org.onap.aaf.auth.dao.cass.CacheInfoDAO;
  48 import org.onap.aaf.auth.dao.cass.DelegateDAO;
  49 import org.onap.aaf.auth.dao.cass.FutureDAO;
  50 import org.onap.aaf.auth.dao.cass.HistoryDAO;
  51 import org.onap.aaf.auth.dao.cass.LocateDAO;
  52 import org.onap.aaf.auth.dao.cass.NsType;
  53 import org.onap.aaf.auth.dao.cass.Status;
  54 import org.onap.aaf.auth.dao.hl.Question;
  55 import org.onap.aaf.auth.env.AuthzEnv;
  56 import org.onap.aaf.auth.env.AuthzTrans;
  57 import org.onap.aaf.auth.layer.Result;
  58 import org.onap.aaf.auth.rserv.RServlet;
  59 import org.onap.aaf.auth.service.AuthzService;
  60 import org.onap.aaf.auth.service.mapper.Mapper;
  61 import org.onap.aaf.misc.env.APIException;
  62 import org.onap.aaf.misc.env.Data;
  63 import org.onap.aaf.misc.env.Data.TYPE;
  64 import org.onap.aaf.misc.env.Encryptor;
  65 import org.onap.aaf.misc.env.LogTarget;
  66 import org.onap.aaf.misc.env.TimeTaken;
  67 import org.onap.aaf.misc.rosetta.env.RosettaDF;
  68 import org.onap.aaf.misc.rosetta.env.RosettaData;
  69
  70 import aaf.v2_0.Api;
  71
  72 public class JU_AuthzFacadeImpl<NSS, PERMS, PERMKEY, ROLES, USERS, USERROLES, DELGS, CERTS, KEYS, REQUEST, HISTORY, ERR, APPROVALS> {
  73
  74     AuthzFacadeImpl<NSS, PERMS, PERMKEY, ROLES, USERS, USERROLES, DELGS, CERTS, KEYS, REQUEST, HISTORY, ERR, APPROVALS> facadeImplObj;
  75
  76     @Mock
  77     AuthzEnv env;
  78     @Mock
  79     AuthzTrans trans;
  80     @Mock
  81     AuthzService authzService;
  82     @Mock
  83     Mapper mapper;
  84
  85     @Mock
  86     RosettaDF rossetaObj;
  87
  88     @Mock
  89     LogTarget lg;
  90     @Mock
  91     TimeTaken tt;
  92     //
  93     // NOTE: Annotation format (@Mock and @Spy) do NOT seem to always work as a
  94     // Base Class,
  95     // so we construct manually.
  96     //
  97     // Mock Objects
  98     protected HistoryDAO historyDAO = mock(HistoryDAO.class);
  99     protected CacheInfoDAO cacheInfoDAO = mock(CacheInfoDAO.class);
 100     protected CachedNSDAO nsDAO = mock(CachedNSDAO.class);
 101     protected CachedPermDAO permDAO = mock(CachedPermDAO.class);
 102     protected CachedRoleDAO roleDAO = mock(CachedRoleDAO.class);
 103     protected CachedUserRoleDAO userRoleDAO = mock(CachedUserRoleDAO.class);
 104     protected CachedCredDAO credDAO = mock(CachedCredDAO.class);
 105     protected CachedCertDAO certDAO = mock(CachedCertDAO.class);
 106     protected LocateDAO locateDAO = mock(LocateDAO.class);
 107     protected FutureDAO futureDAO = mock(FutureDAO.class);
 108     protected DelegateDAO delegateDAO = mock(DelegateDAO.class);
 109     protected ApprovalDAO approvalDAO = mock(ApprovalDAO.class);
 110
 111     @Before
 112     public void setUp() throws APIException, IOException {
 113         initMocks(this);
 114
 115         Mockito.doReturn(lg).when(trans).info();
 116         Mockito.doReturn(lg).when(trans).error();
 117         Mockito.doReturn(lg).when(trans).trace();
 118         Mockito.doReturn(tt).when(trans).start("createNamespace", 40);
 119         Mockito.doReturn(tt).when(trans).start(Mockito.anyString(),
 120                 Mockito.anyInt());
 121         Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
 122         Mockito.doReturn(mapper).when(authzService).mapper();
 123         Mockito.doReturn(rossetaObj).when(env).newDataFactory(Mockito.any());
 124         Mockito.doReturn(rossetaObj).when(rossetaObj).in(Mockito.any());
 125         Mockito.doReturn(rossetaObj).when(rossetaObj).out(Mockito.any());
 126         facadeImplObj = new AuthzFacadeImplImpl(env, authzService,
 127                 Data.TYPE.XML);
 128     }
 129
 130     @Test
 131     public void testMapper() {
 132         facadeImplObj.mapper();
 133     }
 134
 135     @SuppressWarnings({"unchecked", "rawtypes"})
 136     @Test
 137     public void testError() {
 138         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class),
 139                 Mockito.mock(Result.class));
 140
 141         Result<?> rs = new Result(null, Result.ERR_ActionNotCompleted, "test",
 142                 new Object[2]);
 143         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 144
 145         rs = new Result(null, Result.ERR_Policy, "test",
 146                 new Object[]{"test", "test"});
 147         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 148
 149         rs = new Result(null, Result.ERR_Security, "test",
 150                 new Object[]{"", "test"});
 151         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 152
 153         rs = new Result(null, Result.ERR_Denied, "test", null);
 154         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 155
 156         rs = new Result(null, 33, "test", null);
 157         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 158
 159         rs = new Result(null, 21, "test", null);
 160         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 161
 162         rs = new Result(null, 22, "test", null);
 163         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 164         rs = new Result(null, 23, "test", null);
 165         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 166         rs = new Result(null, 24, "test", null);
 167         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 168         rs = new Result(null, 25, "test", null);
 169         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 170
 171         rs = new Result(null, 26, "test", null);
 172         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 173
 174         rs = new Result(null, 27, "test", null);
 175         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 176
 177         rs = new Result(null, 28, "test", null);
 178         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 179
 180         rs = new Result(null, 4, "test", null);
 181         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 182
 183         rs = new Result(null, 5, "test", null);
 184         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 185
 186         rs = new Result(null, 6, "test", null);
 187         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 188
 189         rs = new Result(null, 7, "test", null);
 190         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 191
 192         rs = new Result(null, 31, "test", null);
 193         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 194
 195         rs = new Result(null, 32, "test", null);
 196         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 197
 198         rs = new Result(null, 9, "test", null);
 199         facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
 200     }
 201
 202     @Test
 203     @SuppressWarnings("unchecked")
 204     public void testRequestNS() {
 205         RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
 206         Mockito.doReturn(dataObj).when(rossetaObj).newData();
 207         try {
 208             Mockito.doThrow(new APIException("test exception")).when(dataObj)
 209                     .load(Mockito.any(ServletInputStream.class));
 210         } catch (APIException e) {
 211             // TODO Auto-generated catch block
 212             e.printStackTrace();
 213         }
 214         Result<Void> retVal = (Result<Void>) facadeImplObj.requestNS(trans,
 215                 Mockito.mock(HttpServletRequest.class),
 216                 Mockito.mock(HttpServletResponse.class), NsType.APP);
 217         assertTrue(retVal.status == Status.ERR_BadData);
 218
 219         Data<?> rd = Mockito.mock(Data.class);
 220         try {
 221             Mockito.doReturn(dataObj).when(dataObj)
 222                     .load(Mockito.any(ServletInputStream.class));
 223         } catch (APIException e) {
 224             // TODO Auto-generated catch block
 225             e.printStackTrace();
 226         }
 227         retVal = (Result<Void>) facadeImplObj.requestNS(trans,
 228                 Mockito.mock(HttpServletRequest.class),
 229                 Mockito.mock(HttpServletResponse.class), NsType.APP);
 230         assertTrue(retVal.status == 20);
 231
 232         Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
 233         Mockito.doReturn(rsVoid).when(authzService).createNS(Mockito.any(),
 234                 Mockito.any(), Mockito.any());
 235         retVal = (Result<Void>) facadeImplObj.requestNS(trans,
 236                 Mockito.mock(HttpServletRequest.class),
 237                 Mockito.mock(HttpServletResponse.class), NsType.APP);
 238         assertTrue(retVal.status == 31);
 239
 240         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
 241         Mockito.doReturn(rsVoid).when(authzService).createNS(Mockito.any(),
 242                 Mockito.any(), Mockito.any());
 243         retVal = (Result<Void>) facadeImplObj.requestNS(trans,
 244                 Mockito.mock(HttpServletRequest.class),
 245                 Mockito.mock(HttpServletResponse.class), NsType.APP);
 246         assertTrue(retVal.status == Status.OK);
 247
 248         Mockito.doReturn("user").when(trans).user();
 249         Mockito.doReturn(env).when(trans).env();
 250         Question.specialLogOn(trans, trans.user());
 251         retVal = (Result<Void>) facadeImplObj.requestNS(trans,
 252                 Mockito.mock(HttpServletRequest.class),
 253                 Mockito.mock(HttpServletResponse.class), NsType.APP);
 254         assertTrue(retVal.status == 0);
 255     }
 256
 257     @Test
 258     @SuppressWarnings("unchecked")
 259     public void testAddAdminToNS() {
 260         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 261         Result<Void> retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans,
 262                 respObj, "ns", "id");
 263         assertTrue(retVal.status == 20);
 264
 265         Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
 266         Mockito.doReturn(rsVoid).when(authzService).addAdminNS(trans, "ns",
 267                 "id");
 268         retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans, respObj, "ns",
 269                 "id");
 270         assertTrue(retVal.status == 31);
 271
 272         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
 273         Mockito.doReturn(rsVoid).when(authzService).addAdminNS(trans, "ns",
 274                 "id");
 275         try {
 276             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 277                     .when(respObj).getOutputStream();
 278         } catch (IOException e) {
 279             // TODO Auto-generated catch block
 280             e.printStackTrace();
 281         }
 282         retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans, respObj, "ns",
 283                 "id");
 284         assertTrue(retVal.status == 0);
 285     }
 286
 287     @Test
 288     @SuppressWarnings("unchecked")
 289     public void testDelAdminFromNS() {
 290         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 291         Result<Void> retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans,
 292                 respObj, "ns", "id");
 293         assertTrue(retVal.status == 20);
 294
 295         Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
 296         Mockito.doReturn(rsVoid).when(authzService).delAdminNS(trans, "ns",
 297                 "id");
 298         retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans, respObj,
 299                 "ns", "id");
 300         assertTrue(retVal.status == 31);
 301
 302         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
 303         Mockito.doReturn(rsVoid).when(authzService).delAdminNS(trans, "ns",
 304                 "id");
 305         try {
 306             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 307                     .when(respObj).getOutputStream();
 308         } catch (IOException e) {
 309             // TODO Auto-generated catch block
 310             e.printStackTrace();
 311         }
 312         retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans, respObj,
 313                 "ns", "id");
 314         assertTrue(retVal.status == 0);
 315     }
 316     @Test
 317     @SuppressWarnings("unchecked")
 318     public void testAddResponsibilityForNS() {
 319         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 320         Result<Void> retVal = (Result<Void>) facadeImplObj
 321                 .addResponsibilityForNS(trans, respObj, "ns", "id");
 322         assertTrue(retVal.status == 20);
 323
 324         Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
 325         Mockito.doReturn(rsVoid).when(authzService).addResponsibleNS(trans,
 326                 "ns", "id");
 327         retVal = (Result<Void>) facadeImplObj.addResponsibilityForNS(trans,
 328                 respObj, "ns", "id");
 329         assertTrue(retVal.status == 31);
 330
 331         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
 332         Mockito.doReturn(rsVoid).when(authzService).addResponsibleNS(trans,
 333                 "ns", "id");
 334         try {
 335             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 336                     .when(respObj).getOutputStream();
 337         } catch (IOException e) {
 338             // TODO Auto-generated catch block
 339             e.printStackTrace();
 340         }
 341         retVal = (Result<Void>) facadeImplObj.addResponsibilityForNS(trans,
 342                 respObj, "ns", "id");
 343         assertTrue(retVal.status == 0);
 344     }
 345
 346     @Test
 347     @SuppressWarnings("unchecked")
 348     public void testDelResponsibilityForNS() {
 349         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 350         Result<Void> retVal = (Result<Void>) facadeImplObj
 351                 .delResponsibilityForNS(trans, respObj, "ns", "id");
 352         assertTrue(retVal.status == 20);
 353
 354         Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
 355         Mockito.doReturn(rsVoid).when(authzService).delResponsibleNS(trans,
 356                 "ns", "id");
 357         retVal = (Result<Void>) facadeImplObj.delResponsibilityForNS(trans,
 358                 respObj, "ns", "id");
 359         assertTrue(retVal.status == 31);
 360
 361         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
 362         Mockito.doReturn(rsVoid).when(authzService).delResponsibleNS(trans,
 363                 "ns", "id");
 364         try {
 365             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 366                     .when(respObj).getOutputStream();
 367         } catch (IOException e) {
 368             // TODO Auto-generated catch block
 369             e.printStackTrace();
 370         }
 371         retVal = (Result<Void>) facadeImplObj.delResponsibilityForNS(trans,
 372                 respObj, "ns", "id");
 373         assertTrue(retVal.status == 0);
 374     }
 375
 376     @Test
 377     @SuppressWarnings("unchecked")
 378     public void testGetNSsByName() {
 379         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 380         Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsByName(trans,
 381                 respObj, "ns", true);
 382         assertTrue(retVal.status == 20);
 383
 384         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 385         Mockito.doReturn(rsVoid).when(authzService).getNSbyName(trans, "ns",
 386                 true);
 387         retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
 388                 true);
 389         assertTrue(retVal.status == 31);
 390
 391         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 392         Mockito.doReturn(rsVoid).when(authzService).getNSbyName(trans, "ns",
 393                 true);
 394         try {
 395             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 396                     .when(respObj).getOutputStream();
 397         } catch (IOException e) {
 398             // TODO Auto-generated catch block
 399             e.printStackTrace();
 400         }
 401
 402         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
 403         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 404         try {
 405             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 406         } catch (APIException e) {
 407             // TODO Auto-generated catch block
 408             e.printStackTrace();
 409         }
 410
 411         retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
 412                 true);
 413         assertTrue(retVal.status == 0);
 414
 415         Mockito.doReturn("user").when(trans).user();
 416         Mockito.doReturn(env).when(trans).env();
 417         Question.specialLogOn(trans, trans.user());
 418         retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
 419                 true);
 420         assertTrue(retVal.status == 0);
 421     }
 422
 423     @Test
 424     @SuppressWarnings("unchecked")
 425     public void testGetNSsByAdmin() {
 426         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 427         Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans,
 428                 respObj, "ns", true);
 429         assertTrue(retVal.status == 20);
 430
 431         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 432         Mockito.doReturn(rsVoid).when(authzService).getNSbyAdmin(trans, "ns",
 433                 true);
 434         retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
 435                 "ns", true);
 436         assertTrue(retVal.status == 31);
 437
 438         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 439         Mockito.doReturn(rsVoid).when(authzService).getNSbyAdmin(trans, "ns",
 440                 true);
 441         try {
 442             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 443                     .when(respObj).getOutputStream();
 444         } catch (IOException e) {
 445             // TODO Auto-generated catch block
 446             e.printStackTrace();
 447         }
 448
 449         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
 450         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 451         try {
 452             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 453         } catch (APIException e) {
 454             // TODO Auto-generated catch block
 455             e.printStackTrace();
 456         }
 457
 458         retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
 459                 "ns", true);
 460         assertTrue(retVal.status == 0);
 461
 462         Mockito.doReturn("user").when(trans).user();
 463         Mockito.doReturn(env).when(trans).env();
 464         Question.specialLogOn(trans, trans.user());
 465         retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
 466                 "ns", true);
 467         assertTrue(retVal.status == 0);
 468     }
 469
 470     @Test
 471     @SuppressWarnings("unchecked")
 472     public void testGetNSsByResponsible() {
 473         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 474         Result<Void> retVal = (Result<Void>) facadeImplObj
 475                 .getNSsByResponsible(trans, respObj, "ns", true);
 476         assertTrue(retVal.status == 20);
 477
 478         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 479         Mockito.doReturn(rsVoid).when(authzService).getNSbyResponsible(trans,
 480                 "ns", true);
 481         retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
 482                 respObj, "ns", true);
 483         assertTrue(retVal.status == 31);
 484
 485         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 486         Mockito.doReturn(rsVoid).when(authzService).getNSbyResponsible(trans,
 487                 "ns", true);
 488         try {
 489             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 490                     .when(respObj).getOutputStream();
 491         } catch (IOException e) {
 492             // TODO Auto-generated catch block
 493             e.printStackTrace();
 494         }
 495
 496         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
 497         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 498         try {
 499             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 500         } catch (APIException e) {
 501             // TODO Auto-generated catch block
 502             e.printStackTrace();
 503         }
 504
 505         retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
 506                 respObj, "ns", true);
 507         assertTrue(retVal.status == 0);
 508
 509         Mockito.doReturn("user").when(trans).user();
 510         Mockito.doReturn(env).when(trans).env();
 511         Question.specialLogOn(trans, trans.user());
 512         retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
 513                 respObj, "ns", true);
 514         assertTrue(retVal.status == 0);
 515     }
 516
 517     @Test
 518     @SuppressWarnings("unchecked")
 519     public void testGetNSsByEither() {
 520         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 521         Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans,
 522                 respObj, "ns", true);
 523         assertTrue(retVal.status == 20);
 524
 525         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 526         Mockito.doReturn(rsVoid).when(authzService).getNSbyEither(trans, "ns",
 527                 true);
 528         retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
 529                 "ns", true);
 530         assertTrue(retVal.status == 31);
 531
 532         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 533         Mockito.doReturn(rsVoid).when(authzService).getNSbyEither(trans, "ns",
 534                 true);
 535         try {
 536             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 537                     .when(respObj).getOutputStream();
 538         } catch (IOException e) {
 539             // TODO Auto-generated catch block
 540             e.printStackTrace();
 541         }
 542
 543         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
 544         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 545         try {
 546             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 547         } catch (APIException e) {
 548             // TODO Auto-generated catch block
 549             e.printStackTrace();
 550         }
 551
 552         retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
 553                 "ns", true);
 554         assertTrue(retVal.status == 0);
 555
 556         Mockito.doReturn("user").when(trans).user();
 557         Mockito.doReturn(env).when(trans).env();
 558         Question.specialLogOn(trans, trans.user());
 559         retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
 560                 "ns", true);
 561         assertTrue(retVal.status == 0);
 562     }
 563
 564     @Test
 565     @SuppressWarnings("unchecked")
 566     public void testGetNSsChildren() {
 567         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 568         Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans,
 569                 respObj, "ns");
 570         assertTrue(retVal.status == 20);
 571
 572         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 573         Mockito.doReturn(rsVoid).when(authzService).getNSsChildren(trans, "ns");
 574         retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
 575                 "ns");
 576         assertTrue(retVal.status == 31);
 577
 578         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 579         Mockito.doReturn(rsVoid).when(authzService).getNSsChildren(trans, "ns");
 580         try {
 581             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 582                     .when(respObj).getOutputStream();
 583         } catch (IOException e) {
 584             // TODO Auto-generated catch block
 585             e.printStackTrace();
 586         }
 587
 588         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
 589         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 590         try {
 591             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 592         } catch (APIException e) {
 593             // TODO Auto-generated catch block
 594             e.printStackTrace();
 595         }
 596
 597         retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
 598                 "ns");
 599         assertTrue(retVal.status == 0);
 600
 601         Mockito.doReturn("user").when(trans).user();
 602         Mockito.doReturn(env).when(trans).env();
 603         Question.specialLogOn(trans, trans.user());
 604         retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
 605                 "ns");
 606         assertTrue(retVal.status == 0);
 607     }
 608     @Test
 609     @SuppressWarnings("unchecked")
 610     public void testUpdateNsDescription() {
 611         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 612         Result<Void> retVal = (Result<Void>) facadeImplObj.updateNsDescription(
 613                 trans, Mockito.mock(HttpServletRequest.class), respObj);
 614         assertTrue(retVal.status == 20);
 615
 616         RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
 617         Mockito.doReturn(dataObj).when(rossetaObj).newData();
 618         try {
 619             Mockito.doThrow(new APIException("test exception")).when(dataObj)
 620                     .load(Mockito.any(ServletInputStream.class));
 621         } catch (APIException e) {
 622             // TODO Auto-generated catch block
 623             e.printStackTrace();
 624         }
 625         retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
 626                 Mockito.mock(HttpServletRequest.class), respObj);
 627         assertTrue(retVal.status == 4);
 628
 629         try {
 630             Mockito.doReturn(dataObj).when(dataObj)
 631                     .load(Mockito.any(ServletInputStream.class));
 632         } catch (APIException e) {
 633             // TODO Auto-generated catch block
 634             e.printStackTrace();
 635         }
 636         retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
 637                 Mockito.mock(HttpServletRequest.class), respObj);
 638         assertTrue(retVal.status == 20);
 639
 640         Mockito.doReturn("user").when(trans).user();
 641         Mockito.doReturn(env).when(trans).env();
 642         Question.specialLogOn(trans, trans.user());
 643         retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
 644                 Mockito.mock(HttpServletRequest.class), respObj);
 645         assertTrue(retVal.status == 20);
 646
 647         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 648         Mockito.doReturn(rsVoid).when(authzService)
 649                 .updateNsDescription(Mockito.any(), Mockito.any());
 650         retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
 651                 Mockito.mock(HttpServletRequest.class), respObj);
 652         assertTrue(retVal.status == 31);
 653
 654         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 655         Mockito.doReturn(rsVoid).when(authzService)
 656                 .updateNsDescription(Mockito.any(), Mockito.any());
 657         retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
 658                 Mockito.mock(HttpServletRequest.class), respObj);
 659         assertTrue(retVal.status == 0);
 660     }
 661
 662     @Test
 663     @SuppressWarnings("unchecked")
 664     public void testDeleteNS() {
 665         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 666         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
 667                 Mockito.mock(HttpServletRequest.class), respObj, "ns");
 668         assertTrue(retVal.status == 20);
 669
 670         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 671         Mockito.doReturn(rsVoid).when(authzService).deleteNS(Mockito.any(),
 672                 Mockito.any());
 673         retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
 674                 Mockito.mock(HttpServletRequest.class), respObj, "ns");
 675         assertTrue(retVal.status == 31);
 676
 677         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 678         Mockito.doReturn(rsVoid).when(authzService).deleteNS(Mockito.any(),
 679                 Mockito.any());
 680         retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
 681                 Mockito.mock(HttpServletRequest.class), respObj, "ns");
 682         assertTrue(retVal.status == 0);
 683     }
 684
 685     @Test
 686     @SuppressWarnings("unchecked")
 687     public void testCreateAttribForNS() {
 688         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 689         Result<Void> retVal = (Result<Void>) facadeImplObj
 690                 .createAttribForNS(trans, respObj, "ns", "key", "value");
 691         assertTrue(retVal.status == 20);
 692
 693         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
 694         Mockito.doReturn(rsVoid).when(authzService).createNsAttrib(trans, "ns",
 695                 "key", "value");
 696         retVal = (Result<Void>) facadeImplObj.createAttribForNS(trans, respObj,
 697                 "ns", "key", "value");
 698         assertTrue(retVal.status == 31);
 699
 700         try {
 701             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 702                     .when(respObj).getOutputStream();
 703         } catch (IOException e) {
 704             // TODO Auto-generated catch block
 705             e.printStackTrace();
 706         }
 707         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
 708         Mockito.doReturn(rsVoid).when(authzService).createNsAttrib(trans, "ns",
 709                 "key", "value");
 710         retVal = (Result<Void>) facadeImplObj.createAttribForNS(trans, respObj,
 711                 "ns", "key", "value");
 712         assertTrue(retVal.status == 0);
 713     }
 714
 715     @Test
 716     @SuppressWarnings("unchecked")
 717     public void testReadNsByAttrib() {
 718         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 719         Result<Void> retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans,
 720                 respObj, "key");
 721         assertTrue(retVal.status == 20);
 722
 723         Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
 724         Mockito.doReturn(rsVoid).when(authzService).readNsByAttrib(trans,
 725                 "key");
 726         retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
 727                 "key");
 728         assertTrue(retVal.status == 31);
 729
 730         RosettaData<KEYS> dataObj = Mockito.mock(RosettaData.class);
 731         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 732         try {
 733             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 734         } catch (APIException e) {
 735             // TODO Auto-generated catch block
 736             e.printStackTrace();
 737         }
 738         rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
 739         Mockito.doReturn(rsVoid).when(authzService).readNsByAttrib(trans,
 740                 "key");
 741         retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
 742                 "key");
 743         assertTrue(retVal.status == 0);
 744
 745         Mockito.doReturn("user").when(trans).user();
 746         Mockito.doReturn(env).when(trans).env();
 747         Question.specialLogOn(trans, trans.user());
 748         retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
 749                 "key");
 750         assertTrue(retVal.status == 0);
 751     }
 752     @Test
 753     @SuppressWarnings("unchecked")
 754     public void testUpdAttribForNS() {
 755         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 756         Result<Void> retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans,
 757                 respObj, "ns", "key", "value");
 758         assertTrue(retVal.status == 20);
 759
 760         Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
 761         Mockito.doReturn(rsVoid).when(authzService).updateNsAttrib(trans, "ns",
 762                 "key", "value");
 763         retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans, respObj,
 764                 "ns", "key", "value");
 765         assertTrue(retVal.status == 31);
 766
 767         try {
 768             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 769                     .when(respObj).getOutputStream();
 770         } catch (IOException e) {
 771             // TODO Auto-generated catch block
 772             e.printStackTrace();
 773         }
 774         rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
 775         Mockito.doReturn(rsVoid).when(authzService).updateNsAttrib(trans, "ns",
 776                 "key", "value");
 777         retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans, respObj,
 778                 "ns", "key", "value");
 779         assertTrue(retVal.status == 0);
 780
 781     }
 782
 783     @Test
 784     @SuppressWarnings("unchecked")
 785     public void testDelAttribForNS() {
 786         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 787         Result<Void> retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans,
 788                 respObj, "ns", "key");
 789         assertTrue(retVal.status == 20);
 790
 791         Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
 792         Mockito.doReturn(rsVoid).when(authzService).deleteNsAttrib(trans, "ns",
 793                 "key");
 794         retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans, respObj,
 795                 "ns", "key");
 796         assertTrue(retVal.status == 31);
 797
 798         try {
 799             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 800                     .when(respObj).getOutputStream();
 801         } catch (IOException e) {
 802             // TODO Auto-generated catch block
 803             e.printStackTrace();
 804         }
 805         rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
 806         Mockito.doReturn(rsVoid).when(authzService).deleteNsAttrib(trans, "ns",
 807                 "key");
 808         retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans, respObj,
 809                 "ns", "key");
 810         assertTrue(retVal.status == 0);
 811
 812     }
 813
 814     @Test
 815     @SuppressWarnings("unchecked")
 816     public void testCreatePerm() {
 817         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 818
 819         RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
 820         Mockito.doReturn(dataObj).when(rossetaObj).newData();
 821         try {
 822             Mockito.doThrow(new APIException("test exception")).when(dataObj)
 823                     .load(Mockito.any(ServletInputStream.class));
 824         } catch (APIException e) {
 825             // TODO Auto-generated catch block
 826             e.printStackTrace();
 827         }
 828         Result<Void> retVal = (Result<Void>) facadeImplObj.createPerm(trans,
 829                 Mockito.mock(HttpServletRequest.class), respObj);
 830         assertTrue(retVal.status == 4);
 831
 832         try {
 833             Mockito.doReturn(dataObj).when(dataObj)
 834                     .load(Mockito.any(ServletInputStream.class));
 835         } catch (APIException e) {
 836             // TODO Auto-generated catch block
 837             e.printStackTrace();
 838         }
 839         retVal = (Result<Void>) facadeImplObj.createPerm(trans,
 840                 Mockito.mock(HttpServletRequest.class), respObj);
 841         assertTrue(retVal.status == 20);
 842
 843         Mockito.doReturn("user").when(trans).user();
 844         Mockito.doReturn(env).when(trans).env();
 845         Question.specialLogOn(trans, trans.user());
 846         retVal = (Result<Void>) facadeImplObj.createPerm(trans,
 847                 Mockito.mock(HttpServletRequest.class), respObj);
 848         assertTrue(retVal.status == 20);
 849
 850         Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
 851         try {
 852             Mockito.when(authzService.createPerm(trans, dataObj.asObject()))
 853                     .thenReturn(rsVoid);
 854         } catch (APIException e) {
 855             // TODO Auto-generated catch block
 856             e.printStackTrace();
 857         }
 858         retVal = (Result<Void>) facadeImplObj.createPerm(trans,
 859                 Mockito.mock(HttpServletRequest.class), respObj);
 860         assertTrue(retVal.status == 0);
 861
 862         rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
 863         try {
 864             Mockito.when(authzService.createPerm(trans, dataObj.asObject()))
 865                     .thenReturn(rsVoid);
 866         } catch (APIException e) {
 867             // TODO Auto-generated catch block
 868             e.printStackTrace();
 869         }
 870         retVal = (Result<Void>) facadeImplObj.createPerm(trans,
 871                 Mockito.mock(HttpServletRequest.class), respObj);
 872         assertTrue(retVal.status == 31);
 873     }
 874
 875     @Test
 876     @SuppressWarnings("unchecked")
 877     public void testGetPermsByType() {
 878         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
 879         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 880
 881         Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByType(trans,
 882                 respObj, "perm");
 883         assertTrue(retVal.status == 20);
 884
 885         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
 886                 new Object[0]);
 887         Mockito.doReturn(rsVoid).when(authzService)
 888                 .getPermsByType(Mockito.any(), Mockito.any());
 889         retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
 890                 "perm");
 891         assertTrue(retVal.status == 31);
 892
 893         try {
 894             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 895                     .when(respObj).getOutputStream();
 896         } catch (IOException e) {
 897             // TODO Auto-generated catch block
 898             e.printStackTrace();
 899         }
 900         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
 901         Mockito.doReturn(rsVoid).when(authzService)
 902                 .getPermsByType(Mockito.any(), Mockito.any());
 903         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 904         try {
 905             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 906         } catch (APIException e) {
 907             // TODO Auto-generated catch block
 908             e.printStackTrace();
 909         }
 910         retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
 911                 "perm");
 912         assertTrue(retVal.status == 0);
 913
 914         Mockito.doReturn("user").when(trans).user();
 915         Mockito.doReturn(env).when(trans).env();
 916         Question.specialLogOn(trans, trans.user());
 917         Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
 918         retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
 919                 "perm");
 920         assertTrue(retVal.status == 0);
 921     }
 922     @Test
 923     @SuppressWarnings("unchecked")
 924     public void testGetPermsByName() {
 925         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
 926         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 927
 928         Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByName(trans,
 929                 respObj, "type", "instance", "action");
 930         assertTrue(retVal.status == 20);
 931
 932         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
 933                 new Object[0]);
 934         Mockito.doReturn(rsVoid).when(authzService).getPermsByName(
 935                 Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
 936         retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
 937                 "type", "instance", "action");
 938         assertTrue(retVal.status == 31);
 939
 940         try {
 941             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 942                     .when(respObj).getOutputStream();
 943         } catch (IOException e) {
 944             // TODO Auto-generated catch block
 945             e.printStackTrace();
 946         }
 947         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
 948         Mockito.doReturn(rsVoid).when(authzService).getPermsByName(
 949                 Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
 950         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 951         try {
 952             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
 953         } catch (APIException e) {
 954             // TODO Auto-generated catch block
 955             e.printStackTrace();
 956         }
 957         retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
 958                 "type", "instance", "action");
 959         assertTrue(retVal.status == 0);
 960
 961         Mockito.doReturn("user").when(trans).user();
 962         Mockito.doReturn(env).when(trans).env();
 963         Question.specialLogOn(trans, trans.user());
 964         Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
 965         retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
 966                 "type", "instance", "action");
 967         assertTrue(retVal.status == 0);
 968     }
 969     @Test
 970     @SuppressWarnings("unchecked")
 971     public void testGetPermsByUser() {
 972         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
 973         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
 974
 975         Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans,
 976                 respObj, "user");
 977         assertTrue(retVal.status == 20);
 978
 979         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
 980                 new Object[0]);
 981         Mockito.doReturn(rsVoid).when(authzService)
 982                 .getPermsByUser(Mockito.any(), Mockito.any());
 983         retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
 984                 "user");
 985         assertTrue(retVal.status == 31);
 986
 987         try {
 988             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
 989                     .when(respObj).getOutputStream();
 990         } catch (IOException e) {
 991             // TODO Auto-generated catch block
 992             e.printStackTrace();
 993         }
 994         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
 995         Mockito.doReturn(rsVoid).when(authzService)
 996                 .getPermsByUser(Mockito.any(), Mockito.any());
 997         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
 998         try {
 999             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1000         } catch (APIException e) {
1001             // TODO Auto-generated catch block
1002             e.printStackTrace();
1003         }
1004         retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
1005                 "user");
1006         assertTrue(retVal.status == 0);
1007
1008         Mockito.doReturn("user").when(trans).user();
1009         Mockito.doReturn(env).when(trans).env();
1010         Question.specialLogOn(trans, trans.user());
1011         Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
1012         retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
1013                 "user");
1014         assertTrue(retVal.status == 0);
1015     }
1016     @Test
1017     @SuppressWarnings("unchecked")
1018     public void testGetPermsByUserScope() {
1019         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1020         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1021
1022         Result<Void> retVal = (Result<Void>) facadeImplObj
1023                 .getPermsByUserScope(trans, respObj, "user", new String[]{});
1024         assertTrue(retVal.status == 20);
1025
1026         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1027                 new Object[0]);
1028         Mockito.doReturn(rsVoid).when(authzService).getPermsByUserScope(trans,
1029                 "user", new String[]{});
1030         retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
1031                 respObj, "user", new String[]{});
1032         assertTrue(retVal.status == 31);
1033
1034         try {
1035             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
1036                     .when(respObj).getOutputStream();
1037         } catch (IOException e) {
1038             // TODO Auto-generated catch block
1039             e.printStackTrace();
1040         }
1041         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1042         Mockito.doReturn(rsVoid).when(authzService).getPermsByUserScope(trans,
1043                 "user", new String[]{});
1044         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1045         try {
1046             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1047         } catch (APIException e) {
1048             // TODO Auto-generated catch block
1049             e.printStackTrace();
1050         }
1051         retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
1052                 respObj, "user", new String[]{});
1053         assertTrue(retVal.status == 0);
1054
1055         Mockito.doReturn("user").when(trans).user();
1056         Mockito.doReturn(env).when(trans).env();
1057         Question.specialLogOn(trans, trans.user());
1058         Mockito.doReturn(Mockito.mock(Encryptor.class)).when(env).encryptor();
1059         retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
1060                 respObj, "user", new String[]{});
1061         assertTrue(retVal.status == 0);
1062     }
1063
1064     @Test
1065     @SuppressWarnings("unchecked")
1066     public void testGetPermsByUserWithAAFQuery() {
1067         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1068         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1069         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1070
1071         Result<Void> retVal = (Result<Void>) facadeImplObj
1072                 .getPermsByUserWithAAFQuery(trans, reqObj, respObj, "user");
1073         assertTrue(retVal.status == 20);
1074
1075         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1076         try {
1077             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1078                     .load(Mockito.any(ServletInputStream.class));
1079         } catch (APIException e) {
1080             // TODO Auto-generated catch block
1081             e.printStackTrace();
1082         }
1083         retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1084                 reqObj, respObj, "user");
1085         assertTrue(retVal.status == Status.ERR_BadData);
1086
1087         try {
1088             Mockito.doReturn(dataObj).when(dataObj)
1089                     .load(Mockito.any(ServletInputStream.class));
1090         } catch (APIException e) {
1091             // TODO Auto-generated catch block
1092             e.printStackTrace();
1093         }
1094         retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1095                 reqObj, respObj, "user");
1096         assertTrue(retVal.status == 20);
1097
1098         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1099                 new Object[0]);
1100         Mockito.doReturn(rsVoid).when(authzService).getPermsByUser(
1101                 Mockito.any(), Mockito.any(), Mockito.anyString());
1102         retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1103                 reqObj, respObj, "user");
1104         assertTrue(retVal.status == 31);
1105
1106         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1107         Mockito.doReturn(rsVoid).when(authzService).getPermsByUser(
1108                 Mockito.any(), Mockito.any(), Mockito.anyString());
1109         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1110         try {
1111             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1112         } catch (APIException e) {
1113             // TODO Auto-generated catch block
1114             e.printStackTrace();
1115         }
1116         retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1117                 reqObj, respObj, "user");
1118         assertTrue(retVal.status == 0);
1119
1120         Mockito.doReturn("user").when(trans).user();
1121         Mockito.doReturn(env).when(trans).env();
1122         Question.specialLogOn(trans, trans.user());
1123         retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1124                 reqObj, respObj, "user");
1125         assertTrue(retVal.status == 0);
1126     }
1127
1128     @Test
1129     @SuppressWarnings("unchecked")
1130     public void testGetPermsForRole() {
1131         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1132         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1133
1134         Result<Void> retVal = (Result<Void>) facadeImplObj
1135                 .getPermsForRole(trans, respObj, "roleName");
1136         assertTrue(retVal.status == 20);
1137
1138         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1139                 new Object[0]);
1140         Mockito.doReturn(rsVoid).when(authzService)
1141                 .getPermsByRole(Mockito.any(), Mockito.anyString());
1142         retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
1143                 "roleName");
1144         assertTrue(retVal.status == 31);
1145
1146         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1147         Mockito.doReturn(rsVoid).when(authzService)
1148                 .getPermsByRole(Mockito.any(), Mockito.anyString());
1149         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1150         try {
1151             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1152         } catch (APIException e) {
1153             // TODO Auto-generated catch block
1154             e.printStackTrace();
1155         }
1156         retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
1157                 "roleName");
1158         assertTrue(retVal.status == 0);
1159
1160         Mockito.doReturn("user").when(trans).user();
1161         Mockito.doReturn(env).when(trans).env();
1162         Question.specialLogOn(trans, trans.user());
1163         retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
1164                 "roleName");
1165         assertTrue(retVal.status == 0);
1166     }
1167
1168     @Test
1169     @SuppressWarnings("unchecked")
1170     public void testGetPermsByNS() {
1171         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1172         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1173
1174         Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans,
1175                 respObj, "ns");
1176         assertTrue(retVal.status == 20);
1177
1178         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1179                 new Object[0]);
1180         Mockito.doReturn(rsVoid).when(authzService).getPermsByNS(Mockito.any(),
1181                 Mockito.anyString());
1182         retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
1183                 "ns");
1184         assertTrue(retVal.status == 31);
1185
1186         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1187         Mockito.doReturn(rsVoid).when(authzService).getPermsByNS(Mockito.any(),
1188                 Mockito.anyString());
1189         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1190         try {
1191             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1192         } catch (APIException e) {
1193             // TODO Auto-generated catch block
1194             e.printStackTrace();
1195         }
1196         retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
1197                 "ns");
1198         assertTrue(retVal.status == 0);
1199
1200         Mockito.doReturn("user").when(trans).user();
1201         Mockito.doReturn(env).when(trans).env();
1202         Question.specialLogOn(trans, trans.user());
1203         retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
1204                 "ns");
1205         assertTrue(retVal.status == 0);
1206     }
1207     @Test
1208     @SuppressWarnings("unchecked")
1209     public void testRenamePerm() {
1210         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1211         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1212         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1213
1214         Result<Void> retVal = (Result<Void>) facadeImplObj.renamePerm(trans,
1215                 reqObj, respObj, "origType", "origInstance", "origAction");
1216         assertTrue(retVal.status == 20);
1217
1218         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1219         try {
1220             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1221                     .load(Mockito.any(ServletInputStream.class));
1222         } catch (APIException e) {
1223             // TODO Auto-generated catch block
1224             e.printStackTrace();
1225         }
1226         retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1227                 "origType", "origInstance", "origAction");
1228         assertTrue(retVal.status == Status.ERR_BadData);
1229
1230         try {
1231             Mockito.doReturn(dataObj).when(dataObj)
1232                     .load(Mockito.any(ServletInputStream.class));
1233         } catch (APIException e) {
1234             // TODO Auto-generated catch block
1235             e.printStackTrace();
1236         }
1237         retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1238                 "origType", "origInstance", "origAction");
1239         assertTrue(retVal.status == 20);
1240
1241         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1242                 new Object[0]);
1243         Mockito.doReturn(rsVoid).when(authzService).renamePerm(Mockito.any(),
1244                 Mockito.any(), Mockito.anyString(), Mockito.anyString(),
1245                 Mockito.anyString());
1246         retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1247                 "origType", "origInstance", "origAction");
1248         assertTrue(retVal.status == 31);
1249
1250         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1251         Mockito.doReturn(rsVoid).when(authzService).renamePerm(Mockito.any(),
1252                 Mockito.any(), Mockito.anyString(), Mockito.anyString(),
1253                 Mockito.anyString());
1254         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1255         try {
1256             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1257         } catch (APIException e) {
1258             // TODO Auto-generated catch block
1259             e.printStackTrace();
1260         }
1261         retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1262                 "origType", "origInstance", "origAction");
1263         assertTrue(retVal.status == 0);
1264
1265         Mockito.doReturn("user").when(trans).user();
1266         Mockito.doReturn(env).when(trans).env();
1267         Question.specialLogOn(trans, trans.user());
1268         retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1269                 "origType", "origInstance", "origAction");
1270         assertTrue(retVal.status == 0);
1271     }
1272     @Test
1273     @SuppressWarnings("unchecked")
1274     public void testUpdatePermDescription() {
1275         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1276         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1277         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1278
1279         Result<Void> retVal = (Result<Void>) facadeImplObj
1280                 .updatePermDescription(trans, reqObj, respObj);
1281         assertTrue(retVal.status == 20);
1282
1283         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1284         try {
1285             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1286                     .load(Mockito.any(ServletInputStream.class));
1287         } catch (APIException e) {
1288             // TODO Auto-generated catch block
1289             e.printStackTrace();
1290         }
1291         retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1292                 reqObj, respObj);
1293         assertTrue(retVal.status == Status.ERR_BadData);
1294
1295         try {
1296             Mockito.doReturn(dataObj).when(dataObj)
1297                     .load(Mockito.any(ServletInputStream.class));
1298         } catch (APIException e) {
1299             // TODO Auto-generated catch block
1300             e.printStackTrace();
1301         }
1302         retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1303                 reqObj, respObj);
1304         assertTrue(retVal.status == 20);
1305
1306         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1307                 new Object[0]);
1308         Mockito.doReturn(rsVoid).when(authzService)
1309                 .updatePermDescription(Mockito.any(), Mockito.any());
1310         retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1311                 reqObj, respObj);
1312         assertTrue(retVal.status == 31);
1313
1314         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1315         Mockito.doReturn(rsVoid).when(authzService)
1316                 .updatePermDescription(Mockito.any(), Mockito.any());
1317         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1318         try {
1319             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1320         } catch (APIException e) {
1321             // TODO Auto-generated catch block
1322             e.printStackTrace();
1323         }
1324         retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1325                 reqObj, respObj);
1326         assertTrue(retVal.status == 0);
1327
1328         Mockito.doReturn("user").when(trans).user();
1329         Mockito.doReturn(env).when(trans).env();
1330         Question.specialLogOn(trans, trans.user());
1331         retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1332                 reqObj, respObj);
1333         assertTrue(retVal.status == 0);
1334     }
1335     @Test
1336     @SuppressWarnings("unchecked")
1337     public void testResetPermRoles() {
1338         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1339         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1340         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1341
1342         Result<Void> retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans,
1343                 reqObj, respObj);
1344         assertTrue(retVal.status == 20);
1345
1346         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1347         try {
1348             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1349                     .load(Mockito.any(ServletInputStream.class));
1350         } catch (APIException e) {
1351             // TODO Auto-generated catch block
1352             e.printStackTrace();
1353         }
1354         retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1355                 respObj);
1356         assertTrue(retVal.status == Status.ERR_BadData);
1357
1358         try {
1359             Mockito.doReturn(dataObj).when(dataObj)
1360                     .load(Mockito.any(ServletInputStream.class));
1361         } catch (APIException e) {
1362             // TODO Auto-generated catch block
1363             e.printStackTrace();
1364         }
1365         retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1366                 respObj);
1367         assertTrue(retVal.status == 20);
1368
1369         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1370                 new Object[0]);
1371         Mockito.doReturn(rsVoid).when(authzService)
1372                 .resetPermRoles(Mockito.any(), Mockito.any());
1373         retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1374                 respObj);
1375         assertTrue(retVal.status == 31);
1376
1377         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1378         Mockito.doReturn(rsVoid).when(authzService)
1379                 .resetPermRoles(Mockito.any(), Mockito.any());
1380         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1381         try {
1382             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1383         } catch (APIException e) {
1384             // TODO Auto-generated catch block
1385             e.printStackTrace();
1386         }
1387         retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1388                 respObj);
1389         assertTrue(retVal.status == 0);
1390
1391         Mockito.doReturn("user").when(trans).user();
1392         Mockito.doReturn(env).when(trans).env();
1393         Question.specialLogOn(trans, trans.user());
1394         retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1395                 respObj);
1396         assertTrue(retVal.status == 0);
1397     }
1398     @Test
1399     @SuppressWarnings("unchecked")
1400     public void testDeletePerm() {
1401         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1402         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1403         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1404
1405         Result<Void> retVal = (Result<Void>) facadeImplObj.deletePerm(trans,
1406                 reqObj, respObj);
1407         assertTrue(retVal.status == 20);
1408
1409         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1410         try {
1411             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1412                     .load(Mockito.any(ServletInputStream.class));
1413         } catch (APIException e) {
1414             // TODO Auto-generated catch block
1415             e.printStackTrace();
1416         }
1417         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1418                 respObj);
1419         assertTrue(retVal.status == Status.ERR_BadData);
1420
1421         try {
1422             Mockito.doReturn(dataObj).when(dataObj)
1423                     .load(Mockito.any(ServletInputStream.class));
1424         } catch (APIException e) {
1425             // TODO Auto-generated catch block
1426             e.printStackTrace();
1427         }
1428         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1429                 respObj);
1430         assertTrue(retVal.status == 20);
1431
1432         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1433                 new Object[0]);
1434         Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
1435                 Mockito.any());
1436         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1437                 respObj);
1438         assertTrue(retVal.status == 31);
1439
1440         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1441         Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
1442                 Mockito.any());
1443         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1444         try {
1445             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1446         } catch (APIException e) {
1447             // TODO Auto-generated catch block
1448             e.printStackTrace();
1449         }
1450         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1451                 respObj);
1452         assertTrue(retVal.status == 0);
1453
1454         Mockito.doReturn("user").when(trans).user();
1455         Mockito.doReturn(env).when(trans).env();
1456         Question.specialLogOn(trans, trans.user());
1457         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1458                 respObj);
1459         assertTrue(retVal.status == 0);
1460     }
1461     @Test
1462     @SuppressWarnings("unchecked")
1463     public void testDeletePermWithTypeInstanceAction() {
1464         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1465         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1466
1467         Result<Void> retVal = (Result<Void>) facadeImplObj.deletePerm(trans,
1468                 respObj, "type", "instance", "action");
1469         assertTrue(retVal.status == 20);
1470
1471         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1472                 new Object[0]);
1473         Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
1474                 Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
1475         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, respObj, "type",
1476                 "instance", "action");
1477         assertTrue(retVal.status == 31);
1478
1479         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1480         Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
1481                 Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
1482         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1483         try {
1484             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1485         } catch (APIException e) {
1486             // TODO Auto-generated catch block
1487             e.printStackTrace();
1488         }
1489         retVal = (Result<Void>) facadeImplObj.deletePerm(trans, respObj, "type",
1490                 "instance", "action");
1491         assertTrue(retVal.status == 0);
1492
1493     }
1494
1495     @Test
1496     @SuppressWarnings("unchecked")
1497     public void testCreateRole() {
1498         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1499         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1500         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1501
1502         Result<Void> retVal = (Result<Void>) facadeImplObj.createRole(trans,
1503                 reqObj, respObj);
1504         assertTrue(retVal.status == 20);
1505
1506         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1507         try {
1508             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1509                     .load(Mockito.any(ServletInputStream.class));
1510         } catch (APIException e) {
1511             // TODO Auto-generated catch block
1512             e.printStackTrace();
1513         }
1514         retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1515                 respObj);
1516         assertTrue(retVal.status == Status.ERR_BadData);
1517
1518         try {
1519             Mockito.doReturn(dataObj).when(dataObj)
1520                     .load(Mockito.any(ServletInputStream.class));
1521         } catch (APIException e) {
1522             // TODO Auto-generated catch block
1523             e.printStackTrace();
1524         }
1525         retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1526                 respObj);
1527         assertTrue(retVal.status == 20);
1528
1529         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1530                 new Object[0]);
1531         Mockito.doReturn(rsVoid).when(authzService).createRole(Mockito.any(),
1532                 Mockito.any());
1533         retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1534                 respObj);
1535         assertTrue(retVal.status == 31);
1536
1537         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1538         Mockito.doReturn(rsVoid).when(authzService).createRole(Mockito.any(),
1539                 Mockito.any());
1540         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1541         try {
1542             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1543         } catch (APIException e) {
1544             // TODO Auto-generated catch block
1545             e.printStackTrace();
1546         }
1547         retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1548                 respObj);
1549         assertTrue(retVal.status == 0);
1550
1551         Mockito.doReturn("user").when(trans).user();
1552         Mockito.doReturn(env).when(trans).env();
1553         Question.specialLogOn(trans, trans.user());
1554         retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1555                 respObj);
1556         assertTrue(retVal.status == 0);
1557     }
1558     @Test
1559     @SuppressWarnings("unchecked")
1560     public void testGetRolesByName() {
1561         RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1562         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1563
1564         Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByName(trans,
1565                 respObj, "role");
1566         assertTrue(retVal.status == 20);
1567
1568         Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1569                 new Object[0]);
1570         Mockito.doReturn(rsVoid).when(authzService)
1571                 .getRolesByName(Mockito.any(), Mockito.any());
1572         retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
1573                 "role");
1574         assertTrue(retVal.status == 31);
1575
1576         rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
1577         Mockito.doReturn(rsVoid).when(authzService)
1578                 .getRolesByName(Mockito.any(), Mockito.anyString());
1579         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1580         try {
1581             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1582         } catch (APIException e) {
1583             // TODO Auto-generated catch block
1584             e.printStackTrace();
1585         }
1586         retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
1587                 "role");
1588         assertTrue(retVal.status == 0);
1589
1590         Mockito.doReturn("user").when(trans).user();
1591         Mockito.doReturn(env).when(trans).env();
1592         Question.specialLogOn(trans, trans.user());
1593         retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
1594                 "role");
1595         assertTrue(retVal.status == 0);
1596     }
1597     @Test
1598     @SuppressWarnings("unchecked")
1599     public void testGetRolesByUser() {
1600         RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1601         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1602
1603         Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans,
1604                 respObj, "user");
1605         assertTrue(retVal.status == 20);
1606
1607         Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1608                 new Object[0]);
1609         Mockito.doReturn(rsVoid).when(authzService)
1610                 .getRolesByUser(Mockito.any(), Mockito.any());
1611         retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
1612                 "user");
1613         assertTrue(retVal.status == 31);
1614
1615         rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
1616         Mockito.doReturn(rsVoid).when(authzService)
1617                 .getRolesByUser(Mockito.any(), Mockito.anyString());
1618         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1619         try {
1620             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1621         } catch (APIException e) {
1622             // TODO Auto-generated catch block
1623             e.printStackTrace();
1624         }
1625         retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
1626                 "user");
1627         assertTrue(retVal.status == 0);
1628
1629         Mockito.doReturn("user").when(trans).user();
1630         Mockito.doReturn(env).when(trans).env();
1631         Question.specialLogOn(trans, trans.user());
1632         retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
1633                 "user");
1634         assertTrue(retVal.status == 0);
1635     }
1636     @Test
1637     @SuppressWarnings("unchecked")
1638     public void testGetRolesByNS() {
1639         Mockito.doReturn("user").when(trans).user();
1640         Mockito.doReturn(env).when(trans).env();
1641         RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1642         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1643
1644         Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans,
1645                 respObj, "ns");
1646         assertTrue(retVal.status == 20);
1647
1648         Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1649                 new Object[0]);
1650         Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
1651                 Mockito.any());
1652         retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1653                 "ns");
1654         assertTrue(retVal.status == 31);
1655
1656         rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
1657         Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
1658                 Mockito.anyString());
1659         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1660         try {
1661             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1662         } catch (APIException e) {
1663             // TODO Auto-generated catch block
1664             e.printStackTrace();
1665         }
1666         retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1667                 "ns");
1668         assertTrue(retVal.status == 0);
1669
1670         rsVoid = Mockito.mock(Result.class);
1671         Mockito.doReturn(false).when(rsVoid).isEmpty();
1672         Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
1673                 Mockito.anyString());
1674         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1675         try {
1676             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1677         } catch (APIException e) {
1678             // TODO Auto-generated catch block
1679             e.printStackTrace();
1680         }
1681         retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1682                 "ns");
1683         assertTrue(retVal.status == 0);
1684
1685         Question.specialLogOn(trans, trans.user());
1686         retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1687                 "ns");
1688         assertTrue(retVal.status == 0);
1689     }
1690
1691     @Test
1692     @SuppressWarnings("unchecked")
1693     public void testGetRolesByNameOnly() {
1694         Mockito.doReturn("user").when(trans).user();
1695         Mockito.doReturn(env).when(trans).env();
1696         RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1697         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1698
1699         Result<Void> retVal = (Result<Void>) facadeImplObj
1700                 .getRolesByNameOnly(trans, respObj, "ns");
1701         assertTrue(retVal.status == 20);
1702
1703         Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1704                 new Object[0]);
1705         Mockito.doReturn(rsVoid).when(authzService)
1706                 .getRolesByNameOnly(Mockito.any(), Mockito.any());
1707         retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1708                 "ns");
1709         assertTrue(retVal.status == 31);
1710
1711         rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
1712         Mockito.doReturn(rsVoid).when(authzService)
1713                 .getRolesByNameOnly(Mockito.any(), Mockito.anyString());
1714         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1715         try {
1716             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1717         } catch (APIException e) {
1718             // TODO Auto-generated catch block
1719             e.printStackTrace();
1720         }
1721         retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1722                 "ns");
1723         assertTrue(retVal.status == 0);
1724
1725         rsVoid = Mockito.mock(Result.class);
1726         Mockito.doReturn(false).when(rsVoid).isEmpty();
1727         Mockito.doReturn(rsVoid).when(authzService)
1728                 .getRolesByNameOnly(Mockito.any(), Mockito.anyString());
1729         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1730         try {
1731             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1732         } catch (APIException e) {
1733             // TODO Auto-generated catch block
1734             e.printStackTrace();
1735         }
1736         retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1737                 "ns");
1738         assertTrue(retVal.status == 0);
1739
1740         Question.specialLogOn(trans, trans.user());
1741         retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1742                 "ns");
1743         assertTrue(retVal.status == 0);
1744     }
1745
1746     @Test
1747     @SuppressWarnings("unchecked")
1748     public void testGetRolesByPerm() {
1749         RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1750         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1751
1752         Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans,
1753                 respObj, "type", "instance", "action");
1754         assertTrue(retVal.status == 20);
1755
1756         Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1757                 new Object[0]);
1758         Mockito.doReturn(rsVoid).when(authzService).getRolesByPerm(trans,
1759                 "type", "instance", "action");
1760         retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
1761                 "type", "instance", "action");
1762         assertTrue(retVal.status == 31);
1763
1764         rsVoid = new Result<ROLES>(null, 0, "test", new Object[0]);
1765         Mockito.doReturn(rsVoid).when(authzService).getRolesByPerm(trans,
1766                 "type", "instance", "action");
1767         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1768         try {
1769             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1770         } catch (APIException e) {
1771             // TODO Auto-generated catch block
1772             e.printStackTrace();
1773         }
1774         retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
1775                 "type", "instance", "action");
1776         assertTrue(retVal.status == 0);
1777
1778         Mockito.doReturn("user").when(trans).user();
1779         Mockito.doReturn(env).when(trans).env();
1780         Question.specialLogOn(trans, trans.user());
1781         retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
1782                 "type", "instance", "action");
1783         assertTrue(retVal.status == 0);
1784     }
1785     @Test
1786     @SuppressWarnings("unchecked")
1787     public void testUpdateRoleDescription() {
1788         RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1789         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1790         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1791
1792         Result<Void> retVal = (Result<Void>) facadeImplObj
1793                 .updateRoleDescription(trans, reqObj, respObj);
1794         assertTrue(retVal.status == 20);
1795
1796         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1797         try {
1798             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1799                     .load(Mockito.any(ServletInputStream.class));
1800         } catch (APIException e) {
1801             // TODO Auto-generated catch block
1802             e.printStackTrace();
1803         }
1804         retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1805                 reqObj, respObj);
1806         assertTrue(retVal.status == Status.ERR_BadData);
1807
1808         try {
1809             Mockito.doReturn(dataObj).when(dataObj)
1810                     .load(Mockito.any(ServletInputStream.class));
1811         } catch (APIException e) {
1812             // TODO Auto-generated catch block
1813             e.printStackTrace();
1814         }
1815         retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1816                 reqObj, respObj);
1817         assertTrue(retVal.status == 20);
1818
1819         Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1820                 new Object[0]);
1821         Mockito.doReturn(rsVoid).when(authzService)
1822                 .updateRoleDescription(Mockito.any(), Mockito.any());
1823         retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1824                 reqObj, respObj);
1825         assertTrue(retVal.status == 31);
1826
1827         rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1828         Mockito.doReturn(rsVoid).when(authzService)
1829                 .updateRoleDescription(Mockito.any(), Mockito.any());
1830         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1831         try {
1832             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1833         } catch (APIException e) {
1834             // TODO Auto-generated catch block
1835             e.printStackTrace();
1836         }
1837         retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1838                 reqObj, respObj);
1839         assertTrue(retVal.status == 0);
1840
1841         Mockito.doReturn("user").when(trans).user();
1842         Mockito.doReturn(env).when(trans).env();
1843         Question.specialLogOn(trans, trans.user());
1844         retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1845                 reqObj, respObj);
1846         assertTrue(retVal.status == 0);
1847     }
1848     @Test
1849     @SuppressWarnings("unchecked")
1850     public void testAddPermToRole() {
1851         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
1852         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1853         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1854
1855         Result<Void> retVal = (Result<Void>) facadeImplObj.addPermToRole(trans,
1856                 reqObj, respObj);
1857         assertTrue(retVal.status == 20);
1858
1859         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1860         try {
1861             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1862                     .load(Mockito.any(ServletInputStream.class));
1863         } catch (APIException e) {
1864             // TODO Auto-generated catch block
1865             e.printStackTrace();
1866         }
1867         retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1868                 respObj);
1869         assertTrue(retVal.status == Status.ERR_BadData);
1870
1871         try {
1872             Mockito.doReturn(dataObj).when(dataObj)
1873                     .load(Mockito.any(ServletInputStream.class));
1874         } catch (APIException e) {
1875             // TODO Auto-generated catch block
1876             e.printStackTrace();
1877         }
1878         retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1879                 respObj);
1880         assertTrue(retVal.status == 20);
1881
1882         Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
1883                 new Object[0]);
1884         Mockito.doReturn(rsRequest).when(authzService)
1885                 .addPermToRole(Mockito.any(), Mockito.any());
1886         retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1887                 respObj);
1888         assertTrue(retVal.status == 31);
1889
1890         rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
1891         Mockito.doReturn(rsRequest).when(authzService)
1892                 .addPermToRole(Mockito.any(), Mockito.any());
1893         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1894         try {
1895             Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
1896         } catch (APIException e) {
1897             // TODO Auto-generated catch block
1898             e.printStackTrace();
1899         }
1900         try {
1901             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
1902                     .when(respObj).getOutputStream();
1903         } catch (IOException e) {
1904             // TODO Auto-generated catch block
1905             e.printStackTrace();
1906         }
1907         retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1908                 respObj);
1909         assertTrue(retVal.status == 0);
1910
1911         Mockito.doReturn("user").when(trans).user();
1912         Mockito.doReturn(env).when(trans).env();
1913         Question.specialLogOn(trans, trans.user());
1914         retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1915                 respObj);
1916         assertTrue(retVal.status == 0);
1917     }
1918     @Test
1919     @SuppressWarnings("unchecked")
1920     public void testDelPermFromRole() {
1921         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
1922         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
1923         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1924
1925         Result<Void> retVal = (Result<Void>) facadeImplObj
1926                 .delPermFromRole(trans, reqObj, respObj);
1927         assertTrue(retVal.status == 20);
1928
1929         Mockito.doReturn(dataObj).when(rossetaObj).newData();
1930         try {
1931             Mockito.doThrow(new APIException("test exception")).when(dataObj)
1932                     .load(Mockito.any(ServletInputStream.class));
1933         } catch (APIException e) {
1934             // TODO Auto-generated catch block
1935             e.printStackTrace();
1936         }
1937         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1938                 respObj);
1939         assertTrue(retVal.status == Status.ERR_BadData);
1940
1941         try {
1942             Mockito.doReturn(dataObj).when(dataObj)
1943                     .load(Mockito.any(ServletInputStream.class));
1944         } catch (APIException e) {
1945             // TODO Auto-generated catch block
1946             e.printStackTrace();
1947         }
1948         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1949                 respObj);
1950         assertTrue(retVal.status == 20);
1951
1952         Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
1953                 new Object[0]);
1954         Mockito.doReturn(rsRequest).when(authzService)
1955                 .delPermFromRole(Mockito.any(), Mockito.any());
1956         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1957                 respObj);
1958         assertTrue(retVal.status == 31);
1959
1960         rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
1961         Mockito.doReturn(rsRequest).when(authzService)
1962                 .delPermFromRole(Mockito.any(), Mockito.any());
1963         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1964         try {
1965             Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
1966         } catch (APIException e) {
1967             // TODO Auto-generated catch block
1968             e.printStackTrace();
1969         }
1970         try {
1971             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
1972                     .when(respObj).getOutputStream();
1973         } catch (IOException e) {
1974             // TODO Auto-generated catch block
1975             e.printStackTrace();
1976         }
1977         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1978                 respObj);
1979         assertTrue(retVal.status == 0);
1980
1981         Mockito.doReturn("user").when(trans).user();
1982         Mockito.doReturn(env).when(trans).env();
1983         Question.specialLogOn(trans, trans.user());
1984         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1985                 respObj);
1986         assertTrue(retVal.status == 0);
1987     }
1988     @Test
1989     @SuppressWarnings("unchecked")
1990     public void testDelPermFromRoleWithAddlParams() {
1991         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
1992         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1993
1994         Result<Void> retVal = (Result<Void>) facadeImplObj.delPermFromRole(
1995                 trans, respObj, "role", "type", "instance", "action");
1996         assertTrue(retVal.status == 20);
1997
1998         Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
1999                 new Object[0]);
2000         Mockito.doReturn(rsRequest).when(authzService).delPermFromRole(trans,
2001                 "role", "type", "instance", "action");
2002         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
2003                 "role", "type", "instance", "action");
2004         assertTrue(retVal.status == 31);
2005
2006         rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
2007         Mockito.doReturn(rsRequest).when(authzService).delPermFromRole(trans,
2008                 "role", "type", "instance", "action");
2009         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2010         try {
2011             Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
2012         } catch (APIException e) {
2013             // TODO Auto-generated catch block
2014             e.printStackTrace();
2015         }
2016         try {
2017             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2018                     .when(respObj).getOutputStream();
2019         } catch (IOException e) {
2020             // TODO Auto-generated catch block
2021             e.printStackTrace();
2022         }
2023         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
2024                 "role", "type", "instance", "action");
2025         assertTrue(retVal.status == 0);
2026
2027         Mockito.doReturn("user").when(trans).user();
2028         Mockito.doReturn(env).when(trans).env();
2029         Question.specialLogOn(trans, trans.user());
2030         retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
2031                 "role", "type", "instance", "action");
2032         assertTrue(retVal.status == 0);
2033     }
2034     @Test
2035     @SuppressWarnings("unchecked")
2036     public void testDeleteRole() {
2037         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2038         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2039
2040         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteRole(trans,
2041                 respObj, "role");
2042         assertTrue(retVal.status == 20);
2043
2044         Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
2045                 new Object[0]);
2046         Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans,
2047                 "role");
2048         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
2049                 "role");
2050         assertTrue(retVal.status == 31);
2051
2052         rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
2053         Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans,
2054                 "role");
2055         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2056         try {
2057             Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
2058         } catch (APIException e) {
2059             // TODO Auto-generated catch block
2060             e.printStackTrace();
2061         }
2062         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
2063                 "role");
2064         assertTrue(retVal.status == 0);
2065
2066         Mockito.doReturn("user").when(trans).user();
2067         Mockito.doReturn(env).when(trans).env();
2068         Question.specialLogOn(trans, trans.user());
2069         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
2070                 "role");
2071         assertTrue(retVal.status == 0);
2072     }
2073     @Test
2074     @SuppressWarnings("unchecked")
2075     public void testDeleteRole2() {
2076         RosettaData<Void> dataObj = Mockito.mock(RosettaData.class);
2077         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2078         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2079
2080         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteRole(trans,
2081                 reqObj, respObj);
2082         assertTrue(retVal.status == 20);
2083
2084         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2085         try {
2086             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2087                     .load(Mockito.any(ServletInputStream.class));
2088         } catch (APIException e) {
2089             // TODO Auto-generated catch block
2090             e.printStackTrace();
2091         }
2092         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2093                 respObj);
2094         assertTrue(retVal.status == Status.ERR_BadData);
2095
2096         Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2097                 new Object[0]);
2098         Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans, null);
2099
2100         try {
2101             Mockito.doReturn(dataObj).when(dataObj)
2102                     .load(Mockito.any(ServletInputStream.class));
2103         } catch (APIException e) {
2104             // TODO Auto-generated catch block
2105             e.printStackTrace();
2106         }
2107         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2108                 respObj);
2109         assertTrue(retVal.status == 20);
2110
2111         rsRequest = new Result<Void>(null, 0, "test", new Object[0]);
2112         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2113         try {
2114             Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
2115         } catch (APIException e) {
2116             // TODO Auto-generated catch block
2117             e.printStackTrace();
2118         }
2119         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2120                 respObj);
2121         assertTrue(retVal.status == 20);
2122
2123         Mockito.doReturn("user").when(trans).user();
2124         Mockito.doReturn(env).when(trans).env();
2125         Question.specialLogOn(trans, trans.user());
2126         retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2127                 respObj);
2128         assertTrue(retVal.status == 20);
2129     }
2130
2131     @Test
2132     @SuppressWarnings("unchecked")
2133     public void testCreateUserCred() {
2134         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2135         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2136
2137         Result<Void> retVal = (Result<Void>) facadeImplObj.createUserCred(trans,
2138                 reqObj);
2139         assertTrue(retVal.status == 20);
2140
2141         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2142         try {
2143             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2144                     .load(Mockito.any(ServletInputStream.class));
2145         } catch (APIException e) {
2146             // TODO Auto-generated catch block
2147             e.printStackTrace();
2148         }
2149         retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
2150         assertTrue(retVal.status == Status.ERR_BadData);
2151
2152         try {
2153             Mockito.doReturn(dataObj).when(dataObj)
2154                     .load(Mockito.any(ServletInputStream.class));
2155         } catch (APIException e) {
2156             // TODO Auto-generated catch block
2157             e.printStackTrace();
2158         }
2159         Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2160                 new Object[0]);
2161         Mockito.doReturn(rsRequest).when(authzService)
2162                 .createUserCred(Mockito.any(), Mockito.any());
2163         retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
2164
2165         assertTrue(retVal.status == 31);
2166
2167         Mockito.doReturn("user").when(trans).user();
2168         Mockito.doReturn(env).when(trans).env();
2169         Question.specialLogOn(trans, trans.user());
2170         retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
2171         assertTrue(retVal.status == 31);
2172     }
2173     @Test
2174     @SuppressWarnings("unchecked")
2175     public void testChangeUserCred() {
2176         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2177         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2178
2179         Result<Void> retVal = (Result<Void>) facadeImplObj.changeUserCred(trans,
2180                 reqObj);
2181         assertTrue(retVal.status == 20);
2182
2183         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2184         try {
2185             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2186                     .load(Mockito.any(ServletInputStream.class));
2187         } catch (APIException e) {
2188             // TODO Auto-generated catch block
2189             e.printStackTrace();
2190         }
2191         retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
2192         assertTrue(retVal.status == Status.ERR_BadData);
2193
2194         try {
2195             Mockito.doReturn(dataObj).when(dataObj)
2196                     .load(Mockito.any(ServletInputStream.class));
2197         } catch (APIException e) {
2198             // TODO Auto-generated catch block
2199             e.printStackTrace();
2200         }
2201         Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2202                 new Object[0]);
2203         Mockito.doReturn(rsRequest).when(authzService)
2204                 .resetUserCred(Mockito.any(), Mockito.any());
2205         retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
2206
2207         assertTrue(retVal.status == 31);
2208
2209         Mockito.doReturn("user").when(trans).user();
2210         Mockito.doReturn(env).when(trans).env();
2211         Question.specialLogOn(trans, trans.user());
2212         retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
2213         assertTrue(retVal.status == 31);
2214     }
2215
2216     @Test
2217     @SuppressWarnings("unchecked")
2218     public void testExtendUserCred() {
2219         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2220         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2221
2222         Result<Void> retVal = (Result<Void>) facadeImplObj.extendUserCred(trans,
2223                 reqObj, "10");
2224         assertTrue(retVal.status == 20);
2225
2226         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2227         try {
2228             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2229                     .load(Mockito.any(ServletInputStream.class));
2230         } catch (APIException e) {
2231             // TODO Auto-generated catch block
2232             e.printStackTrace();
2233         }
2234         retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
2235                 "10");
2236         assertTrue(retVal.status == Status.ERR_BadData);
2237
2238         try {
2239             Mockito.doReturn(dataObj).when(dataObj)
2240                     .load(Mockito.any(ServletInputStream.class));
2241         } catch (APIException e) {
2242             // TODO Auto-generated catch block
2243             e.printStackTrace();
2244         }
2245         Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2246                 new Object[0]);
2247         Mockito.doReturn(rsRequest).when(authzService).extendUserCred(
2248                 Mockito.any(), Mockito.any(), Mockito.anyString());
2249         retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
2250                 "10");
2251
2252         assertTrue(retVal.status == 31);
2253
2254         Mockito.doReturn("user").when(trans).user();
2255         Mockito.doReturn(env).when(trans).env();
2256         Question.specialLogOn(trans, trans.user());
2257         retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
2258                 "10");
2259         assertTrue(retVal.status == 31);
2260     }
2261
2262     @Test
2263     @SuppressWarnings("unchecked")
2264     public void testGetCredsByNS() {
2265         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2266         Result<Void> retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans,
2267                 respObj, "ns");
2268         assertTrue(retVal.status == 20);
2269
2270         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2271         Mockito.doReturn(rsVoid).when(authzService).getCredsByNS(trans, "ns");
2272         retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
2273                 "ns");
2274         assertTrue(retVal.status == 31);
2275
2276         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2277         Mockito.doReturn(rsVoid).when(authzService).getCredsByNS(trans, "ns");
2278         try {
2279             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2280                     .when(respObj).getOutputStream();
2281         } catch (IOException e) {
2282             // TODO Auto-generated catch block
2283             e.printStackTrace();
2284         }
2285
2286         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2287         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2288         try {
2289             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2290         } catch (APIException e) {
2291             // TODO Auto-generated catch block
2292             e.printStackTrace();
2293         }
2294
2295         retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
2296                 "ns");
2297         assertTrue(retVal.status == 0);
2298
2299         Mockito.doReturn("user").when(trans).user();
2300         Mockito.doReturn(env).when(trans).env();
2301         Question.specialLogOn(trans, trans.user());
2302         retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
2303                 "ns");
2304         assertTrue(retVal.status == 0);
2305     }
2306     @Test
2307     @SuppressWarnings("unchecked")
2308     public void testGetCredsByID() {
2309         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2310         Result<Void> retVal = (Result<Void>) facadeImplObj.getCredsByID(trans,
2311                 respObj, "id");
2312         assertTrue(retVal.status == 20);
2313
2314         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2315         Mockito.doReturn(rsVoid).when(authzService).getCredsByID(trans, "id");
2316         retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
2317                 "id");
2318         assertTrue(retVal.status == 31);
2319
2320         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2321         Mockito.doReturn(rsVoid).when(authzService).getCredsByID(trans, "id");
2322         try {
2323             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2324                     .when(respObj).getOutputStream();
2325         } catch (IOException e) {
2326             // TODO Auto-generated catch block
2327             e.printStackTrace();
2328         }
2329
2330         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2331         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2332         try {
2333             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2334         } catch (APIException e) {
2335             // TODO Auto-generated catch block
2336             e.printStackTrace();
2337         }
2338
2339         retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
2340                 "id");
2341         assertTrue(retVal.status == 0);
2342
2343         Mockito.doReturn("user").when(trans).user();
2344         Mockito.doReturn(env).when(trans).env();
2345         Question.specialLogOn(trans, trans.user());
2346         retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
2347                 "id");
2348         assertTrue(retVal.status == 0);
2349     }
2350     @Test
2351     @SuppressWarnings("unchecked")
2352     public void testDeleteUserCred() {
2353         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2354         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans,
2355                 reqObj);
2356         assertTrue(retVal.status == 20);
2357
2358         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2359         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2360         try {
2361             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2362                     .load(Mockito.any(ServletInputStream.class));
2363         } catch (APIException e) {
2364             // TODO Auto-generated catch block
2365             e.printStackTrace();
2366         }
2367         retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
2368         assertTrue(retVal.status == 4);
2369
2370         try {
2371             Mockito.doReturn(dataObj).when(dataObj)
2372                     .load(Mockito.any(ServletInputStream.class));
2373         } catch (APIException e) {
2374             // TODO Auto-generated catch block
2375             e.printStackTrace();
2376         }
2377
2378         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2379         Mockito.doReturn(rsVoid).when(authzService)
2380                 .deleteUserCred(Mockito.any(), Mockito.any());
2381         retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
2382         assertTrue(retVal.status == 31);
2383
2384         Mockito.doReturn("user").when(trans).user();
2385         Mockito.doReturn(env).when(trans).env();
2386         Question.specialLogOn(trans, trans.user());
2387         retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
2388         assertTrue(retVal.status == 31);
2389     }
2390     @Test
2391     @SuppressWarnings("unchecked")
2392     public void testDoesCredentialMatch() {
2393         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2394         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2395
2396         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2397         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2398         try {
2399             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2400                     .load(Mockito.any(ServletInputStream.class));
2401         } catch (APIException e) {
2402             // TODO Auto-generated catch block
2403             e.printStackTrace();
2404         }
2405         Result<Date> retVal = (Result<Date>) facadeImplObj
2406                 .doesCredentialMatch(trans, reqObj, respObj);
2407         assertTrue(retVal.status == 4);
2408
2409         try {
2410             Mockito.doReturn(dataObj).when(dataObj)
2411                     .load(Mockito.any(ServletInputStream.class));
2412         } catch (APIException e) {
2413             // TODO Auto-generated catch block
2414             e.printStackTrace();
2415         }
2416
2417         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2418         Mockito.doReturn(rsVoid).when(authzService)
2419                 .doesCredentialMatch(Mockito.any(), Mockito.any());
2420         retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
2421                 respObj);
2422         assertTrue(retVal.status == 31);
2423
2424         Mockito.doReturn("user").when(trans).user();
2425         Mockito.doReturn(env).when(trans).env();
2426         Question.specialLogOn(trans, trans.user());
2427         retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
2428                 respObj);
2429         assertTrue(retVal.status == 31);
2430
2431         try {
2432             Mockito.doThrow(new IOException("test exception")).when(reqObj)
2433                     .getInputStream();
2434         } catch (IOException e) {
2435             // TODO Auto-generated catch block
2436             e.printStackTrace();
2437         }
2438         retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
2439                 respObj);
2440         assertTrue(retVal.status == 20);
2441     }
2442     @Test
2443     @SuppressWarnings("unchecked")
2444     public void testValidBasicAuth() {
2445         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2446
2447         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2448         Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
2449                 "basicAuth");
2450         Result<Void> retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans,
2451                 respObj, "basicAuth");
2452         assertTrue(retVal.status == 31);
2453
2454         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2455         Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
2456                 "basicAuth");
2457         retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans, respObj,
2458                 "basicAuth");
2459         assertTrue(retVal.status == 20);
2460
2461         try {
2462             Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2463                     .when(respObj).getOutputStream();
2464         } catch (IOException e) {
2465             // TODO Auto-generated catch block
2466             e.printStackTrace();
2467         }
2468         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2469         Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
2470                 "basicAuth");
2471         retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans, respObj,
2472                 "basicAuth");
2473         assertTrue(retVal.status == 0);
2474
2475     }
2476     @Test
2477     @SuppressWarnings("unchecked")
2478     public void testGetCertInfoByID() {
2479         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2480         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2481
2482         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2483         Mockito.doReturn(rsVoid).when(authzService).getCertInfoByID(trans,
2484                 reqObj, "id");
2485         Result<Void> retVal = (Result<Void>) facadeImplObj
2486                 .getCertInfoByID(trans, reqObj, respObj, "id");
2487         assertTrue(retVal.status == 31);
2488
2489         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2490         Mockito.doReturn(rsVoid).when(authzService).getCertInfoByID(trans,
2491                 reqObj, "id");
2492         retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
2493                 respObj, "id");
2494         assertTrue(retVal.status == 0);
2495
2496         Mockito.doReturn("user").when(trans).user();
2497         Mockito.doReturn(env).when(trans).env();
2498         Question.specialLogOn(trans, trans.user());
2499         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2500         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2501         try {
2502             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2503         } catch (APIException e) {
2504             // TODO Auto-generated catch block
2505             e.printStackTrace();
2506         }
2507         retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
2508                 respObj, "id");
2509         assertTrue(retVal.status == 0);
2510
2511         try {
2512             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2513                     .load(rsVoid.value);
2514         } catch (APIException e) {
2515             // TODO Auto-generated catch block
2516             e.printStackTrace();
2517         }
2518         retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
2519                 respObj, "id");
2520         assertTrue(retVal.status == 20);
2521     }
2522
2523     @Test
2524     @SuppressWarnings("unchecked")
2525     public void testCreateDelegate() {
2526         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2527         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2528
2529         Result<Void> retVal = (Result<Void>) facadeImplObj.createDelegate(trans,
2530                 reqObj, respObj);
2531         assertTrue(retVal.status == 20);
2532
2533         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2534         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2535         try {
2536             Mockito.doReturn(Mockito.mock(ServletInputStream.class))
2537                     .when(reqObj).getInputStream();
2538
2539             Mockito.doReturn(dataObj).when(dataObj)
2540                     .load(Mockito.any(ServletInputStream.class));
2541         } catch (Exception e) {
2542             // TODO Auto-generated catch block
2543             e.printStackTrace();
2544         }
2545         Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2546         Mockito.doReturn(rsVoid).when(authzService)
2547                 .createDelegate(Mockito.any(), Mockito.anyObject());
2548
2549         retVal = (Result<Void>) facadeImplObj.createDelegate(trans, reqObj,
2550                 respObj);
2551         assertTrue(retVal.status == 0);
2552
2553         Mockito.doReturn("user").when(trans).user();
2554         Mockito.doReturn(env).when(trans).env();
2555         Question.specialLogOn(trans, trans.user());
2556
2557         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2558         Mockito.doReturn(rsVoid).when(authzService)
2559                 .createDelegate(Mockito.any(), Mockito.any());
2560         retVal = (Result<Void>) facadeImplObj.createDelegate(trans, reqObj,
2561                 respObj);
2562         assertTrue(retVal.status == 0);
2563
2564     }
2565     @Test
2566     @SuppressWarnings("unchecked")
2567     public void testUpdateDelegate() {
2568         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2569         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2570
2571         Result<Void> retVal = (Result<Void>) facadeImplObj.updateDelegate(trans,
2572                 reqObj, respObj);
2573         assertTrue(retVal.status == 20);
2574
2575         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2576         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2577         try {
2578             Mockito.doReturn(Mockito.mock(ServletInputStream.class))
2579                     .when(reqObj).getInputStream();
2580
2581             Mockito.doReturn(dataObj).when(dataObj)
2582                     .load(Mockito.any(ServletInputStream.class));
2583         } catch (Exception e) {
2584             // TODO Auto-generated catch block
2585             e.printStackTrace();
2586         }
2587         Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2588         Mockito.doReturn(rsVoid).when(authzService)
2589                 .updateDelegate(Mockito.any(), Mockito.anyObject());
2590
2591         retVal = (Result<Void>) facadeImplObj.updateDelegate(trans, reqObj,
2592                 respObj);
2593         assertTrue(retVal.status == 0);
2594
2595         Mockito.doReturn("user").when(trans).user();
2596         Mockito.doReturn(env).when(trans).env();
2597         Question.specialLogOn(trans, trans.user());
2598
2599         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2600         Mockito.doReturn(rsVoid).when(authzService)
2601                 .updateDelegate(Mockito.any(), Mockito.any());
2602         retVal = (Result<Void>) facadeImplObj.updateDelegate(trans, reqObj,
2603                 respObj);
2604         assertTrue(retVal.status == 0);
2605
2606     }
2607
2608     @Test
2609     @SuppressWarnings("unchecked")
2610     public void testDeleteDelegate() {
2611         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2612         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2613
2614         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans,
2615                 reqObj, respObj);
2616         assertTrue(retVal.status == 20);
2617
2618         RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2619         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2620         try {
2621             Mockito.doReturn(Mockito.mock(ServletInputStream.class))
2622                     .when(reqObj).getInputStream();
2623
2624             Mockito.doReturn(dataObj).when(dataObj)
2625                     .load(Mockito.any(ServletInputStream.class));
2626         } catch (Exception e) {
2627             // TODO Auto-generated catch block
2628             e.printStackTrace();
2629         }
2630         Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2631         Mockito.doReturn(rsVoid).when(authzService)
2632                 .deleteDelegate(Mockito.any(), Mockito.anyObject());
2633
2634         retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, reqObj,
2635                 respObj);
2636         assertNull(retVal);
2637
2638         Mockito.doReturn("user").when(trans).user();
2639         Mockito.doReturn(env).when(trans).env();
2640         Question.specialLogOn(trans, trans.user());
2641
2642         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2643         Mockito.doReturn(rsVoid).when(authzService)
2644                 .deleteDelegate(Mockito.any(), Mockito.any());
2645         retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, reqObj,
2646                 respObj);
2647         assertNull(retVal);
2648
2649     }
2650
2651     @Test
2652     @SuppressWarnings("unchecked")
2653     public void testDeleteDelegate2() {
2654
2655         Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2656         Mockito.doReturn(rsVoid).when(authzService).deleteDelegate(trans,
2657                 "userName");
2658
2659         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans,
2660                 "userName");
2661         assertTrue(retVal.status == 0);
2662
2663         Mockito.doThrow(new RuntimeException("test exception"))
2664                 .when(authzService).deleteDelegate(trans, "userName");
2665         retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, "userName");
2666         assertTrue(retVal.status == 20);
2667     }
2668     @Test
2669     @SuppressWarnings("unchecked")
2670     public void testGetDelegatesByUser() {
2671         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2672
2673         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2674         Mockito.doReturn(rsVoid).when(authzService).getDelegatesByUser(trans,
2675                 "user");
2676         Result<Void> retVal = (Result<Void>) facadeImplObj
2677                 .getDelegatesByUser(trans, "user", respObj);
2678         assertTrue(retVal.status == 31);
2679
2680         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2681         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2682         try {
2683             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2684         } catch (APIException e) {
2685             // TODO Auto-generated catch block
2686             e.printStackTrace();
2687         }
2688         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2689         Mockito.doReturn(rsVoid).when(authzService).getDelegatesByUser(trans,
2690                 "user");
2691         retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
2692                 respObj);
2693         assertTrue(retVal.status == 0);
2694
2695         Mockito.doReturn("user").when(trans).user();
2696         Mockito.doReturn(env).when(trans).env();
2697         Question.specialLogOn(trans, trans.user());
2698         retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
2699                 respObj);
2700         assertTrue(retVal.status == 0);
2701
2702         try {
2703             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2704                     .load(rsVoid.value);
2705         } catch (APIException e) {
2706             // TODO Auto-generated catch block
2707             e.printStackTrace();
2708         }
2709         retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
2710                 respObj);
2711         assertTrue(retVal.status == 20);
2712     }
2713     @Test
2714     @SuppressWarnings("unchecked")
2715     public void testGetDelegatesByDelegate() {
2716         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2717
2718         Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2719         Mockito.doReturn(rsVoid).when(authzService)
2720                 .getDelegatesByDelegate(trans, "delegate");
2721         Result<Void> retVal = (Result<Void>) facadeImplObj
2722                 .getDelegatesByDelegate(trans, "delegate", respObj);
2723         assertTrue(retVal.status == 31);
2724
2725         RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2726         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2727         try {
2728             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2729         } catch (APIException e) {
2730             // TODO Auto-generated catch block
2731             e.printStackTrace();
2732         }
2733         rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2734         Mockito.doReturn(rsVoid).when(authzService)
2735                 .getDelegatesByDelegate(trans, "delegate");
2736         retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
2737                 "delegate", respObj);
2738         assertTrue(retVal.status == 0);
2739
2740         Mockito.doReturn("user").when(trans).user();
2741         Mockito.doReturn(env).when(trans).env();
2742         Question.specialLogOn(trans, trans.user());
2743         retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
2744                 "delegate", respObj);
2745         assertTrue(retVal.status == 0);
2746
2747         try {
2748             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2749                     .load(rsVoid.value);
2750         } catch (APIException e) {
2751             // TODO Auto-generated catch block
2752             e.printStackTrace();
2753         }
2754         retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
2755                 "delegate", respObj);
2756         assertTrue(retVal.status == 20);
2757     }
2758
2759     @Test
2760     @SuppressWarnings("unchecked")
2761     public void testRequestUserRole() {
2762         RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
2763         Mockito.doReturn(dataObj).when(rossetaObj).newData();
2764         try {
2765             Mockito.doThrow(new APIException("test exception")).when(dataObj)
2766                     .load(Mockito.any(ServletInputStream.class));
2767         } catch (APIException e) {
2768             // TODO Auto-generated catch block
2769             e.printStackTrace();
2770         }
2771         Result<Void> retVal = (Result<Void>) facadeImplObj.requestUserRole(
2772                 trans, Mockito.mock(HttpServletRequest.class),
2773                 Mockito.mock(HttpServletResponse.class));
2774         assertTrue(retVal.status == Status.ERR_BadData);
2775
2776         try {
2777             Mockito.doReturn(dataObj).when(dataObj)
2778                     .load(Mockito.any(ServletInputStream.class));
2779         } catch (APIException e) {
2780             // TODO Auto-generated catch block
2781             e.printStackTrace();
2782         }
2783         retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
2784                 Mockito.mock(HttpServletRequest.class),
2785                 Mockito.mock(HttpServletResponse.class));
2786         assertTrue(retVal.status == 20);
2787
2788         Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
2789         Mockito.doReturn(rsVoid).when(authzService)
2790                 .createUserRole(Mockito.any(), Mockito.any());
2791         retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
2792                 Mockito.mock(HttpServletRequest.class),
2793                 Mockito.mock(HttpServletResponse.class));
2794         assertTrue(retVal.status == 31);
2795
2796         rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2797         Mockito.doReturn(rsVoid).when(authzService)
2798                 .createUserRole(Mockito.any(), Mockito.any());
2799         retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
2800                 Mockito.mock(HttpServletRequest.class),
2801                 Mockito.mock(HttpServletResponse.class));
2802         assertTrue(retVal.status == Status.OK);
2803
2804         Mockito.doReturn("user").when(trans).user();
2805         Mockito.doReturn(env).when(trans).env();
2806         Question.specialLogOn(trans, trans.user());
2807         retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
2808                 Mockito.mock(HttpServletRequest.class),
2809                 Mockito.mock(HttpServletResponse.class));
2810         assertTrue(retVal.status == 0);
2811     }
2812
2813     @Test
2814     @SuppressWarnings("unchecked")
2815     public void testGetUserInRole() {
2816         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
2817
2818         try {
2819             Mockito.doReturn(dataObj).when(dataObj)
2820                     .load(Mockito.any(ServletInputStream.class));
2821         } catch (APIException e) {
2822             // TODO Auto-generated catch block
2823             e.printStackTrace();
2824         }
2825         Result<Void> retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2826                 Mockito.mock(HttpServletResponse.class), "user", "role");
2827         assertTrue(retVal.status == 20);
2828
2829         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2830                 new Object[0]);
2831         Mockito.doReturn(rsVoid).when(authzService).getUserInRole(trans, "user",
2832                 "role");
2833         retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2834                 Mockito.mock(HttpServletResponse.class), "user", "role");
2835         assertTrue(retVal.status == 31);
2836
2837         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2838         Mockito.doReturn(rsVoid).when(authzService).getUserInRole(trans, "user",
2839                 "role");
2840         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2841         try {
2842             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2843         } catch (APIException e) {
2844             // TODO Auto-generated catch block
2845             e.printStackTrace();
2846         }
2847         retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2848                 Mockito.mock(HttpServletResponse.class), "user", "role");
2849         assertTrue(retVal.status == 0);
2850
2851         Mockito.doReturn("user").when(trans).user();
2852         Mockito.doReturn(env).when(trans).env();
2853         Question.specialLogOn(trans, trans.user());
2854         retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2855                 Mockito.mock(HttpServletResponse.class), "user", "role");
2856         assertTrue(retVal.status == 0);
2857     }
2858     @Test
2859     @SuppressWarnings("unchecked")
2860     public void testGetUserRolesByUser() {
2861         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
2862
2863         try {
2864             Mockito.doReturn(dataObj).when(dataObj)
2865                     .load(Mockito.any(ServletInputStream.class));
2866         } catch (APIException e) {
2867             // TODO Auto-generated catch block
2868             e.printStackTrace();
2869         }
2870         Result<Void> retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(
2871                 trans, Mockito.mock(HttpServletResponse.class), "user");
2872         assertTrue(retVal.status == 20);
2873
2874         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2875                 new Object[0]);
2876         Mockito.doReturn(rsVoid).when(authzService).getUserRolesByUser(trans,
2877                 "user");
2878         retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
2879                 Mockito.mock(HttpServletResponse.class), "user");
2880         assertTrue(retVal.status == 31);
2881
2882         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2883         Mockito.doReturn(rsVoid).when(authzService).getUserRolesByUser(trans,
2884                 "user");
2885         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2886         try {
2887             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2888         } catch (APIException e) {
2889             // TODO Auto-generated catch block
2890             e.printStackTrace();
2891         }
2892         retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
2893                 Mockito.mock(HttpServletResponse.class), "user");
2894         assertTrue(retVal.status == 0);
2895
2896         Mockito.doReturn("user").when(trans).user();
2897         Mockito.doReturn(env).when(trans).env();
2898         Question.specialLogOn(trans, trans.user());
2899         retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
2900                 Mockito.mock(HttpServletResponse.class), "user");
2901         assertTrue(retVal.status == 0);
2902     }
2903     @Test
2904     @SuppressWarnings("unchecked")
2905     public void testGetUserRolesByRole() {
2906         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
2907
2908         try {
2909             Mockito.doReturn(dataObj).when(dataObj)
2910                     .load(Mockito.any(ServletInputStream.class));
2911         } catch (APIException e) {
2912             // TODO Auto-generated catch block
2913             e.printStackTrace();
2914         }
2915         Result<Void> retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(
2916                 trans, Mockito.mock(HttpServletResponse.class), "role");
2917         assertTrue(retVal.status == 20);
2918
2919         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2920                 new Object[0]);
2921         Mockito.doReturn(rsVoid).when(authzService).getUserRolesByRole(trans,
2922                 "role");
2923         retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
2924                 Mockito.mock(HttpServletResponse.class), "role");
2925         assertTrue(retVal.status == 31);
2926
2927         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2928         Mockito.doReturn(rsVoid).when(authzService).getUserRolesByRole(trans,
2929                 "role");
2930         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2931         try {
2932             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2933         } catch (APIException e) {
2934             // TODO Auto-generated catch block
2935             e.printStackTrace();
2936         }
2937         retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
2938                 Mockito.mock(HttpServletResponse.class), "role");
2939         assertTrue(retVal.status == 0);
2940
2941         Mockito.doReturn("user").when(trans).user();
2942         Mockito.doReturn(env).when(trans).env();
2943         Question.specialLogOn(trans, trans.user());
2944         retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
2945                 Mockito.mock(HttpServletResponse.class), "role");
2946         assertTrue(retVal.status == 0);
2947     }
2948
2949     @Test
2950     public void testExtendUserRoleExpiration() {
2951
2952         Mockito.doThrow(new RuntimeException("test exception"))
2953                 .when(authzService).extendUserRole(trans, "user", "role");
2954         Result<Void> retVal = (Result<Void>) facadeImplObj
2955                 .extendUserRoleExpiration(trans,
2956                         Mockito.mock(HttpServletResponse.class), "user",
2957                         "role");
2958         assertTrue(retVal.status == 20);
2959
2960         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2961                 new Object[0]);
2962         Mockito.doReturn(rsVoid).when(authzService).extendUserRole(trans,
2963                 "user", "role");
2964         retVal = (Result<Void>) facadeImplObj.extendUserRoleExpiration(trans,
2965                 Mockito.mock(HttpServletResponse.class), "user", "role");
2966         assertTrue(retVal.status == 31);
2967
2968     }
2969     @Test
2970     @SuppressWarnings("unchecked")
2971     public void testDeleteUserRole() {
2972
2973         Mockito.doThrow(new RuntimeException("test exception"))
2974                 .when(authzService).deleteUserRole(trans, "user", "role");
2975         Result<Void> retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
2976                 Mockito.mock(HttpServletResponse.class), "user", "role");
2977         assertTrue(retVal.status == 20);
2978
2979         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2980                 new Object[0]);
2981         Mockito.doReturn(rsVoid).when(authzService).deleteUserRole(trans,
2982                 "user", "role");
2983         retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
2984                 Mockito.mock(HttpServletResponse.class), "user", "role");
2985         assertTrue(retVal.status == 31);
2986
2987         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2988         Mockito.doReturn(rsVoid).when(authzService).deleteUserRole(trans,
2989                 "user", "role");
2990
2991         retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
2992                 Mockito.mock(HttpServletResponse.class), "user", "role");
2993         assertTrue(retVal.status == 0);
2994
2995     }
2996     @Test
2997     @SuppressWarnings("unchecked")
2998     public void testUpdateApproval() {
2999         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3000         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3001         HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
3002
3003         Mockito.doReturn(dataObj).when(rossetaObj).newData();
3004         try {
3005             Mockito.doReturn(dataObj).when(dataObj)
3006                     .load(Mockito.any(ServletInputStream.class));
3007         } catch (APIException e) {
3008             // TODO Auto-generated catch block
3009             e.printStackTrace();
3010         }
3011         Result<Void> retVal = (Result<Void>) facadeImplObj.updateApproval(trans,
3012                 reqObj, respObj);
3013         assertTrue(retVal.status == 20);
3014
3015         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3016                 new Object[0]);
3017         Mockito.doReturn(rsVoid).when(authzService)
3018                 .updateApproval(Mockito.any(), Mockito.anyObject());
3019         retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
3020                 respObj);
3021         assertTrue(retVal.status == 31);
3022
3023         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3024         Mockito.doReturn(rsVoid).when(authzService)
3025                 .updateApproval(Mockito.any(), Mockito.anyObject());
3026         retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
3027                 respObj);
3028         assertTrue(retVal.status == 0);
3029
3030         Mockito.doReturn("user").when(trans).user();
3031         Mockito.doReturn(env).when(trans).env();
3032         Question.specialLogOn(trans, trans.user());
3033         retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
3034                 respObj);
3035         assertTrue(retVal.status == 0);
3036     }
3037     @Test
3038     @SuppressWarnings("unchecked")
3039     public void testGetApprovalsByUser() {
3040         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3041         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3042
3043         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3044         Result<Void> retVal = (Result<Void>) facadeImplObj
3045                 .getApprovalsByUser(trans, respObj, "user");
3046         assertTrue(retVal.status == 20);
3047
3048         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3049                 new Object[0]);
3050         try {
3051             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3052         } catch (APIException e) {
3053             // TODO Auto-generated catch block
3054             e.printStackTrace();
3055         }
3056         Mockito.doReturn(rsVoid).when(authzService).getApprovalsByUser(trans,
3057                 "user");
3058         retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
3059                 "user");
3060         assertTrue(retVal.status == 31);
3061
3062         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3063         Mockito.doReturn(rsVoid).when(authzService).getApprovalsByUser(trans,
3064                 "user");
3065         retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
3066                 "user");
3067         assertTrue(retVal.status == 0);
3068
3069         Mockito.doReturn("user").when(trans).user();
3070         Mockito.doReturn(env).when(trans).env();
3071         Question.specialLogOn(trans, trans.user());
3072         retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
3073                 "user");
3074         assertTrue(retVal.status == 0);
3075     }
3076     @Test
3077     @SuppressWarnings("unchecked")
3078     public void testGetApprovalsByApprover() {
3079         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3080         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3081
3082         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3083         Result<Void> retVal = (Result<Void>) facadeImplObj
3084                 .getApprovalsByApprover(trans, respObj, "approver");
3085         assertTrue(retVal.status == 20);
3086
3087         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3088                 new Object[0]);
3089         try {
3090             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3091         } catch (APIException e) {
3092             // TODO Auto-generated catch block
3093             e.printStackTrace();
3094         }
3095         Mockito.doReturn(rsVoid).when(authzService)
3096                 .getApprovalsByApprover(trans, "approver");
3097         retVal = (Result<Void>) facadeImplObj.getApprovalsByApprover(trans,
3098                 respObj, "approver");
3099         assertTrue(retVal.status == 31);
3100
3101         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3102         Mockito.doReturn(rsVoid).when(authzService)
3103                 .getApprovalsByApprover(trans, "approver");
3104         retVal = (Result<Void>) facadeImplObj.getApprovalsByApprover(trans,
3105                 respObj, "approver");
3106         assertTrue(retVal.status == 0);
3107
3108         Mockito.doReturn("user").when(trans).user();
3109         Mockito.doReturn(env).when(trans).env();
3110         Question.specialLogOn(trans, trans.user());
3111         retVal = (Result<Void>) facadeImplObj.getApprovalsByApprover(trans,
3112                 respObj, "approver");
3113         assertTrue(retVal.status == 0);
3114     }
3115     @Test
3116     @SuppressWarnings("unchecked")
3117     public void testGetApprovalsByTicket() {
3118         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3119         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3120
3121         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3122         Result<Void> retVal = (Result<Void>) facadeImplObj
3123                 .getApprovalsByTicket(trans, respObj, "ticket");
3124         assertTrue(retVal.status == 20);
3125
3126         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3127                 new Object[0]);
3128         try {
3129             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3130         } catch (APIException e) {
3131             // TODO Auto-generated catch block
3132             e.printStackTrace();
3133         }
3134         Mockito.doReturn(rsVoid).when(authzService).getApprovalsByTicket(trans,
3135                 "ticket");
3136         retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
3137                 respObj, "ticket");
3138         assertTrue(retVal.status == 31);
3139
3140         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3141         Mockito.doReturn(rsVoid).when(authzService).getApprovalsByTicket(trans,
3142                 "ticket");
3143         retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
3144                 respObj, "ticket");
3145         assertTrue(retVal.status == 0);
3146
3147         Mockito.doReturn("user").when(trans).user();
3148         Mockito.doReturn(env).when(trans).env();
3149         Question.specialLogOn(trans, trans.user());
3150         retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
3151                 respObj, "ticket");
3152         assertTrue(retVal.status == 0);
3153     }
3154     @Test
3155     @SuppressWarnings("unchecked")
3156     public void testGetUsersByRole() {
3157         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3158         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3159
3160         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3161         Result<Void> retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans,
3162                 respObj, "role");
3163         assertTrue(retVal.status == 20);
3164
3165         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3166                 new Object[0]);
3167         try {
3168             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3169         } catch (APIException e) {
3170             // TODO Auto-generated catch block
3171             e.printStackTrace();
3172         }
3173         Mockito.doReturn(rsVoid).when(authzService).getUsersByRole(trans,
3174                 "role");
3175         retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
3176                 "role");
3177         assertTrue(retVal.status == 31);
3178
3179         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3180         Mockito.doReturn(rsVoid).when(authzService).getUsersByRole(trans,
3181                 "role");
3182         retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
3183                 "role");
3184         assertTrue(retVal.status == 0);
3185
3186         Mockito.doReturn("user").when(trans).user();
3187         Mockito.doReturn(env).when(trans).env();
3188         Question.specialLogOn(trans, trans.user());
3189         retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
3190                 "role");
3191         assertTrue(retVal.status == 0);
3192     }
3193     @Test
3194     @SuppressWarnings("unchecked")
3195     public void testGetUsersByPermission() {
3196         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3197         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3198
3199         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3200         Result<Void> retVal = (Result<Void>) facadeImplObj.getUsersByPermission(
3201                 trans, respObj, "type", "instance", "action");
3202         assertTrue(retVal.status == 20);
3203
3204         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3205                 new Object[0]);
3206         try {
3207             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3208         } catch (APIException e) {
3209             // TODO Auto-generated catch block
3210             e.printStackTrace();
3211         }
3212         Mockito.doReturn(rsVoid).when(authzService).getUsersByPermission(trans,
3213                 "type", "instance", "action");
3214         retVal = (Result<Void>) facadeImplObj.getUsersByPermission(trans,
3215                 respObj, "type", "instance", "action");
3216         assertTrue(retVal.status == 31);
3217
3218         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3219         Mockito.doReturn(rsVoid).when(authzService).getUsersByPermission(trans,
3220                 "type", "instance", "action");
3221         retVal = (Result<Void>) facadeImplObj.getUsersByPermission(trans,
3222                 respObj, "type", "instance", "action");
3223         assertTrue(retVal.status == 0);
3224
3225         Mockito.doReturn("user").when(trans).user();
3226         Mockito.doReturn(env).when(trans).env();
3227         Question.specialLogOn(trans, trans.user());
3228         retVal = (Result<Void>) facadeImplObj.getUsersByPermission(trans,
3229                 respObj, "type", "instance", "action");
3230         assertTrue(retVal.status == 0);
3231     }
3232
3233     @Test
3234     @SuppressWarnings("unchecked")
3235     public void testGetHistoryByUser() {
3236         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3237         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3238
3239         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3240         Result<Void> retVal = (Result<Void>) facadeImplObj
3241                 .getHistoryByUser(trans, respObj, "user", new int[]{201907}, 1);
3242         assertTrue(retVal.status == 20);
3243
3244         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3245                 new Object[0]);
3246         try {
3247             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3248         } catch (APIException e) {
3249             // TODO Auto-generated catch block
3250             e.printStackTrace();
3251         }
3252         Mockito.doReturn(rsVoid).when(authzService).getHistoryByUser(trans,
3253                 "user", new int[]{201907}, 1);
3254         retVal = (Result<Void>) facadeImplObj.getHistoryByUser(trans, respObj,
3255                 "user", new int[]{201907}, 1);
3256         assertTrue(retVal.status == 31);
3257
3258         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3259         Mockito.doReturn(rsVoid).when(authzService).getHistoryByUser(trans,
3260                 "user", new int[]{201907}, 1);
3261         retVal = (Result<Void>) facadeImplObj.getHistoryByUser(trans, respObj,
3262                 "user", new int[]{201907}, 1);
3263         assertTrue(retVal.status == 0);
3264
3265         Mockito.doReturn("user").when(trans).user();
3266         Mockito.doReturn(env).when(trans).env();
3267         Question.specialLogOn(trans, trans.user());
3268         retVal = (Result<Void>) facadeImplObj.getHistoryByUser(trans, respObj,
3269                 "user", new int[]{201907}, 1);
3270         assertTrue(retVal.status == 0);
3271     }
3272     @Test
3273     @SuppressWarnings("unchecked")
3274     public void testGetHistoryByRole() {
3275         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3276         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3277
3278         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3279         Result<Void> retVal = (Result<Void>) facadeImplObj
3280                 .getHistoryByRole(trans, respObj, "role", new int[]{201907}, 1);
3281         assertTrue(retVal.status == 20);
3282
3283         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3284                 new Object[0]);
3285         try {
3286             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3287         } catch (APIException e) {
3288             // TODO Auto-generated catch block
3289             e.printStackTrace();
3290         }
3291         Mockito.doReturn(rsVoid).when(authzService).getHistoryByRole(trans,
3292                 "role", new int[]{201907}, 1);
3293         retVal = (Result<Void>) facadeImplObj.getHistoryByRole(trans, respObj,
3294                 "role", new int[]{201907}, 1);
3295         assertTrue(retVal.status == 31);
3296
3297         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3298         Mockito.doReturn(rsVoid).when(authzService).getHistoryByRole(trans,
3299                 "role", new int[]{201907}, 1);
3300         retVal = (Result<Void>) facadeImplObj.getHistoryByRole(trans, respObj,
3301                 "role", new int[]{201907}, 1);
3302         assertTrue(retVal.status == 0);
3303
3304         Mockito.doReturn("user").when(trans).user();
3305         Mockito.doReturn(env).when(trans).env();
3306         Question.specialLogOn(trans, trans.user());
3307         retVal = (Result<Void>) facadeImplObj.getHistoryByRole(trans, respObj,
3308                 "role", new int[]{201907}, 1);
3309         assertTrue(retVal.status == 0);
3310     }
3311     @Test
3312     @SuppressWarnings("unchecked")
3313     public void testGetHistoryByNS() {
3314         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3315         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3316
3317         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3318         Result<Void> retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans,
3319                 respObj, "ns", new int[]{201907}, 1);
3320         assertTrue(retVal.status == 20);
3321
3322         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3323                 new Object[0]);
3324         try {
3325             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3326         } catch (APIException e) {
3327             // TODO Auto-generated catch block
3328             e.printStackTrace();
3329         }
3330         Mockito.doReturn(rsVoid).when(authzService).getHistoryByNS(trans, "ns",
3331                 new int[]{201907}, 1);
3332         retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans, respObj,
3333                 "ns", new int[]{201907}, 1);
3334         assertTrue(retVal.status == 31);
3335
3336         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3337         Mockito.doReturn(rsVoid).when(authzService).getHistoryByNS(trans, "ns",
3338                 new int[]{201907}, 1);
3339         retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans, respObj,
3340                 "ns", new int[]{201907}, 1);
3341         assertTrue(retVal.status == 0);
3342
3343         Mockito.doReturn("user").when(trans).user();
3344         Mockito.doReturn(env).when(trans).env();
3345         Question.specialLogOn(trans, trans.user());
3346         retVal = (Result<Void>) facadeImplObj.getHistoryByNS(trans, respObj,
3347                 "ns", new int[]{201907}, 1);
3348         assertTrue(retVal.status == 0);
3349     }
3350     @Test
3351     @SuppressWarnings("unchecked")
3352     public void testGetHistoryByPerm() {
3353         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3354         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3355
3356         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3357         Result<Void> retVal = (Result<Void>) facadeImplObj
3358                 .getHistoryByPerm(trans, respObj, "perm", new int[]{201907}, 1);
3359         assertTrue(retVal.status == 20);
3360
3361         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3362                 new Object[0]);
3363         try {
3364             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3365         } catch (APIException e) {
3366             // TODO Auto-generated catch block
3367             e.printStackTrace();
3368         }
3369         Mockito.doReturn(rsVoid).when(authzService).getHistoryByPerm(trans,
3370                 "perm", new int[]{201907}, 1);
3371         retVal = (Result<Void>) facadeImplObj.getHistoryByPerm(trans, respObj,
3372                 "perm", new int[]{201907}, 1);
3373         assertTrue(retVal.status == 31);
3374
3375         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3376         Mockito.doReturn(rsVoid).when(authzService).getHistoryByPerm(trans,
3377                 "perm", new int[]{201907}, 1);
3378         retVal = (Result<Void>) facadeImplObj.getHistoryByPerm(trans, respObj,
3379                 "perm", new int[]{201907}, 1);
3380         assertTrue(retVal.status == 0);
3381
3382         Mockito.doReturn("user").when(trans).user();
3383         Mockito.doReturn(env).when(trans).env();
3384         Question.specialLogOn(trans, trans.user());
3385         retVal = (Result<Void>) facadeImplObj.getHistoryByPerm(trans, respObj,
3386                 "perm", new int[]{201907}, 1);
3387         assertTrue(retVal.status == 0);
3388     }
3389     @Test
3390     @SuppressWarnings("unchecked")
3391     public void testGetHistoryBySubject() {
3392         RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3393         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3394
3395         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3396         Result<Void> retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(
3397                 trans, respObj, "subject", "target", new int[]{201907}, 1);
3398         assertTrue(retVal.status == 20);
3399
3400         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3401                 new Object[0]);
3402         try {
3403             Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3404         } catch (APIException e) {
3405             // TODO Auto-generated catch block
3406             e.printStackTrace();
3407         }
3408         Mockito.doReturn(rsVoid).when(authzService).getHistoryBySubject(trans,
3409                 "subject", "target", new int[]{201907}, 1);
3410         retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(trans,
3411                 respObj, "subject", "target", new int[]{201907}, 1);
3412         assertTrue(retVal.status == 31);
3413
3414         rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3415         Mockito.doReturn(rsVoid).when(authzService).getHistoryBySubject(trans,
3416                 "subject", "target", new int[]{201907}, 1);
3417         retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(trans,
3418                 respObj, "subject", "target", new int[]{201907}, 1);
3419         assertTrue(retVal.status == 0);
3420
3421         Mockito.doReturn("user").when(trans).user();
3422         Mockito.doReturn(env).when(trans).env();
3423         Question.specialLogOn(trans, trans.user());
3424         retVal = (Result<Void>) facadeImplObj.getHistoryBySubject(trans,
3425                 respObj, "subject", "target", new int[]{201907}, 1);
3426         assertTrue(retVal.status == 0);
3427     }
3428     @Test
3429     public void testCacheClear() {
3430
3431         Mockito.doThrow(new RuntimeException("test exception"))
3432                 .when(authzService).cacheClear(trans, "cname");
3433         Result<Void> retVal = (Result<Void>) facadeImplObj.cacheClear(trans,
3434                 "cname");
3435         assertTrue(retVal.status == 20);
3436
3437         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3438                 new Object[0]);
3439         Mockito.doReturn(rsVoid).when(authzService).cacheClear(trans, "cname");
3440         retVal = (Result<Void>) facadeImplObj.cacheClear(trans, "cname");
3441         assertTrue(retVal.status == 31);
3442
3443     }
3444     @Test
3445     public void testCacheClear2() {
3446
3447         Mockito.doThrow(new RuntimeException("test exception"))
3448                 .when(authzService)
3449                 .cacheClear(trans, "cname", new int[]{1, -1});
3450         Result<Void> retVal = (Result<Void>) facadeImplObj.cacheClear(trans,
3451                 "cname", "1,a");
3452         assertTrue(retVal.status == 20);
3453
3454         Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3455                 new Object[0]);
3456         Mockito.doReturn(rsVoid).when(authzService).cacheClear(trans, "cname",
3457                 new int[]{1, 1});
3458         retVal = (Result<Void>) facadeImplObj.cacheClear(trans, "cname", "1,1");
3459         assertTrue(retVal.status == 31);
3460
3461     }
3462
3463     @Test
3464     public void testDbReset() {
3465         facadeImplObj.dbReset(trans);
3466     }
3467     @Test
3468     public void testGetAPI() {
3469         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3470         RServlet<AuthzTrans> rservlet = Mockito.mock(RServlet.class);
3471         facadeImplObj.getAPI(trans, respObj, rservlet);
3472
3473         RosettaData<Api> dataObj = Mockito.mock(RosettaData.class);
3474         Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3475         try {
3476             Mockito.doReturn(dataObj).when(dataObj)
3477                     .load(Mockito.any(Api.class));
3478         } catch (APIException e) {
3479             // TODO Auto-generated catch block
3480             e.printStackTrace();
3481         }
3482         facadeImplObj.getAPI(trans, respObj, rservlet);
3483
3484         Mockito.doReturn("user").when(trans).user();
3485         Mockito.doReturn(env).when(trans).env();
3486         Question.specialLogOn(trans, trans.user());
3487         facadeImplObj.getAPI(trans, respObj, rservlet);
3488     }
3489     @Test
3490     public void testGetAPIExample() {
3491         HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3492         facadeImplObj.getAPIExample(trans, respObj, "nameOrContentType", true);
3493     }
3494 }
3495 class AuthzFacadeImplImpl extends AuthzFacadeImpl {
3496
3497     public AuthzFacadeImplImpl(AuthzEnv env, AuthzService service,
3498             TYPE dataType) throws APIException {
3499         super(env, service, dataType);
3500     }
3501
3502 }