auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/hl/JU_Function.java

   1 /*******************************************************************************
   2  * ============LICENSE_START====================================================
   3  * * org.onap.aaf
   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
  10  * *
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0
  12  * *
  13  *  * Unless required by applicable law or agreed to in writing, software
  14  * * distributed under the License is distributed on an "AS IS" BASIS,
  15  * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * * See the License for the specific language governing permissions and
  17  * * limitations under the License.
  18  * * ============LICENSE_END====================================================
  19  * *
  20  * *
  21  ******************************************************************************/
  22
  23 package org.onap.aaf.auth.dao.hl;
  24
  25 import static org.junit.Assert.assertNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.mockito.MockitoAnnotations.initMocks;
  28
  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;
  41 import java.util.Set;
  42 import java.util.UUID;
  43
  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;
  80
  81 public class JU_Function {
  82
  83     private static final Object NO_PARAM = new Object[0];
  84
  85     @Mock
  86     AuthzTrans trans;
  87     @Mock
  88     PropAccess access;
  89
  90     @Mock
  91     Question ques;
  92
  93     @Mock
  94     Organization org;
  95
  96     @Mock
  97     CachedNSDAO nsDAO;
  98
  99     @Mock
 100     CachedRoleDAO roleDAO;
 101
 102     @Mock
 103     CachedPermDAO permDAO;
 104
 105     @Mock
 106     CachedCredDAO credDAO;
 107
 108     @Mock
 109     CachedUserRoleDAO userRoleDAO;
 110
 111     @Mock
 112     ApprovalDAO approvalDAO;
 113
 114     @Mock
 115     FutureDAO futureDAO;
 116
 117     @Before
 118     public void setUp() throws APIException, IOException {
 119         initMocks(this);
 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();
 128
 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");
 134
 135         try {
 136             Define.set(access);
 137         } catch (CadiException e) {
 138         }
 139     }
 140
 141     @Test
 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;
 147
 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");
 150
 151         NsDAO.Data data = new NsDAO.Data();
 152         data.name="test";
 153         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 154         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 155
 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);
 159
 160         Function funcObj = new Function(trans, ques);
 161         Result<Void>  result = funcObj.createNS(trans, namespace, true);
 162         assertTrue(3 == result.status);
 163     }
 164
 165     @Test
 166     public void testCreateNsReadSuccess() {
 167         Namespace namespace = Mockito.mock(Namespace.class);
 168         namespace.name = "test.test";
 169         List<String> owner = new ArrayList<String>();
 170         owner.add("test");
 171         namespace.owner = owner;
 172         List<String> admin = new ArrayList<String>();
 173         admin.add("test");
 174         namespace.admin= admin;
 175
 176         Organization org = Mockito.mock(Organization.class);
 177         Mockito.doReturn(org).when(trans).org();
 178
 179         NsDAO.Data data = new NsDAO.Data();
 180         data.name="test";
 181         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 182         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 183
 184         Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
 185         Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
 186
 187         Function funcObj = new Function(trans, ques);
 188         Result<Void>  result = funcObj.createNS(trans, namespace, true);
 189         assertTrue(3 == result.status);
 190     }
 191
 192     @Test
 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;
 198
 199         Organization org = Mockito.mock(Organization.class);
 200         Mockito.doReturn(org).when(trans).org();
 201
 202         NsDAO.Data data = new NsDAO.Data();
 203         data.name="test";
 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);
 208
 209         Function funcObj = new Function(trans, ques);
 210         Result<Void>  result = funcObj.createNS(trans, namespace, false);
 211         assertTrue(1 == result.status);
 212
 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);
 217     }
 218
 219     @Test
 220     public void testCreateNsownerLoop() {
 221         Namespace namespace = Mockito.mock(Namespace.class);
 222         namespace.name = "test.test";
 223         List<String> owner = new ArrayList<String>();
 224         owner.add("test");
 225         namespace.owner = owner;
 226
 227         Organization org = Mockito.mock(Organization.class);
 228         Mockito.doReturn(org).when(trans).org();
 229         Mockito.doReturn(org).when(trans).org();
 230
 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"));
 235
 236         Identity iden=Mockito.mock(Identity.class);
 237         try {
 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
 242             e.printStackTrace();
 243         }
 244         result = funcObj.createNS(trans, namespace, true);
 245         assertTrue(result.status == Status.ERR_Policy);
 246         assertTrue(result.details.contains("is an invalid Identity"));
 247
 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 "));
 252
 253         Mockito.doReturn(true).when(org).isTestEnv();
 254         try {
 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
 261             e.printStackTrace();
 262         }
 263     }
 264
 265     @Test
 266     public void testCreateNsownerLoopException() {
 267         Namespace namespace = Mockito.mock(Namespace.class);
 268         namespace.name = "test";
 269         List<String> owner = new ArrayList<String>();
 270         owner.add("test");
 271         namespace.owner = owner;
 272
 273         Organization org = Mockito.mock(Organization.class);
 274         Mockito.doReturn(org).when(trans).org();
 275
 276         Function funcObj = new Function(trans, ques);
 277
 278         Identity iden=Mockito.mock(Identity.class);
 279         try {
 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
 284             e.printStackTrace();
 285         }
 286
 287         NsDAO.Data data = new NsDAO.Data();
 288         data.name="test";
 289         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 290         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 291
 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"));
 295
 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);
 299
 300         Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
 301         Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
 302
 303         result = funcObj.createNS(trans, namespace, true);
 304         assertTrue(24 == result.status);
 305
 306     }
 307
 308     @Test
 309     public void testCreateNsAdminLoop() {
 310         Namespace namespace = Mockito.mock(Namespace.class);
 311         namespace.name = "test.test";
 312         List<String> owner = new ArrayList<String>();
 313         owner.add("test");
 314         namespace.owner = owner;
 315         namespace.admin = owner;
 316
 317         Organization org = Mockito.mock(Organization.class);
 318         Mockito.doReturn(org).when(trans).org();
 319
 320         NsDAO.Data data = new NsDAO.Data();
 321         data.name="test";
 322         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 323         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 324
 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();
 330         indData.id = "test";
 331         indData.notes = "test";
 332         DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
 333         try {
 334             indData.expires = sdf.parse("2090/01/01");
 335         } catch (ParseException e1) {
 336             // TODO Auto-generated catch block
 337             e1.printStackTrace();
 338         }
 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());
 342
 343         Identity iden=Mockito.mock(Identity.class);
 344         try {
 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
 350             e.printStackTrace();
 351         }
 352
 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");
 355
 356         Function funcObj = new Function(trans, ques);
 357         Result<Void>  result = funcObj.createNS(trans, namespace, true);
 358         assertTrue(result.status == 1);
 359
 360     }
 361
 362     @Test
 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");
 368         try {
 369             Define.set(access);
 370         } catch (CadiException e) {
 371             // TODO Auto-generated catch block
 372             e.printStackTrace();
 373         }
 374         Namespace namespace = Mockito.mock(Namespace.class);
 375         namespace.name = "test.test";
 376         List<String> owner = new ArrayList<String>();
 377         owner.add("test");
 378         namespace.owner = owner;
 379         namespace.admin = owner;
 380
 381         Organization org = Mockito.mock(Organization.class);
 382         Mockito.doReturn(org).when(trans).org();
 383
 384         NsDAO.Data data = new NsDAO.Data();
 385         data.name="test";
 386         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 387         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 388
 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();
 394         indData.id = "test";
 395         indData.notes = "test";
 396         DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
 397         try {
 398             indData.expires = sdf.parse("2090/01/01");
 399         } catch (ParseException e1) {
 400             // TODO Auto-generated catch block
 401             e1.printStackTrace();
 402         }
 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);
 412
 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);
 418
 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);
 424
 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");
 439
 440         Identity iden=Mockito.mock(Identity.class);
 441         try {
 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
 448             e.printStackTrace();
 449         }
 450
 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");
 454
 455         Result<Void>  result = funcObj.createNS(trans, namespace, true);
 456         assertTrue(result.status == Status.ERR_ActionNotCompleted);
 457
 458     }
 459
 460     @Test
 461     public void testCreateNsAdminLoopCreateSuc() {
 462         Namespace namespace = Mockito.mock(Namespace.class);
 463         namespace.name = "test.test";
 464         List<String> owner = new ArrayList<String>();
 465         owner.add("test");
 466         namespace.owner = owner;
 467         namespace.admin = owner;
 468
 469         Organization org = Mockito.mock(Organization.class);
 470         Mockito.doReturn(org).when(trans).org();
 471
 472         NsDAO.Data data = new NsDAO.Data();
 473         data.name="test";
 474         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 475         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 476
 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();
 482         indData.id = "test";
 483         indData.notes = "test";
 484         DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
 485         try {
 486             indData.expires = sdf.parse("2090/01/01");
 487         } catch (ParseException e1) {
 488             // TODO Auto-generated catch block
 489             e1.printStackTrace();
 490         }
 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);
 500
 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);
 506
 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);
 515
 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");
 529
 530         Identity iden=Mockito.mock(Identity.class);
 531         try {
 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
 538             e.printStackTrace();
 539         }
 540
 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");
 543
 544         Function funcObj = new Function(trans, ques);
 545         Result<Void>  result = funcObj.createNS(trans, namespace, true);
 546         assertTrue(result.status == 0);
 547
 548     }
 549
 550     @Test
 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());
 554
 555         Function funcObj = new Function(trans, ques);
 556         Result<Void> result = funcObj.deleteNS(trans, "test");
 557
 558         assertTrue(result.status == Status.ERR_NsNotFound);
 559     }
 560
 561     @Test
 562     public void test4DeleteCanMoveFail() {
 563         List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 564         NsDAO.Data dataObj = new NsDAO.Data();
 565         dataObj.type=1;
 566         dataAl.add(dataObj);
 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());
 569
 570         Mockito.doReturn(false).when(ques).canMove(Mockito.any());
 571         Mockito.doReturn(retVal).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 572
 573         Function funcObj = new Function(trans, ques);
 574         Result<Void> result = funcObj.deleteNS(trans, "test");
 575         assertTrue(result.status == Status.ERR_Security);
 576
 577     }
 578
 579     @Test
 580     public void test4DeleteNsReadSuc() {
 581         List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 582         NsDAO.Data dataObj = new NsDAO.Data();
 583         dataObj.type=1;
 584         dataAl.add(dataObj);
 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());
 587
 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);
 590
 591         Function funcObj = new Function(trans, ques);
 592         Result<Void> result = funcObj.deleteNS(trans, "test");
 593         assertTrue(result.status == 1);
 594
 595     }
 596
 597     @Test
 598     public void test4DeleteNsMayUserSuc() {
 599         List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 600         NsDAO.Data dataObj = new NsDAO.Data();
 601         dataObj.type=1;
 602         dataAl.add(dataObj);
 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());
 605
 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);
 608
 609         Function funcObj = new Function(trans, ques);
 610         Result<Void> result = funcObj.deleteNS(trans, "test");
 611         assertTrue(result.status == 1);
 612
 613         Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 614
 615         Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
 616
 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");
 619
 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");
 627
 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);
 639
 640         funcObj = new Function(trans, ques);
 641         result = funcObj.deleteNS(trans, "test");
 642         assertTrue(result.status == Status.ERR_DependencyExists);
 643
 644         Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
 645
 646         Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
 647         funcObj = new Function(trans, ques);
 648         result = funcObj.deleteNS(trans, "test");
 649         assertNull(result);
 650     }
 651     @Test
 652     public void test4DeleteNsDrivensFailure() {
 653         List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 654         NsDAO.Data dataObj = new NsDAO.Data();
 655         dataObj.type=1;
 656         dataAl.add(dataObj);
 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());
 659
 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);
 662
 663         Function funcObj = new Function(trans, ques);
 664         Result<Void> result = funcObj.deleteNS(trans, "test");
 665         assertTrue(result.status == 1);
 666
 667         Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 668
 669         Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
 670
 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);
 680
 681
 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);
 694
 695         funcObj = new Function(trans, ques);
 696         result = funcObj.deleteNS(trans, "test");
 697         assertTrue(result.status == Status.ERR_DependencyExists);
 698
 699         NsDAO.Data data = new NsDAO.Data();
 700         data.name="test";
 701         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
 702         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 703
 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);
 708     }
 709
 710     @Test
 711     public void test4DeleteNsWithDot() {
 712         List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 713         NsDAO.Data dataObj = new NsDAO.Data();
 714         dataObj.type=1;
 715         dataAl.add(dataObj);
 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());
 718
 719         List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
 720         CredDAO.Data nsData = new CredDAO.Data();
 721         nsData.id="test";
 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);
 726
 727         Function funcObj = new Function(trans, ques);
 728         Result<Void> result = funcObj.deleteNS(trans, "test");
 729         assertTrue(result.status == 1);
 730
 731         Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 732
 733         Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
 734         Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
 735
 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);
 745
 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());
 754
 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);
 767
 768         funcObj = new Function(trans, ques);
 769         result = funcObj.deleteNS(trans, "test");
 770         assertTrue(result.status == Status.ERR_DependencyExists);
 771
 772         NsDAO.Data data = new NsDAO.Data();
 773         data.name="test";
 774         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 775         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 776
 777         Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
 778         funcObj = new Function(trans, ques);
 779         result = funcObj.deleteNS(trans, "test.test");
 780         assertNull(result);
 781     }
 782
 783     @Test
 784     public void testGetOwners() {
 785 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 786 //        NsDAO.Data dataObj = new NsDAO.Data();
 787 //        dataObj.type=1;
 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());
 791 //
 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);
 794 //
 795         Function funcObj = new Function(trans, ques);
 796         Result<List<String>> result = funcObj.getOwners(trans, "test", false);
 797         assertTrue(result.status == 1);
 798 //
 799     }
 800
 801     @Test
 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));
 806
 807         NsDAO.Data data = new NsDAO.Data();
 808         data.name="test";
 809         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 810         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 811
 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);
 814
 815         Function funcObj = new Function(trans, ques);
 816         Result<Void> result = funcObj.delOwner(trans, "test", "test");
 817         assertTrue(result.status == 1);
 818
 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);
 823
 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");
 830 //
 831     }
 832
 833     @Test
 834     public void testGetAdmins() {
 835 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 836 //        NsDAO.Data dataObj = new NsDAO.Data();
 837 //        dataObj.type=1;
 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());
 841 //
 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);
 844 //
 845         Function funcObj = new Function(trans, ques);
 846         Result<List<String>> result = funcObj.getAdmins(trans, "test", false);
 847         assertTrue(result.status == 1);
 848 //
 849     }
 850
 851     @Test
 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));
 856
 857         NsDAO.Data data = new NsDAO.Data();
 858         data.name="test";
 859         Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
 860         Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 861
 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);
 864
 865         Function funcObj = new Function(trans, ques);
 866         Result<Void> result = funcObj.delAdmin(trans, "test", "test");
 867         assertTrue(result.status == 1);
 868
 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);
 873
 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");
 880 //
 881     }
 882
 883     @Test
 884     public void testMovePerms() {
 885 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 886 //        NsDAO.Data dataObj = new NsDAO.Data();
 887 //        dataObj.type=1;
 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());
 891
 892         Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
 893
 894         Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
 895
 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);
 900
 901         invokeMovePerms(nsDataObj, sb, retVal1);
 902
 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);
 916
 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());
 920
 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());
 924
 925         invokeMovePerms(nsDataObj, sb, retVal1);
 926
 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);
 930
 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);
 934
 935     }
 936
 937     private void invokeMovePerms(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<PermDAO.Data>> retVal1) {
 938         Function funcObj = new Function(trans, ques);
 939         Method met;
 940         try {
 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
 946             e.printStackTrace();
 947         } catch (IllegalAccessException e) {
 948             // TODO Auto-generated catch block
 949             e.printStackTrace();
 950         } catch (IllegalArgumentException e) {
 951             // TODO Auto-generated catch block
 952             e.printStackTrace();
 953         } catch (InvocationTargetException e) {
 954             // TODO Auto-generated catch block
 955             e.printStackTrace();
 956         }
 957     }
 958
 959     @Test
 960     public void testMoveRoles() {
 961 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 962 //        NsDAO.Data dataObj = new NsDAO.Data();
 963 //        dataObj.type=1;
 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());
 967
 968         Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
 969
 970         Mockito.doReturn(retVal).when(roleDAO).create(Mockito.any(), Mockito.any());
 971
 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);
 976
 977         invokeMoveRoles(nsDataObj, sb, retVal1);
 978
 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);
 992
 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());
 996
 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());
1000
1001         invokeMoveRoles(nsDataObj, sb, retVal1);
1002
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);
1006
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);
1010
1011     }
1012
1013     private void invokeMoveRoles(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<RoleDAO.Data>> retVal1) {
1014         Function funcObj = new Function(trans, ques);
1015         Method met;
1016         try {
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();
1032         }
1033     }
1034
1035     @Test
1036     public void testCreatePerm() {
1037         try {
1038             Define.set(access);
1039         } catch (CadiException e) {
1040             // TODO Auto-generated catch block
1041             e.printStackTrace();
1042         }
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;
1048 //        perm.type=1
1049         dataAl.add(perm);
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());
1052
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));
1055
1056         Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
1057         Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
1058
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);
1061
1062         Function funcObj = new Function(trans, ques);
1063         Result<Void> result = funcObj.createPerm(trans, perm, false);
1064         assertTrue(result.status == 1);
1065
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);
1070
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);
1080
1081         Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
1082         result = funcObj.createPerm(trans, perm, true);
1083         assertTrue(result.status == 1);
1084
1085         Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
1086         result = funcObj.createPerm(trans, perm, true);
1087         assertTrue(result.status == 0);
1088
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);
1094
1095     }
1096     @Test
1097     public void testDeletePerm() {
1098         try {
1099             Define.set(access);
1100         } catch (CadiException e) {
1101             // TODO Auto-generated catch block
1102             e.printStackTrace();
1103         }
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;
1109 //        perm.type=1
1110         dataAl.add(perm);
1111
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);
1114
1115 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1116 //        NsDAO.Data dataObj = new NsDAO.Data();
1117 //        dataObj.type=1;
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());
1121
1122         Function funcObj = new Function(trans, ques);
1123         Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
1124         assertTrue(result.status == 1);
1125
1126 //        Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1127         Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
1128
1129         result = funcObj.deletePerm(trans, perm, true,true);
1130         assertTrue(result.status == Status.ERR_PermissionNotFound);
1131
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);
1136
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());
1140
1141         Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1142
1143         result = funcObj.deletePerm(trans, perm, true,false);
1144         assertNull(result);
1145
1146         Mockito.doReturn(retVal2).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1147         result = funcObj.deletePerm(trans, perm, true,false);
1148         assertNull(result);
1149
1150         result = funcObj.deletePerm(trans, perm, false,false);
1151 //        assertTrue(result.status == 1);
1152     }
1153
1154     @Test
1155     public void testDeleteRole() {
1156         try {
1157             Define.set(access);
1158         } catch (CadiException e) {
1159             // TODO Auto-generated catch block
1160             e.printStackTrace();
1161         }
1162
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;
1168 //        perm.type=1
1169         dataAlUser.add(roleUser);
1170
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;
1177 //        perm.type=1
1178         dataAl.add(role);
1179
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);
1182
1183 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1184 //        NsDAO.Data dataObj = new NsDAO.Data();
1185 //        dataObj.type=1;
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());
1189 //
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);
1192 //
1193         Function funcObj = new Function(trans, ques);
1194         Result<Void> result = funcObj.deleteRole(trans, role, true, false);
1195         assertTrue(result.status == 1);
1196
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);
1205         assertNull(result);
1206
1207         Mockito.doReturn(retVal1).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
1208         result = funcObj.deleteRole(trans, role, true, true);
1209         assertNull(result);
1210
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);
1214
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);
1219     }
1220
1221     @Test
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;
1228 //        perm.type=1
1229         dataAlPerm.add(rolePerm);
1230
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;
1237 //        perm.type=1
1238         dataAl.add(role);
1239
1240         NsDAO.Data nsObj = new NsDAO.Data();
1241         nsObj.name="test";
1242         NsDAO.Data nsObj1 = new NsDAO.Data();
1243         nsObj1.name="test12";
1244
1245 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1246 //        NsDAO.Data dataObj = new NsDAO.Data();
1247 //        dataObj.type=1;
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());
1251
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);
1255
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);
1259
1260         Function funcObj = new Function(trans, ques);
1261         Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
1262         assertTrue(result.status == 1);
1263
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);
1269
1270         role.ns="test2";
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);
1275
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);
1282
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);
1288
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));
1291
1292         result = funcObj.addPermToRole(trans, role, rolePerm, false);
1293         assertTrue(result.status == Status.ERR_PermissionNotFound);
1294
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));
1297
1298         Mockito.doReturn(retVal3).when(roleDAO).read(trans, role);
1299
1300         result = funcObj.addPermToRole(trans, role, rolePerm, true);
1301         assertTrue(result.status == 22);
1302
1303         Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1304         result = funcObj.addPermToRole(trans, role, rolePerm, true);
1305         assertTrue(result.status == 2);
1306
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);
1312         assertNull(result);
1313
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);
1318
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);
1323     }
1324
1325     @Test
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;
1332 //        perm.type=1
1333         dataAlPerm.add(rolePerm);
1334
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;
1340         dataAl.add(role);
1341
1342 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1343 //        NsDAO.Data dataObj = new NsDAO.Data();
1344 //        dataObj.type=1;
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());
1348
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);
1353
1354         Function funcObj = new Function(trans, ques);
1355         Result<Void> result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1356         assertTrue(result.status == Status.ERR_Denied);
1357
1358         Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
1359         Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);
1360
1361         Mockito.doReturn(retValFail).when(roleDAO).read(trans, role);
1362
1363         Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1364
1365         result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1366         assertTrue(result.status == 1);
1367
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);
1372
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);
1377
1378         role.perms = null;
1379         dataAl.add(role);
1380         rolesSet.add("null|null|null|null");
1381         role.perms = rolesSet;
1382         dataAl.add(role);
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);
1387
1388         Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1389         result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1390         assertTrue(result.status == 1);
1391
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);
1396
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);
1400
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);
1404
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);
1408
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);
1416
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);
1421     }
1422     @Test
1423     public void testAddUserRole() {
1424         List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1425         UserRoleDAO.Data urData = new UserRoleDAO.Data();
1426         urData.ns="test";
1427         urData.rname="test";
1428         urData.user="test";
1429         urDataAl.add(urData);
1430
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());
1434
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());
1441
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());
1444
1445         Function funcObj = new Function(trans, ques);
1446         Result<Void> result = funcObj.addUserRole(trans, urData);
1447         assertTrue(result.status == 1);
1448
1449         urData.rname=Question.ADMIN;
1450         result = funcObj.addUserRole(trans, urData);
1451         assertTrue(result.status == 1);
1452
1453         NsDAO.Data data = new NsDAO.Data();
1454         data.name="test";
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");
1458         try {
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();
1463         }
1464         urData.rname=Question.OWNER;
1465         result = funcObj.addUserRole(trans, urData);
1466         assertTrue(result.status == 1);
1467
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);
1471
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);
1475
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);
1479
1480         result = funcObj.addUserRole(trans, "test", "test", "test");
1481         assertTrue(result.status == 1);
1482
1483         try {
1484             Mockito.doReturn(null).when(org).getIdentity(trans, "test");
1485         } catch (OrganizationException e) {
1486             // TODO Auto-generated catch block
1487             e.printStackTrace();
1488         }
1489         result = funcObj.addUserRole(trans, "test", "test", "test");
1490         assertTrue(result.status == Result.ERR_BadData);
1491
1492         try {
1493             Mockito.doThrow(OrganizationException.class).when(org).getIdentity(trans, "test");
1494         } catch (OrganizationException e) {
1495             // TODO Auto-generated catch block
1496             e.printStackTrace();
1497         }
1498         result = funcObj.addUserRole(trans, "test", "test", "test");
1499         assertTrue(result.status == 20);
1500     }
1501
1502     @Test
1503     public void testExtendUserRole() {
1504         List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1505         UserRoleDAO.Data urData = new UserRoleDAO.Data();
1506         urData.ns="test";
1507         urData.rname="test";
1508         urData.user="test";
1509         urData.expires=new Date();
1510         urDataAl.add(urData);
1511
1512 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1513 //        NsDAO.Data dataObj = new NsDAO.Data();
1514 //        dataObj.type=1;
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());
1520
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());
1524
1525         Function funcObj = new Function(trans, ques);
1526         Result<Void> result = funcObj.extendUserRole(trans, urData, false);
1527         assertNull(result);
1528
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);
1533
1534         Mockito.doReturn(retVal).when(userRoleDAO).read(trans, urData);
1535         result = funcObj.extendUserRole(trans, urData, true);
1536         assertTrue(result.status == Status.ERR_UserRoleNotFound);
1537     }
1538
1539     @SuppressWarnings("deprecation")
1540     @Test
1541     public void testGetUsersByRole() {
1542         List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1543         UserRoleDAO.Data urData = new UserRoleDAO.Data();
1544         urData.ns="test";
1545         urData.rname="test";
1546         urData.user="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());
1551
1552         Function funcObj = new Function(trans, ques);
1553         Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
1554         assertTrue(result.status == 0);
1555
1556         result = funcObj.getUsersByRole(trans, "test", true);
1557         assertTrue(result.status == 0);
1558
1559         urData.expires=new Date(130,1,1);
1560         result = funcObj.getUsersByRole(trans, "test", true);
1561         assertTrue(result.status == 0);
1562 //
1563     }
1564     @Test
1565     public void testDelUserRole() {
1566         List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1567         UserRoleDAO.Data urData = new UserRoleDAO.Data();
1568         urData.ns="test";
1569         urData.rname="test";
1570         urData.user="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));
1575
1576         Function funcObj = new Function(trans, ques);
1577         Result<Void> result = funcObj.delUserRole(trans, "test", "test", "test");
1578         assertNull(result);
1579
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);
1584 //
1585     }
1586
1587     @Test
1588     public void testCreateFuture() {
1589         FutureDAO.Data data = new FutureDAO.Data();
1590         data.memo = "test";
1591         NsDAO.Data nsd = new NsDAO.Data();
1592         nsd.name = "test";
1593
1594         List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1595         UserRoleDAO.Data urData = new UserRoleDAO.Data();
1596         urData.ns="test";
1597         urData.rname="test";
1598         urData.user="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));
1604
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);
1608
1609         Identity iden=Mockito.mock(Identity.class);
1610         try {
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();
1616         }
1617         FutureDAO.Data futureData = new FutureDAO.Data();
1618         data.memo = "test";
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());
1621
1622         ApprovalDAO.Data approvalData = new ApprovalDAO.Data();
1623         data.memo = "test";
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));
1626
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);
1630
1631         result = funcObj.createFuture(trans, data, "test", "test", null, FUTURE_OP.A);
1632         assertTrue(result.status == 20);
1633
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);
1637
1638         Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1639         try {
1640             Mockito.doReturn(null).when(org).getIdentity(trans, "test");
1641         } catch (OrganizationException e) {
1642             // TODO Auto-generated catch block
1643             e.printStackTrace();
1644         }
1645         result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
1646         assertTrue(result.status == Result.ERR_NotFound);
1647
1648         try {
1649             Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
1650         } catch (OrganizationException e) {
1651             // TODO Auto-generated catch block
1652             e.printStackTrace();
1653         }
1654         result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
1655         assertTrue(result.status == 0);
1656
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);
1661     }
1662     @Test
1663     public void testUbLookup() {
1664         Object[] objArr = new Object[10];
1665         List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1666         UserRoleDAO.Data urData = new UserRoleDAO.Data();
1667         urData.ns="test";
1668         urData.rname="test";
1669         urData.user="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);
1675
1676         Function funcObj = new Function(trans, ques);
1677         funcObj.urDBLookup.get(trans, objArr);
1678
1679         Mockito.doReturn(retValFail).when(userRoleDAO).read(trans, objArr);
1680         funcObj.urDBLookup.get(trans, objArr);
1681     }
1682
1683     @Test
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);
1689
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>>() {
1696             @Override
1697             public List<ApprovalDAO.Data> get(AuthzTrans trans, Object ... keys) {
1698                 return apprs;
1699             }
1700         };
1701
1702         final UserRoleDAO.Data userObj = new UserRoleDAO.Data();
1703         Lookup<UserRoleDAO.Data> lookupUserObj = new Lookup<UserRoleDAO.Data>() {
1704             @Override
1705             public UserRoleDAO.Data get(AuthzTrans trans, Object ... keys) {
1706                 return userObj;
1707             }
1708         };
1709
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());
1714
1715 //        List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1716 //        NsDAO.Data dataObj = new NsDAO.Data();
1717 //        dataObj.type=1;
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());
1721 //
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);
1724 //
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);
1728
1729         approvalObj.status = "approved";
1730         approvalObj.type = "supervisor";
1731         result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1732         assertTrue(result.status == 0);
1733
1734         approvalObj.status = "approved";
1735         approvalObj.type = "";
1736         result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1737         assertTrue(result.status == 0);
1738
1739         approvalObj.status = "pending";
1740         approvalObj.type = "supervisor";
1741         result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1742         assertTrue(result.status == 0);
1743
1744         approvalObj.status = "pending";
1745         approvalObj.type = "owner";
1746         result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1747         assertTrue(result.status == 0);
1748
1749         approvalObj.status = "pending";
1750         approvalObj.type = "";
1751         result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1752         assertTrue(result.status == 0);
1753
1754         approvalObj.status = "denied";
1755         approvalObj.type = "";
1756         result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
1757         assertTrue(result.status == 0);
1758
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);
1764 //
1765     }
1766 }