2 * ============LICENSE_START====================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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====================================================
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;
28 import java.io.IOException;
29 import java.util.Date;
31 import javax.servlet.ServletInputStream;
32 import javax.servlet.ServletOutputStream;
33 import javax.servlet.http.HttpServletRequest;
34 import javax.servlet.http.HttpServletResponse;
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;
72 public class JU_AuthzFacadeImpl<NSS, PERMS, PERMKEY, ROLES, USERS, USERROLES, DELGS, CERTS, KEYS, REQUEST, HISTORY, ERR, APPROVALS> {
74 AuthzFacadeImpl<NSS, PERMS, PERMKEY, ROLES, USERS, USERROLES, DELGS, CERTS, KEYS, REQUEST, HISTORY, ERR, APPROVALS> facadeImplObj;
81 AuthzService authzService;
93 // NOTE: Annotation format (@Mock and @Spy) do NOT seem to always work as a
95 // so we construct manually.
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);
112 public void setUp() throws APIException, IOException {
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(),
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,
131 public void testMapper() {
132 facadeImplObj.mapper();
135 @SuppressWarnings({"unchecked", "rawtypes"})
137 public void testError() {
138 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class),
139 Mockito.mock(Result.class));
141 Result<?> rs = new Result(null, Result.ERR_ActionNotCompleted, "test",
143 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
145 rs = new Result(null, Result.ERR_Policy, "test",
146 new Object[]{"test", "test"});
147 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
149 rs = new Result(null, Result.ERR_Security, "test",
150 new Object[]{"", "test"});
151 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
153 rs = new Result(null, Result.ERR_Denied, "test", null);
154 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
156 rs = new Result(null, 33, "test", null);
157 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
159 rs = new Result(null, 21, "test", null);
160 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
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);
171 rs = new Result(null, 26, "test", null);
172 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
174 rs = new Result(null, 27, "test", null);
175 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
177 rs = new Result(null, 28, "test", null);
178 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
180 rs = new Result(null, 4, "test", null);
181 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
183 rs = new Result(null, 5, "test", null);
184 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
186 rs = new Result(null, 6, "test", null);
187 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
189 rs = new Result(null, 7, "test", null);
190 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
192 rs = new Result(null, 31, "test", null);
193 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
195 rs = new Result(null, 32, "test", null);
196 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
198 rs = new Result(null, 9, "test", null);
199 facadeImplObj.error(trans, Mockito.mock(HttpServletResponse.class), rs);
203 @SuppressWarnings("unchecked")
204 public void testRequestNS() {
205 RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
206 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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
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);
219 Data<?> rd = Mockito.mock(Data.class);
221 Mockito.doReturn(dataObj).when(dataObj)
222 .load(Mockito.any(ServletInputStream.class));
223 } catch (APIException e) {
224 // TODO Auto-generated catch block
227 retVal = (Result<Void>) facadeImplObj.requestNS(trans,
228 Mockito.mock(HttpServletRequest.class),
229 Mockito.mock(HttpServletResponse.class), NsType.APP);
230 assertTrue(retVal.status == 20);
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);
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);
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);
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);
265 Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
266 Mockito.doReturn(rsVoid).when(authzService).addAdminNS(trans, "ns",
268 retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans, respObj, "ns",
270 assertTrue(retVal.status == 31);
272 rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
273 Mockito.doReturn(rsVoid).when(authzService).addAdminNS(trans, "ns",
276 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
277 .when(respObj).getOutputStream();
278 } catch (IOException e) {
279 // TODO Auto-generated catch block
282 retVal = (Result<Void>) facadeImplObj.addAdminToNS(trans, respObj, "ns",
284 assertTrue(retVal.status == 0);
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);
295 Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
296 Mockito.doReturn(rsVoid).when(authzService).delAdminNS(trans, "ns",
298 retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans, respObj,
300 assertTrue(retVal.status == 31);
302 rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
303 Mockito.doReturn(rsVoid).when(authzService).delAdminNS(trans, "ns",
306 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
307 .when(respObj).getOutputStream();
308 } catch (IOException e) {
309 // TODO Auto-generated catch block
312 retVal = (Result<Void>) facadeImplObj.delAdminFromNS(trans, respObj,
314 assertTrue(retVal.status == 0);
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);
324 Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
325 Mockito.doReturn(rsVoid).when(authzService).addResponsibleNS(trans,
327 retVal = (Result<Void>) facadeImplObj.addResponsibilityForNS(trans,
328 respObj, "ns", "id");
329 assertTrue(retVal.status == 31);
331 rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
332 Mockito.doReturn(rsVoid).when(authzService).addResponsibleNS(trans,
335 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
336 .when(respObj).getOutputStream();
337 } catch (IOException e) {
338 // TODO Auto-generated catch block
341 retVal = (Result<Void>) facadeImplObj.addResponsibilityForNS(trans,
342 respObj, "ns", "id");
343 assertTrue(retVal.status == 0);
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);
354 Result<Void> rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
355 Mockito.doReturn(rsVoid).when(authzService).delResponsibleNS(trans,
357 retVal = (Result<Void>) facadeImplObj.delResponsibilityForNS(trans,
358 respObj, "ns", "id");
359 assertTrue(retVal.status == 31);
361 rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
362 Mockito.doReturn(rsVoid).when(authzService).delResponsibleNS(trans,
365 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
366 .when(respObj).getOutputStream();
367 } catch (IOException e) {
368 // TODO Auto-generated catch block
371 retVal = (Result<Void>) facadeImplObj.delResponsibilityForNS(trans,
372 respObj, "ns", "id");
373 assertTrue(retVal.status == 0);
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);
384 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
385 Mockito.doReturn(rsVoid).when(authzService).getNSbyName(trans, "ns",
387 retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
389 assertTrue(retVal.status == 31);
391 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
392 Mockito.doReturn(rsVoid).when(authzService).getNSbyName(trans, "ns",
395 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
396 .when(respObj).getOutputStream();
397 } catch (IOException e) {
398 // TODO Auto-generated catch block
402 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
403 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
405 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
406 } catch (APIException e) {
407 // TODO Auto-generated catch block
411 retVal = (Result<Void>) facadeImplObj.getNSsByName(trans, respObj, "ns",
413 assertTrue(retVal.status == 0);
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",
420 assertTrue(retVal.status == 0);
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);
431 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
432 Mockito.doReturn(rsVoid).when(authzService).getNSbyAdmin(trans, "ns",
434 retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
436 assertTrue(retVal.status == 31);
438 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
439 Mockito.doReturn(rsVoid).when(authzService).getNSbyAdmin(trans, "ns",
442 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
443 .when(respObj).getOutputStream();
444 } catch (IOException e) {
445 // TODO Auto-generated catch block
449 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
450 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
452 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
453 } catch (APIException e) {
454 // TODO Auto-generated catch block
458 retVal = (Result<Void>) facadeImplObj.getNSsByAdmin(trans, respObj,
460 assertTrue(retVal.status == 0);
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,
467 assertTrue(retVal.status == 0);
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);
478 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
479 Mockito.doReturn(rsVoid).when(authzService).getNSbyResponsible(trans,
481 retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
482 respObj, "ns", true);
483 assertTrue(retVal.status == 31);
485 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
486 Mockito.doReturn(rsVoid).when(authzService).getNSbyResponsible(trans,
489 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
490 .when(respObj).getOutputStream();
491 } catch (IOException e) {
492 // TODO Auto-generated catch block
496 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
497 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
499 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
500 } catch (APIException e) {
501 // TODO Auto-generated catch block
505 retVal = (Result<Void>) facadeImplObj.getNSsByResponsible(trans,
506 respObj, "ns", true);
507 assertTrue(retVal.status == 0);
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);
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);
525 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
526 Mockito.doReturn(rsVoid).when(authzService).getNSbyEither(trans, "ns",
528 retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
530 assertTrue(retVal.status == 31);
532 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
533 Mockito.doReturn(rsVoid).when(authzService).getNSbyEither(trans, "ns",
536 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
537 .when(respObj).getOutputStream();
538 } catch (IOException e) {
539 // TODO Auto-generated catch block
543 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
544 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
546 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
547 } catch (APIException e) {
548 // TODO Auto-generated catch block
552 retVal = (Result<Void>) facadeImplObj.getNSsByEither(trans, respObj,
554 assertTrue(retVal.status == 0);
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,
561 assertTrue(retVal.status == 0);
565 @SuppressWarnings("unchecked")
566 public void testGetNSsChildren() {
567 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
568 Result<Void> retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans,
570 assertTrue(retVal.status == 20);
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,
576 assertTrue(retVal.status == 31);
578 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
579 Mockito.doReturn(rsVoid).when(authzService).getNSsChildren(trans, "ns");
581 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
582 .when(respObj).getOutputStream();
583 } catch (IOException e) {
584 // TODO Auto-generated catch block
588 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
589 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
591 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
592 } catch (APIException e) {
593 // TODO Auto-generated catch block
597 retVal = (Result<Void>) facadeImplObj.getNSsChildren(trans, respObj,
599 assertTrue(retVal.status == 0);
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,
606 assertTrue(retVal.status == 0);
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);
616 RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
617 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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
625 retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
626 Mockito.mock(HttpServletRequest.class), respObj);
627 assertTrue(retVal.status == 4);
630 Mockito.doReturn(dataObj).when(dataObj)
631 .load(Mockito.any(ServletInputStream.class));
632 } catch (APIException e) {
633 // TODO Auto-generated catch block
636 retVal = (Result<Void>) facadeImplObj.updateNsDescription(trans,
637 Mockito.mock(HttpServletRequest.class), respObj);
638 assertTrue(retVal.status == 20);
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);
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);
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);
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);
670 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
671 Mockito.doReturn(rsVoid).when(authzService).deleteNS(Mockito.any(),
673 retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
674 Mockito.mock(HttpServletRequest.class), respObj, "ns");
675 assertTrue(retVal.status == 31);
677 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
678 Mockito.doReturn(rsVoid).when(authzService).deleteNS(Mockito.any(),
680 retVal = (Result<Void>) facadeImplObj.deleteNS(trans,
681 Mockito.mock(HttpServletRequest.class), respObj, "ns");
682 assertTrue(retVal.status == 0);
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);
693 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
694 Mockito.doReturn(rsVoid).when(authzService).createNsAttrib(trans, "ns",
696 retVal = (Result<Void>) facadeImplObj.createAttribForNS(trans, respObj,
697 "ns", "key", "value");
698 assertTrue(retVal.status == 31);
701 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
702 .when(respObj).getOutputStream();
703 } catch (IOException e) {
704 // TODO Auto-generated catch block
707 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
708 Mockito.doReturn(rsVoid).when(authzService).createNsAttrib(trans, "ns",
710 retVal = (Result<Void>) facadeImplObj.createAttribForNS(trans, respObj,
711 "ns", "key", "value");
712 assertTrue(retVal.status == 0);
716 @SuppressWarnings("unchecked")
717 public void testReadNsByAttrib() {
718 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
719 Result<Void> retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans,
721 assertTrue(retVal.status == 20);
723 Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
724 Mockito.doReturn(rsVoid).when(authzService).readNsByAttrib(trans,
726 retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
728 assertTrue(retVal.status == 31);
730 RosettaData<KEYS> dataObj = Mockito.mock(RosettaData.class);
731 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
733 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
734 } catch (APIException e) {
735 // TODO Auto-generated catch block
738 rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
739 Mockito.doReturn(rsVoid).when(authzService).readNsByAttrib(trans,
741 retVal = (Result<Void>) facadeImplObj.readNsByAttrib(trans, respObj,
743 assertTrue(retVal.status == 0);
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,
750 assertTrue(retVal.status == 0);
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);
760 Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
761 Mockito.doReturn(rsVoid).when(authzService).updateNsAttrib(trans, "ns",
763 retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans, respObj,
764 "ns", "key", "value");
765 assertTrue(retVal.status == 31);
768 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
769 .when(respObj).getOutputStream();
770 } catch (IOException e) {
771 // TODO Auto-generated catch block
774 rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
775 Mockito.doReturn(rsVoid).when(authzService).updateNsAttrib(trans, "ns",
777 retVal = (Result<Void>) facadeImplObj.updAttribForNS(trans, respObj,
778 "ns", "key", "value");
779 assertTrue(retVal.status == 0);
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);
791 Result<KEYS> rsVoid = new Result<KEYS>(null, 31, "test", new Object[0]);
792 Mockito.doReturn(rsVoid).when(authzService).deleteNsAttrib(trans, "ns",
794 retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans, respObj,
796 assertTrue(retVal.status == 31);
799 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
800 .when(respObj).getOutputStream();
801 } catch (IOException e) {
802 // TODO Auto-generated catch block
805 rsVoid = new Result<KEYS>(null, 0, "test", new Object[0]);
806 Mockito.doReturn(rsVoid).when(authzService).deleteNsAttrib(trans, "ns",
808 retVal = (Result<Void>) facadeImplObj.delAttribForNS(trans, respObj,
810 assertTrue(retVal.status == 0);
815 @SuppressWarnings("unchecked")
816 public void testCreatePerm() {
817 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
819 RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
820 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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
828 Result<Void> retVal = (Result<Void>) facadeImplObj.createPerm(trans,
829 Mockito.mock(HttpServletRequest.class), respObj);
830 assertTrue(retVal.status == 4);
833 Mockito.doReturn(dataObj).when(dataObj)
834 .load(Mockito.any(ServletInputStream.class));
835 } catch (APIException e) {
836 // TODO Auto-generated catch block
839 retVal = (Result<Void>) facadeImplObj.createPerm(trans,
840 Mockito.mock(HttpServletRequest.class), respObj);
841 assertTrue(retVal.status == 20);
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);
850 Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
852 Mockito.when(authzService.createPerm(trans, dataObj.asObject()))
854 } catch (APIException e) {
855 // TODO Auto-generated catch block
858 retVal = (Result<Void>) facadeImplObj.createPerm(trans,
859 Mockito.mock(HttpServletRequest.class), respObj);
860 assertTrue(retVal.status == 0);
862 rsVoid = new Result<Void>(null, 31, "test", new Object[0]);
864 Mockito.when(authzService.createPerm(trans, dataObj.asObject()))
866 } catch (APIException e) {
867 // TODO Auto-generated catch block
870 retVal = (Result<Void>) facadeImplObj.createPerm(trans,
871 Mockito.mock(HttpServletRequest.class), respObj);
872 assertTrue(retVal.status == 31);
876 @SuppressWarnings("unchecked")
877 public void testGetPermsByType() {
878 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
879 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
881 Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByType(trans,
883 assertTrue(retVal.status == 20);
885 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
887 Mockito.doReturn(rsVoid).when(authzService)
888 .getPermsByType(Mockito.any(), Mockito.any());
889 retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
891 assertTrue(retVal.status == 31);
894 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
895 .when(respObj).getOutputStream();
896 } catch (IOException e) {
897 // TODO Auto-generated catch block
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);
905 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
906 } catch (APIException e) {
907 // TODO Auto-generated catch block
910 retVal = (Result<Void>) facadeImplObj.getPermsByType(trans, respObj,
912 assertTrue(retVal.status == 0);
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,
920 assertTrue(retVal.status == 0);
923 @SuppressWarnings("unchecked")
924 public void testGetPermsByName() {
925 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
926 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
928 Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByName(trans,
929 respObj, "type", "instance", "action");
930 assertTrue(retVal.status == 20);
932 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
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);
941 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
942 .when(respObj).getOutputStream();
943 } catch (IOException e) {
944 // TODO Auto-generated catch block
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);
952 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
953 } catch (APIException e) {
954 // TODO Auto-generated catch block
957 retVal = (Result<Void>) facadeImplObj.getPermsByName(trans, respObj,
958 "type", "instance", "action");
959 assertTrue(retVal.status == 0);
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);
970 @SuppressWarnings("unchecked")
971 public void testGetPermsByUser() {
972 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
973 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
975 Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans,
977 assertTrue(retVal.status == 20);
979 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
981 Mockito.doReturn(rsVoid).when(authzService)
982 .getPermsByUser(Mockito.any(), Mockito.any());
983 retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
985 assertTrue(retVal.status == 31);
988 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
989 .when(respObj).getOutputStream();
990 } catch (IOException e) {
991 // TODO Auto-generated catch block
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);
999 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1000 } catch (APIException e) {
1001 // TODO Auto-generated catch block
1002 e.printStackTrace();
1004 retVal = (Result<Void>) facadeImplObj.getPermsByUser(trans, respObj,
1006 assertTrue(retVal.status == 0);
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,
1014 assertTrue(retVal.status == 0);
1017 @SuppressWarnings("unchecked")
1018 public void testGetPermsByUserScope() {
1019 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1020 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1022 Result<Void> retVal = (Result<Void>) facadeImplObj
1023 .getPermsByUserScope(trans, respObj, "user", new String[]{});
1024 assertTrue(retVal.status == 20);
1026 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
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);
1035 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
1036 .when(respObj).getOutputStream();
1037 } catch (IOException e) {
1038 // TODO Auto-generated catch block
1039 e.printStackTrace();
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);
1046 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1047 } catch (APIException e) {
1048 // TODO Auto-generated catch block
1049 e.printStackTrace();
1051 retVal = (Result<Void>) facadeImplObj.getPermsByUserScope(trans,
1052 respObj, "user", new String[]{});
1053 assertTrue(retVal.status == 0);
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);
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);
1071 Result<Void> retVal = (Result<Void>) facadeImplObj
1072 .getPermsByUserWithAAFQuery(trans, reqObj, respObj, "user");
1073 assertTrue(retVal.status == 20);
1075 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1083 retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1084 reqObj, respObj, "user");
1085 assertTrue(retVal.status == Status.ERR_BadData);
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();
1094 retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1095 reqObj, respObj, "user");
1096 assertTrue(retVal.status == 20);
1098 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
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);
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);
1111 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1112 } catch (APIException e) {
1113 // TODO Auto-generated catch block
1114 e.printStackTrace();
1116 retVal = (Result<Void>) facadeImplObj.getPermsByUserWithAAFQuery(trans,
1117 reqObj, respObj, "user");
1118 assertTrue(retVal.status == 0);
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);
1129 @SuppressWarnings("unchecked")
1130 public void testGetPermsForRole() {
1131 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1132 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1134 Result<Void> retVal = (Result<Void>) facadeImplObj
1135 .getPermsForRole(trans, respObj, "roleName");
1136 assertTrue(retVal.status == 20);
1138 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1140 Mockito.doReturn(rsVoid).when(authzService)
1141 .getPermsByRole(Mockito.any(), Mockito.anyString());
1142 retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
1144 assertTrue(retVal.status == 31);
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);
1151 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1152 } catch (APIException e) {
1153 // TODO Auto-generated catch block
1154 e.printStackTrace();
1156 retVal = (Result<Void>) facadeImplObj.getPermsForRole(trans, respObj,
1158 assertTrue(retVal.status == 0);
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,
1165 assertTrue(retVal.status == 0);
1169 @SuppressWarnings("unchecked")
1170 public void testGetPermsByNS() {
1171 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1172 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1174 Result<Void> retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans,
1176 assertTrue(retVal.status == 20);
1178 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1180 Mockito.doReturn(rsVoid).when(authzService).getPermsByNS(Mockito.any(),
1181 Mockito.anyString());
1182 retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
1184 assertTrue(retVal.status == 31);
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);
1191 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1192 } catch (APIException e) {
1193 // TODO Auto-generated catch block
1194 e.printStackTrace();
1196 retVal = (Result<Void>) facadeImplObj.getPermsByNS(trans, respObj,
1198 assertTrue(retVal.status == 0);
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,
1205 assertTrue(retVal.status == 0);
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);
1214 Result<Void> retVal = (Result<Void>) facadeImplObj.renamePerm(trans,
1215 reqObj, respObj, "origType", "origInstance", "origAction");
1216 assertTrue(retVal.status == 20);
1218 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1226 retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1227 "origType", "origInstance", "origAction");
1228 assertTrue(retVal.status == Status.ERR_BadData);
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();
1237 retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1238 "origType", "origInstance", "origAction");
1239 assertTrue(retVal.status == 20);
1241 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
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);
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);
1256 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1257 } catch (APIException e) {
1258 // TODO Auto-generated catch block
1259 e.printStackTrace();
1261 retVal = (Result<Void>) facadeImplObj.renamePerm(trans, reqObj, respObj,
1262 "origType", "origInstance", "origAction");
1263 assertTrue(retVal.status == 0);
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);
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);
1279 Result<Void> retVal = (Result<Void>) facadeImplObj
1280 .updatePermDescription(trans, reqObj, respObj);
1281 assertTrue(retVal.status == 20);
1283 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1291 retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1293 assertTrue(retVal.status == Status.ERR_BadData);
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();
1302 retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1304 assertTrue(retVal.status == 20);
1306 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1308 Mockito.doReturn(rsVoid).when(authzService)
1309 .updatePermDescription(Mockito.any(), Mockito.any());
1310 retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1312 assertTrue(retVal.status == 31);
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);
1319 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1320 } catch (APIException e) {
1321 // TODO Auto-generated catch block
1322 e.printStackTrace();
1324 retVal = (Result<Void>) facadeImplObj.updatePermDescription(trans,
1326 assertTrue(retVal.status == 0);
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,
1333 assertTrue(retVal.status == 0);
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);
1342 Result<Void> retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans,
1344 assertTrue(retVal.status == 20);
1346 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1354 retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1356 assertTrue(retVal.status == Status.ERR_BadData);
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();
1365 retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1367 assertTrue(retVal.status == 20);
1369 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1371 Mockito.doReturn(rsVoid).when(authzService)
1372 .resetPermRoles(Mockito.any(), Mockito.any());
1373 retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1375 assertTrue(retVal.status == 31);
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);
1382 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1383 } catch (APIException e) {
1384 // TODO Auto-generated catch block
1385 e.printStackTrace();
1387 retVal = (Result<Void>) facadeImplObj.resetPermRoles(trans, reqObj,
1389 assertTrue(retVal.status == 0);
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,
1396 assertTrue(retVal.status == 0);
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);
1405 Result<Void> retVal = (Result<Void>) facadeImplObj.deletePerm(trans,
1407 assertTrue(retVal.status == 20);
1409 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1417 retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1419 assertTrue(retVal.status == Status.ERR_BadData);
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();
1428 retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1430 assertTrue(retVal.status == 20);
1432 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1434 Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
1436 retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1438 assertTrue(retVal.status == 31);
1440 rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1441 Mockito.doReturn(rsVoid).when(authzService).deletePerm(Mockito.any(),
1443 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1445 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1446 } catch (APIException e) {
1447 // TODO Auto-generated catch block
1448 e.printStackTrace();
1450 retVal = (Result<Void>) facadeImplObj.deletePerm(trans, reqObj,
1452 assertTrue(retVal.status == 0);
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,
1459 assertTrue(retVal.status == 0);
1462 @SuppressWarnings("unchecked")
1463 public void testDeletePermWithTypeInstanceAction() {
1464 RosettaData<PERMS> dataObj = Mockito.mock(RosettaData.class);
1465 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1467 Result<Void> retVal = (Result<Void>) facadeImplObj.deletePerm(trans,
1468 respObj, "type", "instance", "action");
1469 assertTrue(retVal.status == 20);
1471 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
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);
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);
1484 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1485 } catch (APIException e) {
1486 // TODO Auto-generated catch block
1487 e.printStackTrace();
1489 retVal = (Result<Void>) facadeImplObj.deletePerm(trans, respObj, "type",
1490 "instance", "action");
1491 assertTrue(retVal.status == 0);
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);
1502 Result<Void> retVal = (Result<Void>) facadeImplObj.createRole(trans,
1504 assertTrue(retVal.status == 20);
1506 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1514 retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1516 assertTrue(retVal.status == Status.ERR_BadData);
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();
1525 retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1527 assertTrue(retVal.status == 20);
1529 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1531 Mockito.doReturn(rsVoid).when(authzService).createRole(Mockito.any(),
1533 retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1535 assertTrue(retVal.status == 31);
1537 rsVoid = new Result<PERMS>(null, 0, "test", new Object[0]);
1538 Mockito.doReturn(rsVoid).when(authzService).createRole(Mockito.any(),
1540 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
1542 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1543 } catch (APIException e) {
1544 // TODO Auto-generated catch block
1545 e.printStackTrace();
1547 retVal = (Result<Void>) facadeImplObj.createRole(trans, reqObj,
1549 assertTrue(retVal.status == 0);
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,
1556 assertTrue(retVal.status == 0);
1559 @SuppressWarnings("unchecked")
1560 public void testGetRolesByName() {
1561 RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1562 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1564 Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByName(trans,
1566 assertTrue(retVal.status == 20);
1568 Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1570 Mockito.doReturn(rsVoid).when(authzService)
1571 .getRolesByName(Mockito.any(), Mockito.any());
1572 retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
1574 assertTrue(retVal.status == 31);
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);
1581 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1582 } catch (APIException e) {
1583 // TODO Auto-generated catch block
1584 e.printStackTrace();
1586 retVal = (Result<Void>) facadeImplObj.getRolesByName(trans, respObj,
1588 assertTrue(retVal.status == 0);
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,
1595 assertTrue(retVal.status == 0);
1598 @SuppressWarnings("unchecked")
1599 public void testGetRolesByUser() {
1600 RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1601 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1603 Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans,
1605 assertTrue(retVal.status == 20);
1607 Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1609 Mockito.doReturn(rsVoid).when(authzService)
1610 .getRolesByUser(Mockito.any(), Mockito.any());
1611 retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
1613 assertTrue(retVal.status == 31);
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);
1620 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1621 } catch (APIException e) {
1622 // TODO Auto-generated catch block
1623 e.printStackTrace();
1625 retVal = (Result<Void>) facadeImplObj.getRolesByUser(trans, respObj,
1627 assertTrue(retVal.status == 0);
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,
1634 assertTrue(retVal.status == 0);
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);
1644 Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans,
1646 assertTrue(retVal.status == 20);
1648 Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1650 Mockito.doReturn(rsVoid).when(authzService).getRolesByNS(Mockito.any(),
1652 retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1654 assertTrue(retVal.status == 31);
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);
1661 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1662 } catch (APIException e) {
1663 // TODO Auto-generated catch block
1664 e.printStackTrace();
1666 retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1668 assertTrue(retVal.status == 0);
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);
1676 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1677 } catch (APIException e) {
1678 // TODO Auto-generated catch block
1679 e.printStackTrace();
1681 retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1683 assertTrue(retVal.status == 0);
1685 Question.specialLogOn(trans, trans.user());
1686 retVal = (Result<Void>) facadeImplObj.getRolesByNS(trans, respObj,
1688 assertTrue(retVal.status == 0);
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);
1699 Result<Void> retVal = (Result<Void>) facadeImplObj
1700 .getRolesByNameOnly(trans, respObj, "ns");
1701 assertTrue(retVal.status == 20);
1703 Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
1705 Mockito.doReturn(rsVoid).when(authzService)
1706 .getRolesByNameOnly(Mockito.any(), Mockito.any());
1707 retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1709 assertTrue(retVal.status == 31);
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);
1716 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1717 } catch (APIException e) {
1718 // TODO Auto-generated catch block
1719 e.printStackTrace();
1721 retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1723 assertTrue(retVal.status == 0);
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);
1731 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1732 } catch (APIException e) {
1733 // TODO Auto-generated catch block
1734 e.printStackTrace();
1736 retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1738 assertTrue(retVal.status == 0);
1740 Question.specialLogOn(trans, trans.user());
1741 retVal = (Result<Void>) facadeImplObj.getRolesByNameOnly(trans, respObj,
1743 assertTrue(retVal.status == 0);
1747 @SuppressWarnings("unchecked")
1748 public void testGetRolesByPerm() {
1749 RosettaData<ROLES> dataObj = Mockito.mock(RosettaData.class);
1750 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1752 Result<Void> retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans,
1753 respObj, "type", "instance", "action");
1754 assertTrue(retVal.status == 20);
1756 Result<ROLES> rsVoid = new Result<ROLES>(null, 31, "test",
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);
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);
1769 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1770 } catch (APIException e) {
1771 // TODO Auto-generated catch block
1772 e.printStackTrace();
1774 retVal = (Result<Void>) facadeImplObj.getRolesByPerm(trans, respObj,
1775 "type", "instance", "action");
1776 assertTrue(retVal.status == 0);
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);
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);
1792 Result<Void> retVal = (Result<Void>) facadeImplObj
1793 .updateRoleDescription(trans, reqObj, respObj);
1794 assertTrue(retVal.status == 20);
1796 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1804 retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1806 assertTrue(retVal.status == Status.ERR_BadData);
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();
1815 retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1817 assertTrue(retVal.status == 20);
1819 Result<PERMS> rsVoid = new Result<PERMS>(null, 31, "test",
1821 Mockito.doReturn(rsVoid).when(authzService)
1822 .updateRoleDescription(Mockito.any(), Mockito.any());
1823 retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1825 assertTrue(retVal.status == 31);
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);
1832 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
1833 } catch (APIException e) {
1834 // TODO Auto-generated catch block
1835 e.printStackTrace();
1837 retVal = (Result<Void>) facadeImplObj.updateRoleDescription(trans,
1839 assertTrue(retVal.status == 0);
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,
1846 assertTrue(retVal.status == 0);
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);
1855 Result<Void> retVal = (Result<Void>) facadeImplObj.addPermToRole(trans,
1857 assertTrue(retVal.status == 20);
1859 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1867 retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1869 assertTrue(retVal.status == Status.ERR_BadData);
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();
1878 retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1880 assertTrue(retVal.status == 20);
1882 Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
1884 Mockito.doReturn(rsRequest).when(authzService)
1885 .addPermToRole(Mockito.any(), Mockito.any());
1886 retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1888 assertTrue(retVal.status == 31);
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);
1895 Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
1896 } catch (APIException e) {
1897 // TODO Auto-generated catch block
1898 e.printStackTrace();
1901 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
1902 .when(respObj).getOutputStream();
1903 } catch (IOException e) {
1904 // TODO Auto-generated catch block
1905 e.printStackTrace();
1907 retVal = (Result<Void>) facadeImplObj.addPermToRole(trans, reqObj,
1909 assertTrue(retVal.status == 0);
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,
1916 assertTrue(retVal.status == 0);
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);
1925 Result<Void> retVal = (Result<Void>) facadeImplObj
1926 .delPermFromRole(trans, reqObj, respObj);
1927 assertTrue(retVal.status == 20);
1929 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
1937 retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1939 assertTrue(retVal.status == Status.ERR_BadData);
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();
1948 retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1950 assertTrue(retVal.status == 20);
1952 Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
1954 Mockito.doReturn(rsRequest).when(authzService)
1955 .delPermFromRole(Mockito.any(), Mockito.any());
1956 retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1958 assertTrue(retVal.status == 31);
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);
1965 Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
1966 } catch (APIException e) {
1967 // TODO Auto-generated catch block
1968 e.printStackTrace();
1971 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
1972 .when(respObj).getOutputStream();
1973 } catch (IOException e) {
1974 // TODO Auto-generated catch block
1975 e.printStackTrace();
1977 retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, reqObj,
1979 assertTrue(retVal.status == 0);
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,
1986 assertTrue(retVal.status == 0);
1989 @SuppressWarnings("unchecked")
1990 public void testDelPermFromRoleWithAddlParams() {
1991 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
1992 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
1994 Result<Void> retVal = (Result<Void>) facadeImplObj.delPermFromRole(
1995 trans, respObj, "role", "type", "instance", "action");
1996 assertTrue(retVal.status == 20);
1998 Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
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);
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);
2011 Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
2012 } catch (APIException e) {
2013 // TODO Auto-generated catch block
2014 e.printStackTrace();
2017 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2018 .when(respObj).getOutputStream();
2019 } catch (IOException e) {
2020 // TODO Auto-generated catch block
2021 e.printStackTrace();
2023 retVal = (Result<Void>) facadeImplObj.delPermFromRole(trans, respObj,
2024 "role", "type", "instance", "action");
2025 assertTrue(retVal.status == 0);
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);
2035 @SuppressWarnings("unchecked")
2036 public void testDeleteRole() {
2037 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2038 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2040 Result<Void> retVal = (Result<Void>) facadeImplObj.deleteRole(trans,
2042 assertTrue(retVal.status == 20);
2044 Result<REQUEST> rsRequest = new Result<REQUEST>(null, 31, "test",
2046 Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans,
2048 retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
2050 assertTrue(retVal.status == 31);
2052 rsRequest = new Result<REQUEST>(null, 0, "test", new Object[0]);
2053 Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans,
2055 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2057 Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
2058 } catch (APIException e) {
2059 // TODO Auto-generated catch block
2060 e.printStackTrace();
2062 retVal = (Result<Void>) facadeImplObj.deleteRole(trans, respObj,
2064 assertTrue(retVal.status == 0);
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,
2071 assertTrue(retVal.status == 0);
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);
2080 Result<Void> retVal = (Result<Void>) facadeImplObj.deleteRole(trans,
2082 assertTrue(retVal.status == 20);
2084 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
2092 retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2094 assertTrue(retVal.status == Status.ERR_BadData);
2096 Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2098 Mockito.doReturn(rsRequest).when(authzService).deleteRole(trans, null);
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();
2107 retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2109 assertTrue(retVal.status == 20);
2111 rsRequest = new Result<Void>(null, 0, "test", new Object[0]);
2112 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2114 Mockito.doReturn(dataObj).when(dataObj).load(rsRequest.value);
2115 } catch (APIException e) {
2116 // TODO Auto-generated catch block
2117 e.printStackTrace();
2119 retVal = (Result<Void>) facadeImplObj.deleteRole(trans, reqObj,
2121 assertTrue(retVal.status == 20);
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,
2128 assertTrue(retVal.status == 20);
2132 @SuppressWarnings("unchecked")
2133 public void testCreateUserCred() {
2134 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2135 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2137 Result<Void> retVal = (Result<Void>) facadeImplObj.createUserCred(trans,
2139 assertTrue(retVal.status == 20);
2141 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
2149 retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
2150 assertTrue(retVal.status == Status.ERR_BadData);
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();
2159 Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2161 Mockito.doReturn(rsRequest).when(authzService)
2162 .createUserCred(Mockito.any(), Mockito.any());
2163 retVal = (Result<Void>) facadeImplObj.createUserCred(trans, reqObj);
2165 assertTrue(retVal.status == 31);
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);
2174 @SuppressWarnings("unchecked")
2175 public void testChangeUserCred() {
2176 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2177 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2179 Result<Void> retVal = (Result<Void>) facadeImplObj.changeUserCred(trans,
2181 assertTrue(retVal.status == 20);
2183 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
2191 retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
2192 assertTrue(retVal.status == Status.ERR_BadData);
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();
2201 Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2203 Mockito.doReturn(rsRequest).when(authzService)
2204 .resetUserCred(Mockito.any(), Mockito.any());
2205 retVal = (Result<Void>) facadeImplObj.changeUserCred(trans, reqObj);
2207 assertTrue(retVal.status == 31);
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);
2217 @SuppressWarnings("unchecked")
2218 public void testExtendUserCred() {
2219 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2220 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2222 Result<Void> retVal = (Result<Void>) facadeImplObj.extendUserCred(trans,
2224 assertTrue(retVal.status == 20);
2226 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
2234 retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
2236 assertTrue(retVal.status == Status.ERR_BadData);
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();
2245 Result<Void> rsRequest = new Result<Void>(null, 31, "test",
2247 Mockito.doReturn(rsRequest).when(authzService).extendUserCred(
2248 Mockito.any(), Mockito.any(), Mockito.anyString());
2249 retVal = (Result<Void>) facadeImplObj.extendUserCred(trans, reqObj,
2252 assertTrue(retVal.status == 31);
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,
2259 assertTrue(retVal.status == 31);
2263 @SuppressWarnings("unchecked")
2264 public void testGetCredsByNS() {
2265 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2266 Result<Void> retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans,
2268 assertTrue(retVal.status == 20);
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,
2274 assertTrue(retVal.status == 31);
2276 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2277 Mockito.doReturn(rsVoid).when(authzService).getCredsByNS(trans, "ns");
2279 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2280 .when(respObj).getOutputStream();
2281 } catch (IOException e) {
2282 // TODO Auto-generated catch block
2283 e.printStackTrace();
2286 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2287 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2289 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2290 } catch (APIException e) {
2291 // TODO Auto-generated catch block
2292 e.printStackTrace();
2295 retVal = (Result<Void>) facadeImplObj.getCredsByNS(trans, respObj,
2297 assertTrue(retVal.status == 0);
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,
2304 assertTrue(retVal.status == 0);
2307 @SuppressWarnings("unchecked")
2308 public void testGetCredsByID() {
2309 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2310 Result<Void> retVal = (Result<Void>) facadeImplObj.getCredsByID(trans,
2312 assertTrue(retVal.status == 20);
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,
2318 assertTrue(retVal.status == 31);
2320 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2321 Mockito.doReturn(rsVoid).when(authzService).getCredsByID(trans, "id");
2323 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2324 .when(respObj).getOutputStream();
2325 } catch (IOException e) {
2326 // TODO Auto-generated catch block
2327 e.printStackTrace();
2330 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2331 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2333 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2334 } catch (APIException e) {
2335 // TODO Auto-generated catch block
2336 e.printStackTrace();
2339 retVal = (Result<Void>) facadeImplObj.getCredsByID(trans, respObj,
2341 assertTrue(retVal.status == 0);
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,
2348 assertTrue(retVal.status == 0);
2351 @SuppressWarnings("unchecked")
2352 public void testDeleteUserCred() {
2353 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2354 Result<Void> retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans,
2356 assertTrue(retVal.status == 20);
2358 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2359 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
2367 retVal = (Result<Void>) facadeImplObj.deleteUserCred(trans, reqObj);
2368 assertTrue(retVal.status == 4);
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();
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);
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);
2391 @SuppressWarnings("unchecked")
2392 public void testDoesCredentialMatch() {
2393 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2394 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2396 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2397 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
2405 Result<Date> retVal = (Result<Date>) facadeImplObj
2406 .doesCredentialMatch(trans, reqObj, respObj);
2407 assertTrue(retVal.status == 4);
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();
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,
2422 assertTrue(retVal.status == 31);
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,
2429 assertTrue(retVal.status == 31);
2432 Mockito.doThrow(new IOException("test exception")).when(reqObj)
2434 } catch (IOException e) {
2435 // TODO Auto-generated catch block
2436 e.printStackTrace();
2438 retVal = (Result<Date>) facadeImplObj.doesCredentialMatch(trans, reqObj,
2440 assertTrue(retVal.status == 20);
2443 @SuppressWarnings("unchecked")
2444 public void testValidBasicAuth() {
2445 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2447 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2448 Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
2450 Result<Void> retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans,
2451 respObj, "basicAuth");
2452 assertTrue(retVal.status == 31);
2454 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2455 Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
2457 retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans, respObj,
2459 assertTrue(retVal.status == 20);
2462 Mockito.doReturn(Mockito.mock(ServletOutputStream.class))
2463 .when(respObj).getOutputStream();
2464 } catch (IOException e) {
2465 // TODO Auto-generated catch block
2466 e.printStackTrace();
2468 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2469 Mockito.doReturn(rsVoid).when(authzService).validateBasicAuth(trans,
2471 retVal = (Result<Void>) facadeImplObj.validBasicAuth(trans, respObj,
2473 assertTrue(retVal.status == 0);
2477 @SuppressWarnings("unchecked")
2478 public void testGetCertInfoByID() {
2479 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2480 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2482 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2483 Mockito.doReturn(rsVoid).when(authzService).getCertInfoByID(trans,
2485 Result<Void> retVal = (Result<Void>) facadeImplObj
2486 .getCertInfoByID(trans, reqObj, respObj, "id");
2487 assertTrue(retVal.status == 31);
2489 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2490 Mockito.doReturn(rsVoid).when(authzService).getCertInfoByID(trans,
2492 retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
2494 assertTrue(retVal.status == 0);
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);
2502 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2503 } catch (APIException e) {
2504 // TODO Auto-generated catch block
2505 e.printStackTrace();
2507 retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
2509 assertTrue(retVal.status == 0);
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();
2518 retVal = (Result<Void>) facadeImplObj.getCertInfoByID(trans, reqObj,
2520 assertTrue(retVal.status == 20);
2524 @SuppressWarnings("unchecked")
2525 public void testCreateDelegate() {
2526 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2527 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2529 Result<Void> retVal = (Result<Void>) facadeImplObj.createDelegate(trans,
2531 assertTrue(retVal.status == 20);
2533 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2534 Mockito.doReturn(dataObj).when(rossetaObj).newData();
2536 Mockito.doReturn(Mockito.mock(ServletInputStream.class))
2537 .when(reqObj).getInputStream();
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();
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());
2549 retVal = (Result<Void>) facadeImplObj.createDelegate(trans, reqObj,
2551 assertTrue(retVal.status == 0);
2553 Mockito.doReturn("user").when(trans).user();
2554 Mockito.doReturn(env).when(trans).env();
2555 Question.specialLogOn(trans, trans.user());
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,
2562 assertTrue(retVal.status == 0);
2566 @SuppressWarnings("unchecked")
2567 public void testUpdateDelegate() {
2568 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2569 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2571 Result<Void> retVal = (Result<Void>) facadeImplObj.updateDelegate(trans,
2573 assertTrue(retVal.status == 20);
2575 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2576 Mockito.doReturn(dataObj).when(rossetaObj).newData();
2578 Mockito.doReturn(Mockito.mock(ServletInputStream.class))
2579 .when(reqObj).getInputStream();
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();
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());
2591 retVal = (Result<Void>) facadeImplObj.updateDelegate(trans, reqObj,
2593 assertTrue(retVal.status == 0);
2595 Mockito.doReturn("user").when(trans).user();
2596 Mockito.doReturn(env).when(trans).env();
2597 Question.specialLogOn(trans, trans.user());
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,
2604 assertTrue(retVal.status == 0);
2609 @SuppressWarnings("unchecked")
2610 public void testDeleteDelegate() {
2611 HttpServletRequest reqObj = Mockito.mock(HttpServletRequest.class);
2612 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2614 Result<Void> retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans,
2616 assertTrue(retVal.status == 20);
2618 RosettaData<REQUEST> dataObj = Mockito.mock(RosettaData.class);
2619 Mockito.doReturn(dataObj).when(rossetaObj).newData();
2621 Mockito.doReturn(Mockito.mock(ServletInputStream.class))
2622 .when(reqObj).getInputStream();
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();
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());
2634 retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans, reqObj,
2638 Mockito.doReturn("user").when(trans).user();
2639 Mockito.doReturn(env).when(trans).env();
2640 Question.specialLogOn(trans, trans.user());
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,
2652 @SuppressWarnings("unchecked")
2653 public void testDeleteDelegate2() {
2655 Result<Void> rsVoid = new Result<Void>(null, 0, "test", new Object[0]);
2656 Mockito.doReturn(rsVoid).when(authzService).deleteDelegate(trans,
2659 Result<Void> retVal = (Result<Void>) facadeImplObj.deleteDelegate(trans,
2661 assertTrue(retVal.status == 0);
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);
2669 @SuppressWarnings("unchecked")
2670 public void testGetDelegatesByUser() {
2671 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
2673 Result<NSS> rsVoid = new Result<NSS>(null, 31, "test", new Object[0]);
2674 Mockito.doReturn(rsVoid).when(authzService).getDelegatesByUser(trans,
2676 Result<Void> retVal = (Result<Void>) facadeImplObj
2677 .getDelegatesByUser(trans, "user", respObj);
2678 assertTrue(retVal.status == 31);
2680 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2681 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2683 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2684 } catch (APIException e) {
2685 // TODO Auto-generated catch block
2686 e.printStackTrace();
2688 rsVoid = new Result<NSS>(null, 0, "test", new Object[0]);
2689 Mockito.doReturn(rsVoid).when(authzService).getDelegatesByUser(trans,
2691 retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
2693 assertTrue(retVal.status == 0);
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",
2700 assertTrue(retVal.status == 0);
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();
2709 retVal = (Result<Void>) facadeImplObj.getDelegatesByUser(trans, "user",
2711 assertTrue(retVal.status == 20);
2714 @SuppressWarnings("unchecked")
2715 public void testGetDelegatesByDelegate() {
2716 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
2725 RosettaData<NSS> dataObj = Mockito.mock(RosettaData.class);
2726 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2728 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2729 } catch (APIException e) {
2730 // TODO Auto-generated catch block
2731 e.printStackTrace();
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);
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);
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();
2754 retVal = (Result<Void>) facadeImplObj.getDelegatesByDelegate(trans,
2755 "delegate", respObj);
2756 assertTrue(retVal.status == 20);
2760 @SuppressWarnings("unchecked")
2761 public void testRequestUserRole() {
2762 RosettaData<?> dataObj = Mockito.mock(RosettaData.class);
2763 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
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);
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();
2783 retVal = (Result<Void>) facadeImplObj.requestUserRole(trans,
2784 Mockito.mock(HttpServletRequest.class),
2785 Mockito.mock(HttpServletResponse.class));
2786 assertTrue(retVal.status == 20);
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);
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);
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);
2814 @SuppressWarnings("unchecked")
2815 public void testGetUserInRole() {
2816 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
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();
2825 Result<Void> retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2826 Mockito.mock(HttpServletResponse.class), "user", "role");
2827 assertTrue(retVal.status == 20);
2829 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2831 Mockito.doReturn(rsVoid).when(authzService).getUserInRole(trans, "user",
2833 retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2834 Mockito.mock(HttpServletResponse.class), "user", "role");
2835 assertTrue(retVal.status == 31);
2837 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2838 Mockito.doReturn(rsVoid).when(authzService).getUserInRole(trans, "user",
2840 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2842 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2843 } catch (APIException e) {
2844 // TODO Auto-generated catch block
2845 e.printStackTrace();
2847 retVal = (Result<Void>) facadeImplObj.getUserInRole(trans,
2848 Mockito.mock(HttpServletResponse.class), "user", "role");
2849 assertTrue(retVal.status == 0);
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);
2859 @SuppressWarnings("unchecked")
2860 public void testGetUserRolesByUser() {
2861 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
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();
2870 Result<Void> retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(
2871 trans, Mockito.mock(HttpServletResponse.class), "user");
2872 assertTrue(retVal.status == 20);
2874 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2876 Mockito.doReturn(rsVoid).when(authzService).getUserRolesByUser(trans,
2878 retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
2879 Mockito.mock(HttpServletResponse.class), "user");
2880 assertTrue(retVal.status == 31);
2882 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2883 Mockito.doReturn(rsVoid).when(authzService).getUserRolesByUser(trans,
2885 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2887 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2888 } catch (APIException e) {
2889 // TODO Auto-generated catch block
2890 e.printStackTrace();
2892 retVal = (Result<Void>) facadeImplObj.getUserRolesByUser(trans,
2893 Mockito.mock(HttpServletResponse.class), "user");
2894 assertTrue(retVal.status == 0);
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);
2904 @SuppressWarnings("unchecked")
2905 public void testGetUserRolesByRole() {
2906 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
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();
2915 Result<Void> retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(
2916 trans, Mockito.mock(HttpServletResponse.class), "role");
2917 assertTrue(retVal.status == 20);
2919 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2921 Mockito.doReturn(rsVoid).when(authzService).getUserRolesByRole(trans,
2923 retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
2924 Mockito.mock(HttpServletResponse.class), "role");
2925 assertTrue(retVal.status == 31);
2927 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2928 Mockito.doReturn(rsVoid).when(authzService).getUserRolesByRole(trans,
2930 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
2932 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
2933 } catch (APIException e) {
2934 // TODO Auto-generated catch block
2935 e.printStackTrace();
2937 retVal = (Result<Void>) facadeImplObj.getUserRolesByRole(trans,
2938 Mockito.mock(HttpServletResponse.class), "role");
2939 assertTrue(retVal.status == 0);
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);
2950 public void testExtendUserRoleExpiration() {
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",
2958 assertTrue(retVal.status == 20);
2960 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2962 Mockito.doReturn(rsVoid).when(authzService).extendUserRole(trans,
2964 retVal = (Result<Void>) facadeImplObj.extendUserRoleExpiration(trans,
2965 Mockito.mock(HttpServletResponse.class), "user", "role");
2966 assertTrue(retVal.status == 31);
2970 @SuppressWarnings("unchecked")
2971 public void testDeleteUserRole() {
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);
2979 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
2981 Mockito.doReturn(rsVoid).when(authzService).deleteUserRole(trans,
2983 retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
2984 Mockito.mock(HttpServletResponse.class), "user", "role");
2985 assertTrue(retVal.status == 31);
2987 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
2988 Mockito.doReturn(rsVoid).when(authzService).deleteUserRole(trans,
2991 retVal = (Result<Void>) facadeImplObj.deleteUserRole(trans,
2992 Mockito.mock(HttpServletResponse.class), "user", "role");
2993 assertTrue(retVal.status == 0);
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);
3003 Mockito.doReturn(dataObj).when(rossetaObj).newData();
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();
3011 Result<Void> retVal = (Result<Void>) facadeImplObj.updateApproval(trans,
3013 assertTrue(retVal.status == 20);
3015 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3017 Mockito.doReturn(rsVoid).when(authzService)
3018 .updateApproval(Mockito.any(), Mockito.anyObject());
3019 retVal = (Result<Void>) facadeImplObj.updateApproval(trans, reqObj,
3021 assertTrue(retVal.status == 31);
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,
3028 assertTrue(retVal.status == 0);
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,
3035 assertTrue(retVal.status == 0);
3038 @SuppressWarnings("unchecked")
3039 public void testGetApprovalsByUser() {
3040 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3041 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3048 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3051 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3052 } catch (APIException e) {
3053 // TODO Auto-generated catch block
3054 e.printStackTrace();
3056 Mockito.doReturn(rsVoid).when(authzService).getApprovalsByUser(trans,
3058 retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
3060 assertTrue(retVal.status == 31);
3062 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3063 Mockito.doReturn(rsVoid).when(authzService).getApprovalsByUser(trans,
3065 retVal = (Result<Void>) facadeImplObj.getApprovalsByUser(trans, respObj,
3067 assertTrue(retVal.status == 0);
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,
3074 assertTrue(retVal.status == 0);
3077 @SuppressWarnings("unchecked")
3078 public void testGetApprovalsByApprover() {
3079 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3080 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3087 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3090 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3091 } catch (APIException e) {
3092 // TODO Auto-generated catch block
3093 e.printStackTrace();
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);
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);
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);
3116 @SuppressWarnings("unchecked")
3117 public void testGetApprovalsByTicket() {
3118 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3119 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3126 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3129 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3130 } catch (APIException e) {
3131 // TODO Auto-generated catch block
3132 e.printStackTrace();
3134 Mockito.doReturn(rsVoid).when(authzService).getApprovalsByTicket(trans,
3136 retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
3138 assertTrue(retVal.status == 31);
3140 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3141 Mockito.doReturn(rsVoid).when(authzService).getApprovalsByTicket(trans,
3143 retVal = (Result<Void>) facadeImplObj.getApprovalsByTicket(trans,
3145 assertTrue(retVal.status == 0);
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,
3152 assertTrue(retVal.status == 0);
3155 @SuppressWarnings("unchecked")
3156 public void testGetUsersByRole() {
3157 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3158 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3160 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
3161 Result<Void> retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans,
3163 assertTrue(retVal.status == 20);
3165 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3168 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3169 } catch (APIException e) {
3170 // TODO Auto-generated catch block
3171 e.printStackTrace();
3173 Mockito.doReturn(rsVoid).when(authzService).getUsersByRole(trans,
3175 retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
3177 assertTrue(retVal.status == 31);
3179 rsVoid = new Result<USERS>(null, 0, "test", new Object[0]);
3180 Mockito.doReturn(rsVoid).when(authzService).getUsersByRole(trans,
3182 retVal = (Result<Void>) facadeImplObj.getUsersByRole(trans, respObj,
3184 assertTrue(retVal.status == 0);
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,
3191 assertTrue(retVal.status == 0);
3194 @SuppressWarnings("unchecked")
3195 public void testGetUsersByPermission() {
3196 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3197 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3204 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3207 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3208 } catch (APIException e) {
3209 // TODO Auto-generated catch block
3210 e.printStackTrace();
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);
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);
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);
3234 @SuppressWarnings("unchecked")
3235 public void testGetHistoryByUser() {
3236 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3237 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3244 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3247 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3248 } catch (APIException e) {
3249 // TODO Auto-generated catch block
3250 e.printStackTrace();
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);
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);
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);
3273 @SuppressWarnings("unchecked")
3274 public void testGetHistoryByRole() {
3275 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3276 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3283 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3286 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3287 } catch (APIException e) {
3288 // TODO Auto-generated catch block
3289 e.printStackTrace();
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);
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);
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);
3312 @SuppressWarnings("unchecked")
3313 public void testGetHistoryByNS() {
3314 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3315 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3322 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3325 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3326 } catch (APIException e) {
3327 // TODO Auto-generated catch block
3328 e.printStackTrace();
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);
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);
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);
3351 @SuppressWarnings("unchecked")
3352 public void testGetHistoryByPerm() {
3353 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3354 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3361 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3364 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3365 } catch (APIException e) {
3366 // TODO Auto-generated catch block
3367 e.printStackTrace();
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);
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);
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);
3390 @SuppressWarnings("unchecked")
3391 public void testGetHistoryBySubject() {
3392 RosettaData<USERS> dataObj = Mockito.mock(RosettaData.class);
3393 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
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);
3400 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3403 Mockito.doReturn(dataObj).when(dataObj).load(rsVoid.value);
3404 } catch (APIException e) {
3405 // TODO Auto-generated catch block
3406 e.printStackTrace();
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);
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);
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);
3429 public void testCacheClear() {
3431 Mockito.doThrow(new RuntimeException("test exception"))
3432 .when(authzService).cacheClear(trans, "cname");
3433 Result<Void> retVal = (Result<Void>) facadeImplObj.cacheClear(trans,
3435 assertTrue(retVal.status == 20);
3437 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3439 Mockito.doReturn(rsVoid).when(authzService).cacheClear(trans, "cname");
3440 retVal = (Result<Void>) facadeImplObj.cacheClear(trans, "cname");
3441 assertTrue(retVal.status == 31);
3445 public void testCacheClear2() {
3447 Mockito.doThrow(new RuntimeException("test exception"))
3449 .cacheClear(trans, "cname", new int[]{1, -1});
3450 Result<Void> retVal = (Result<Void>) facadeImplObj.cacheClear(trans,
3452 assertTrue(retVal.status == 20);
3454 Result<USERS> rsVoid = new Result<USERS>(null, 31, "test",
3456 Mockito.doReturn(rsVoid).when(authzService).cacheClear(trans, "cname",
3458 retVal = (Result<Void>) facadeImplObj.cacheClear(trans, "cname", "1,1");
3459 assertTrue(retVal.status == 31);
3464 public void testDbReset() {
3465 facadeImplObj.dbReset(trans);
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);
3473 RosettaData<Api> dataObj = Mockito.mock(RosettaData.class);
3474 Mockito.doReturn(dataObj).when(rossetaObj).newData(trans);
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();
3482 facadeImplObj.getAPI(trans, respObj, rservlet);
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);
3490 public void testGetAPIExample() {
3491 HttpServletResponse respObj = Mockito.mock(HttpServletResponse.class);
3492 facadeImplObj.getAPIExample(trans, respObj, "nameOrContentType", true);
3495 class AuthzFacadeImplImpl extends AuthzFacadeImpl {
3497 public AuthzFacadeImplImpl(AuthzEnv env, AuthzService service,
3498 TYPE dataType) throws APIException {
3499 super(env, service, dataType);