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.Field;
  31 import java.lang.reflect.InvocationTargetException;
  32 import java.lang.reflect.Method;
  33 import java.lang.reflect.Modifier;
  34 import java.nio.ByteBuffer;
  35 import java.text.DateFormat;
  36 import java.text.ParseException;
  37 import java.text.SimpleDateFormat;
  38 import java.util.ArrayList;
  39 import java.util.Date;
  40 import java.util.GregorianCalendar;
  41 import java.util.HashSet;
  42 import java.util.List;
  43 import java.util.Properties;
  44 import java.util.Set;
  45 import java.util.UUID;
  46
  47 import org.junit.Before;
  48 import org.junit.Test;
  49 import org.mockito.Mock;
  50 import org.mockito.Mockito;
  51 import org.onap.aaf.auth.common.Define;
  52 import org.onap.aaf.auth.dao.cached.CachedCredDAO;
  53 import org.onap.aaf.auth.dao.cached.CachedNSDAO;
  54 import org.onap.aaf.auth.dao.cached.CachedPermDAO;
  55 import org.onap.aaf.auth.dao.cached.CachedRoleDAO;
  56 import org.onap.aaf.auth.dao.cached.CachedUserRoleDAO;
  57 import org.onap.aaf.auth.dao.cass.ApprovalDAO;
  58 import org.onap.aaf.auth.dao.cass.CredDAO;
  59 import org.onap.aaf.auth.dao.cass.FutureDAO;
  60 import org.onap.aaf.auth.dao.cass.Namespace;
  61 import org.onap.aaf.auth.dao.cass.NsDAO;
  62 import org.onap.aaf.auth.dao.cass.NsSplit;
  63 import org.onap.aaf.auth.dao.cass.NsType;
  64 import org.onap.aaf.auth.dao.cass.PermDAO;
  65 import org.onap.aaf.auth.dao.cass.RoleDAO;
  66 import org.onap.aaf.auth.dao.cass.Status;
  67 import org.onap.aaf.auth.dao.cass.UserRoleDAO;
  68 import org.onap.aaf.auth.dao.hl.Function.FUTURE_OP;
  69 import org.onap.aaf.auth.dao.hl.Function.Lookup;
  70 import org.onap.aaf.auth.dao.hl.Question.Access;
  71 import org.onap.aaf.auth.env.AuthzTrans;
  72 import org.onap.aaf.auth.env.AuthzTrans.REQD_TYPE;
  73 import org.onap.aaf.auth.layer.Result;
  74 import org.onap.aaf.auth.org.Organization;
  75 import org.onap.aaf.auth.org.Organization.Expiration;
  76 import org.onap.aaf.auth.org.Organization.Identity;
  77 import org.onap.aaf.auth.org.OrganizationException;
  78 import org.onap.aaf.cadi.CadiException;
  79 import org.onap.aaf.cadi.PropAccess;
  80 import org.onap.aaf.cadi.config.Config;
  81 import org.onap.aaf.misc.env.APIException;
  82 import org.onap.aaf.misc.env.LogTarget;
  83
  84 public class JU_Function {
  85
  86         @Mock
  87     AuthzTrans trans;
  88         @Mock
  89         PropAccess access;
  90
  91         @Mock
  92         Question ques;
  93
  94         @Before
  95         public void setUp() throws APIException, IOException {
  96                 initMocks(this);
  97         }
  98
  99         @Test
 100         public void testCreateNs() {
 101                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 102                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 103                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 104                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 105                 try {
 106                         Define.set(access);
 107                 } catch (CadiException e) {
 108                         // TODO Auto-generated catch block
 109                         e.printStackTrace();
 110                 }
 111                 Namespace namespace = Mockito.mock(Namespace.class);
 112                 namespace.name = "test.test";
 113                 List<String> owner = new ArrayList<String>();
 114                 namespace.owner = owner;
 115
 116                 Organization org = Mockito.mock(Organization.class);
 117                 Mockito.doReturn(org).when(trans).org();
 118
 119                 NsDAO.Data data = new NsDAO.Data();
 120                 data.name="test";
 121                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 122                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 123
 124                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 125                 Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
 126                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 127                 setQuestion(ques, nsDaoObj);
 128
 129                 Function funcObj = new Function(trans, ques);
 130                 Result<Void>  result = funcObj.createNS(trans, namespace, true);
 131                 assertTrue(3 == result.status);
 132         }
 133
 134         @Test
 135         public void testCreateNsReadSuccess() {
 136                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 137                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 138                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 139                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 140                 try {
 141                         Define.set(access);
 142                 } catch (CadiException e) {
 143                         // TODO Auto-generated catch block
 144                         e.printStackTrace();
 145                 }
 146                 Namespace namespace = Mockito.mock(Namespace.class);
 147                 namespace.name = "test.test";
 148                 List<String> owner = new ArrayList<String>();
 149                 owner.add("test");
 150                 namespace.owner = owner;
 151                 List<String> admin = new ArrayList<String>();
 152                 admin.add("test");
 153                 namespace.admin= admin;
 154
 155                 Organization org = Mockito.mock(Organization.class);
 156                 Mockito.doReturn(org).when(trans).org();
 157
 158                 NsDAO.Data data = new NsDAO.Data();
 159                 data.name="test";
 160                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 161                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 162
 163                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 164                 Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
 165                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 166                 setQuestion(ques, nsDaoObj);
 167
 168                 Function funcObj = new Function(trans, ques);
 169                 Result<Void>  result = funcObj.createNS(trans, namespace, true);
 170                 assertTrue(3 == result.status);
 171         }
 172
 173         @Test
 174         public void testCreateNsFromApprovaFalse() {
 175                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 176                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 177                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 178                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 179                 try {
 180                         Define.set(access);
 181                 } catch (CadiException e) {
 182                         // TODO Auto-generated catch block
 183                         e.printStackTrace();
 184                 }
 185                 Namespace namespace = Mockito.mock(Namespace.class);
 186                 namespace.name = "test.test";
 187                 List<String> owner = new ArrayList<String>();
 188                 namespace.owner = owner;
 189
 190                 Organization org = Mockito.mock(Organization.class);
 191                 Mockito.doReturn(org).when(trans).org();
 192
 193                 NsDAO.Data data = new NsDAO.Data();
 194                 data.name="test";
 195                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 196                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 197                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
 198                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
 199
 200                 Function funcObj = new Function(trans, ques);
 201                 Result<Void>  result = funcObj.createNS(trans, namespace, false);
 202                 assertTrue(1 == result.status);
 203
 204                 Mockito.doReturn(retVal2).when(ques).deriveNs(trans, "test");
 205                 funcObj = new Function(trans, ques);
 206                 result = funcObj.createNS(trans, namespace, false);
 207                 assertTrue(1 == result.status);
 208         }
 209
 210         @Test
 211         public void testCreateNsownerLoop() {
 212                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 213                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 214                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 215                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 216                 try {
 217                         Define.set(access);
 218                 } catch (CadiException e) {
 219                         // TODO Auto-generated catch block
 220                         e.printStackTrace();
 221                 }
 222                 Namespace namespace = Mockito.mock(Namespace.class);
 223                 namespace.name = "test.test";
 224                 List<String> owner = new ArrayList<String>();
 225                 owner.add("test");
 226                 namespace.owner = owner;
 227
 228                 Organization org = Mockito.mock(Organization.class);
 229                 Mockito.doReturn(org).when(trans).org();
 230                 Mockito.doReturn(org).when(trans).org();
 231
 232                 Function funcObj = new Function(trans, ques);
 233                 Result<Void>  result = funcObj.createNS(trans, namespace, true);
 234                 assertTrue(result.status == Status.ERR_Policy);
 235                 assertTrue(result.details.contains("is not a valid user at"));
 236
 237                 Identity iden=Mockito.mock(Identity.class);
 238                 try {
 239                         Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
 240                         Mockito.doReturn("test").when(iden).mayOwn();
 241                 } catch (OrganizationException e) {
 242                         // TODO Auto-generated catch block
 243                         e.printStackTrace();
 244                 }
 245                 result = funcObj.createNS(trans, namespace, true);
 246                 assertTrue(result.status == Status.ERR_Policy);
 247                 assertTrue(result.details.contains("is an invalid Identity"));
 248
 249                 Mockito.doReturn(true).when(iden).isFound();
 250                 result = funcObj.createNS(trans, namespace, true);
 251                 assertTrue(result.status == Status.ERR_Policy);
 252                 assertTrue(result.details.contains("cannot be the owner of the namespace "));
 253
 254                 Mockito.doReturn(true).when(org).isTestEnv();
 255                 try {
 256                         Mockito.doReturn("test").when(org).validate(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
 257                         result = funcObj.createNS(trans, namespace, true);
 258                         assertTrue(result.status == Status.ERR_Policy);
 259                         assertTrue(result.details.contains("cannot be the owner of the namespace "));
 260                 } catch (OrganizationException e) {
 261                         // TODO Auto-generated catch block
 262                         e.printStackTrace();
 263                 }
 264         }
 265
 266         @Test
 267         public void testCreateNsownerLoopException() {
 268                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 269                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 270                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 271                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 272                 try {
 273                         Define.set(access);
 274                 } catch (CadiException e) {
 275                         // TODO Auto-generated catch block
 276                         e.printStackTrace();
 277                 }
 278                 Namespace namespace = Mockito.mock(Namespace.class);
 279                 namespace.name = "test";
 280                 List<String> owner = new ArrayList<String>();
 281                 owner.add("test");
 282                 namespace.owner = owner;
 283
 284                 Organization org = Mockito.mock(Organization.class);
 285                 Mockito.doReturn(org).when(trans).org();
 286
 287                 Function funcObj = new Function(trans, ques);
 288
 289                 Identity iden=Mockito.mock(Identity.class);
 290                 try {
 291                         Mockito.doThrow(new OrganizationException()).when(org).getIdentity(trans, "test");
 292                         Mockito.doReturn("test").when(iden).mayOwn();
 293                 } catch (OrganizationException e) {
 294                         // TODO Auto-generated catch block
 295                         e.printStackTrace();
 296                 }
 297
 298                 NsDAO.Data data = new NsDAO.Data();
 299                 data.name="test";
 300                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
 301                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 302
 303                 Result<Void> result = funcObj.createNS(trans, namespace, true);
 304                 assertTrue(result.status == Status.ERR_Security);
 305                 assertTrue(result.details.contains("may not create Root Namespaces"));
 306
 307                 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 308                 retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 309                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, null);
 310
 311                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 312                 Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
 313                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 314                 setQuestion(ques, nsDaoObj);
 315
 316                 result = funcObj.createNS(trans, namespace, true);
 317                 assertTrue(24 == result.status);
 318
 319         }
 320
 321         public void setQuestion(Question ques, CachedNSDAO userRoleDaoObj) {
 322                 Field nsDaoField;
 323                 try {
 324                         nsDaoField = Question.class.getDeclaredField("nsDAO");
 325
 326                         nsDaoField.setAccessible(true);
 327                 // remove final modifier from field
 328                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 329                 modifiersField.setAccessible(true);
 330                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 331
 332                 nsDaoField.set(ques, userRoleDaoObj);
 333                 } catch (NoSuchFieldException | SecurityException e) {
 334                         // TODO Auto-generated catch block
 335                         e.printStackTrace();
 336                 } catch (IllegalArgumentException e) {
 337                         // TODO Auto-generated catch block
 338                         e.printStackTrace();
 339                 } catch (IllegalAccessException e) {
 340                         // TODO Auto-generated catch block
 341                         e.printStackTrace();
 342                 }
 343         }
 344
 345         public void setQuestionCredDao(Question ques, CachedCredDAO credDaoObj) {
 346                 Field nsDaoField;
 347                 try {
 348                         nsDaoField = Question.class.getDeclaredField("credDAO");
 349
 350                         nsDaoField.setAccessible(true);
 351                 // remove final modifier from field
 352                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 353                 modifiersField.setAccessible(true);
 354                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 355
 356                 nsDaoField.set(ques, credDaoObj);
 357                 } catch (NoSuchFieldException | SecurityException e) {
 358                         // TODO Auto-generated catch block
 359                         e.printStackTrace();
 360                 } catch (IllegalArgumentException e) {
 361                         // TODO Auto-generated catch block
 362                         e.printStackTrace();
 363                 } catch (IllegalAccessException e) {
 364                         // TODO Auto-generated catch block
 365                         e.printStackTrace();
 366                 }
 367         }
 368
 369         public void setQuestionUserRoleDao(Question ques, CachedUserRoleDAO credDaoObj) {
 370                 Field nsDaoField;
 371                 try {
 372                         nsDaoField = Question.class.getDeclaredField("userRoleDAO");
 373
 374                         nsDaoField.setAccessible(true);
 375                 // remove final modifier from field
 376                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 377                 modifiersField.setAccessible(true);
 378                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 379
 380                 nsDaoField.set(ques, credDaoObj);
 381                 } catch (NoSuchFieldException | SecurityException e) {
 382                         // TODO Auto-generated catch block
 383                         e.printStackTrace();
 384                 } catch (IllegalArgumentException e) {
 385                         // TODO Auto-generated catch block
 386                         e.printStackTrace();
 387                 } catch (IllegalAccessException e) {
 388                         // TODO Auto-generated catch block
 389                         e.printStackTrace();
 390                 }
 391         }
 392         public void setQuestionCachedRoleDao(Question ques, CachedRoleDAO credDaoObj) {
 393                 Field nsDaoField;
 394                 try {
 395                         nsDaoField = Question.class.getDeclaredField("roleDAO");
 396
 397                         nsDaoField.setAccessible(true);
 398                 // remove final modifier from field
 399                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 400                 modifiersField.setAccessible(true);
 401                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 402
 403                 nsDaoField.set(ques, credDaoObj);
 404                 } catch (NoSuchFieldException | SecurityException e) {
 405                         // TODO Auto-generated catch block
 406                         e.printStackTrace();
 407                 } catch (IllegalArgumentException e) {
 408                         // TODO Auto-generated catch block
 409                         e.printStackTrace();
 410                 } catch (IllegalAccessException e) {
 411                         // TODO Auto-generated catch block
 412                         e.printStackTrace();
 413                 }
 414         }
 415
 416         public void setQuestionCachedPermDao(Question ques, CachedPermDAO credDaoObj) {
 417                 Field nsDaoField;
 418                 try {
 419                         nsDaoField = Question.class.getDeclaredField("permDAO");
 420
 421                         nsDaoField.setAccessible(true);
 422                 // remove final modifier from field
 423                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 424                 modifiersField.setAccessible(true);
 425                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 426
 427                 nsDaoField.set(ques, credDaoObj);
 428                 } catch (NoSuchFieldException | SecurityException e) {
 429                         // TODO Auto-generated catch block
 430                         e.printStackTrace();
 431                 } catch (IllegalArgumentException e) {
 432                         // TODO Auto-generated catch block
 433                         e.printStackTrace();
 434                 } catch (IllegalAccessException e) {
 435                         // TODO Auto-generated catch block
 436                         e.printStackTrace();
 437                 }
 438         }
 439         public void setQuestionFutureDao(Question ques, FutureDAO futureDaoObj) {
 440                 Field nsDaoField;
 441                 try {
 442                         nsDaoField = Question.class.getDeclaredField("futureDAO");
 443
 444                         nsDaoField.setAccessible(true);
 445                 // remove final modifier from field
 446                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 447                 modifiersField.setAccessible(true);
 448                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 449
 450                 nsDaoField.set(ques, futureDaoObj);
 451                 } catch (NoSuchFieldException | SecurityException e) {
 452                         // TODO Auto-generated catch block
 453                         e.printStackTrace();
 454                 } catch (IllegalArgumentException e) {
 455                         // TODO Auto-generated catch block
 456                         e.printStackTrace();
 457                 } catch (IllegalAccessException e) {
 458                         // TODO Auto-generated catch block
 459                         e.printStackTrace();
 460                 }
 461         }
 462         public void setQuestionApprovalDao(Question ques, ApprovalDAO approvalDaoObj) {
 463                 Field nsDaoField;
 464                 try {
 465                         nsDaoField = Question.class.getDeclaredField("approvalDAO");
 466
 467                         nsDaoField.setAccessible(true);
 468                 // remove final modifier from field
 469                 Field modifiersField = Field.class.getDeclaredField("modifiers");
 470                 modifiersField.setAccessible(true);
 471                 modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
 472
 473                 nsDaoField.set(ques, approvalDaoObj);
 474                 } catch (NoSuchFieldException | SecurityException e) {
 475                         // TODO Auto-generated catch block
 476                         e.printStackTrace();
 477                 } catch (IllegalArgumentException e) {
 478                         // TODO Auto-generated catch block
 479                         e.printStackTrace();
 480                 } catch (IllegalAccessException e) {
 481                         // TODO Auto-generated catch block
 482                         e.printStackTrace();
 483                 }
 484         }
 485         @Test
 486         public void testCreateNsAdminLoop() {
 487                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 488                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 489                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 490                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 491                 try {
 492                         Define.set(access);
 493                 } catch (CadiException e) {
 494                         // TODO Auto-generated catch block
 495                         e.printStackTrace();
 496                 }
 497                 Namespace namespace = Mockito.mock(Namespace.class);
 498                 namespace.name = "test.test";
 499                 List<String> owner = new ArrayList<String>();
 500                 owner.add("test");
 501                 namespace.owner = owner;
 502                 namespace.admin = owner;
 503
 504                 Organization org = Mockito.mock(Organization.class);
 505                 Mockito.doReturn(org).when(trans).org();
 506
 507                 NsDAO.Data data = new NsDAO.Data();
 508                 data.name="test";
 509                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 510                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 511
 512                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 513                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 514                 Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
 515                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 516                 Mockito.doReturn(retVal).when(nsDaoObj).create(Mockito.any(), Mockito.any());
 517                 List<CredDAO.Data> dataObj = new ArrayList<>();
 518                 CredDAO.Data indData = new CredDAO.Data();
 519                 indData.id = "test";
 520                 indData.notes = "test";
 521                 DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
 522                 try {
 523                         indData.expires = sdf.parse("2090/01/01");
 524                 } catch (ParseException e1) {
 525                         // TODO Auto-generated catch block
 526                         e1.printStackTrace();
 527                 }
 528                 dataObj.add(indData);
 529                 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
 530                 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
 531                 setQuestion(ques, nsDaoObj);
 532                 setQuestionCredDao(ques, credDAO);
 533
 534                 Identity iden=Mockito.mock(Identity.class);
 535                 try {
 536                         Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
 537                         Mockito.doReturn("test").when(iden).mayOwn();
 538                         Mockito.doReturn(true).when(org).isTestEnv();
 539                 } catch (OrganizationException e) {
 540                         // TODO Auto-generated catch block
 541                         e.printStackTrace();
 542                 }
 543
 544                 Function funcObj = new Function(trans, ques);
 545                 Result<Void>  result = funcObj.createNS(trans, namespace, true);
 546                 assertTrue(result.status == 1);
 547
 548         }
 549
 550         @Test
 551         public void testCreateNsAdminLoopCreateSucReadChildrenFailure() {
 552                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 553                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 554                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 555                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 556                 try {
 557                         Define.set(access);
 558                 } catch (CadiException e) {
 559                         // TODO Auto-generated catch block
 560                         e.printStackTrace();
 561                 }
 562                 Namespace namespace = Mockito.mock(Namespace.class);
 563                 namespace.name = "test.test";
 564                 List<String> owner = new ArrayList<String>();
 565                 owner.add("test");
 566                 namespace.owner = owner;
 567                 namespace.admin = owner;
 568
 569                 Organization org = Mockito.mock(Organization.class);
 570                 Mockito.doReturn(org).when(trans).org();
 571
 572                 NsDAO.Data data = new NsDAO.Data();
 573                 data.name="test";
 574                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 575                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 576
 577                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 578                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 579                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 580                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 581                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 582                 Result<Void> retVal = new Result<Void>(null,0,"test",new String[0]);
 583                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 584                 Mockito.doReturn(retVal).when(nsDaoObj).create(Mockito.any(), Mockito.any());
 585                 List<CredDAO.Data> dataObj = new ArrayList<>();
 586                 CredDAO.Data indData = new CredDAO.Data();
 587                 indData.id = "test";
 588                 indData.notes = "test";
 589                 DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
 590                 try {
 591                         indData.expires = sdf.parse("2090/01/01");
 592                 } catch (ParseException e1) {
 593                         // TODO Auto-generated catch block
 594                         e1.printStackTrace();
 595                 }
 596                 dataObj.add(indData);
 597                 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 598                 RoleDAO.Data indData1 = new RoleDAO.Data();
 599                 indData1.ns = "test";
 600                 indData1.name = "test";
 601                 Set<String> permsSet = new HashSet<>();
 602                 permsSet.add("test|test");
 603                 indData1.perms = permsSet;
 604                 dataObj1.add(indData1);
 605
 606                 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
 607                 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
 608                 indData4.ns = "test";
 609                 indData4.rname = "test";
 610                 dataObj4.add(indData4);
 611
 612                 List<PermDAO.Data> dataObj5 = new ArrayList<>();
 613                 PermDAO.Data indData5 = new PermDAO.Data();
 614                 indData5.ns = "test";
 615                 indData5.type = "test";
 616                 dataObj5.add(indData5);
 617
 618                 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
 619                 Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",new String[0]);
 620                 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
 621                 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
 622                 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
 623                 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
 624                 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
 625                 Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
 626                 Mockito.doReturn(retVal6).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
 627                 Mockito.doReturn(retVal6).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
 628                 Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
 629                 Mockito.doReturn(retVal5).when(cachedPermDAO).readChildren(trans, "test", "test");
 630                 Mockito.doReturn(retVal5).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
 631                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readChildren(trans, "test", "test");
 632                 setQuestion(ques, nsDaoObj);
 633                 setQuestionCredDao(ques, credDAO);
 634                 setQuestionUserRoleDao(ques, userRoleDAO);
 635                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
 636                 setQuestionCachedPermDao(ques, cachedPermDAO);
 637
 638                 Identity iden=Mockito.mock(Identity.class);
 639                 try {
 640                         Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
 641                         Mockito.doReturn("test").when(iden).mayOwn();
 642                         Mockito.doReturn(true).when(org).isTestEnv();
 643                         Mockito.doReturn(new GregorianCalendar(2010, 01, 01)).when(org).expiration(null, Expiration.UserInRole);
 644                 } catch (OrganizationException e) {
 645                         // TODO Auto-generated catch block
 646                         e.printStackTrace();
 647                 }
 648
 649                 Function funcObj = new Function(trans, ques);
 650                 Result<Void>  result = funcObj.createNS(trans, namespace, true);
 651                 assertTrue(result.status == Status.ERR_ActionNotCompleted);
 652
 653         }
 654
 655         @Test
 656         public void testCreateNsAdminLoopCreateSuc() {
 657                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 658                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 659                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 660                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 661                 try {
 662                         Define.set(access);
 663                 } catch (CadiException e) {
 664                         // TODO Auto-generated catch block
 665                         e.printStackTrace();
 666                 }
 667                 Namespace namespace = Mockito.mock(Namespace.class);
 668                 namespace.name = "test.test";
 669                 List<String> owner = new ArrayList<String>();
 670                 owner.add("test");
 671                 namespace.owner = owner;
 672                 namespace.admin = owner;
 673
 674                 Organization org = Mockito.mock(Organization.class);
 675                 Mockito.doReturn(org).when(trans).org();
 676
 677                 NsDAO.Data data = new NsDAO.Data();
 678                 data.name="test";
 679                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
 680                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 681
 682                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 683                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 684                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 685                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 686                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 687                 Result<Void> retVal = new Result<Void>(null,0,"test",new String[0]);
 688                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 689                 Mockito.doReturn(retVal).when(nsDaoObj).create(Mockito.any(), Mockito.any());
 690                 List<CredDAO.Data> dataObj = new ArrayList<>();
 691                 CredDAO.Data indData = new CredDAO.Data();
 692                 indData.id = "test";
 693                 indData.notes = "test";
 694                 DateFormat sdf = new SimpleDateFormat("yyyy/mm/dd");
 695                 try {
 696                         indData.expires = sdf.parse("2090/01/01");
 697                 } catch (ParseException e1) {
 698                         // TODO Auto-generated catch block
 699                         e1.printStackTrace();
 700                 }
 701                 dataObj.add(indData);
 702                 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 703                 RoleDAO.Data indData1 = new RoleDAO.Data();
 704                 indData1.ns = "test";
 705                 indData1.name = "test";
 706                 Set<String> permsSet = new HashSet<>();
 707                 permsSet.add("test|test|test|test");
 708                 indData1.perms = permsSet;
 709                 dataObj1.add(indData1);
 710
 711                 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
 712                 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
 713                 indData4.ns = "test";
 714                 indData4.rname = "test";
 715                 dataObj4.add(indData4);
 716
 717                 List<PermDAO.Data> dataObj5 = new ArrayList<>();
 718                 PermDAO.Data indData5 = new PermDAO.Data();
 719                 indData5.ns = "test";
 720                 indData5.type = "test";
 721                 Set<String> rolesSet = new HashSet<>();
 722                 rolesSet.add("test|test|test|test");
 723                 indData5.roles = rolesSet;
 724                 dataObj5.add(indData5);
 725
 726                 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
 727                 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
 728                 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
 729                 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
 730                 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
 731                 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
 732                 Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
 733                 Mockito.doReturn(retVal2).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
 734                 Mockito.doReturn(retVal2).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
 735                 Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
 736                 Mockito.doReturn(retVal5).when(cachedPermDAO).readChildren(trans, "test", "test");
 737                 Mockito.doReturn(retVal5).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
 738                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readChildren(trans, "test", "test");
 739                 setQuestion(ques, nsDaoObj);
 740                 setQuestionCredDao(ques, credDAO);
 741                 setQuestionUserRoleDao(ques, userRoleDAO);
 742                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
 743                 setQuestionCachedPermDao(ques, cachedPermDAO);
 744
 745                 Identity iden=Mockito.mock(Identity.class);
 746                 try {
 747                         Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
 748                         Mockito.doReturn("test").when(iden).mayOwn();
 749                         Mockito.doReturn(true).when(org).isTestEnv();
 750                         Mockito.doReturn(new GregorianCalendar(2010, 01, 01)).when(org).expiration(null, Expiration.UserInRole);
 751                 } catch (OrganizationException e) {
 752                         // TODO Auto-generated catch block
 753                         e.printStackTrace();
 754                 }
 755
 756                 Function funcObj = new Function(trans, ques);
 757                 Result<Void>  result = funcObj.createNS(trans, namespace, true);
 758                 assertTrue(result.status == 0);
 759
 760         }
 761
 762         @Test
 763         public void test4DeleteNs() {
 764                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 765                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 766                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 767                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 768                 try {
 769                         Define.set(access);
 770                 } catch (CadiException e) {
 771                         // TODO Auto-generated catch block
 772                         e.printStackTrace();
 773                 }
 774                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 775                 Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
 776                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 777                 setQuestion(ques, nsDaoObj);
 778
 779                 Function funcObj = new Function(trans, ques);
 780                 Result<Void> result = funcObj.deleteNS(trans, "test");
 781
 782                 assertTrue(result.status == Status.ERR_NsNotFound);
 783         }
 784         @Test
 785         public void test4DeleteCanMOveFail() {
 786                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 787                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 788                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.move);
 789                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 790                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 791                 try {
 792                         Define.set(access);
 793                 } catch (CadiException e) {
 794                         // TODO Auto-generated catch block
 795                         e.printStackTrace();
 796                 }
 797                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 798                 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 799                 NsDAO.Data dataObj = new NsDAO.Data();
 800                 dataObj.type=1;
 801                 dataAl.add(dataObj);
 802                 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
 803                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 804                 setQuestion(ques, nsDaoObj);
 805
 806                 Mockito.doReturn(false).when(ques).canMove(Mockito.any());
 807
 808                 Function funcObj = new Function(trans, ques);
 809                 Result<Void> result = funcObj.deleteNS(trans, "test");
 810                 assertTrue(result.status == Status.ERR_Denied);
 811
 812         }
 813         @Test
 814         public void test4DeleteNsReadSuc() {
 815                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 816                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 817                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 818                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 819                 try {
 820                         Define.set(access);
 821                 } catch (CadiException e) {
 822                         // TODO Auto-generated catch block
 823                         e.printStackTrace();
 824                 }
 825                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 826                 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 827                 NsDAO.Data dataObj = new NsDAO.Data();
 828                 dataObj.type=1;
 829                 dataAl.add(dataObj);
 830                 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
 831                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 832                 setQuestion(ques, nsDaoObj);
 833
 834                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
 835                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 836
 837                 Function funcObj = new Function(trans, ques);
 838                 Result<Void> result = funcObj.deleteNS(trans, "test");
 839                 assertTrue(result.status == 1);
 840
 841         }
 842         @Test
 843         public void test4DeleteNsMayUserSuc() {
 844                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 845                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 846                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 847                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 848                 try {
 849                         Define.set(access);
 850                 } catch (CadiException e) {
 851                         // TODO Auto-generated catch block
 852                         e.printStackTrace();
 853                 }
 854                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 855                 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 856                 NsDAO.Data dataObj = new NsDAO.Data();
 857                 dataObj.type=1;
 858                 dataAl.add(dataObj);
 859                 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
 860                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 861                 setQuestion(ques, nsDaoObj);
 862
 863                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
 864                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 865
 866                 Function funcObj = new Function(trans, ques);
 867                 Result<Void> result = funcObj.deleteNS(trans, "test");
 868                 assertTrue(result.status == 1);
 869
 870                 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 871
 872                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 873                 Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
 874                 setQuestionCredDao(ques, credDAO);
 875
 876                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 877                 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",new String[0]);
 878                 Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
 879                 setQuestionCachedPermDao(ques, cachedPermDAO);
 880
 881                 CachedUserRoleDAO cachedUserRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 882                 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
 883                 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
 884                 indData4.ns = "test";
 885                 indData4.rname = "test";
 886                 dataObj4.add(indData4);
 887                 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
 888                 Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByRole(trans, "test");
 889                 setQuestionUserRoleDao(ques, cachedUserRoleDAO);
 890
 891                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 892                 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 893                 RoleDAO.Data indData1 = new RoleDAO.Data();
 894                 indData1.ns = "test";
 895                 indData1.name = "test";
 896                 Set<String> permsSet = new HashSet<>();
 897                 permsSet.add("test|test");
 898                 indData1.perms = permsSet;
 899                 dataObj1.add(indData1);
 900                 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
 901                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");
 902                 Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
 903                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
 904
 905                 funcObj = new Function(trans, ques);
 906                 result = funcObj.deleteNS(trans, "test");
 907                 assertTrue(result.status == Status.ERR_DependencyExists);
 908
 909                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
 910                 setQuestionUserRoleDao(ques, userRoleDAO);
 911                 Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
 912
 913                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
 914                 funcObj = new Function(trans, ques);
 915                 result = funcObj.deleteNS(trans, "test");
 916                 assertNull(result);
 917         }
 918         @Test
 919         public void test4DeleteNsDrivensFailure() {
 920                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 921                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 922                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 923                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
 924                 try {
 925                         Define.set(access);
 926                 } catch (CadiException e) {
 927                         // TODO Auto-generated catch block
 928                         e.printStackTrace();
 929                 }
 930                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
 931                 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
 932                 NsDAO.Data dataObj = new NsDAO.Data();
 933                 dataObj.type=1;
 934                 dataAl.add(dataObj);
 935                 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
 936                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
 937                 setQuestion(ques, nsDaoObj);
 938
 939                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
 940                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
 941
 942                 Function funcObj = new Function(trans, ques);
 943                 Result<Void> result = funcObj.deleteNS(trans, "test");
 944                 assertTrue(result.status == 1);
 945
 946                 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
 947
 948                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
 949                 Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
 950                 setQuestionCredDao(ques, credDAO);
 951
 952                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
 953                 List<PermDAO.Data> dataObj5 = new ArrayList<>();
 954                 PermDAO.Data indData5 = new PermDAO.Data();
 955                 indData5.ns = "test";
 956                 indData5.type = "test";
 957                 dataObj5.add(indData5);
 958                 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
 959                 Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
 960                 Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test.test");
 961                 Mockito.doReturn(retVal5).when(cachedPermDAO).read(trans, indData5);
 962                 setQuestionCachedPermDao(ques, cachedPermDAO);
 963
 964
 965                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
 966                 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
 967                 RoleDAO.Data indData1 = new RoleDAO.Data();
 968                 indData1.ns = "test";
 969                 indData1.name = "test";
 970                 Set<String> permsSet = new HashSet<>();
 971                 permsSet.add("test|test");
 972                 indData1.perms = permsSet;
 973                 dataObj1.add(indData1);
 974                 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
 975                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");
 976                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test.test");
 977                 Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
 978                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
 979
 980                 funcObj = new Function(trans, ques);
 981                 result = funcObj.deleteNS(trans, "test");
 982                 assertTrue(result.status == Status.ERR_DependencyExists);
 983
 984                 NsDAO.Data data = new NsDAO.Data();
 985                 data.name="test";
 986                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
 987                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
 988
 989                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
 990                 funcObj = new Function(trans, ques);
 991                 result = funcObj.deleteNS(trans, "test.test");
 992                 assertTrue(result.status == 1);
 993         }
 994         @Test
 995         public void test4DeleteNsWithDot() {
 996                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
 997                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
 998                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
 999                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1000                 try {
1001                         Define.set(access);
1002                 } catch (CadiException e) {
1003                         // TODO Auto-generated catch block
1004                         e.printStackTrace();
1005                 }
1006                 CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
1007                 List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1008                 NsDAO.Data dataObj = new NsDAO.Data();
1009                 dataObj.type=1;
1010                 dataAl.add(dataObj);
1011                 Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
1012                 Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
1013                 setQuestion(ques, nsDaoObj);
1014
1015                 List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
1016                 CredDAO.Data nsData = new CredDAO.Data();
1017                 nsData.id="test";
1018                 nsDataList.add(nsData);
1019                 Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",new String[0]);
1020                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1021                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
1022
1023                 Function funcObj = new Function(trans, ques);
1024                 Result<Void> result = funcObj.deleteNS(trans, "test");
1025                 assertTrue(result.status == 1);
1026
1027                 Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
1028
1029                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
1030                 Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
1031                 Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
1032                 setQuestionCredDao(ques, credDAO);
1033
1034                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1035                 List<PermDAO.Data> dataObj5 = new ArrayList<>();
1036                 PermDAO.Data indData5 = new PermDAO.Data();
1037                 indData5.ns = "test";
1038                 indData5.type = "test";
1039                 dataObj5.add(indData5);
1040                 Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
1041                 Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
1042                 Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test.test");
1043                 Mockito.doReturn(retVal5).when(cachedPermDAO).read(trans, indData5);
1044                 setQuestionCachedPermDao(ques, cachedPermDAO);
1045
1046                 CachedUserRoleDAO cachedUserRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1047                 List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
1048                 UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
1049                 indData4.ns = "test";
1050                 indData4.rname = "test";
1051                 dataObj4.add(indData4);
1052                 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
1053                 Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1054                 Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
1055                 setQuestionUserRoleDao(ques, cachedUserRoleDAO);
1056
1057                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1058                 List<RoleDAO.Data> dataObj1 = new ArrayList<>();
1059                 RoleDAO.Data indData1 = new RoleDAO.Data();
1060                 indData1.ns = "test";
1061                 indData1.name = "admin";
1062                 Set<String> permsSet = new HashSet<>();
1063                 permsSet.add("test|test");
1064                 indData1.perms = permsSet;
1065                 dataObj1.add(indData1);
1066                 Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
1067                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");
1068                 Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test.test");
1069                 Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
1070                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1071
1072                 funcObj = new Function(trans, ques);
1073                 result = funcObj.deleteNS(trans, "test");
1074                 assertTrue(result.status == Status.ERR_DependencyExists);
1075
1076                 NsDAO.Data data = new NsDAO.Data();
1077                 data.name="test";
1078                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1079                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1080
1081                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1082                 funcObj = new Function(trans, ques);
1083                 result = funcObj.deleteNS(trans, "test.test");
1084                 assertNull(result);
1085         }
1086         @Test
1087         public void testGetOwners() {
1088                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1089                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1090                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1091                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1092                 try {
1093                         Define.set(access);
1094                 } catch (CadiException e) {
1095                         // TODO Auto-generated catch block
1096                         e.printStackTrace();
1097                 }
1098                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1099 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1100 //              NsDAO.Data dataObj = new NsDAO.Data();
1101 //              dataObj.type=1;
1102 //              dataAl.add(dataObj);
1103                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1104                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1105                 setQuestionUserRoleDao(ques, userRoleDAO);
1106 //
1107 //              Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1108 //              Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
1109 //
1110                 Function funcObj = new Function(trans, ques);
1111                 Result<List<String>> result = funcObj.getOwners(trans, "test", false);
1112                 assertTrue(result.status == 1);
1113 //
1114         }
1115
1116         @Test
1117         public void testDelOwner() {
1118                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1119                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1120                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1121                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1122                 try {
1123                         Define.set(access);
1124                 } catch (CadiException e) {
1125                         // TODO Auto-generated catch block
1126                         e.printStackTrace();
1127                 }
1128                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1129                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1130                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1131                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
1132                 setQuestionUserRoleDao(ques, userRoleDAO);
1133
1134                 NsDAO.Data data = new NsDAO.Data();
1135                 data.name="test";
1136                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1137                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1138
1139                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
1140                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
1141
1142                 Function funcObj = new Function(trans, ques);
1143                 Result<Void> result = funcObj.delOwner(trans, "test", "test");
1144                 assertTrue(result.status == 1);
1145
1146                 retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
1147                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1148                 result = funcObj.delOwner(trans, "test", "test");
1149                 assertTrue(result.status == 1);
1150
1151                 retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1152                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1153                 result = funcObj.delOwner(trans, "test", "test");
1154                 retVal2 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1155                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
1156                 result = funcObj.delOwner(trans, "test", "test");
1157 //
1158         }
1159
1160         @Test
1161         public void testGetAdmins() {
1162                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1163                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1164                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1165                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1166                 try {
1167                         Define.set(access);
1168                 } catch (CadiException e) {
1169                         // TODO Auto-generated catch block
1170                         e.printStackTrace();
1171                 }
1172                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1173 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1174 //              NsDAO.Data dataObj = new NsDAO.Data();
1175 //              dataObj.type=1;
1176 //              dataAl.add(dataObj);
1177                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1178                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1179                 setQuestionUserRoleDao(ques, userRoleDAO);
1180 //
1181 //              Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1182 //              Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
1183 //
1184                 Function funcObj = new Function(trans, ques);
1185                 Result<List<String>> result = funcObj.getAdmins(trans, "test", false);
1186                 assertTrue(result.status == 1);
1187 //
1188         }
1189
1190         @Test
1191         public void testDelAdmin() {
1192                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1193                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1194                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1195                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1196                 try {
1197                         Define.set(access);
1198                 } catch (CadiException e) {
1199                         // TODO Auto-generated catch block
1200                         e.printStackTrace();
1201                 }
1202                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1203                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1204                 Mockito.doReturn(retVal).when(userRoleDAO).readUserInRole(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1205                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
1206                 setQuestionUserRoleDao(ques, userRoleDAO);
1207
1208                 NsDAO.Data data = new NsDAO.Data();
1209                 data.name="test";
1210                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1211                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1212
1213                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
1214                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
1215
1216                 Function funcObj = new Function(trans, ques);
1217                 Result<Void> result = funcObj.delAdmin(trans, "test", "test");
1218                 assertTrue(result.status == 1);
1219
1220                 retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
1221                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1222                 result = funcObj.delAdmin(trans, "test", "test");
1223                 assertTrue(result.status == 1);
1224
1225                 retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1226                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1227                 result = funcObj.delOwner(trans, "test", "test");
1228                 retVal2 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1229                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
1230                 result = funcObj.delAdmin(trans, "test", "test");
1231 //
1232         }
1233
1234         @Test
1235         public void testMovePerms() {
1236                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1237                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1238                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1239                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1240                 try {
1241                         Define.set(access);
1242                 } catch (CadiException e) {
1243                         // TODO Auto-generated catch block
1244                         e.printStackTrace();
1245                 }
1246                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1247 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1248 //              NsDAO.Data dataObj = new NsDAO.Data();
1249 //              dataObj.type=1;
1250 //              dataAl.add(dataObj);
1251                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1252                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1253                 setQuestionUserRoleDao(ques, userRoleDAO);
1254
1255                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1256                 Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1257                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1258
1259                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1260                 Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1261                 setQuestionCachedPermDao(ques, cachedPermDAO);
1262
1263                 NsDAO.Data nsDataObj = new NsDAO.Data();
1264                 nsDataObj.name="test";
1265                 StringBuilder sb = new StringBuilder();
1266                 Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",new String[0]);
1267
1268                 invokeMovePerms(nsDataObj, sb, retVal1);
1269
1270                 List<PermDAO.Data> dataObj5 = new ArrayList<>();
1271                 PermDAO.Data indData5 = new PermDAO.Data();
1272                 indData5.ns = "test";
1273                 indData5.type = "test";
1274                 Set<String> rolesSet = new HashSet<>();
1275                 rolesSet.add("testRole");
1276                 indData5.roles = rolesSet;
1277                 dataObj5.add(indData5);
1278                 indData5 = new PermDAO.Data();
1279                 indData5.ns = "test";
1280                 indData5.type = "access";
1281                 dataObj5.add(indData5);
1282                 retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
1283
1284                 Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",new String[0]);
1285                 Mockito.doReturn(retVal3).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1286                 Mockito.doReturn(retVal3).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
1287
1288                 NsSplit splitObj = new NsSplit("test", "test");
1289                 Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
1290                 Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1291
1292                 invokeMovePerms(nsDataObj, sb, retVal1);
1293
1294                 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1295                 Mockito.doReturn(retVal4).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1296                 invokeMovePerms(nsDataObj, sb, retVal1);
1297
1298                 Mockito.doReturn(retVal3).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1299                 Mockito.doReturn(retVal4).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
1300                 invokeMovePerms(nsDataObj, sb, retVal1);
1301
1302         }
1303
1304         private void invokeMovePerms(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<PermDAO.Data>> retVal1) {
1305                 Function funcObj = new Function(trans, ques);
1306                 Method met;
1307                 try {
1308                         met = Function.class.getDeclaredMethod("movePerms", AuthzTrans.class, NsDAO.Data.class, StringBuilder.class, Result.class);
1309                         met.setAccessible(true);
1310                         met.invoke(funcObj, trans, nsDataObj, sb, retVal1);
1311                 } catch (NoSuchMethodException | SecurityException e) {
1312                         // TODO Auto-generated catch block
1313                         e.printStackTrace();
1314                 } catch (IllegalAccessException e) {
1315                         // TODO Auto-generated catch block
1316                         e.printStackTrace();
1317                 } catch (IllegalArgumentException e) {
1318                         // TODO Auto-generated catch block
1319                         e.printStackTrace();
1320                 } catch (InvocationTargetException e) {
1321                         // TODO Auto-generated catch block
1322                         e.printStackTrace();
1323                 }
1324         }
1325
1326         @Test
1327         public void testMoveRoles() {
1328                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1329                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1330                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1331                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1332                 try {
1333                         Define.set(access);
1334                 } catch (CadiException e) {
1335                         // TODO Auto-generated catch block
1336                         e.printStackTrace();
1337                 }
1338                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1339 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1340 //              NsDAO.Data dataObj = new NsDAO.Data();
1341 //              dataObj.type=1;
1342 //              dataAl.add(dataObj);
1343                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1344                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1345                 setQuestionUserRoleDao(ques, userRoleDAO);
1346
1347                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1348                 Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1349                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1350
1351                 Mockito.doReturn(retVal).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
1352
1353                 NsDAO.Data nsDataObj = new NsDAO.Data();
1354                 nsDataObj.name="test";
1355                 StringBuilder sb = new StringBuilder();
1356                 Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",new String[0]);
1357
1358                 invokeMoveRoles(nsDataObj, sb, retVal1);
1359
1360                 List<RoleDAO.Data> dataObj5 = new ArrayList<>();
1361                 RoleDAO.Data indData5 = new RoleDAO.Data();
1362                 indData5.ns = "test";
1363                 indData5.name = "test";
1364                 Set<String> rolesSet = new HashSet<>();
1365                 rolesSet.add("testRole");
1366                 indData5.perms = rolesSet;
1367                 dataObj5.add(indData5);
1368                 indData5 = new RoleDAO.Data();
1369                 indData5.ns = "test";
1370                 indData5.name = "admin";
1371                 dataObj5.add(indData5);
1372                 retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",new String[0]);
1373
1374                 Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",new String[0]);
1375                 Mockito.doReturn(retVal3).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
1376                 Mockito.doReturn(retVal3).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
1377
1378                 NsSplit splitObj = new NsSplit("test", "test");
1379                 Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
1380                 Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1381
1382                 invokeMoveRoles(nsDataObj, sb, retVal1);
1383
1384                 Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1385                 Mockito.doReturn(retVal4).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
1386                 invokeMoveRoles(nsDataObj, sb, retVal1);
1387
1388                 Mockito.doReturn(retVal3).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
1389                 Mockito.doReturn(retVal4).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
1390                 invokeMoveRoles(nsDataObj, sb, retVal1);
1391
1392         }
1393
1394         private void invokeMoveRoles(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<RoleDAO.Data>> retVal1) {
1395                 Function funcObj = new Function(trans, ques);
1396                 Method met;
1397                 try {
1398                         met = Function.class.getDeclaredMethod("moveRoles", AuthzTrans.class, NsDAO.Data.class, StringBuilder.class, Result.class);
1399                         met.setAccessible(true);
1400                         met.invoke(funcObj, trans, nsDataObj, sb, retVal1);
1401                 } catch (NoSuchMethodException | SecurityException e) {
1402                         // TODO Auto-generated catch block
1403                         e.printStackTrace();
1404                 } catch (IllegalAccessException e) {
1405                         // TODO Auto-generated catch block
1406                         e.printStackTrace();
1407                 } catch (IllegalArgumentException e) {
1408                         // TODO Auto-generated catch block
1409                         e.printStackTrace();
1410                 } catch (InvocationTargetException e) {
1411                         // TODO Auto-generated catch block
1412                         e.printStackTrace();
1413                 }
1414         }
1415
1416         @Test
1417         public void testCreatePerm() {
1418                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1419                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1420                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1421                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1422                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1423                 try {
1424                         Define.set(access);
1425                 } catch (CadiException e) {
1426                         // TODO Auto-generated catch block
1427                         e.printStackTrace();
1428                 }
1429                 List<PermDAO.Data> dataAl = new ArrayList<PermDAO.Data>();
1430                 PermDAO.Data perm = new PermDAO.Data();
1431                 Set<String> rolesSet = new HashSet<>();
1432                 rolesSet.add("testRole");
1433                 perm.roles = rolesSet;
1434 //              perm.type=1
1435                 dataAl.add(perm);
1436                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1437                 Mockito.doReturn(retVal).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1438
1439                 CachedRoleDAO userRoleDAO = Mockito.mock(CachedRoleDAO.class);
1440                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1441                 Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1442                 setQuestionCachedRoleDao(ques, userRoleDAO);
1443
1444                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1445                 Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1446                 Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);
1447                 setQuestionCachedPermDao(ques, cachedPermDAO);
1448
1449                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
1450                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1451
1452                 Function funcObj = new Function(trans, ques);
1453                 Result<Void> result = funcObj.createPerm(trans, perm, false);
1454                 assertTrue(result.status == 1);
1455
1456                 retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1457                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1458                 result = funcObj.createPerm(trans, perm, false);
1459                 assertTrue(result.status == 1);
1460
1461                 NsSplit nsObj = new NsSplit("test","test");
1462                 Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",new String[0]);
1463                 Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1464                 Mockito.doReturn(retVal2).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
1465                 result = funcObj.createPerm(trans, perm, false);
1466
1467                 Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);
1468                 result = funcObj.createPerm(trans, perm, true);
1469                 assertTrue(result.status == 1);
1470
1471                 Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1472                 result = funcObj.createPerm(trans, perm, true);
1473                 assertTrue(result.status == 0);
1474
1475                 Mockito.doReturn(false).when(trans).requested(REQD_TYPE.force);
1476                 Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",new String[0]);
1477                 Mockito.doReturn(retVal1).when(cachedPermDAO).read(trans, perm);
1478                 result = funcObj.createPerm(trans, perm, true);
1479                 assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
1480
1481         }
1482         @Test
1483         public void testDeletePerm() {
1484                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1485                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1486                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1487                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1488                 try {
1489                         Define.set(access);
1490                 } catch (CadiException e) {
1491                         // TODO Auto-generated catch block
1492                         e.printStackTrace();
1493                 }
1494                 List<PermDAO.Data> dataAl = new ArrayList<PermDAO.Data>();
1495                 PermDAO.Data perm = new PermDAO.Data();
1496                 Set<String> rolesSet = new HashSet<>();
1497                 rolesSet.add("testRole");
1498                 perm.roles = rolesSet;
1499 //              perm.type=1
1500                 dataAl.add(perm);
1501
1502                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
1503                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1504
1505                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1506 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1507 //              NsDAO.Data dataObj = new NsDAO.Data();
1508 //              dataObj.type=1;
1509 //              dataAl.add(dataObj);
1510                 Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",new String[0]);
1511                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1512                 setQuestionUserRoleDao(ques, userRoleDAO);
1513
1514                 Function funcObj = new Function(trans, ques);
1515                 Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
1516                 assertTrue(result.status == 1);
1517
1518                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1519 //              Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1520                 Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);
1521                 setQuestionCachedPermDao(ques, cachedPermDAO);
1522
1523                 result = funcObj.deletePerm(trans, perm, true,true);
1524                 assertTrue(result.status == Status.ERR_PermissionNotFound);
1525
1526                 retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1527                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
1528                 Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",new String[0]);
1529                 Mockito.doReturn(retVal3).when(cachedPermDAO).read(trans, perm);
1530
1531                 NsSplit nsObj = new NsSplit("test","test");
1532                 Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",new String[0]);
1533                 Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1534
1535                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1536                 Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1537                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1538
1539                 result = funcObj.deletePerm(trans, perm, true,false);
1540                 assertNull(result);
1541
1542                 Mockito.doReturn(retVal2).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
1543                 result = funcObj.deletePerm(trans, perm, true,false);
1544                 assertNull(result);
1545
1546                 result = funcObj.deletePerm(trans, perm, false,false);
1547 //              assertTrue(result.status == 1);
1548         }
1549
1550         @Test
1551         public void testDeleteRole() {
1552                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1553                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1554                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1555                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1556                 try {
1557                         Define.set(access);
1558                 } catch (CadiException e) {
1559                         // TODO Auto-generated catch block
1560                         e.printStackTrace();
1561                 }
1562
1563                 List<UserRoleDAO.Data> dataAlUser = new ArrayList<UserRoleDAO.Data>();
1564                 UserRoleDAO.Data roleUser = new UserRoleDAO.Data();
1565                 Set<String> rolesSetUser = new HashSet<>();
1566                 rolesSetUser.add("testRole|test|test");
1567 //              perm.roles = rolesSet;
1568 //              perm.type=1
1569                 dataAlUser.add(roleUser);
1570
1571                 List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
1572                 RoleDAO.Data role = new RoleDAO.Data();
1573                 Set<String> rolesSet = new HashSet<>();
1574                 rolesSet.add("testRole|test|test");
1575                 role.perms = rolesSet;
1576 //              perm.roles = rolesSet;
1577 //              perm.type=1
1578                 dataAl.add(role);
1579
1580                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
1581                 Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
1582
1583                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1584 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1585 //              NsDAO.Data dataObj = new NsDAO.Data();
1586 //              dataObj.type=1;
1587 //              dataAl.add(dataObj);
1588                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1589                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1590                 setQuestionUserRoleDao(ques, userRoleDAO);
1591 //
1592 //              Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1593 //              Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
1594 //
1595                 Function funcObj = new Function(trans, ques);
1596                 Result<Void> result = funcObj.deleteRole(trans, role, true, false);
1597                 assertTrue(result.status == 1);
1598
1599                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1600                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1601                 Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
1602                 Mockito.doReturn(retVal1).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1603                 NsSplit splitObj = new NsSplit("test", "test");
1604                 Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
1605                 Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1606                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1607 //              Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1608                 Mockito.doReturn(retVal).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
1609                 setQuestionCachedPermDao(ques, cachedPermDAO);
1610                 result = funcObj.deleteRole(trans, role, true, true);
1611                 assertNull(result);
1612
1613                 Mockito.doReturn(retVal1).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
1614                 result = funcObj.deleteRole(trans, role, true, true);
1615                 assertNull(result);
1616
1617                 Mockito.doReturn(retVal).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1618                 result = funcObj.deleteRole(trans, role, true, true);
1619                 assertTrue(result.status == Status.ERR_RoleNotFound);
1620
1621                 retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",new String[0]);
1622                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1623                 result = funcObj.deleteRole(trans, role, false, true);
1624                 assertTrue(result.status == Status.ERR_DependencyExists);
1625         }
1626
1627         @Test
1628         public void testAddPermToRole() {
1629                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1630                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1631                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1632                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1633                 try {
1634                         Define.set(access);
1635                 } catch (CadiException e) {
1636                         // TODO Auto-generated catch block
1637                         e.printStackTrace();
1638                 }
1639                 List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
1640                 PermDAO.Data rolePerm = new PermDAO.Data();
1641                 Set<String> rolesSetUser = new HashSet<>();
1642                 rolesSetUser.add("testRole|test|test");
1643 //              perm.roles = rolesSet;
1644 //              perm.type=1
1645                 dataAlPerm.add(rolePerm);
1646
1647                 List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
1648                 RoleDAO.Data role = new RoleDAO.Data();
1649                 Set<String> rolesSet = new HashSet<>();
1650                 rolesSet.add("17623");
1651                 role.perms = rolesSet;
1652 //              perm.roles = rolesSet;
1653 //              perm.type=1
1654                 dataAl.add(role);
1655
1656                 NsDAO.Data nsObj = new NsDAO.Data();
1657                 nsObj.name="test";
1658                 NsDAO.Data nsObj1 = new NsDAO.Data();
1659                 nsObj1.name="test12";
1660
1661                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1662 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1663 //              NsDAO.Data dataObj = new NsDAO.Data();
1664 //              dataObj.type=1;
1665 //              dataAl.add(dataObj);
1666                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1667                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1668                 setQuestionUserRoleDao(ques, userRoleDAO);
1669
1670                 Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",new String[0]);
1671                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1672                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1673
1674                 Result<NsDAO.Data> retVal3 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
1675                 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
1676                 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
1677
1678                 Function funcObj = new Function(trans, ques);
1679                 Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
1680                 assertTrue(result.status == 1);
1681
1682                 retVal2 = new Result<NsDAO.Data>(nsObj,1,"test",new String[0]);
1683                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1684                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1685                 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1686                 assertTrue(result.status == 1);
1687
1688                 role.ns="test2";
1689                 retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",new String[0]);
1690                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1691                 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1692                 assertTrue(result.status == 1);
1693
1694                 retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",new String[0]);
1695                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1696                 Result<NsDAO.Data> retVal21 = new Result<NsDAO.Data>(nsObj1,0,"test1",new String[0]);
1697                 Mockito.doReturn(retVal21).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1698                 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1699                 assertTrue(result.status == 1);
1700
1701                 retVal3 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1702                 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
1703                 retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",new String[0]);
1704                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
1705                 Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
1706
1707                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1708 //              Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
1709                 Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1710                 setQuestionCachedPermDao(ques, cachedPermDAO);
1711
1712                 result = funcObj.addPermToRole(trans, role, rolePerm, false);
1713                 assertTrue(result.status == Status.ERR_PermissionNotFound);
1714
1715                 Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",new String[0]);
1716                 Mockito.doReturn(retValPerm).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1717
1718                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1719                 Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, role);
1720                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1721
1722                 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1723                 assertTrue(result.status == 22);
1724
1725                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1726                 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1727                 assertTrue(result.status == 2);
1728
1729                 retVal3 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1730                 Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
1731                 Mockito.doReturn(retVal3).when(cachedRoleDAO).create(trans, role);
1732                 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1733 //              System.out.println(result.status);
1734                 assertNull(result);
1735
1736                 retVal3 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
1737                 Mockito.doReturn(retVal3).when(cachedRoleDAO).create(trans, role);
1738                 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1739                 assertTrue(result.status == 1);
1740
1741                 Result<List<RoleDAO.Data>> retVal31 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
1742                 Mockito.doReturn(retVal31).when(cachedRoleDAO).read(trans, role);
1743                 result = funcObj.addPermToRole(trans, role, rolePerm, true);
1744                 assertTrue(result.status == 7);
1745         }
1746
1747         @Test
1748         public void testDelPermFromRole() {
1749                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1750                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1751                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1752                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1753                 try {
1754                         Define.set(access);
1755                 } catch (CadiException e) {
1756                         // TODO Auto-generated catch block
1757                         e.printStackTrace();
1758                 }
1759                 List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
1760                 PermDAO.Data rolePerm = new PermDAO.Data();
1761                 Set<String> rolesSetUser = new HashSet<>();
1762                 rolesSetUser.add("testRole|test|test");
1763 //              perm.roles = rolesSet;
1764 //              perm.type=1
1765                 dataAlPerm.add(rolePerm);
1766
1767                 List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
1768                 RoleDAO.Data role = new RoleDAO.Data();
1769                 Set<String> rolesSet = new HashSet<>();
1770                 rolesSet.add("17623");
1771                 role.perms = rolesSet;
1772                 dataAl.add(role);
1773
1774                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1775 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1776 //              NsDAO.Data dataObj = new NsDAO.Data();
1777 //              dataObj.type=1;
1778 //              dataAl.add(dataObj);
1779                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1780                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1781                 setQuestionUserRoleDao(ques, userRoleDAO);
1782
1783                 Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",new String[0]);
1784                 Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",new String[0]);
1785                 Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
1786                 Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,role, Access.write);
1787
1788                 Function funcObj = new Function(trans, ques);
1789                 Result<Void> result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1790                 assertTrue(result.status == Status.ERR_Denied);
1791
1792                 Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
1793                 Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);
1794
1795                 CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
1796                 Mockito.doReturn(retValFail).when(cachedRoleDAO).read(trans, role);
1797                 setQuestionCachedRoleDao(ques, cachedRoleDAO);
1798
1799                 CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
1800                 Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1801                 setQuestionCachedPermDao(ques, cachedPermDAO);
1802
1803                 result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1804                 assertTrue(result.status == 1);
1805
1806                 Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",new String[0]);
1807                 Mockito.doReturn(retValPermSuc).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1808                 result = funcObj.delPermFromRole(trans, role, rolePerm, false);
1809                 assertTrue(result.status == 1);
1810
1811                 Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
1812                 Mockito.doReturn(retValRoleSuc).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1813                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1814                 assertTrue(result.status == Status.ERR_PermissionNotFound);
1815
1816                 role.perms = null;
1817                 dataAl.add(role);
1818                 rolesSet.add("null|null|null|null");
1819                 role.perms = rolesSet;
1820                 dataAl.add(role);
1821                 Mockito.doReturn(retValRoleSuc).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
1822                 Mockito.doReturn(retVal).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
1823                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1824                 assertTrue(result.status == 1);
1825
1826                 Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
1827                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1828                 assertTrue(result.status == 1);
1829
1830                 Mockito.doReturn(retValRoleSuc).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
1831                 Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
1832                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1833                 assertTrue(result.status == 1);
1834
1835                 Mockito.doReturn(retValPermSuc).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
1836                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1837                 assertTrue(result.status == 0);
1838
1839                 Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
1840                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1841                 assertTrue(result.status == 0);
1842
1843                 Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
1844                 result = funcObj.delPermFromRole(trans, role, rolePerm, true);
1845                 assertTrue(result.status == 1);
1846
1847                 NsSplit splitObj = new NsSplit("test", "test");
1848                 Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
1849                 Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1850                 Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
1851                 Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(PermDAO.Data.class), Mockito.any());
1852                 result = funcObj.delPermFromRole(trans, "test", rolePerm);
1853                 assertTrue(result.status == 2);
1854
1855                 retVal3 = new Result<NsSplit>(null,1,"test",new String[0]);
1856                 Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
1857                 result = funcObj.delPermFromRole(trans, "test", rolePerm);
1858                 assertTrue(result.status == 1);
1859         }
1860         @Test
1861         public void testAddUserRole() {
1862                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1863                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1864                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1865                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1866                 try {
1867                         Define.set(access);
1868                 } catch (CadiException e) {
1869                         // TODO Auto-generated catch block
1870                         e.printStackTrace();
1871                 }
1872                 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1873                 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1874                 urData.ns="test";
1875                 urData.rname="test";
1876                 urData.user="test";
1877                 urDataAl.add(urData);
1878
1879                 Organization org = Mockito.mock(Organization.class);
1880                 Mockito.doReturn(org).when(trans).org();
1881                 Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
1882
1883                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1884                 CachedRoleDAO roleDAO = Mockito.mock(CachedRoleDAO.class);
1885                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1886                 Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
1887                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1888                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1889                 Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1890                 Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1891                 setQuestionUserRoleDao(ques, userRoleDAO);
1892                 setQuestionCachedRoleDao(ques, roleDAO);
1893
1894                 CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
1895                 Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",new String[0]);
1896                 Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
1897                 setQuestionCredDao(ques, credDAO);
1898
1899                 Function funcObj = new Function(trans, ques);
1900                 Result<Void> result = funcObj.addUserRole(trans, urData);
1901                 assertTrue(result.status == 1);
1902
1903                 urData.rname=Question.ADMIN;
1904                 result = funcObj.addUserRole(trans, urData);
1905                 assertTrue(result.status == 1);
1906
1907                 NsDAO.Data data = new NsDAO.Data();
1908                 data.name="test";
1909                 Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
1910                 Mockito.doReturn(retVal1).when(ques).mayUser(trans, null,retVal1.value, Access.write);
1911                 Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
1912                 try {
1913                         Mockito.doReturn(Mockito.mock(Identity.class)).when(org).getIdentity(trans, "test");
1914                 } catch (OrganizationException e) {
1915                         // TODO Auto-generated catch block
1916                         e.printStackTrace();
1917                 }
1918                 urData.rname=Question.OWNER;
1919                 result = funcObj.addUserRole(trans, urData);
1920                 assertTrue(result.status == 1);
1921
1922                 Mockito.doReturn(retValSuc).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1923                 result = funcObj.addUserRole(trans, urData);
1924                 assertTrue(result.status == 0);
1925
1926                 Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1927                 result = funcObj.addUserRole(trans, urData);
1928                 assertTrue(result.status == Status.ERR_RoleNotFound);
1929
1930                 Mockito.doReturn(retValSuc).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
1931                 result = funcObj.addUserRole(trans, urData);
1932                 assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
1933
1934                 result = funcObj.addUserRole(trans, "test", "test", "test");
1935                 assertTrue(result.status == 1);
1936
1937                 try {
1938                         Mockito.doReturn(null).when(org).getIdentity(trans, "test");
1939                 } catch (OrganizationException e) {
1940                         // TODO Auto-generated catch block
1941                         e.printStackTrace();
1942                 }
1943                 result = funcObj.addUserRole(trans, "test", "test", "test");
1944                 assertTrue(result.status == Result.ERR_BadData);
1945
1946                 try {
1947                         Mockito.doThrow(OrganizationException.class).when(org).getIdentity(trans, "test");
1948                 } catch (OrganizationException e) {
1949                         // TODO Auto-generated catch block
1950                         e.printStackTrace();
1951                 }
1952                 result = funcObj.addUserRole(trans, "test", "test", "test");
1953                 assertTrue(result.status == 20);
1954         }
1955         @Test
1956         public void testExtendUserRole() {
1957                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
1958                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
1959                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
1960                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
1961                 try {
1962                         Define.set(access);
1963                 } catch (CadiException e) {
1964                         // TODO Auto-generated catch block
1965                         e.printStackTrace();
1966                 }
1967                 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
1968                 UserRoleDAO.Data urData = new UserRoleDAO.Data();
1969                 urData.ns="test";
1970                 urData.rname="test";
1971                 urData.user="test";
1972                 urData.expires=new Date();
1973                 urDataAl.add(urData);
1974
1975                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
1976                 CachedRoleDAO roleDAO = Mockito.mock(CachedRoleDAO.class);
1977 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
1978 //              NsDAO.Data dataObj = new NsDAO.Data();
1979 //              dataObj.type=1;
1980 //              dataAl.add(dataObj);
1981                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
1982                 Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
1983                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
1984                 Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1985                 setQuestionUserRoleDao(ques, userRoleDAO);
1986                 setQuestionCachedRoleDao(ques, roleDAO);
1987
1988                 Organization org = Mockito.mock(Organization.class);
1989                 Mockito.doReturn(org).when(trans).org();
1990                 Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any());
1991
1992                 Function funcObj = new Function(trans, ques);
1993                 Result<Void> result = funcObj.extendUserRole(trans, urData, false);
1994                 assertNull(result);
1995
1996                 Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
1997                 Mockito.doReturn(retValSuc).when(userRoleDAO).read(trans, urData);
1998                 result = funcObj.extendUserRole(trans, urData, true);
1999                 assertTrue(result.status == Status.ERR_RoleNotFound);
2000
2001                 Mockito.doReturn(retVal).when(userRoleDAO).read(trans, urData);
2002                 result = funcObj.extendUserRole(trans, urData, true);
2003                 assertTrue(result.status == Status.ERR_UserRoleNotFound);
2004         }
2005
2006         @Test
2007         public void testGetUsersByRole() {
2008                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
2009                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
2010                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
2011                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
2012                 try {
2013                         Define.set(access);
2014                 } catch (CadiException e) {
2015                         // TODO Auto-generated catch block
2016                         e.printStackTrace();
2017                 }
2018                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
2019                 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
2020                 UserRoleDAO.Data urData = new UserRoleDAO.Data();
2021                 urData.ns="test";
2022                 urData.rname="test";
2023                 urData.user="test";
2024                 urData.expires=new Date();
2025                 urDataAl.add(urData);
2026                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
2027                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
2028                 setQuestionUserRoleDao(ques, userRoleDAO);
2029
2030                 Function funcObj = new Function(trans, ques);
2031                 Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
2032                 assertTrue(result.status == 0);
2033
2034                 result = funcObj.getUsersByRole(trans, "test", true);
2035                 assertTrue(result.status == 0);
2036
2037                 urData.expires=new Date(130,1,1);
2038                 result = funcObj.getUsersByRole(trans, "test", true);
2039                 assertTrue(result.status == 0);
2040 //
2041         }
2042         @Test
2043         public void testDelUserRole() {
2044                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
2045                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
2046                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
2047                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
2048                 try {
2049                         Define.set(access);
2050                 } catch (CadiException e) {
2051                         // TODO Auto-generated catch block
2052                         e.printStackTrace();
2053                 }
2054                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
2055                 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
2056                 UserRoleDAO.Data urData = new UserRoleDAO.Data();
2057                 urData.ns="test";
2058                 urData.rname="test";
2059                 urData.user="test";
2060                 urData.expires=new Date();
2061                 urDataAl.add(urData);
2062                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
2063                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
2064                 setQuestionUserRoleDao(ques, userRoleDAO);
2065
2066                 Function funcObj = new Function(trans, ques);
2067                 Result<Void> result = funcObj.delUserRole(trans, "test", "test", "test");
2068                 assertNull(result);
2069
2070                 retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",new String[0]);
2071                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
2072                 result = funcObj.delUserRole(trans, "test", "test", "test");
2073 //              assertTrue(result.status ==1);
2074 //
2075         }
2076
2077         @Test
2078         public void testCreateFuture() {
2079                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
2080                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
2081                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
2082                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
2083                 try {
2084                         Define.set(access);
2085                 } catch (CadiException e) {
2086                         // TODO Auto-generated catch block
2087                         e.printStackTrace();
2088                 }
2089                 FutureDAO.Data data = new FutureDAO.Data();
2090                 data.memo = "test";
2091                 NsDAO.Data nsd = new NsDAO.Data();
2092                 nsd.name = "test";
2093
2094                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
2095                 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
2096                 UserRoleDAO.Data urData = new UserRoleDAO.Data();
2097                 urData.ns="test";
2098                 urData.rname="test";
2099                 urData.user="test";
2100                 urData.expires=new Date();
2101                 urDataAl.add(urData);
2102                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
2103                 Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",new String[0]);
2104                 Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
2105                 setQuestionUserRoleDao(ques, userRoleDAO);
2106
2107                 Function funcObj = new Function(trans, ques);
2108                 Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
2109                 assertTrue(result.status == 20);
2110
2111                 Organization org = Mockito.mock(Organization.class);
2112                 Mockito.doReturn(org).when(trans).org();
2113                 Identity iden=Mockito.mock(Identity.class);
2114                 try {
2115                         Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
2116                         Mockito.doReturn("test").when(iden).mayOwn();
2117                 } catch (OrganizationException e) {
2118                         // TODO Auto-generated catch block
2119                         e.printStackTrace();
2120                 }
2121                 FutureDAO.Data futureData = new FutureDAO.Data();
2122                 data.memo = "test";
2123                 FutureDAO futureDaoObj = Mockito.mock(FutureDAO.class);
2124                 Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",new String[0]);
2125                 Mockito.doReturn(retValFuture).when(futureDaoObj).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
2126                 setQuestionFutureDao(ques, futureDaoObj);
2127
2128                 ApprovalDAO.Data approvalData = new ApprovalDAO.Data();
2129                 data.memo = "test";
2130                 ApprovalDAO approvalDaoObj = Mockito.mock(ApprovalDAO.class);
2131                 Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",new String[0]);
2132                 Mockito.doReturn(retValApproval).when(approvalDaoObj).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
2133                 setQuestionApprovalDao(ques, approvalDaoObj);
2134
2135                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
2136                 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
2137                 assertTrue(result.status == 0);
2138
2139                 result = funcObj.createFuture(trans, data, "test", "test", null, FUTURE_OP.A);
2140                 assertTrue(result.status == 20);
2141
2142                 Mockito.doReturn(retValFail).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
2143                 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
2144                 assertTrue(result.status == Result.ERR_NotFound);
2145
2146                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
2147                 try {
2148                         Mockito.doReturn(null).when(org).getIdentity(trans, "test");
2149                 } catch (OrganizationException e) {
2150                         // TODO Auto-generated catch block
2151                         e.printStackTrace();
2152                 }
2153                 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
2154                 assertTrue(result.status == Result.ERR_NotFound);
2155
2156                 try {
2157                         Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
2158                 } catch (OrganizationException e) {
2159                         // TODO Auto-generated catch block
2160                         e.printStackTrace();
2161                 }
2162                 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
2163                 assertTrue(result.status == 0);
2164
2165                 retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",new String[0]);
2166                 Mockito.doReturn(retValApproval).when(approvalDaoObj).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
2167                 result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
2168                 assertTrue(result.status == 8);
2169         }
2170         @Test
2171         public void testUbLookup() {
2172                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
2173                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
2174                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
2175                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
2176                 try {
2177                         Define.set(access);
2178                 } catch (CadiException e) {
2179                         // TODO Auto-generated catch block
2180                         e.printStackTrace();
2181                 }
2182                 Object[] objArr = new Object[10];
2183                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
2184                 List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
2185                 UserRoleDAO.Data urData = new UserRoleDAO.Data();
2186                 urData.ns="test";
2187                 urData.rname="test";
2188                 urData.user="test";
2189                 urData.expires=new Date();
2190                 urDataAl.add(urData);
2191                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
2192                 Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
2193                 Mockito.doReturn(retVal).when(userRoleDAO).read(trans, objArr);
2194                 setQuestionUserRoleDao(ques, userRoleDAO);
2195
2196                 Function funcObj = new Function(trans, ques);
2197                 funcObj.urDBLookup.get(trans, objArr);
2198
2199                 Mockito.doReturn(retValFail).when(userRoleDAO).read(trans, objArr);
2200                 funcObj.urDBLookup.get(trans, objArr);
2201         }
2202
2203         @Test
2204         public void testPerformFutureOp() {
2205                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
2206                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
2207                 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
2208                 Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
2209                 Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
2210                 try {
2211                         Define.set(access);
2212                 } catch (CadiException e) {
2213                         // TODO Auto-generated catch block
2214                         e.printStackTrace();
2215                 }
2216                 FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
2217                 futureDataDaoObj.memo="test";
2218                 futureDataDaoObj.target = "test";
2219                 futureDataDaoObj.id = new UUID(10L,10L);
2220
2221                 final List<ApprovalDAO.Data> apprs = new ArrayList<>();
2222                 ApprovalDAO.Data approvalObj = new ApprovalDAO.Data();
2223                 approvalObj.status = "approved";
2224                 approvalObj.type = "owner";
2225                 apprs.add(approvalObj);
2226                 Lookup<List<ApprovalDAO.Data>> lookupApprovalObj = new Lookup<List<ApprovalDAO.Data>>() {
2227             @Override
2228             public List<ApprovalDAO.Data> get(AuthzTrans trans, Object ... keys) {
2229                 return apprs;
2230             }
2231         };
2232
2233         final UserRoleDAO.Data userObj = new UserRoleDAO.Data();
2234         Lookup<UserRoleDAO.Data> lookupUserObj = new Lookup<UserRoleDAO.Data>() {
2235             @Override
2236             public UserRoleDAO.Data get(AuthzTrans trans, Object ... keys) {
2237                 return userObj;
2238             }
2239         };
2240
2241         FutureDAO.Data futureData = new FutureDAO.Data();
2242 //              data.memo = "test";
2243                 FutureDAO futureDaoObj = Mockito.mock(FutureDAO.class);
2244                 Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",new String[0]);
2245                 Mockito.doReturn(retValFuture).when(futureDaoObj).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
2246                 setQuestionFutureDao(ques, futureDaoObj);
2247
2248                 CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
2249 //              List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
2250 //              NsDAO.Data dataObj = new NsDAO.Data();
2251 //              dataObj.type=1;
2252 //              dataAl.add(dataObj);
2253                 Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
2254                 Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
2255                 setQuestionUserRoleDao(ques, userRoleDAO);
2256 //
2257 //              Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
2258 //              Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
2259 //
2260                 Function funcObj = new Function(trans, ques);
2261                 Result<Function.OP_STATUS> result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2262                 assertTrue(result.status == 0);
2263
2264                 approvalObj.status = "approved";
2265                 approvalObj.type = "supervisor";
2266                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2267                 assertTrue(result.status == 0);
2268
2269                 approvalObj.status = "approved";
2270                 approvalObj.type = "";
2271                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2272                 assertTrue(result.status == 0);
2273
2274                 approvalObj.status = "pending";
2275                 approvalObj.type = "supervisor";
2276                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2277                 assertTrue(result.status == 0);
2278
2279                 approvalObj.status = "pending";
2280                 approvalObj.type = "owner";
2281                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2282                 assertTrue(result.status == 0);
2283
2284                 approvalObj.status = "pending";
2285                 approvalObj.type = "";
2286                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2287                 assertTrue(result.status == 0);
2288
2289                 approvalObj.status = "denied";
2290                 approvalObj.type = "";
2291                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2292                 assertTrue(result.status == 0);
2293
2294                 retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",new String[0]);
2295                 Mockito.doReturn(retValFuture).when(futureDaoObj).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
2296                 result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
2297                 System.out.println(result);
2298                 assertTrue(result.status == 0);
2299 //
2300         }
2301 }