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 }