* * Licensed under the Apache License, Version 2.0 (the "License");
* * you may not use this file except in compliance with the License.
* * You may obtain a copy of the License at
* * Licensed under the Apache License, Version 2.0 (the "License");
* * you may not use this file except in compliance with the License.
* * You may obtain a copy of the License at
* * Unless required by applicable law or agreed to in writing, software
* * distributed under the License is distributed on an "AS IS" BASIS,
* * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* * Unless required by applicable law or agreed to in writing, software
* * distributed under the License is distributed on an "AS IS" BASIS,
* * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(3 == result.status);
}
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(3 == result.status);
}
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(3 == result.status);
}
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(3 == result.status);
}
@Test
public void testCreateNsFromApprovaFalse() {
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
namespace.owner = owner;
@Test
public void testCreateNsFromApprovaFalse() {
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
namespace.owner = owner;
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, false);
assertTrue(1 == result.status);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, false);
assertTrue(1 == result.status);
Mockito.doReturn(retVal2).when(ques).deriveNs(trans, "test");
funcObj = new Function(trans, ques);
result = funcObj.createNS(trans, namespace, false);
assertTrue(1 == result.status);
}
Mockito.doReturn(retVal2).when(ques).deriveNs(trans, "test");
funcObj = new Function(trans, ques);
result = funcObj.createNS(trans, namespace, false);
assertTrue(1 == result.status);
}
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(org).when(trans).org();
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(org).when(trans).org();
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_Policy);
assertTrue(result.details.contains("is not a valid user at"));
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_Policy);
assertTrue(result.details.contains("is not a valid user at"));
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_Policy);
assertTrue(result.details.contains("cannot be the owner of the namespace "));
result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_Policy);
assertTrue(result.details.contains("cannot be the owner of the namespace "));
Mockito.doReturn(true).when(org).isTestEnv();
try {
Mockito.doReturn("test").when(org).validate(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Mockito.doReturn(true).when(org).isTestEnv();
try {
Mockito.doReturn("test").when(org).validate(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any());
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doThrow(new OrganizationException()).when(org).getIdentity(trans, "test");
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doThrow(new OrganizationException()).when(org).getIdentity(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_Security);
assertTrue(result.details.contains("may not create Root Namespaces"));
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_Security);
assertTrue(result.details.contains("may not create Root Namespaces"));
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, null);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, null);
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
result = funcObj.createNS(trans, namespace, true);
assertTrue(24 == result.status);
result = funcObj.createNS(trans, namespace, true);
assertTrue(24 == result.status);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
}
dataObj.add(indData);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
}
dataObj.add(indData);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == 1);
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == 1);
@Test
public void testCreateNsAdminLoopCreateSucReadChildrenFailure() {
Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
@Test
public void testCreateNsAdminLoopCreateSucReadChildrenFailure() {
Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
indData4.rname = "test";
dataObj4.add(indData4);
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
indData4.rname = "test";
dataObj4.add(indData4);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",NO_PARAM);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",NO_PARAM);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
- Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal6).when(roleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal6).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");
- Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");
-
+ Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
+ Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+ Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal6).when(roleDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal6).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");
+ Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");
+
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Function funcObj = new Function(trans, ques);
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_ActionNotCompleted);
Function funcObj = new Function(trans, ques);
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == Status.ERR_ActionNotCompleted);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
Result<Void> retVal = new Result<Void>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(nsDAO).create(Mockito.any(), Mockito.any());
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
indData4.rname = "test";
dataObj4.add(indData4);
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
indData4.rname = "test";
dataObj4.add(indData4);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
- Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal2).when(roleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal2).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");
- Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");
-
+ Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
+ Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+ Mockito.doReturn(retVal2).when(userRoleDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal2).when(roleDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal2).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal5).when(permDAO).readChildren(trans, "test", "test");
+ Mockito.doReturn(retVal5).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal3).when(roleDAO).readChildren(trans, "test", "test");
+
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == 0);
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(roleDAO).read(trans, "test","test");
Mockito.doReturn(Result.err(Result.ERR_NotFound, "Not Found")).when(permDAO).readByType(trans, "test","test");
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
assertTrue(result.status == 0);
@Test
public void test4DeleteNs() {
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
@Test
public void test4DeleteNs() {
Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
Mockito.doReturn(false).when(ques).canMove(Mockito.any());
Mockito.doReturn(retVal).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Mockito.doReturn(false).when(ques).canMove(Mockito.any());
Mockito.doReturn(retVal).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_Security);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_Security);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
dataObj4.add(indData4);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(trans, "test");
dataObj4.add(indData4);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(trans, "test");
indData1.perms = permsSet;
dataObj1.add(indData1);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
indData1.perms = permsSet;
dataObj1.add(indData1);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
indData1.perms = permsSet;
dataObj1.add(indData1);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
indData1.perms = permsSet;
dataObj1.add(indData1);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
- Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
- Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");
+ Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
+ Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test.test");
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test.test");
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
dataObj.type=1;
dataAl.add(dataObj);
Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
CredDAO.Data nsData = new CredDAO.Data();
nsData.id="test";
List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
CredDAO.Data nsData = new CredDAO.Data();
nsData.id="test";
Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",NO_PARAM);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",NO_PARAM);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == 1);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
- Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
+ Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test.test");
Mockito.doReturn(retVal5).when(permDAO).read(trans, indData5);
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal4).when(userRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal4).when(userRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
indData1.perms = permsSet;
dataObj1.add(indData1);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
indData1.perms = permsSet;
dataObj1.add(indData1);
Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",NO_PARAM);
- Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
- Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");
+ Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test");
+ Mockito.doReturn(retVal3).when(roleDAO).readNS(trans, "test.test");
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test.test");
assertNull(result);
}
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test.test");
assertNull(result);
}
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getOwners(trans, "test", false);
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getOwners(trans, "test", false);
assertTrue(result.status == 1);
@Test
public void testDelOwner() {
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
@Test
public void testDelOwner() {
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
- Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
+ Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+ Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delOwner(trans, "test", "test");
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delOwner(trans, "test", "test");
assertTrue(result.status == 1);
retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delOwner(trans, "test", "test");
assertTrue(result.status == 1);
retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delOwner(trans, "test", "test");
assertTrue(result.status == 1);
retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delOwner(trans, "test", "test");
retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
result = funcObj.delOwner(trans, "test", "test");
retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delOwner(trans, "test", "test");
retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
result = funcObj.delOwner(trans, "test", "test");
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getAdmins(trans, "test", false);
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getAdmins(trans, "test", false);
assertTrue(result.status == 1);
@Test
public void testDelAdmin() {
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
@Test
public void testDelAdmin() {
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
- Mockito.doReturn(retVal).when(userRoleDAO).readUserInRole(Mockito.any(), Mockito.anyString(), Mockito.anyString());
- Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
+ Mockito.doReturn(retVal).when(userRoleDAO).readUserInRole(Mockito.any(), Mockito.anyString(), Mockito.anyString());
+ Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delAdmin(trans, "test", "test");
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delAdmin(trans, "test", "test");
assertTrue(result.status == 1);
retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delAdmin(trans, "test", "test");
assertTrue(result.status == 1);
retVal1 = new Result<NsDAO.Data>(data,1,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delAdmin(trans, "test", "test");
assertTrue(result.status == 1);
retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delOwner(trans, "test", "test");
retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
result = funcObj.delAdmin(trans, "test", "test");
retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
result = funcObj.delOwner(trans, "test", "test");
retVal2 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal1.value, Access.write);
result = funcObj.delAdmin(trans, "test", "test");
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
- Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
-
- Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
-
- Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
-
+ Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
+
+ Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
+
NsDAO.Data nsDataObj = new NsDAO.Data();
nsDataObj.name="test";
StringBuilder sb = new StringBuilder();
Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",NO_PARAM);
NsDAO.Data nsDataObj = new NsDAO.Data();
nsDataObj.name="test";
StringBuilder sb = new StringBuilder();
Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",NO_PARAM);
retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
- Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal3).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal3).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
NsSplit splitObj = new NsSplit("test", "test");
Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
NsSplit splitObj = new NsSplit("test", "test");
Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
-
- Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal4).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+
+ Mockito.doReturn(retVal3).when(permDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal4).when(permDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
private void invokeMovePerms(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<PermDAO.Data>> retVal1) {
Function funcObj = new Function(trans, ques);
Method met;
private void invokeMovePerms(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<PermDAO.Data>> retVal1) {
Function funcObj = new Function(trans, ques);
Method met;
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
- Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
-
- Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
-
- Mockito.doReturn(retVal).when(roleDAO).create(Mockito.any(), Mockito.any());
-
+ Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
+
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
+
+ Mockito.doReturn(retVal).when(roleDAO).create(Mockito.any(), Mockito.any());
+
NsDAO.Data nsDataObj = new NsDAO.Data();
nsDataObj.name="test";
StringBuilder sb = new StringBuilder();
Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",NO_PARAM);
NsDAO.Data nsDataObj = new NsDAO.Data();
nsDataObj.name="test";
StringBuilder sb = new StringBuilder();
Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",NO_PARAM);
indData5.name = "admin";
dataObj5.add(indData5);
retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",NO_PARAM);
indData5.name = "admin";
dataObj5.add(indData5);
retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",NO_PARAM);
- Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal3).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal3).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
NsSplit splitObj = new NsSplit("test", "test");
Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
NsSplit splitObj = new NsSplit("test", "test");
Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
-
- Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal4).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+
+ Mockito.doReturn(retVal3).when(roleDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal4).when(roleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
private void invokeMoveRoles(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<RoleDAO.Data>> retVal1) {
Function funcObj = new Function(trans, ques);
Method met;
private void invokeMoveRoles(NsDAO.Data nsDataObj, StringBuilder sb,Result<List<RoleDAO.Data>> retVal1) {
Function funcObj = new Function(trans, ques);
Method met;
dataAl.add(perm);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
dataAl.add(perm);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
-
- Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
- Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
-
+
+ Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
+ Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
+
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createPerm(trans, perm, false);
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createPerm(trans, perm, false);
assertTrue(result.status == 1);
retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
result = funcObj.createPerm(trans, perm, false);
retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
result = funcObj.createPerm(trans, perm, false);
Result<List<RoleDAO.Data>> retVal4 = Result.err(Result.ERR_NotFound,"");
Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(),Mockito.any(RoleDAO.Data.class));
result = funcObj.createPerm(trans, perm, false);
Result<List<RoleDAO.Data>> retVal4 = Result.err(Result.ERR_NotFound,"");
Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(),Mockito.any(RoleDAO.Data.class));
result = funcObj.createPerm(trans, perm, false);
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == 1);
Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == 0);
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == 1);
Mockito.doReturn(retVal2).when(permDAO).create(Mockito.any(), Mockito.any());
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == 0);
Mockito.doReturn(false).when(trans).requested(REQD_TYPE.force);
Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
Mockito.doReturn(false).when(trans).requested(REQD_TYPE.force);
Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",NO_PARAM);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
assertTrue(result.status == 1);
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
assertTrue(result.status == 1);
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
result = funcObj.deletePerm(trans, perm, true,true);
assertTrue(result.status == Status.ERR_PermissionNotFound);
result = funcObj.deletePerm(trans, perm, true,true);
assertTrue(result.status == Status.ERR_PermissionNotFound);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(permDAO).read(trans, perm);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(permDAO).read(trans, perm);
NsSplit nsObj = new NsSplit("test","test");
Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
NsSplit nsObj = new NsSplit("test","test");
Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
result = funcObj.deletePerm(trans, perm, true,false);
result = funcObj.deletePerm(trans, perm, true,false);
result = funcObj.deletePerm(trans, perm, true,false);
result = funcObj.deletePerm(trans, perm, true,false);
result = funcObj.deletePerm(trans, perm, false,false);
// assertTrue(result.status == 1);
}
result = funcObj.deletePerm(trans, perm, false,false);
// assertTrue(result.status == 1);
}
List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
RoleDAO.Data role = new RoleDAO.Data();
Set<String> rolesSet = new HashSet<>();
List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
RoleDAO.Data role = new RoleDAO.Data();
Set<String> rolesSet = new HashSet<>();
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteRole(trans, role, true, false);
assertTrue(result.status == 1);
Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteRole(trans, role, true, false);
assertTrue(result.status == 1);
Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
NsSplit splitObj = new NsSplit("test", "test");
Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
NsSplit splitObj = new NsSplit("test", "test");
Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
result = funcObj.deleteRole(trans, role, true, true);
assertNull(result);
result = funcObj.deleteRole(trans, role, true, true);
assertNull(result);
Mockito.doReturn(retVal1).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
result = funcObj.deleteRole(trans, role, true, true);
assertNull(result);
Mockito.doReturn(retVal1).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
result = funcObj.deleteRole(trans, role, true, true);
assertNull(result);
result = funcObj.deleteRole(trans, role, true, true);
assertTrue(result.status == Status.ERR_RoleNotFound);
result = funcObj.deleteRole(trans, role, true, true);
assertTrue(result.status == Status.ERR_RoleNotFound);
retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",NO_PARAM);
retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",NO_PARAM);
result = funcObj.deleteRole(trans, role, false, true);
assertTrue(result.status == Status.ERR_DependencyExists);
}
result = funcObj.deleteRole(trans, role, false, true);
assertTrue(result.status == Status.ERR_DependencyExists);
}
List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
RoleDAO.Data role = new RoleDAO.Data();
Set<String> rolesSet = new HashSet<>();
List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
RoleDAO.Data role = new RoleDAO.Data();
Set<String> rolesSet = new HashSet<>();
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
Result<NsDAO.Data> retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
Result<NsDAO.Data> retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
role.ns="test2";
retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
role.ns="test2";
retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
Result<NsDAO.Data> retVal21 = new Result<NsDAO.Data>(nsObj1,0,"test1",NO_PARAM);
Mockito.doReturn(retVal21).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
Result<NsDAO.Data> retVal21 = new Result<NsDAO.Data>(nsObj1,0,"test1",NO_PARAM);
Mockito.doReturn(retVal21).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,rolePerm, Access.write);
retVal2 = new Result<NsDAO.Data>(nsObj,0,"test1",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, role.ns, NsType.COMPANY);
Mockito.doReturn(retVal2).when(ques).deriveFirstNsForType(trans, rolePerm.ns, NsType.COMPANY);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == Status.ERR_PermissionNotFound);
result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == Status.ERR_PermissionNotFound);
Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",NO_PARAM);
Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",NO_PARAM);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 22);
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 2);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 22);
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 2);
retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
// System.out.println(result.status);
assertNull(result);
retVal3 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).mayUser(trans, null,role, Access.write);
Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
// System.out.println(result.status);
assertNull(result);
retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
retVal3 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(roleDAO).create(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
Result<List<RoleDAO.Data>> retVal31 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal31).when(roleDAO).read(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 7);
}
Result<List<RoleDAO.Data>> retVal31 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal31).when(roleDAO).read(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 7);
}
List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
RoleDAO.Data role = new RoleDAO.Data();
Set<String> rolesSet = new HashSet<>();
rolesSet.add("17623");
role.perms = rolesSet;
dataAl.add(role);
List<RoleDAO.Data> dataAl = new ArrayList<RoleDAO.Data>();
RoleDAO.Data role = new RoleDAO.Data();
Set<String> rolesSet = new HashSet<>();
rolesSet.add("17623");
role.perms = rolesSet;
dataAl.add(role);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,role, Access.write);
Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,role, Access.write);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == Status.ERR_Denied);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == Status.ERR_Denied);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
- Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);
-
+ Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);
+
result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",NO_PARAM);
Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",NO_PARAM);
result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == Status.ERR_PermissionNotFound);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == Status.ERR_PermissionNotFound);
- Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
- Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
+ Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
+ Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
Mockito.doReturn(retValRoleSuc).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
Mockito.doReturn(retValRoleSuc).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
- Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
-
- Mockito.doReturn(retValPermSuc).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
+
+ Mockito.doReturn(retValPermSuc).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 0);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 0);
Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 0);
Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 0);
-
- Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
+
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(PermDAO.Data.class), Mockito.any());
result = funcObj.delPermFromRole(trans, "test", rolePerm);
assertTrue(result.status == 2);
Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(PermDAO.Data.class), Mockito.any());
result = funcObj.delPermFromRole(trans, "test", rolePerm);
assertTrue(result.status == 2);
retVal3 = new Result<NsSplit>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
result = funcObj.delPermFromRole(trans, "test", rolePerm);
retVal3 = new Result<NsSplit>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
result = funcObj.delPermFromRole(trans, "test", rolePerm);
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
- Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
- Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
+ Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
+ Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 1);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 1);
urData.rname=Question.ADMIN;
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 1);
urData.rname=Question.ADMIN;
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 1);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 1);
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 1);
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 0);
Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == Status.ERR_RoleNotFound);
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == 0);
Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == Status.ERR_RoleNotFound);
Mockito.doReturn(retValSuc).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
Mockito.doReturn(retValSuc).when(userRoleDAO).read(Mockito.any(), Mockito.any(UserRoleDAO.Data.class));
result = funcObj.addUserRole(trans, urData);
assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == 1);
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == 1);
try {
Mockito.doReturn(null).when(org).getIdentity(trans, "test");
} catch (OrganizationException e) {
try {
Mockito.doReturn(null).when(org).getIdentity(trans, "test");
} catch (OrganizationException e) {
}
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == Result.ERR_BadData);
}
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == Result.ERR_BadData);
try {
Mockito.doThrow(OrganizationException.class).when(org).getIdentity(trans, "test");
} catch (OrganizationException e) {
try {
Mockito.doThrow(OrganizationException.class).when(org).getIdentity(trans, "test");
} catch (OrganizationException e) {
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == 20);
}
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == 20);
}
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any());
Mockito.doReturn(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.extendUserRole(trans, urData, false);
assertNull(result);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.extendUserRole(trans, urData, false);
assertNull(result);
Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
Mockito.doReturn(retValSuc).when(userRoleDAO).read(trans, urData);
result = funcObj.extendUserRole(trans, urData, true);
assertTrue(result.status == Status.ERR_RoleNotFound);
Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
Mockito.doReturn(retValSuc).when(userRoleDAO).read(trans, urData);
result = funcObj.extendUserRole(trans, urData, true);
assertTrue(result.status == Status.ERR_RoleNotFound);
Mockito.doReturn(retVal).when(userRoleDAO).read(trans, urData);
result = funcObj.extendUserRole(trans, urData, true);
assertTrue(result.status == Status.ERR_UserRoleNotFound);
}
Mockito.doReturn(retVal).when(userRoleDAO).read(trans, urData);
result = funcObj.extendUserRole(trans, urData, true);
assertTrue(result.status == Status.ERR_UserRoleNotFound);
}
urData.expires=new Date();
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
urData.expires=new Date();
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
result = funcObj.getUsersByRole(trans, "test", true);
assertTrue(result.status == 0);
result = funcObj.getUsersByRole(trans, "test", true);
assertTrue(result.status == 0);
urData.expires=new Date(130,1,1);
result = funcObj.getUsersByRole(trans, "test", true);
assertTrue(result.status == 0);
urData.expires=new Date(130,1,1);
result = funcObj.getUsersByRole(trans, "test", true);
assertTrue(result.status == 0);
urData.expires=new Date();
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
urData.expires=new Date();
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delUserRole(trans, "test", "test", "test");
assertNull(result);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.delUserRole(trans, "test", "test", "test");
assertNull(result);
retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
result = funcObj.delUserRole(trans, "test", "test", "test");
retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
result = funcObj.delUserRole(trans, "test", "test", "test");
@Test
public void testCreateFuture() {
FutureDAO.Data data = new FutureDAO.Data();
data.memo = "test";
NsDAO.Data nsd = new NsDAO.Data();
nsd.name = "test";
@Test
public void testCreateFuture() {
FutureDAO.Data data = new FutureDAO.Data();
data.memo = "test";
NsDAO.Data nsd = new NsDAO.Data();
nsd.name = "test";
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
Function funcObj = new Function(trans, ques);
Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
data.memo = "test";
Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
Mockito.doReturn(retValFuture).when(futureDAO).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
data.memo = "test";
Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
Mockito.doReturn(retValFuture).when(futureDAO).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
ApprovalDAO.Data approvalData = new ApprovalDAO.Data();
data.memo = "test";
Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",NO_PARAM);
Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
ApprovalDAO.Data approvalData = new ApprovalDAO.Data();
data.memo = "test";
Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",NO_PARAM);
Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == 0);
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == 0);
result = funcObj.createFuture(trans, data, "test", "test", null, FUTURE_OP.A);
assertTrue(result.status == 20);
Mockito.doReturn(retValFail).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == Result.ERR_NotFound);
result = funcObj.createFuture(trans, data, "test", "test", null, FUTURE_OP.A);
assertTrue(result.status == 20);
Mockito.doReturn(retValFail).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == Result.ERR_NotFound);
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
try {
Mockito.doReturn(null).when(org).getIdentity(trans, "test");
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
try {
Mockito.doReturn(null).when(org).getIdentity(trans, "test");
}
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == Result.ERR_NotFound);
}
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == Result.ERR_NotFound);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
} catch (OrganizationException e) {
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
} catch (OrganizationException e) {
}
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
assertTrue(result.status == 0);
}
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
assertTrue(result.status == 0);
retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retValApproval).when(approvalDAO).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
urDataAl.add(urData);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
Function funcObj = new Function(trans, ques);
funcObj.urDBLookup.get(trans, objArr);
Function funcObj = new Function(trans, ques);
funcObj.urDBLookup.get(trans, objArr);
@Test
public void testPerformFutureOp() {
FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
futureDataDaoObj.memo="test";
futureDataDaoObj.target = "test";
futureDataDaoObj.id = new UUID(10L,10L);
@Test
public void testPerformFutureOp() {
FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
futureDataDaoObj.memo="test";
futureDataDaoObj.target = "test";
futureDataDaoObj.id = new UUID(10L,10L);
final List<ApprovalDAO.Data> apprs = new ArrayList<>();
ApprovalDAO.Data approvalObj = new ApprovalDAO.Data();
approvalObj.status = "approved";
final List<ApprovalDAO.Data> apprs = new ArrayList<>();
ApprovalDAO.Data approvalObj = new ApprovalDAO.Data();
approvalObj.status = "approved";
final UserRoleDAO.Data userObj = new UserRoleDAO.Data();
Lookup<UserRoleDAO.Data> lookupUserObj = new Lookup<UserRoleDAO.Data>() {
@Override
final UserRoleDAO.Data userObj = new UserRoleDAO.Data();
Lookup<UserRoleDAO.Data> lookupUserObj = new Lookup<UserRoleDAO.Data>() {
@Override
FutureDAO.Data futureData = new FutureDAO.Data();
// data.memo = "test";
Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
FutureDAO.Data futureData = new FutureDAO.Data();
// data.memo = "test";
Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",NO_PARAM);
Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
// NsDAO.Data dataObj = new NsDAO.Data();
// dataObj.type=1;
// dataAl.add(dataObj);
Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
// Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,retVal.value.get(0), Access.write);
Function funcObj = new Function(trans, ques);
Result<Function.OP_STATUS> result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
Function funcObj = new Function(trans, ques);
Result<Function.OP_STATUS> result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "approved";
approvalObj.type = "supervisor";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "approved";
approvalObj.type = "supervisor";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "approved";
approvalObj.type = "";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "approved";
approvalObj.type = "";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "pending";
approvalObj.type = "supervisor";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "pending";
approvalObj.type = "supervisor";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "pending";
approvalObj.type = "owner";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "pending";
approvalObj.type = "owner";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "pending";
approvalObj.type = "";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "pending";
approvalObj.type = "";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "denied";
approvalObj.type = "";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
approvalObj.status = "denied";
approvalObj.type = "";
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",NO_PARAM);
Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
System.out.println(result);
assertTrue(result.status == 0);
retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",NO_PARAM);
Mockito.doReturn(retValFuture).when(futureDAO).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
result = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
System.out.println(result);
assertTrue(result.status == 0);