1 /*******************************************************************************
2 * ============LICENSE_START====================================================
4 * * ===========================================================================
5 * * Copyright © 2017 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====================================================
21 ******************************************************************************/
23 package org.onap.aaf.auth.dao.hl;
25 import static org.junit.Assert.assertNull;
26 import static org.junit.Assert.assertTrue;
27 import static org.mockito.MockitoAnnotations.initMocks;
29 import java.io.IOException;
30 import java.lang.reflect.InvocationTargetException;
31 import java.lang.reflect.Method;
32 import java.text.DateFormat;
33 import java.text.ParseException;
34 import java.text.SimpleDateFormat;
35 import java.util.ArrayList;
36 import java.util.Date;
37 import java.util.GregorianCalendar;
38 import java.util.HashSet;
39 import java.util.List;
40 import java.util.Properties;
42 import java.util.UUID;
44 import org.junit.Before;
45 import org.junit.Test;
46 import org.mockito.Mock;
47 import org.mockito.Mockito;
48 import org.onap.aaf.auth.common.Define;
49 import org.onap.aaf.auth.dao.cached.CachedCredDAO;
50 import org.onap.aaf.auth.dao.cached.CachedNSDAO;
51 import org.onap.aaf.auth.dao.cached.CachedPermDAO;
52 import org.onap.aaf.auth.dao.cached.CachedRoleDAO;
53 import org.onap.aaf.auth.dao.cached.CachedUserRoleDAO;
54 import org.onap.aaf.auth.dao.cass.ApprovalDAO;
55 import org.onap.aaf.auth.dao.cass.CredDAO;
56 import org.onap.aaf.auth.dao.cass.FutureDAO;
57 import org.onap.aaf.auth.dao.cass.Namespace;
58 import org.onap.aaf.auth.dao.cass.NsDAO;
59 import org.onap.aaf.auth.dao.cass.NsSplit;
60 import org.onap.aaf.auth.dao.cass.NsType;
61 import org.onap.aaf.auth.dao.cass.PermDAO;
62 import org.onap.aaf.auth.dao.cass.RoleDAO;
63 import org.onap.aaf.auth.dao.cass.Status;
64 import org.onap.aaf.auth.dao.cass.UserRoleDAO;
65 import org.onap.aaf.auth.dao.hl.Function.FUTURE_OP;
66 import org.onap.aaf.auth.dao.hl.Function.Lookup;
67 import org.onap.aaf.auth.dao.hl.Question.Access;
68 import org.onap.aaf.auth.env.AuthzTrans;
69 import org.onap.aaf.auth.env.AuthzTrans.REQD_TYPE;
70 import org.onap.aaf.auth.layer.Result;
71 import org.onap.aaf.auth.org.Organization;
72 import org.onap.aaf.auth.org.Organization.Expiration;
73 import org.onap.aaf.auth.org.Organization.Identity;
74 import org.onap.aaf.auth.org.OrganizationException;
75 import org.onap.aaf.cadi.CadiException;
76 import org.onap.aaf.cadi.PropAccess;
77 import org.onap.aaf.cadi.config.Config;
78 import org.onap.aaf.misc.env.APIException;
79 import org.onap.aaf.misc.env.LogTarget;
81 public class JU_Function {
83 private static final Object NO_PARAM = new Object[0];
100 CachedRoleDAO roleDAO;
103 CachedPermDAO permDAO;
106 CachedCredDAO credDAO;
109 CachedUserRoleDAO userRoleDAO;
112 ApprovalDAO approvalDAO;
118 public void setUp() throws APIException, IOException {
120 Mockito.doReturn(org).when(trans).org();
121 Mockito.doReturn(nsDAO).when(ques).nsDAO();
122 Mockito.doReturn(roleDAO).when(ques).roleDAO();
123 Mockito.doReturn(permDAO).when(ques).permDAO();
124 Mockito.doReturn(credDAO).when(ques).credDAO();
125 Mockito.doReturn(userRoleDAO).when(ques).userRoleDAO();
126 Mockito.doReturn(approvalDAO).when(ques).approvalDAO();
127 Mockito.doReturn(futureDAO).when(ques).futureDAO();
129 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
130 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
131 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
132 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
133 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
137 } catch (CadiException e) {
142 public void testCreateNs() {
143 Namespace namespace = Mockito.mock(Namespace.class);
144 namespace.name = "test.test";
145 List<String> owner = new ArrayList<String>();
146 namespace.owner = owner;
148 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
149 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
151 NsDAO.Data data = new NsDAO.Data();
153 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
154 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
156 Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
157 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
158 //setQuestion(ques, cachedNS);
160 Function funcObj = new Function(trans, ques);
161 Result<Void> result = funcObj.createNS(trans, namespace, true);
162 assertTrue(3 == result.status);
166 public void testCreateNsReadSuccess() {
167 Namespace namespace = Mockito.mock(Namespace.class);
168 namespace.name = "test.test";
169 List<String> owner = new ArrayList<String>();
171 namespace.owner = owner;
172 List<String> admin = new ArrayList<String>();
174 namespace.admin= admin;
176 Organization org = Mockito.mock(Organization.class);
177 Mockito.doReturn(org).when(trans).org();
179 NsDAO.Data data = new NsDAO.Data();
181 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
182 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
184 Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
185 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
187 Function funcObj = new Function(trans, ques);
188 Result<Void> result = funcObj.createNS(trans, namespace, true);
189 assertTrue(3 == result.status);
193 public void testCreateNsFromApprovaFalse() {
194 Namespace namespace = Mockito.mock(Namespace.class);
195 namespace.name = "test.test";
196 List<String> owner = new ArrayList<String>();
197 namespace.owner = owner;
199 Organization org = Mockito.mock(Organization.class);
200 Mockito.doReturn(org).when(trans).org();
202 NsDAO.Data data = new NsDAO.Data();
204 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
205 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
206 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
207 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
209 Function funcObj = new Function(trans, ques);
210 Result<Void> result = funcObj.createNS(trans, namespace, false);
211 assertTrue(1 == result.status);
213 Mockito.doReturn(retVal2).when(ques).deriveNs(trans, "test");
214 funcObj = new Function(trans, ques);
215 result = funcObj.createNS(trans, namespace, false);
216 assertTrue(1 == result.status);
220 public void testCreateNsownerLoop() {
221 Namespace namespace = Mockito.mock(Namespace.class);
222 namespace.name = "test.test";
223 List<String> owner = new ArrayList<String>();
225 namespace.owner = owner;
227 Organization org = Mockito.mock(Organization.class);
228 Mockito.doReturn(org).when(trans).org();
229 Mockito.doReturn(org).when(trans).org();
231 Function funcObj = new Function(trans, ques);
232 Result<Void> result = funcObj.createNS(trans, namespace, true);
233 assertTrue(result.status == Status.ERR_Policy);
234 assertTrue(result.details.contains("is not a valid user at"));
236 Identity iden=Mockito.mock(Identity.class);
238 Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
239 Mockito.doReturn("test").when(iden).mayOwn();
240 } catch (OrganizationException e) {
241 // TODO Auto-generated catch block
244 result = funcObj.createNS(trans, namespace, true);
245 assertTrue(result.status == Status.ERR_Policy);
246 assertTrue(result.details.contains("is an invalid Identity"));
248 Mockito.doReturn(true).when(iden).isFound();
249 result = funcObj.createNS(trans, namespace, true);
250 assertTrue(result.status == Status.ERR_Policy);
251 assertTrue(result.details.contains("cannot be the owner of the namespace "));
253 Mockito.doReturn(true).when(org).isTestEnv();
255 Mockito.doReturn("test").when(org).validate(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
256 result = funcObj.createNS(trans, namespace, true);
257 assertTrue(result.status == Status.ERR_Policy);
258 assertTrue(result.details.contains("cannot be the owner of the namespace "));
259 } catch (OrganizationException e) {
260 // TODO Auto-generated catch block
266 public void testCreateNsownerLoopException() {
267 Namespace namespace = Mockito.mock(Namespace.class);
268 namespace.name = "test";
269 List<String> owner = new ArrayList<String>();
271 namespace.owner = owner;
273 Organization org = Mockito.mock(Organization.class);
274 Mockito.doReturn(org).when(trans).org();
276 Function funcObj = new Function(trans, ques);
278 Identity iden=Mockito.mock(Identity.class);
280 Mockito.doThrow(new OrganizationException()).when(org).getIdentity(trans, "test");
281 Mockito.doReturn("test").when(iden).mayOwn();
282 } catch (OrganizationException e) {
283 // TODO Auto-generated catch block
287 NsDAO.Data data = new NsDAO.Data();
289 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
290 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
292 Result<Void> result = funcObj.createNS(trans, namespace, true);
293 assertTrue(result.status == Status.ERR_Security);
294 assertTrue(result.details.contains("may not create Root Namespaces"));
296 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
297 retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
298 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, null);
300 Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
301 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
303 result = funcObj.createNS(trans, namespace, true);
304 assertTrue(24 == result.status);
309 public void testCreateNsAdminLoop() {
310 Namespace namespace = Mockito.mock(Namespace.class);
311 namespace.name = "test.test";
312 List<String> owner = new ArrayList<String>();
314 namespace.owner = owner;
315 namespace.admin = owner;
317 Organization org = Mockito.mock(Organization.class);
318 Mockito.doReturn(org).when(trans).org();
320 NsDAO.Data data = new NsDAO.Data();
322 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
323 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
325 Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
326 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
327 Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
328 List<CredDAO.Data> dataObj = new ArrayList<>();
329 CredDAO.Data indData = new CredDAO.Data();
331 indData.notes = "test";
332 DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
334 indData.expires = sdf.parse("2090/01/01");
335 } catch (ParseException e1) {
336 // TODO Auto-generated catch block
337 e1.printStackTrace();
339 dataObj.add(indData);
340 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
341 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
343 Identity iden=Mockito.mock(Identity.class);
345 Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
346 Mockito.doReturn("test").when(iden).mayOwn();
347 Mockito.doReturn(true).when(org).isTestEnv();
348 } catch (OrganizationException e) {
349 // TODO Auto-generated catch block
353 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
354 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
356 Function funcObj = new Function(trans, ques);
357 Result<Void> result = funcObj.createNS(trans, namespace, true);
358 assertTrue(result.status == 1);
363 public void testCreateNsAdminLoopCreateSucReadChildrenFailure() {
364 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
365 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
366 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
367 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
370 } catch (CadiException e) {
371 // TODO Auto-generated catch block
374 Namespace namespace = Mockito.mock(Namespace.class);
375 namespace.name = "test.test";
376 List<String> owner = new ArrayList<String>();
378 namespace.owner = owner;
379 namespace.admin = owner;
381 Organization org = Mockito.mock(Organization.class);
382 Mockito.doReturn(org).when(trans).org();
384 NsDAO.Data data = new NsDAO.Data();
386 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
387 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
389 Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
390 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
391 Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
392 List<CredDAO.Data> dataObj = new ArrayList<>();
393 CredDAO.Data indData = new CredDAO.Data();
395 indData.notes = "test";
396 DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
398 indData.expires = sdf.parse("2090/01/01");
399 } catch (ParseException e1) {
400 // TODO Auto-generated catch block
401 e1.printStackTrace();
403 dataObj.add(indData);
404 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
405 RoleDAO.Data indData1 = new RoleDAO.Data();
406 indData1.ns = "test";
407 indData1.name = "test";
408 Set<String> permsSet = new HashSet<>();
409 permsSet.add("test|test");
410 indData1.perms = permsSet;
411 dataObj1.add(indData1);
413 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
414 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
415 indData4.ns = "test";
416 indData4.rname = "test";
417 dataObj4.add(indData4);
419 List<PermDAO.Data> dataObj5 = new ArrayList<>();
420 PermDAO.Data indData5 = new PermDAO.Data();
421 indData5.ns = "test";
422 indData5.type = "test";
423 dataObj5.add(indData5);
425 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
426 Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",NO_PARAM);
427 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
428 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
429 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
430 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
431 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
432 Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
433 Mockito.doReturn(retVal6).when(roleDAO).create(Mockito.any(), Mockito.any());
434 Mockito.doReturn(retVal6).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
435 Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
436 Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");
437 Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
438 Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");
440 Identity iden=Mockito.mock(Identity.class);
442 Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
443 Mockito.doReturn("test").when(iden).mayOwn();
444 Mockito.doReturn(true).when(org).isTestEnv();
445 Mockito.doReturn(new GregorianCalendar(2010, 01, 01)).when(org).expiration(null, Expiration.UserInRole);
446 } catch (OrganizationException e) {
447 // TODO Auto-generated catch block
451 Function funcObj = new Function(trans, ques);
452 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
453 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
455 Result<Void> result = funcObj.createNS(trans, namespace, true);
456 assertTrue(result.status == Status.ERR_ActionNotCompleted);
461 public void testCreateNsAdminLoopCreateSuc() {
462 Namespace namespace = Mockito.mock(Namespace.class);
463 namespace.name = "test.test";
464 List<String> owner = new ArrayList<String>();
466 namespace.owner = owner;
467 namespace.admin = owner;
469 Organization org = Mockito.mock(Organization.class);
470 Mockito.doReturn(org).when(trans).org();
472 NsDAO.Data data = new NsDAO.Data();
474 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
475 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
477 Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
478 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
479 Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
480 List<CredDAO.Data> dataObj = new ArrayList<>();
481 CredDAO.Data indData = new CredDAO.Data();
483 indData.notes = "test";
484 DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
486 indData.expires = sdf.parse("2090/01/01");
487 } catch (ParseException e1) {
488 // TODO Auto-generated catch block
489 e1.printStackTrace();
491 dataObj.add(indData);
492 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
493 RoleDAO.Data indData1 = new RoleDAO.Data();
494 indData1.ns = "test";
495 indData1.name = "test";
496 Set<String> permsSet = new HashSet<>();
497 permsSet.add("test|test|test|test");
498 indData1.perms = permsSet;
499 dataObj1.add(indData1);
501 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
502 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
503 indData4.ns = "test";
504 indData4.rname = "test";
505 dataObj4.add(indData4);
507 List<PermDAO.Data> dataObj5 = new ArrayList<>();
508 PermDAO.Data indData5 = new PermDAO.Data();
509 indData5.ns = "test";
510 indData5.type = "test";
511 Set<String> rolesSet = new HashSet<>();
512 rolesSet.add("test|test|test|test");
513 indData5.roles = rolesSet;
514 dataObj5.add(indData5);
516 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
517 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
518 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
519 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
520 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
521 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
522 Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
523 Mockito.doReturn(retVal2).when(roleDAO).create(Mockito.any(), Mockito.any());
524 Mockito.doReturn(retVal2).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
525 Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
526 Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");
527 Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
528 Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");
530 Identity iden=Mockito.mock(Identity.class);
532 Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
533 Mockito.doReturn("test").when(iden).mayOwn();
534 Mockito.doReturn(true).when(org).isTestEnv();
535 Mockito.doReturn(new GregorianCalendar(2010, 01, 01)).when(org).expiration(null, Expiration.UserInRole);
536 } catch (OrganizationException e) {
537 // TODO Auto-generated catch block
541 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
542 Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
544 Function funcObj = new Function(trans, ques);
545 Result<Void> result = funcObj.createNS(trans, namespace, true);
546 assertTrue(result.status == 0);
551 public void test4DeleteNs() {
552 Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
553 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
555 Function funcObj = new Function(trans, ques);
556 Result<Void> result = funcObj.deleteNS(trans, "test");
558 assertTrue(result.status == Status.ERR_NsNotFound);
562 public void test4DeleteCanMoveFail() {
563 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
564 NsDAO.Data dataObj = new NsDAO.Data();
567 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
568 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
570 Mockito.doReturn(false).when(ques).canMove(Mockito.any());
571 Mockito.doReturn(retVal).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
573 Function funcObj = new Function(trans, ques);
574 Result<Void> result = funcObj.deleteNS(trans, "test");
575 assertTrue(result.status == Status.ERR_Security);
580 public void test4DeleteNsReadSuc() {
581 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
582 NsDAO.Data dataObj = new NsDAO.Data();
585 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
586 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
588 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
589 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
591 Function funcObj = new Function(trans, ques);
592 Result<Void> result = funcObj.deleteNS(trans, "test");
593 assertTrue(result.status == 1);
598 public void test4DeleteNsMayUserSuc() {
599 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
600 NsDAO.Data dataObj = new NsDAO.Data();
603 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
604 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
606 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
607 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
609 Function funcObj = new Function(trans, ques);
610 Result<Void> result = funcObj.deleteNS(trans, "test");
611 assertTrue(result.status == 1);
613 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
615 Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
617 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",NO_PARAM);
618 Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
620 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
621 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
622 indData4.ns = "test";
623 indData4.rname = "test";
624 dataObj4.add(indData4);
625 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
626 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(trans, "test");
628 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
629 RoleDAO.Data indData1 = new RoleDAO.Data();
630 indData1.ns = "test";
631 indData1.name = "test";
632 Set<String> permsSet = new HashSet<>();
633 permsSet.add("test|test");
634 indData1.perms = permsSet;
635 dataObj1.add(indData1);
636 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
637 Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
638 Mockito.doReturn(retVal3).when(roleDAO).read(trans, indData1);
640 funcObj = new Function(trans, ques);
641 result = funcObj.deleteNS(trans, "test");
642 assertTrue(result.status == Status.ERR_DependencyExists);
644 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
646 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
647 funcObj = new Function(trans, ques);
648 result = funcObj.deleteNS(trans, "test");
652 public void test4DeleteNsDrivensFailure() {
653 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
654 NsDAO.Data dataObj = new NsDAO.Data();
657 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
658 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
660 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
661 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
663 Function funcObj = new Function(trans, ques);
664 Result<Void> result = funcObj.deleteNS(trans, "test");
665 assertTrue(result.status == 1);
667 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
669 Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
671 List<PermDAO.Data> dataObj5 = new ArrayList<>();
672 PermDAO.Data indData5 = new PermDAO.Data();
673 indData5.ns = "test";
674 indData5.type = "test";
675 dataObj5.add(indData5);
676 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
677 Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
678 Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
679 Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
682 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
683 RoleDAO.Data indData1 = new RoleDAO.Data();
684 indData1.ns = "test";
685 indData1.name = "test";
686 Set<String> permsSet = new HashSet<>();
687 permsSet.add("test|test");
688 indData1.perms = permsSet;
689 dataObj1.add(indData1);
690 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
691 Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
692 Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");
693 Mockito.doReturn(retVal3).when(roleDAO).read(trans, indData1);
695 funcObj = new Function(trans, ques);
696 result = funcObj.deleteNS(trans, "test");
697 assertTrue(result.status == Status.ERR_DependencyExists);
699 NsDAO.Data data = new NsDAO.Data();
701 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
702 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
704 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
705 funcObj = new Function(trans, ques);
706 result = funcObj.deleteNS(trans, "test.test");
707 assertTrue(result.status == 1);
711 public void test4DeleteNsWithDot() {
712 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
713 NsDAO.Data dataObj = new NsDAO.Data();
716 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
717 Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
719 List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
720 CredDAO.Data nsData = new CredDAO.Data();
722 nsDataList.add(nsData);
723 Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",NO_PARAM);
724 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
725 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
727 Function funcObj = new Function(trans, ques);
728 Result<Void> result = funcObj.deleteNS(trans, "test");
729 assertTrue(result.status == 1);
731 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
733 Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
734 Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
736 List<PermDAO.Data> dataObj5 = new ArrayList<>();
737 PermDAO.Data indData5 = new PermDAO.Data();
738 indData5.ns = "test";
739 indData5.type = "test";
740 dataObj5.add(indData5);
741 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new Object[0]);
742 Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
743 Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
744 Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
746 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
747 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
748 indData4.ns = "test";
749 indData4.rname = "test";
750 dataObj4.add(indData4);
751 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
752 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
753 Mockito.doReturn(retVal4).when(userRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
755 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
756 RoleDAO.Data indData1 = new RoleDAO.Data();
757 indData1.ns = "test";
758 indData1.name = "admin";
759 Set<String> permsSet = new HashSet<>();
760 permsSet.add("test|test");
761 indData1.perms = permsSet;
762 dataObj1.add(indData1);
763 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
764 Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
765 Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");
766 Mockito.doReturn(retVal3).when(roleDAO).read(trans, indData1);
768 funcObj = new Function(trans, ques);
769 result = funcObj.deleteNS(trans, "test");
770 assertTrue(result.status == Status.ERR_DependencyExists);
772 NsDAO.Data data = new NsDAO.Data();
774 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
775 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
777 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
778 funcObj = new Function(trans, ques);
779 result = funcObj.deleteNS(trans, "test.test");
784 public void testGetOwners() {
785 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
786 // NsDAO.Data dataObj = new NsDAO.Data();
788 // dataAl.add(dataObj);
789 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
790 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
792 // Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
793 // Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
795 Function funcObj = new Function(trans, ques);
796 Result<List<String>> result = funcObj.getOwners(trans, "test", false);
797 assertTrue(result.status == 1);
802 public void testDelOwner() {
803 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
804 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
805 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
807 NsDAO.Data data = new NsDAO.Data();
809 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
810 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
812 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
813 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
815 Function funcObj = new Function(trans, ques);
816 Result<Void> result = funcObj.delOwner(trans, "test", "test");
817 assertTrue(result.status == 1);
819 retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
820 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
821 result = funcObj.delOwner(trans, "test", "test");
822 assertTrue(result.status == 1);
824 retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
825 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
826 result = funcObj.delOwner(trans, "test", "test");
827 retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
828 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
829 result = funcObj.delOwner(trans, "test", "test");
834 public void testGetAdmins() {
835 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
836 // NsDAO.Data dataObj = new NsDAO.Data();
838 // dataAl.add(dataObj);
839 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
840 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
842 // Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
843 // Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
845 Function funcObj = new Function(trans, ques);
846 Result<List<String>> result = funcObj.getAdmins(trans, "test", false);
847 assertTrue(result.status == 1);
852 public void testDelAdmin() {
853 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
854 Mockito.doReturn(retVal).when(userRoleDAO).readUserInRole(Mockito.any(), Mockito.anyString(), Mockito.anyString());
855 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
857 NsDAO.Data data = new NsDAO.Data();
859 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
860 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
862 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
863 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
865 Function funcObj = new Function(trans, ques);
866 Result<Void> result = funcObj.delAdmin(trans, "test", "test");
867 assertTrue(result.status == 1);
869 retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
870 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
871 result = funcObj.delAdmin(trans, "test", "test");
872 assertTrue(result.status == 1);
874 retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
875 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
876 result = funcObj.delOwner(trans, "test", "test");
877 retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
878 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
879 result = funcObj.delAdmin(trans, "test", "test");
884 public void testMovePerms() {
885 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
886 // NsDAO.Data dataObj = new NsDAO.Data();
888 // dataAl.add(dataObj);
889 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
890 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
892 Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
894 Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
896 NsDAO.Data nsDataObj = new NsDAO.Data();
897 nsDataObj.name="test";
898 StringBuilder sb = new StringBuilder();
899 Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",NO_PARAM);
901 invokeMovePerms(nsDataObj, sb, retVal1);
903 List<PermDAO.Data> dataObj5 = new ArrayList<>();
904 PermDAO.Data indData5 = new PermDAO.Data();
905 indData5.ns = "test";
906 indData5.type = "test";
907 Set<String> rolesSet = new HashSet<>();
908 rolesSet.add("testRole");
909 indData5.roles = rolesSet;
910 dataObj5.add(indData5);
911 indData5 = new PermDAO.Data();
912 indData5.ns = "test";
913 indData5.type = "access";
914 dataObj5.add(indData5);
915 retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
917 Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
918 Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());
919 Mockito.doReturn(retVal3).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
921 NsSplit splitObj = new NsSplit("test", "test");
922 Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
923 Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
925 invokeMovePerms(nsDataObj, sb, retVal1);
927 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
928 Mockito.doReturn(retVal4).when(permDAO).create(Mockito.any(), Mockito.any());
929 invokeMovePerms(nsDataObj, sb, retVal1);
931 Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());
932 Mockito.doReturn(retVal4).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
933 invokeMovePerms(nsDataObj, sb, retVal1);
937 private void invokeMovePerms(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<PermDAO.Data>> retVal1) {
938 Function funcObj = new Function(trans, ques);
941 met = Function.class.getDeclaredMethod("movePerms", AuthzTrans.class, NsDAO.Data.class, StringBuilder.class, Result.class);
942 met.setAccessible(true);
943 met.invoke(funcObj, trans, nsDataObj, sb, retVal1);
944 } catch (NoSuchMethodException | SecurityException e) {
945 // TODO Auto-generated catch block
947 } catch (IllegalAccessException e) {
948 // TODO Auto-generated catch block
950 } catch (IllegalArgumentException e) {
951 // TODO Auto-generated catch block
953 } catch (InvocationTargetException e) {
954 // TODO Auto-generated catch block
960 public void testMoveRoles() {
961 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
962 // NsDAO.Data dataObj = new NsDAO.Data();
964 // dataAl.add(dataObj);
965 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
966 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
968 Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
970 Mockito.doReturn(retVal).when(roleDAO).create(Mockito.any(), Mockito.any());
972 NsDAO.Data nsDataObj = new NsDAO.Data();
973 nsDataObj.name="test";
974 StringBuilder sb = new StringBuilder();
975 Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",NO_PARAM);
977 invokeMoveRoles(nsDataObj, sb, retVal1);
979 List<RoleDAO.Data> dataObj5 = new ArrayList<>();
980 RoleDAO.Data indData5 = new RoleDAO.Data();
981 indData5.ns = "test";
982 indData5.name = "test";
983 Set<String> rolesSet = new HashSet<>();
984 rolesSet.add("testRole");
985 indData5.perms = rolesSet;
986 dataObj5.add(indData5);
987 indData5 = new RoleDAO.Data();
988 indData5.ns = "test";
989 indData5.name = "admin";
990 dataObj5.add(indData5);
991 retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",NO_PARAM);
993 Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
994 Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());
995 Mockito.doReturn(retVal3).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
997 NsSplit splitObj = new NsSplit("test", "test");
998 Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
999 Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1001 invokeMoveRoles(nsDataObj, sb, retVal1);
1003 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1004 Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(), Mockito.any());
1005 invokeMoveRoles(nsDataObj, sb, retVal1);
1007 Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());
1008 Mockito.doReturn(retVal4).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
1009 invokeMoveRoles(nsDataObj, sb, retVal1);
1013 private void invokeMoveRoles(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<RoleDAO.Data>> retVal1) {
1014 Function funcObj = new Function(trans, ques);
1017 met = Function.class.getDeclaredMethod("moveRoles", AuthzTrans.class, NsDAO.Data.class, StringBuilder.class, Result.class);
1018 met.setAccessible(true);
1019 met.invoke(funcObj, trans, nsDataObj, sb, retVal1);
1020 } catch (NoSuchMethodException | SecurityException e) {
1021 // TODO Auto-generated catch block
1022 e.printStackTrace();
1023 } catch (IllegalAccessException e) {
1024 // TODO Auto-generated catch block
1025 e.printStackTrace();
1026 } catch (IllegalArgumentException e) {
1027 // TODO Auto-generated catch block
1028 e.printStackTrace();
1029 } catch (InvocationTargetException e) {
1030 // TODO Auto-generated catch block
1031 e.printStackTrace();
1036 public void testCreatePerm() {
1039 } catch (CadiException e) {
1040 // TODO Auto-generated catch block
1041 e.printStackTrace();
1043 List<PermDAO.Data> dataAl = new ArrayList<PermDAO.Data>();
1044 PermDAO.Data perm = new PermDAO.Data();
1045 Set<String> rolesSet = new HashSet<>();
1046 rolesSet.add("testRole");
1047 perm.roles = rolesSet;
1050 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1051 Mockito.doReturn(retVal).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1053 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1054 Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1056 Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
1057 Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
1059 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
1060 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1062 Function funcObj = new Function(trans, ques);
1063 Result<Void> result = funcObj.createPerm(trans, perm, false);
1064 assertTrue(result.status == 1);
1066 retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1067 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1068 result = funcObj.createPerm(trans, perm, false);
1069 assertTrue(result.status == 1);
1071 NsSplit nsObj = new NsSplit("test","test");
1072 Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
1073 Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1074 Mockito.doReturn(retVal2).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
1075 Result<List<RoleDAO.Data>> retVal3 = Result.ok(new ArrayList<>());
1076 Mockito.doReturn(retVal3).when(roleDAO).read(Mockito.any(),Mockito.any(RoleDAO.Data.class));
1077 Result<List<RoleDAO.Data>> retVal4 = Result.err(Result.ERR_NotFound,"");
1078 Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(),Mockito.any(RoleDAO.Data.class));
1079 result = funcObj.createPerm(trans, perm, false);
1081 Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
1082 result = funcObj.createPerm(trans, perm, true);
1083 assertTrue(result.status == 1);
1085 Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
1086 result = funcObj.createPerm(trans, perm, true);
1087 assertTrue(result.status == 0);
1089 Mockito.doReturn(false).when(trans).requested(REQD_TYPE.force);
1090 Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
1091 Mockito.doReturn(retVal1).when(permDAO).read(trans, perm);
1092 result = funcObj.createPerm(trans, perm, true);
1093 assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
1097 public void testDeletePerm() {
1100 } catch (CadiException e) {
1101 // TODO Auto-generated catch block
1102 e.printStackTrace();
1104 List<PermDAO.Data> dataAl = new ArrayList<PermDAO.Data>();
1105 PermDAO.Data perm = new PermDAO.Data();
1106 Set<String> rolesSet = new HashSet<>();
1107 rolesSet.add("testRole");
1108 perm.roles = rolesSet;
1112 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
1113 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1115 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1116 // NsDAO.Data dataObj = new NsDAO.Data();
1118 // dataAl.add(dataObj);
1119 Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",NO_PARAM);
1120 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1122 Function funcObj = new Function(trans, ques);
1123 Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
1124 assertTrue(result.status == 1);
1126 // Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1127 Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
1129 result = funcObj.deletePerm(trans, perm, true,true);
1130 assertTrue(result.status == Status.ERR_PermissionNotFound);
1132 retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1133 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1134 Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
1135 Mockito.doReturn(retVal3).when(permDAO).read(trans, perm);
1137 NsSplit nsObj = new NsSplit("test","test");
1138 Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
1139 Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1141 Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1143 result = funcObj.deletePerm(trans, perm, true,false);
1146 Mockito.doReturn(retVal2).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1147 result = funcObj.deletePerm(trans, perm, true,false);
1150 result = funcObj.deletePerm(trans, perm, false,false);
1151 // assertTrue(result.status == 1);
1155 public void testDeleteRole() {
1158 } catch (CadiException e) {
1159 // TODO Auto-generated catch block
1160 e.printStackTrace();
1163 List<UserRoleDAO.Data> dataAlUser = new ArrayList<UserRoleDAO.Data>();
1164 UserRoleDAO.Data roleUser = new UserRoleDAO.Data();
1165 Set<String> rolesSetUser = new HashSet<>();
1166 rolesSetUser.add("testRole|test|test");
1167 // perm.roles = rolesSet;
1169 dataAlUser.add(roleUser);
1171 List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
1172 RoleDAO.Data role = new RoleDAO.Data();
1173 Set<String> rolesSet = new HashSet<>();
1174 rolesSet.add("testRole|test|test");
1175 role.perms = rolesSet;
1176 // perm.roles = rolesSet;
1180 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
1181 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
1183 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1184 // NsDAO.Data dataObj = new NsDAO.Data();
1186 // dataAl.add(dataObj);
1187 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1188 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1190 // Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1191 // Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
1193 Function funcObj = new Function(trans, ques);
1194 Result<Void> result = funcObj.deleteRole(trans, role, true, false);
1195 assertTrue(result.status == 1);
1197 Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
1198 Mockito.doReturn(retVal1).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1199 NsSplit splitObj = new NsSplit("test", "test");
1200 Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
1201 Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1202 // Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1203 Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
1204 result = funcObj.deleteRole(trans, role, true, true);
1207 Mockito.doReturn(retVal1).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
1208 result = funcObj.deleteRole(trans, role, true, true);
1211 Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1212 result = funcObj.deleteRole(trans, role, true, true);
1213 assertTrue(result.status == Status.ERR_RoleNotFound);
1215 retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",NO_PARAM);
1216 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1217 result = funcObj.deleteRole(trans, role, false, true);
1218 assertTrue(result.status == Status.ERR_DependencyExists);
1222 public void testAddPermToRole() {
1223 List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
1224 PermDAO.Data rolePerm = new PermDAO.Data();
1225 Set<String> rolesSetUser = new HashSet<>();
1226 rolesSetUser.add("testRole|test|test");
1227 // perm.roles = rolesSet;
1229 dataAlPerm.add(rolePerm);
1231 List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
1232 RoleDAO.Data role = new RoleDAO.Data();
1233 Set<String> rolesSet = new HashSet<>();
1234 rolesSet.add("17623");
1235 role.perms = rolesSet;
1236 // perm.roles = rolesSet;
1240 NsDAO.Data nsObj = new NsDAO.Data();
1242 NsDAO.Data nsObj1 = new NsDAO.Data();
1243 nsObj1.name="test12";
1245 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1246 // NsDAO.Data dataObj = new NsDAO.Data();
1248 // dataAl.add(dataObj);
1249 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1250 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1252 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
1253 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1254 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1256 Result<NsDAO.Data> retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
1257 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
1258 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
1260 Function funcObj = new Function(trans, ques);
1261 Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
1262 assertTrue(result.status == 1);
1264 retVal2 = new Result<NsDAO.Data>(nsObj,1,"test",NO_PARAM);
1265 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1266 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1267 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1268 assertTrue(result.status == 1);
1271 retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
1272 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1273 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1274 assertTrue(result.status == 1);
1276 retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
1277 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1278 Result<NsDAO.Data> retVal21 = new Result<NsDAO.Data>(nsObj1,0,"test1",NO_PARAM);
1279 Mockito.doReturn(retVal21).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1280 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1281 assertTrue(result.status == 1);
1283 retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1284 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
1285 retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
1286 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1287 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1289 // Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1290 Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1292 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1293 assertTrue(result.status == Status.ERR_PermissionNotFound);
1295 Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",NO_PARAM);
1296 Mockito.doReturn(retValPerm).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1298 Mockito.doReturn(retVal3).when(roleDAO).read(trans, role);
1300 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1301 assertTrue(result.status == 22);
1303 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1304 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1305 assertTrue(result.status == 2);
1307 retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1308 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
1309 Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
1310 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1311 // System.out.println(result.status);
1314 retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
1315 Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
1316 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1317 assertTrue(result.status == 1);
1319 Result<List<RoleDAO.Data>> retVal31 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
1320 Mockito.doReturn(retVal31).when(roleDAO).read(trans, role);
1321 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1322 assertTrue(result.status == 7);
1326 public void testDelPermFromRole() {
1327 List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
1328 PermDAO.Data rolePerm = new PermDAO.Data();
1329 Set<String> rolesSetUser = new HashSet<>();
1330 rolesSetUser.add("testRole|test|test");
1331 // perm.roles = rolesSet;
1333 dataAlPerm.add(rolePerm);
1335 List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
1336 RoleDAO.Data role = new RoleDAO.Data();
1337 Set<String> rolesSet = new HashSet<>();
1338 rolesSet.add("17623");
1339 role.perms = rolesSet;
1342 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1343 // NsDAO.Data dataObj = new NsDAO.Data();
1345 // dataAl.add(dataObj);
1346 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1347 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1349 Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
1350 Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1351 Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
1352 Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,role, Access.write);
1354 Function funcObj = new Function(trans, ques);
1355 Result<Void> result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1356 assertTrue(result.status == Status.ERR_Denied);
1358 Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
1359 Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);
1361 Mockito.doReturn(retValFail).when(roleDAO).read(trans, role);
1363 Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1365 result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1366 assertTrue(result.status == 1);
1368 Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",NO_PARAM);
1369 Mockito.doReturn(retValPermSuc).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1370 result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1371 assertTrue(result.status == 1);
1373 Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
1374 Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1375 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1376 assertTrue(result.status == Status.ERR_PermissionNotFound);
1380 rolesSet.add("null|null|null|null");
1381 role.perms = rolesSet;
1383 Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1384 Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
1385 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1386 assertTrue(result.status == 1);
1388 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1389 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1390 assertTrue(result.status == 1);
1392 Mockito.doReturn(retValRoleSuc).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
1393 Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
1394 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1395 assertTrue(result.status == 1);
1397 Mockito.doReturn(retValPermSuc).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
1398 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1399 assertTrue(result.status == 0);
1401 Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1402 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1403 assertTrue(result.status == 0);
1405 Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
1406 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1407 assertTrue(result.status == 1);
1409 NsSplit splitObj = new NsSplit("test", "test");
1410 Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
1411 Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1412 Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
1413 Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(PermDAO.Data.class), Mockito.any());
1414 result = funcObj.delPermFromRole(trans, "test", rolePerm);
1415 assertTrue(result.status == 2);
1417 retVal3 = new Result<NsSplit>(null,1,"test",NO_PARAM);
1418 Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1419 result = funcObj.delPermFromRole(trans, "test", rolePerm);
1420 assertTrue(result.status == 1);
1423 public void testAddUserRole() {
1424 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1425 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1427 urData.rname="test";
1429 urDataAl.add(urData);
1431 Organization org = Mockito.mock(Organization.class);
1432 Mockito.doReturn(org).when(trans).org();
1433 Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
1435 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1436 Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
1437 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1438 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1439 Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1440 Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1442 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",NO_PARAM);
1443 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
1445 Function funcObj = new Function(trans, ques);
1446 Result<Void> result = funcObj.addUserRole(trans, urData);
1447 assertTrue(result.status == 1);
1449 urData.rname=Question.ADMIN;
1450 result = funcObj.addUserRole(trans, urData);
1451 assertTrue(result.status == 1);
1453 NsDAO.Data data = new NsDAO.Data();
1455 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
1456 Mockito.doReturn(retVal1).when(ques).mayUser(trans, null,retVal1.value, Access.write);
1457 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1459 Mockito.doReturn(Mockito.mock(Identity.class)).when(org).getIdentity(trans, "test");
1460 } catch (OrganizationException e) {
1461 // TODO Auto-generated catch block
1462 e.printStackTrace();
1464 urData.rname=Question.OWNER;
1465 result = funcObj.addUserRole(trans, urData);
1466 assertTrue(result.status == 1);
1468 Mockito.doReturn(retValSuc).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1469 result = funcObj.addUserRole(trans, urData);
1470 assertTrue(result.status == 0);
1472 Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1473 result = funcObj.addUserRole(trans, urData);
1474 assertTrue(result.status == Status.ERR_RoleNotFound);
1476 Mockito.doReturn(retValSuc).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1477 result = funcObj.addUserRole(trans, urData);
1478 assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
1480 result = funcObj.addUserRole(trans, "test", "test", "test");
1481 assertTrue(result.status == 1);
1484 Mockito.doReturn(null).when(org).getIdentity(trans, "test");
1485 } catch (OrganizationException e) {
1486 // TODO Auto-generated catch block
1487 e.printStackTrace();
1489 result = funcObj.addUserRole(trans, "test", "test", "test");
1490 assertTrue(result.status == Result.ERR_BadData);
1493 Mockito.doThrow(OrganizationException.class).when(org).getIdentity(trans, "test");
1494 } catch (OrganizationException e) {
1495 // TODO Auto-generated catch block
1496 e.printStackTrace();
1498 result = funcObj.addUserRole(trans, "test", "test", "test");
1499 assertTrue(result.status == 20);
1503 public void testExtendUserRole() {
1504 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1505 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1507 urData.rname="test";
1509 urData.expires=new Date();
1510 urDataAl.add(urData);
1512 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1513 // NsDAO.Data dataObj = new NsDAO.Data();
1515 // dataAl.add(dataObj);
1516 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1517 Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
1518 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1519 Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1521 Organization org = Mockito.mock(Organization.class);
1522 Mockito.doReturn(org).when(trans).org();
1523 Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any());
1525 Function funcObj = new Function(trans, ques);
1526 Result<Void> result = funcObj.extendUserRole(trans, urData, false);
1529 Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1530 Mockito.doReturn(retValSuc).when(userRoleDAO).read(trans, urData);
1531 result = funcObj.extendUserRole(trans, urData, true);
1532 assertTrue(result.status == Status.ERR_RoleNotFound);
1534 Mockito.doReturn(retVal).when(userRoleDAO).read(trans, urData);
1535 result = funcObj.extendUserRole(trans, urData, true);
1536 assertTrue(result.status == Status.ERR_UserRoleNotFound);
1539 @SuppressWarnings("deprecation")
1541 public void testGetUsersByRole() {
1542 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1543 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1545 urData.rname="test";
1547 urData.expires=new Date();
1548 urDataAl.add(urData);
1549 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
1550 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1552 Function funcObj = new Function(trans, ques);
1553 Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
1554 assertTrue(result.status == 0);
1556 result = funcObj.getUsersByRole(trans, "test", true);
1557 assertTrue(result.status == 0);
1559 urData.expires=new Date(130,1,1);
1560 result = funcObj.getUsersByRole(trans, "test", true);
1561 assertTrue(result.status == 0);
1565 public void testDelUserRole() {
1566 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1567 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1569 urData.rname="test";
1571 urData.expires=new Date();
1572 urDataAl.add(urData);
1573 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
1574 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
1576 Function funcObj = new Function(trans, ques);
1577 Result<Void> result = funcObj.delUserRole(trans, "test", "test", "test");
1580 retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
1581 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
1582 result = funcObj.delUserRole(trans, "test", "test", "test");
1583 // assertTrue(result.status ==1);
1588 public void testCreateFuture() {
1589 FutureDAO.Data data = new FutureDAO.Data();
1591 NsDAO.Data nsd = new NsDAO.Data();
1594 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1595 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1597 urData.rname="test";
1599 urData.expires=new Date();
1600 urDataAl.add(urData);
1601 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
1602 Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
1603 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
1605 Function funcObj = new Function(trans, ques);
1606 Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
1607 assertTrue(result.status == 20);
1609 Identity iden=Mockito.mock(Identity.class);
1611 Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
1612 Mockito.doReturn("test").when(iden).mayOwn();
1613 } catch (OrganizationException e) {
1614 // TODO Auto-generated catch block
1615 e.printStackTrace();
1617 FutureDAO.Data futureData = new FutureDAO.Data();
1619 Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
1620 Mockito.doReturn(retValFuture).when(futureDAO).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
1622 ApprovalDAO.Data approvalData = new ApprovalDAO.Data();
1624 Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",NO_PARAM);
1625 Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
1627 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1628 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
1629 assertTrue(result.status == 0);
1631 result = funcObj.createFuture(trans, data, "test", "test", null, FUTURE_OP.A);
1632 assertTrue(result.status == 20);
1634 Mockito.doReturn(retValFail).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1635 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
1636 assertTrue(result.status == Result.ERR_NotFound);
1638 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1640 Mockito.doReturn(null).when(org).getIdentity(trans, "test");
1641 } catch (OrganizationException e) {
1642 // TODO Auto-generated catch block
1643 e.printStackTrace();
1645 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
1646 assertTrue(result.status == Result.ERR_NotFound);
1649 Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
1650 } catch (OrganizationException e) {
1651 // TODO Auto-generated catch block
1652 e.printStackTrace();
1654 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
1655 assertTrue(result.status == 0);
1657 retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",NO_PARAM);
1658 Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
1659 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
1660 assertTrue(result.status == 8);
1663 public void testUbLookup() {
1664 Object[] objArr = new Object[10];
1665 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1666 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1668 urData.rname="test";
1670 urData.expires=new Date();
1671 urDataAl.add(urData);
1672 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
1673 Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1674 Mockito.doReturn(retVal).when(userRoleDAO).read(trans, objArr);
1676 Function funcObj = new Function(trans, ques);
1677 funcObj.urDBLookup.get(trans, objArr);
1679 Mockito.doReturn(retValFail).when(userRoleDAO).read(trans, objArr);
1680 funcObj.urDBLookup.get(trans, objArr);
1684 public void testPerformFutureOp() {
1685 FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
1686 futureDataDaoObj.memo="test";
1687 futureDataDaoObj.target = "test";
1688 futureDataDaoObj.id = new UUID(10L,10L);
1690 final List<ApprovalDAO.Data> apprs = new ArrayList<>();
1691 ApprovalDAO.Data approvalObj = new ApprovalDAO.Data();
1692 approvalObj.status = "approved";
1693 approvalObj.type = "owner";
1694 apprs.add(approvalObj);
1695 Lookup<List<ApprovalDAO.Data>> lookupApprovalObj = new Lookup<List<ApprovalDAO.Data>>() {
1697 public List<ApprovalDAO.Data> get(AuthzTrans trans, Object ... keys) {
1702 final UserRoleDAO.Data userObj = new UserRoleDAO.Data();
1703 Lookup<UserRoleDAO.Data> lookupUserObj = new Lookup<UserRoleDAO.Data>() {
1705 public UserRoleDAO.Data get(AuthzTrans trans, Object ... keys) {
1710 FutureDAO.Data futureData = new FutureDAO.Data();
1711 // data.memo = "test";
1712 Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
1713 Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
1715 // List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1716 // NsDAO.Data dataObj = new NsDAO.Data();
1718 // dataAl.add(dataObj);
1719 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
1720 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1722 // Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
1723 // Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
1725 Function funcObj = new Function(trans, ques);
1726 Result<Function.OP_STATUS> result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1727 assertTrue(result.status == 0);
1729 approvalObj.status = "approved";
1730 approvalObj.type = "supervisor";
1731 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1732 assertTrue(result.status == 0);
1734 approvalObj.status = "approved";
1735 approvalObj.type = "";
1736 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1737 assertTrue(result.status == 0);
1739 approvalObj.status = "pending";
1740 approvalObj.type = "supervisor";
1741 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1742 assertTrue(result.status == 0);
1744 approvalObj.status = "pending";
1745 approvalObj.type = "owner";
1746 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1747 assertTrue(result.status == 0);
1749 approvalObj.status = "pending";
1750 approvalObj.type = "";
1751 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1752 assertTrue(result.status == 0);
1754 approvalObj.status = "denied";
1755 approvalObj.type = "";
1756 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1757 assertTrue(result.status == 0);
1759 retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",NO_PARAM);
1760 Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
1761 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1762 System.out.println(result);
1763 assertTrue(result.status == 0);