import static org.mockito.MockitoAnnotations.initMocks;
import java.io.IOException;
-import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.nio.ByteBuffer;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class JU_Function {
+ private static final Object NO_PARAM = new Object[0];
+
@Mock
AuthzTrans trans;
@Mock
@Mock
Question ques;
+ @Mock
+ Organization org;
+
+ @Mock
+ CachedNSDAO nsDAO;
+
+ @Mock
+ CachedRoleDAO roleDAO;
+
+ @Mock
+ CachedPermDAO permDAO;
+
+ @Mock
+ CachedCredDAO credDAO;
+
+ @Mock
+ CachedUserRoleDAO userRoleDAO;
+
+ @Mock
+ ApprovalDAO approvalDAO;
+
+ @Mock
+ FutureDAO futureDAO;
+
@Before
public void setUp() throws APIException, IOException {
initMocks(this);
- }
+ Mockito.doReturn(org).when(trans).org();
+ Mockito.doReturn(nsDAO).when(ques).nsDAO();
+ Mockito.doReturn(roleDAO).when(ques).roleDAO();
+ Mockito.doReturn(permDAO).when(ques).permDAO();
+ Mockito.doReturn(credDAO).when(ques).credDAO();
+ Mockito.doReturn(userRoleDAO).when(ques).userRoleDAO();
+ Mockito.doReturn(approvalDAO).when(ques).approvalDAO();
+ Mockito.doReturn(futureDAO).when(ques).futureDAO();
- @Test
- public void testCreateNs() {
Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
+ Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
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");
+
try {
Define.set(access);
} catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
}
+ }
+
+ @Test
+ public void testCreateNs() {
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
namespace.owner = owner;
-
- Organization org = Mockito.mock(Organization.class);
- Mockito.doReturn(org).when(trans).org();
-
+
+ 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");
+
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
+ //setQuestion(ques, cachedNS);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
@Test
public void testCreateNsReadSuccess() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.createNS(trans, namespace, true);
@Test
public void testCreateNsFromApprovaFalse() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ 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",new String[0]);
+ 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);
@Test
public void testCreateNsownerLoop() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
@Test
public void testCreateNsownerLoopException() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test";
List<String> owner = new ArrayList<String>();
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+ 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.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",new String[0]);
+ retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, null);
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
result = funcObj.createNS(trans, namespace, true);
assertTrue(24 == result.status);
}
-
- public void setQuestion(Question ques, CachedNSDAO userRoleDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("nsDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, userRoleDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
-
- public void setQuestionCredDao(Question ques, CachedCredDAO credDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("credDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, credDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
-
- public void setQuestionUserRoleDao(Question ques, CachedUserRoleDAO credDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("userRoleDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, credDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
- public void setQuestionCachedRoleDao(Question ques, CachedRoleDAO credDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("roleDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, credDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
-
- public void setQuestionCachedPermDao(Question ques, CachedPermDAO credDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("permDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, credDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
- public void setQuestionFutureDao(Question ques, FutureDAO futureDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("futureDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, futureDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
- public void setQuestionApprovalDao(Question ques, ApprovalDAO approvalDaoObj) {
- Field nsDaoField;
- try {
- nsDaoField = Question.class.getDeclaredField("approvalDAO");
-
- nsDaoField.setAccessible(true);
- // remove final modifier from field
- Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
-
- nsDaoField.set(ques, approvalDaoObj);
- } catch (NoSuchFieldException | SecurityException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalArgumentException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- } catch (IllegalAccessException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- }
+
@Test
public void testCreateNsAdminLoop() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
- Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal).when(nsDaoObj).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());
List<CredDAO.Data> dataObj = new ArrayList<>();
CredDAO.Data indData = new CredDAO.Data();
indData.id = "test";
e1.printStackTrace();
}
dataObj.add(indData);
- Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
+ Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
- setQuestionCredDao(ques, credDAO);
Identity iden=Mockito.mock(Identity.class);
try {
e.printStackTrace();
}
+ 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);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
- Result<Void> retVal = new Result<Void>(null,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal).when(nsDaoObj).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<CredDAO.Data> dataObj = new ArrayList<>();
CredDAO.Data indData = new CredDAO.Data();
indData.id = "test";
indData5.type = "test";
dataObj5.add(indData5);
- Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
- Result<List<CredDAO.Data>> retVal6 = new Result<List<CredDAO.Data>>(dataObj,1,"test",new String[0]);
- Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
- Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
- Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
+ 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(cachedRoleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal6).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal5).when(cachedPermDAO).readChildren(trans, "test", "test");
- Mockito.doReturn(retVal5).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readChildren(trans, "test", "test");
- setQuestion(ques, nsDaoObj);
- setQuestionCredDao(ques, credDAO);
- setQuestionUserRoleDao(ques, userRoleDAO);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ 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 {
}
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);
@Test
public void testCreateNsAdminLoopCreateSuc() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Namespace namespace = Mockito.mock(Namespace.class);
namespace.name = "test.test";
List<String> owner = new ArrayList<String>();
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
- Result<Void> retVal = new Result<Void>(null,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal).when(nsDaoObj).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<CredDAO.Data> dataObj = new ArrayList<>();
CredDAO.Data indData = new CredDAO.Data();
indData.id = "test";
indData5.roles = rolesSet;
dataObj5.add(indData5);
- Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(dataObj,0,"test",new String[0]);
- Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
- Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
- Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
+ 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(cachedRoleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal2).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal5).when(cachedPermDAO).readChildren(trans, "test", "test");
- Mockito.doReturn(retVal5).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readChildren(trans, "test", "test");
- setQuestion(ques, nsDaoObj);
- setQuestionCredDao(ques, credDAO);
- setQuestionUserRoleDao(ques, userRoleDAO);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ 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 {
e.printStackTrace();
}
+ 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() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
- Result<Void> retVal = new Result<Void>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<Void> retVal = new Result<Void>(null,1,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_NsNotFound);
}
+
@Test
- public void test4DeleteCanMOveFail() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
- Mockito.doReturn(true).when(trans).requested(REQD_TYPE.move);
- Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
- Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
+ public void test4DeleteCanMoveFail() {
List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
NsDAO.Data dataObj = new NsDAO.Data();
dataObj.type=1;
dataAl.add(dataObj);
- Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
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_Denied);
+ assertTrue(result.status == Status.ERR_Security);
}
+
@Test
public void test4DeleteNsReadSuc() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
NsDAO.Data dataObj = new NsDAO.Data();
dataObj.type=1;
dataAl.add(dataObj);
- Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+ 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);
assertTrue(result.status == 1);
}
+
@Test
public void test4DeleteNsMayUserSuc() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
NsDAO.Data dataObj = new NsDAO.Data();
dataObj.type=1;
dataAl.add(dataObj);
- Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ 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);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
- setQuestionCredDao(ques, credDAO);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
- Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",new String[0]);
- Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(null,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal5).when(permDAO).readNS(trans, "test");
- CachedUserRoleDAO cachedUserRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
indData4.rname = "test";
dataObj4.add(indData4);
- Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
- Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByRole(trans, "test");
- setQuestionUserRoleDao(ques, cachedUserRoleDAO);
+ Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(trans, "test");
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
List<RoleDAO.Data> dataObj1 = new ArrayList<>();
RoleDAO.Data indData1 = new RoleDAO.Data();
indData1.ns = "test";
permsSet.add("test|test");
indData1.perms = permsSet;
dataObj1.add(indData1);
- Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");
- Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ 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).read(trans, indData1);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
assertTrue(result.status == Status.ERR_DependencyExists);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- setQuestionUserRoleDao(ques, userRoleDAO);
Mockito.doReturn(retVal4).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
}
@Test
public void test4DeleteNsDrivensFailure() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
NsDAO.Data dataObj = new NsDAO.Data();
dataObj.type=1;
dataAl.add(dataObj);
- Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ 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);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
Mockito.doReturn(retVal2).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
- setQuestionCredDao(ques, credDAO);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
List<PermDAO.Data> dataObj5 = new ArrayList<>();
PermDAO.Data indData5 = new PermDAO.Data();
indData5.ns = "test";
indData5.type = "test";
dataObj5.add(indData5);
- Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
- Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
- Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test.test");
- Mockito.doReturn(retVal5).when(cachedPermDAO).read(trans, indData5);
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
+ 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);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
List<RoleDAO.Data> dataObj1 = new ArrayList<>();
RoleDAO.Data indData1 = new RoleDAO.Data();
indData1.ns = "test";
permsSet.add("test|test");
indData1.perms = permsSet;
dataObj1.add(indData1);
- Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test.test");
- Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ 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).read(trans, indData1);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+ 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);
result = funcObj.deleteNS(trans, "test.test");
assertTrue(result.status == 1);
}
+
@Test
public void test4DeleteNsWithDot() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedNSDAO nsDaoObj = Mockito.mock(CachedNSDAO.class);
List<NsDAO.Data> dataAl = new ArrayList<NsDAO.Data>();
NsDAO.Data dataObj = new NsDAO.Data();
dataObj.type=1;
dataAl.add(dataObj);
- Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal).when(nsDaoObj).read(Mockito.any(), Mockito.anyString());
- setQuestion(ques, nsDaoObj);
+ Result<List<NsDAO.Data>> retVal = new Result<List<NsDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal).when(nsDAO).read(Mockito.any(), Mockito.anyString());
List<CredDAO.Data> nsDataList = new ArrayList<CredDAO.Data>();
CredDAO.Data nsData = new CredDAO.Data();
nsData.id="test";
nsDataList.add(nsData);
- Result<List<CredDAO.Data>> retVal21 = new Result<List<CredDAO.Data>>(nsDataList,0,"test",new String[0]);
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ 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);
Mockito.doReturn(true).when(ques).isGranted(Mockito.any(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString(), Mockito.anyString());
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
Mockito.doReturn(retVal21).when(credDAO).readNS(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal21).when(credDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
- setQuestionCredDao(ques, credDAO);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
List<PermDAO.Data> dataObj5 = new ArrayList<>();
PermDAO.Data indData5 = new PermDAO.Data();
indData5.ns = "test";
indData5.type = "test";
dataObj5.add(indData5);
- Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
- Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test");
- Mockito.doReturn(retVal5).when(cachedPermDAO).readNS(trans, "test.test");
- Mockito.doReturn(retVal5).when(cachedPermDAO).read(trans, indData5);
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Result<List<PermDAO.Data>> retVal5 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new Object[0]);
+ 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);
- CachedUserRoleDAO cachedUserRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
List<UserRoleDAO.Data> dataObj4 = new ArrayList<>();
UserRoleDAO.Data indData4 = new UserRoleDAO.Data();
indData4.ns = "test";
indData4.rname = "test";
dataObj4.add(indData4);
- Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(dataObj4,0,"test",new String[0]);
- Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
- Mockito.doReturn(retVal4).when(cachedUserRoleDAO).readByUser(Mockito.any(), Mockito.anyString());
- setQuestionUserRoleDao(ques, cachedUserRoleDAO);
+ 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());
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
List<RoleDAO.Data> dataObj1 = new ArrayList<>();
RoleDAO.Data indData1 = new RoleDAO.Data();
indData1.ns = "test";
permsSet.add("test|test");
indData1.perms = permsSet;
dataObj1.add(indData1);
- Result<List<RoleDAO.Data>> retVal3 = new Result<List<RoleDAO.Data>>(dataObj1,0,"test",new String[0]);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test");
- Mockito.doReturn(retVal3).when(cachedRoleDAO).readNS(trans, "test.test");
- Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, indData1);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ 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).read(trans, indData1);
funcObj = new Function(trans, ques);
result = funcObj.deleteNS(trans, "test");
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ 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);
result = funcObj.deleteNS(trans, "test.test");
assertNull(result);
}
+
@Test
public void testGetOwners() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
//
-// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+// 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);
@Test
public void testDelOwner() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+ 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));
- setQuestionUserRoleDao(ques, userRoleDAO);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ 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",new String[0]);
+ 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);
- retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+ 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",new String[0]);
+ 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",new String[0]);
+ 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");
//
@Test
public void testGetAdmins() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
//
-// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+// 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);
@Test
public void testDelAdmin() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+ 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));
- setQuestionUserRoleDao(ques, userRoleDAO);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ 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",new String[0]);
+ 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);
- retVal1 = new Result<NsDAO.Data>(data,1,"test",new String[0]);
+ 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",new String[0]);
+ 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",new String[0]);
+ 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");
//
@Test
public void testMovePerms() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
- Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ 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",new String[0]);
+ Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(null,1,"test",NO_PARAM);
invokeMovePerms(nsDataObj, sb, retVal1);
indData5.ns = "test";
indData5.type = "access";
dataObj5.add(indData5);
- retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",new String[0]);
+ retVal1 = new Result<List<PermDAO.Data>>(dataObj5,0,"test",NO_PARAM);
- Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",new String[0]);
- Mockito.doReturn(retVal3).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal3).when(cachedPermDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ 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());
NsSplit splitObj = new NsSplit("test", "test");
- Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+ Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
invokeMovePerms(nsDataObj, sb, retVal1);
- Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal4).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
+ Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
+ Mockito.doReturn(retVal4).when(permDAO).create(Mockito.any(), Mockito.any());
invokeMovePerms(nsDataObj, sb, retVal1);
- Mockito.doReturn(retVal3).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal4).when(cachedPermDAO).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());
invokeMovePerms(nsDataObj, sb, retVal1);
}
@Test
public void testMoveRoles() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal).when(cachedRoleDAO).create(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",new String[0]);
+ Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(null,1,"test",NO_PARAM);
invokeMoveRoles(nsDataObj, sb, retVal1);
indData5.ns = "test";
indData5.name = "admin";
dataObj5.add(indData5);
- retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",new String[0]);
+ retVal1 = new Result<List<RoleDAO.Data>>(dataObj5,0,"test",NO_PARAM);
- Result<List<UserRoleDAO.Data>> retVal3 = new Result<List<UserRoleDAO.Data>>(null,0,"test",new String[0]);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal3).when(cachedRoleDAO).delete(Mockito.any(), Mockito.any(), Mockito.anyBoolean());
+ 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());
NsSplit splitObj = new NsSplit("test", "test");
- Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+ Result<NsSplit> retVal2 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
invokeMoveRoles(nsDataObj, sb, retVal1);
- Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
- Mockito.doReturn(retVal4).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
+ Result<List<UserRoleDAO.Data>> retVal4 = new Result<List<UserRoleDAO.Data>>(null,1,"test",NO_PARAM);
+ Mockito.doReturn(retVal4).when(roleDAO).create(Mockito.any(), Mockito.any());
invokeMoveRoles(nsDataObj, sb, retVal1);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal4).when(cachedRoleDAO).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());
invokeMoveRoles(nsDataObj, sb, retVal1);
}
@Test
public void testCreatePerm() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
- Mockito.doReturn(true).when(trans).requested(REQD_TYPE.force);
- Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
- Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
try {
Define.set(access);
} catch (CadiException e) {
perm.roles = rolesSet;
// perm.type=1
dataAl.add(perm);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+ 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());
- CachedRoleDAO userRoleDAO = Mockito.mock(CachedRoleDAO.class);
- Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
- Mockito.doReturn(retVal).when(userRoleDAO).create(Mockito.any(), Mockito.any(RoleDAO.Data.class));
- setQuestionCachedRoleDao(ques, userRoleDAO);
+ 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));
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
- Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Mockito.doReturn(retVal).when(permDAO).create(Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+ 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);
- retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ 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);
assertTrue(result.status == 1);
NsSplit nsObj = new NsSplit("test","test");
- Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",new String[0]);
+ Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retVal2).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
+ Result<List<RoleDAO.Data>> retVal3 = Result.ok(new ArrayList<>());
+ Mockito.doReturn(retVal3).when(roleDAO).read(Mockito.any(),Mockito.any(RoleDAO.Data.class));
+ 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);
- Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);
+ Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == 1);
- Mockito.doReturn(retVal2).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
+ 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",new String[0]);
- Mockito.doReturn(retVal1).when(cachedPermDAO).read(trans, perm);
+ Result<List<PermDAO.Data>> retVal1 = new Result<List<PermDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal1).when(permDAO).read(trans, perm);
result = funcObj.createPerm(trans, perm, true);
assertTrue(result.status == Status.ERR_ConflictAlreadyExists);
}
@Test
public void testDeletePerm() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
try {
Define.set(access);
} catch (CadiException e) {
// perm.type=1
dataAl.add(perm);
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+ Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ Result<List<PermDAO.Data>> retVal = new Result<List<PermDAO.Data>>(dataAl,1,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
- setQuestionUserRoleDao(ques, userRoleDAO);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.deletePerm(trans, perm, true,false);
assertTrue(result.status == 1);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal).when(cachedPermDAO).read(trans, perm);
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Mockito.doReturn(retVal).when(permDAO).read(trans, perm);
result = funcObj.deletePerm(trans, perm, true,true);
assertTrue(result.status == Status.ERR_PermissionNotFound);
- retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ retVal2 = new Result<NsDAO.Data>(null,0,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,perm, Access.write);
- Result<List<PermDAO.Data>> retVal3 = new Result<List<PermDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal3).when(cachedPermDAO).read(trans, perm);
+ 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",new String[0]);
+ Result<NsSplit> retValNs = new Result<NsSplit>(nsObj,0,"test",NO_PARAM);
Mockito.doReturn(retValNs).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ Mockito.doReturn(retVal).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
result = funcObj.deletePerm(trans, perm, true,false);
assertNull(result);
- Mockito.doReturn(retVal2).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
+ Mockito.doReturn(retVal2).when(roleDAO).delPerm(Mockito.any(), Mockito.any(), Mockito.any());
result = funcObj.deletePerm(trans, perm, true,false);
assertNull(result);
@Test
public void testDeleteRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
try {
Define.set(access);
} catch (CadiException e) {
// perm.type=1
dataAl.add(role);
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",new String[0]);
+ Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(ques).mayUser(trans, null,role, Access.write);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
//
-// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+// 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);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
- Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retVal1).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
+ Result<List<RoleDAO.Data>> retVal1 = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retVal1).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
NsSplit splitObj = new NsSplit("test", "test");
- Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+ Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Mockito.doReturn(retVal).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
result = funcObj.deleteRole(trans, role, true, true);
assertNull(result);
- Mockito.doReturn(retVal1).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
+ Mockito.doReturn(retVal1).when(permDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any());
result = funcObj.deleteRole(trans, role, true, true);
assertNull(result);
- Mockito.doReturn(retVal).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
+ Mockito.doReturn(retVal).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
result = funcObj.deleteRole(trans, role, true, true);
assertTrue(result.status == Status.ERR_RoleNotFound);
- retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",new String[0]);
+ retVal = new Result<List<UserRoleDAO.Data>>(dataAlUser,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
result = funcObj.deleteRole(trans, role, false, true);
assertTrue(result.status == Status.ERR_DependencyExists);
@Test
public void testAddPermToRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
PermDAO.Data rolePerm = new PermDAO.Data();
Set<String> rolesSetUser = new HashSet<>();
NsDAO.Data nsObj1 = new NsDAO.Data();
nsObj1.name="test12";
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
- Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",new String[0]);
+ 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",new String[0]);
+ 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<Void> result = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
- retVal2 = new Result<NsDAO.Data>(nsObj,1,"test",new String[0]);
+ retVal2 = new Result<NsDAO.Data>(nsObj,1,"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 = funcObj.addPermToRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
role.ns="test2";
- retVal2 = new Result<NsDAO.Data>(nsObj,0,"test",new String[0]);
+ 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",new String[0]);
+ 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",new String[0]);
+ 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",new String[0]);
+ 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",new String[0]);
+ 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);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
// Mockito.doReturn(retVal).when(cachedPermDAO).create(Mockito.any(), Mockito.any());
- Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
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",new String[0]);
- Mockito.doReturn(retValPerm).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
+ Result<List<PermDAO.Data>> retValPerm= new Result<List<PermDAO.Data>>(dataAlPerm,0,"test1",NO_PARAM);
+ Mockito.doReturn(retValPerm).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).read(trans, role);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ Mockito.doReturn(retVal3).when(roleDAO).read(trans, role);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 22);
result = funcObj.addPermToRole(trans, role, rolePerm, true);
assertTrue(result.status == 2);
- retVal3 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ 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(cachedRoleDAO).create(trans, role);
+ 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",new String[0]);
- Mockito.doReturn(retVal3).when(cachedRoleDAO).create(trans, role);
+ 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",new String[0]);
- Mockito.doReturn(retVal31).when(cachedRoleDAO).read(trans, role);
+ 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);
}
@Test
public void testDelPermFromRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
List<PermDAO.Data> dataAlPerm = new ArrayList<PermDAO.Data>();
PermDAO.Data rolePerm = new PermDAO.Data();
Set<String> rolesSetUser = new HashSet<>();
role.perms = rolesSet;
dataAl.add(role);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
- Result<NsDAO.Data> retValFail = new Result<NsDAO.Data>(null,1,"test",new String[0]);
- Result<NsDAO.Data> retValSuc = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+ 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);
Mockito.doReturn(retValFail).when(ques).mayUser(trans, null,rolePerm, Access.write);
Mockito.doReturn(retValSuc).when(ques).mayUser(trans, null,role, Access.write);
- CachedRoleDAO cachedRoleDAO = Mockito.mock(CachedRoleDAO.class);
- Mockito.doReturn(retValFail).when(cachedRoleDAO).read(trans, role);
- setQuestionCachedRoleDao(ques, cachedRoleDAO);
+ Mockito.doReturn(retValFail).when(roleDAO).read(trans, role);
- CachedPermDAO cachedPermDAO = Mockito.mock(CachedPermDAO.class);
- Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
- setQuestionCachedPermDao(ques, cachedPermDAO);
+ Mockito.doReturn(retVal).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
- Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",new String[0]);
- Mockito.doReturn(retValPermSuc).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
+ Result<List<PermDAO.Data>> retValPermSuc = new Result<List<PermDAO.Data>>(dataAlPerm,0,"test",NO_PARAM);
+ Mockito.doReturn(retValPermSuc).when(permDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, false);
assertTrue(result.status == 1);
- Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",new String[0]);
- Mockito.doReturn(retValRoleSuc).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
+ Result<List<RoleDAO.Data>> retValRoleSuc = new Result<List<RoleDAO.Data>>(dataAl,0,"test",NO_PARAM);
+ Mockito.doReturn(retValRoleSuc).when(roleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == Status.ERR_PermissionNotFound);
rolesSet.add("null|null|null|null");
role.perms = rolesSet;
dataAl.add(role);
- Mockito.doReturn(retValRoleSuc).when(cachedRoleDAO).read(Mockito.any(), Mockito.any(RoleDAO.Data.class));
- Mockito.doReturn(retVal).when(cachedPermDAO).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);
- Mockito.doReturn(retValRoleSuc).when(cachedPermDAO).delRole(Mockito.any(), Mockito.any(),Mockito.any(RoleDAO.Data.class));
- Mockito.doReturn(retVal).when(cachedRoleDAO).delPerm(Mockito.any(), Mockito.any(),Mockito.any(PermDAO.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));
result = funcObj.delPermFromRole(trans, role, rolePerm, true);
assertTrue(result.status == 1);
- Mockito.doReturn(retValPermSuc).when(cachedRoleDAO).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);
- Mockito.doReturn(retVal).when(cachedPermDAO).read(Mockito.any(), Mockito.any(PermDAO.Data.class));
+ 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(cachedRoleDAO).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);
NsSplit splitObj = new NsSplit("test", "test");
- Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",new String[0]);
+ Result<NsSplit> retVal3 = new Result<NsSplit>(splitObj,0,"test",NO_PARAM);
Mockito.doReturn(retVal3).when(ques).deriveNsSplit(Mockito.any(), Mockito.anyString());
Mockito.doReturn(retValFail).when(ques).mayUser(Mockito.any(), Mockito.anyString(),Mockito.any(RoleDAO.Data.class), Mockito.any());
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",new String[0]);
+ 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);
assertTrue(result.status == 1);
}
@Test
public void testAddUserRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
Mockito.doReturn(org).when(trans).org();
Mockito.doReturn(Mockito.mock(GregorianCalendar.class)).when(org).expiration(Mockito.any(), Mockito.any(), Mockito.anyString());
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- CachedRoleDAO roleDAO = Mockito.mock(CachedRoleDAO.class);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
- Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
- setQuestionCachedRoleDao(ques, roleDAO);
-
- CachedCredDAO credDAO = Mockito.mock(CachedCredDAO.class);
- Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",new String[0]);
+
+ Result<List<CredDAO.Data>> retVal2 = new Result<List<CredDAO.Data>>(null,1,"test",NO_PARAM);
Mockito.doReturn(retVal2).when(credDAO).readID(Mockito.any(), Mockito.anyString());
- setQuestionCredDao(ques, credDAO);
Function funcObj = new Function(trans, ques);
Result<Void> result = funcObj.addUserRole(trans, urData);
NsDAO.Data data = new NsDAO.Data();
data.name="test";
- Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",new String[0]);
+ Result<NsDAO.Data> retVal1 = new Result<NsDAO.Data>(data,0,"test",NO_PARAM);
Mockito.doReturn(retVal1).when(ques).mayUser(trans, null,retVal1.value, Access.write);
Mockito.doReturn(retVal1).when(ques).deriveNs(trans, "test");
try {
result = funcObj.addUserRole(trans, "test", "test", "test");
assertTrue(result.status == 20);
}
+
@Test
public void testExtendUserRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
urData.expires=new Date();
urDataAl.add(urData);
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
- CachedRoleDAO roleDAO = Mockito.mock(CachedRoleDAO.class);
// 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",new String[0]);
- Result<List<UserRoleDAO.Data>> retValSuc = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+ 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(retValSuc).when(roleDAO).read(Mockito.any(), Mockito.anyString(), Mockito.anyString());
- setQuestionUserRoleDao(ques, userRoleDAO);
- setQuestionCachedRoleDao(ques, roleDAO);
Organization org = Mockito.mock(Organization.class);
Mockito.doReturn(org).when(trans).org();
assertTrue(result.status == Status.ERR_UserRoleNotFound);
}
+ @SuppressWarnings("deprecation")
@Test
public void testGetUsersByRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
urData.user="test";
urData.expires=new Date();
urDataAl.add(urData);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+ Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
- setQuestionUserRoleDao(ques, userRoleDAO);
Function funcObj = new Function(trans, ques);
Result<List<String>> result = funcObj.getUsersByRole(trans, "test", false);
}
@Test
public void testDelUserRole() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
urData.user="test";
urData.expires=new Date();
urDataAl.add(urData);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
+ Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",NO_PARAM);
Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
- setQuestionUserRoleDao(ques, userRoleDAO);
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",new String[0]);
+ 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");
// assertTrue(result.status ==1);
@Test
public void testCreateFuture() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
FutureDAO.Data data = new FutureDAO.Data();
data.memo = "test";
NsDAO.Data nsd = new NsDAO.Data();
nsd.name = "test";
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
urData.user="test";
urData.expires=new Date();
urDataAl.add(urData);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
- Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(urDataAl,1,"test",new String[0]);
+ 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);
Mockito.doReturn(retVal).when(userRoleDAO).read(Mockito.any(), Mockito.any( UserRoleDAO.Data.class));
- setQuestionUserRoleDao(ques, userRoleDAO);
Function funcObj = new Function(trans, ques);
Result<String> result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
assertTrue(result.status == 20);
- Organization org = Mockito.mock(Organization.class);
- Mockito.doReturn(org).when(trans).org();
Identity iden=Mockito.mock(Identity.class);
try {
Mockito.doReturn(iden).when(org).getIdentity(trans, "test");
}
FutureDAO.Data futureData = new FutureDAO.Data();
data.memo = "test";
- FutureDAO futureDaoObj = Mockito.mock(FutureDAO.class);
- Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",new String[0]);
- Mockito.doReturn(retValFuture).when(futureDaoObj).create(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyString());
- setQuestionFutureDao(ques, futureDaoObj);
+ 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";
- ApprovalDAO approvalDaoObj = Mockito.mock(ApprovalDAO.class);
- Result<ApprovalDAO.Data> retValApproval = new Result<ApprovalDAO.Data>(approvalData,0,"test",new String[0]);
- Mockito.doReturn(retValApproval).when(approvalDaoObj).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
- setQuestionApprovalDao(ques, approvalDaoObj);
+ 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));
Mockito.doReturn(retVal).when(userRoleDAO).readByRole(Mockito.any(), Mockito.anyString());
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.A);
result = funcObj.createFuture(trans, data, "test", "test", nsd, FUTURE_OP.C);
assertTrue(result.status == 0);
- retValApproval = new Result<ApprovalDAO.Data>(null,1,"test",new String[0]);
- Mockito.doReturn(retValApproval).when(approvalDaoObj).create(Mockito.any(), Mockito.any( ApprovalDAO.Data.class));
+ 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);
assertTrue(result.status == 8);
}
@Test
public void testUbLookup() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- 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");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
Object[] objArr = new Object[10];
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
List<UserRoleDAO.Data> urDataAl = new ArrayList<>();
UserRoleDAO.Data urData = new UserRoleDAO.Data();
urData.ns="test";
urData.user="test";
urData.expires=new Date();
urDataAl.add(urData);
- Result<List<UserRoleDAO.Data>> retVal = new Result<List<UserRoleDAO.Data>>(urDataAl,0,"test",new String[0]);
- Result<List<UserRoleDAO.Data>> retValFail = new Result<List<UserRoleDAO.Data>>(null,1,"test",new String[0]);
+ 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);
Mockito.doReturn(retVal).when(userRoleDAO).read(trans, objArr);
- setQuestionUserRoleDao(ques, userRoleDAO);
Function funcObj = new Function(trans, ques);
funcObj.urDBLookup.get(trans, objArr);
@Test
public void testPerformFutureOp() {
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
- Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
- Mockito.doReturn(Mockito.mock(Properties.class)).when(access).getProperties();
- Mockito.doReturn("test.test").when(access).getProperty(Config.AAF_ROOT_NS,"org.osaaf.aaf");
- try {
- Define.set(access);
- } catch (CadiException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
- }
FutureDAO.Data futureDataDaoObj = new FutureDAO.Data();
futureDataDaoObj.memo="test";
futureDataDaoObj.target = "test";
FutureDAO.Data futureData = new FutureDAO.Data();
// data.memo = "test";
- FutureDAO futureDaoObj = Mockito.mock(FutureDAO.class);
- Result<FutureDAO.Data> retValFuture = new Result<FutureDAO.Data>(futureData,0,"test",new String[0]);
- Mockito.doReturn(retValFuture).when(futureDaoObj).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
- setQuestionFutureDao(ques, futureDaoObj);
+ 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());
- CachedUserRoleDAO userRoleDAO = Mockito.mock(CachedUserRoleDAO.class);
// 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",new String[0]);
+ 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());
- setQuestionUserRoleDao(ques, userRoleDAO);
//
-// Result<NsDAO.Data> retVal2 = new Result<NsDAO.Data>(null,0,"test",new String[0]);
+// 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 = funcObj.performFutureOp(trans, FUTURE_OP.A, futureDataDaoObj, lookupApprovalObj, lookupUserObj);
assertTrue(result.status == 0);
- retValFuture = new Result<FutureDAO.Data>(futureData,1,"test",new String[0]);
- Mockito.doReturn(retValFuture).when(futureDaoObj).delete(Mockito.any(), Mockito.any( FutureDAO.Data.class), Mockito.anyBoolean());
+ 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);