@Test
public void testGetNextTaskInRank_iteration() {
iter.setId(1);
executeClassSql();
Task actual = taskDAO.getNextTaskInRank(0, iter, null);
assertEquals(1, actual.getRank());
}
@Test
public void testGetLastTaskInRank_story() {
story.setId(55);
executeClassSql();
Task actual = taskDAO.getLastTaskInRank(story, null);
assertEquals(22, actual.getId());
assertEquals(666, actual.getRank());
}
@Test
public void testGetLastTaskInRank_iteration() {
iter.setId(3);
executeClassSql();
Task actual = taskDAO.getLastTaskInRank(null, iter);
assertEquals(17, actual.getId());
assertEquals(1500, actual.getRank());
}
@Test
public void testGetNextTaskInRank_story() {
story.setId(55);
executeClassSql();
Task actual = taskDAO.getNextTaskInRank(0, null, story);
assertEquals(1, actual.getRank());
assertEquals(21, actual.getId());
}
@Test
public void testGetNextTaskInRank_iteration_largeCap() {
iter.setId(3);
executeClassSql();
Task actual = taskDAO.getNextTaskInRank(25, iter, null);
assertEquals(17, actual.getId());
assertEquals(1500, actual.getRank());
}
@Test
public void testGetNextTaskInRank_story_largeCap() {
story.setId(55);
executeClassSql();
Task actual = taskDAO.getNextTaskInRank(25, null, story);
assertEquals(22, actual.getId());
assertEquals(666, actual.getRank());
}
public void setTasksToDone(int backlogItemId) throws ObjectNotFoundException {
BacklogItem backlogItem = backlogItemDAO.get(backlogItemId);
if (backlogItem == null) {
throw new ObjectNotFoundException("backlogItem.notFound");
} else {
Map<Integer, State> doneStates = new HashMap<Integer, State>();
for (Task t : backlogItem.getTasks()) {
doneStates.put(t.getId(), State.DONE);
}
taskBusiness.updateMultipleTasks(backlogItem, doneStates, new HashMap<Integer, String>());
}
}
@Test
public void testDelete_taskChoice_delete() {
Task task = new Task();
storyInIteration.getTasks().add(task);
hourEntryBusiness.moveToBacklog(task.getHourEntries(), storyInIteration.getBacklog());
taskBusiness.delete(task.getId(), HourEntryHandlingChoice.MOVE);
// storyRankBusiness.removeStoryRanks(storyInIteration);
storyDAO.remove(storyInIteration);
replayAll();
storyBusiness.delete(
storyInIteration, TaskHandlingChoice.DELETE, null, HourEntryHandlingChoice.MOVE, null);
verifyAll();
assertNull(task.getStory());
assertTrue(storyInIteration.getTasks().isEmpty());
}
@Test
public void testGetAllIterationAndStoryTasks() {
executeClassSql();
DateTime start = new DateTime(2009, 6, 10, 1, 0, 0, 0);
Interval interval = new Interval(start, start.plusDays(5));
User user = new User();
user.setId(1);
List<Task> actual = this.taskDAO.getAllIterationAndStoryTasks(user, interval);
HashSet<Integer> actualIds = new HashSet<Integer>();
for (Task t : actual) {
actualIds.add(t.getId());
}
HashSet<Integer> expectedIds = new HashSet<Integer>(Arrays.asList(2, 3, 4));
assertEquals(expectedIds, actualIds);
}
public BacklogItem createBacklogItemFromTodo(int todoId) {
BacklogItem backlogItem = new BacklogItem();
Task data = taskBusiness.getTask(todoId);
if (data != null) {
backlogItem.setName(data.getName());
backlogItem.setState(data.getState());
backlogItem.setBacklog(data.getBacklogItem().getBacklog());
backlogItem.setIterationGoal(data.getBacklogItem().getIterationGoal());
backlogItem.setPriority(data.getBacklogItem().getPriority());
backlogItem.setResponsibles(data.getBacklogItem().getResponsibles());
backlogItem.setBusinessThemes(data.getBacklogItem().getBusinessThemes());
}
return backlogItem;
}
@Test
public void testStore_dontSetTasksToDone() {
this.store_createMockStoryBusiness();
Task task1 = new Task();
task1.setId(11);
task1.setState(TaskState.BLOCKED);
Task task2 = new Task();
task2.setId(12);
task2.setState(TaskState.BLOCKED);
story1.setIteration(iteration);
story1.setTasks(new HashSet<Task>(Arrays.asList(task1, task2)));
expect(storyDAO.get(story1.getId())).andReturn(story1);
storyDAO.store(story1);
replayAll();
Story actual = storyBusiness.store(story1.getId(), story1, null, null, false);
verifyAll();
for (Task t : actual.getTasks()) {
assertEquals(TaskState.BLOCKED, t.getState());
}
}
@Test
public void testStore_tasksToDone() {
Task task1 = new Task();
task1.setId(11);
task1.setState(TaskState.BLOCKED);
Task task2 = new Task();
task2.setId(12);
task2.setState(TaskState.PENDING);
story1.setIteration(iteration);
story1.setTasks(new HashSet<Task>(Arrays.asList(task1, task2)));
expect(storyDAO.get(story1.getId())).andReturn(story1);
storyDAO.store(story1);
taskBusiness.setTaskToDone(task1);
taskBusiness.setTaskToDone(task2);
iheBusiness.updateIterationHistory(story1.getIteration().getId());
replayAll();
storyBusiness.store(story1.getId(), story1, null, null, true);
verifyAll();
}
@Override
public String intercept(ActionInvocation invocation) throws Exception {
// System.out.println("URL: " + ServletActionContext.getRequest().getRequestURL().toString());
HttpServletRequest req = ServletActionContext.getRequest();
String actionName = ServletActionContext.getActionMapping().getName();
User loggedUser =
SecurityUtil
.getLoggedUser(); // SecurityUtil.getLoggedUser() can't get all needed information of
// user -> should retrieve by making new user.
User user = userBusiness.retrieve(loggedUser.getId());
boolean admin = user.isAdmin();
boolean readOnly = user.getName().equals("readonly");
boolean access = false;
if (admin) {
// if admin, everything is fine
access = true;
} else if (readOnly) {
// check read only operations
if (actionName.equals("ROIterationHistoryByToken")
|| actionName.equals("ROIterationMetricsByToken")
|| actionName.equals(("ROIterationData"))) {
access = true;
}
} else {
if (actionName.equals("createTeam")
|| actionName.equals("deleteTeam")
|| actionName.equals("deleteTeamForm")
|| actionName.equals("storeTeam")
|| actionName.equals("storeNewTeam")) {
// these are admin-only operations
access = false;
} else if (actionName.equals("storeUserAndRedirect")) {
Map params = req.getParameterMap();
boolean attemptAdmin = params.containsKey("user.admin");
int id = Integer.parseInt(((String[]) params.get("userId"))[0]);
if (id == user.getId() && !attemptAdmin) {
access = true;
}
} else if (actionName.equals("storeUser")) {
// check if ID is of current user, and what is being stored
// can't set user.admin or team
Map params = req.getParameterMap();
boolean attemptAdmin = params.containsKey("user.admin");
boolean attemptTeam = params.containsKey("teamsChanged") || params.containsKey("teamIds");
int id = Integer.parseInt(((String[]) params.get("userId"))[0]);
if (id == user.getId() && !attemptAdmin && !attemptTeam) {
// check not setting user.admin
access = true;
}
} else if (actionName.equals("storeNewUser")) {
Map params = req.getParameterMap();
boolean attemptToCreateNonAdmin =
params.containsKey("user.admin")
&& ((String[]) params.get("user.admin"))[0].equals("false");
// Non admins can create only other non admin users
if (attemptToCreateNonAdmin) {
// Non admins can only add new users to their teams
if (params.containsKey("teamIds")) {
Set<String> myTeamIds = new HashSet<String>();
for (Team team : user.getTeams()) {
myTeamIds.add("" + team.getId());
}
String[] teamIds = (String[]) params.get("teamIds");
Set<String> newUserTeamIds = new HashSet<String>();
for (String teamId : teamIds) {
newUserTeamIds.add(teamId);
}
if (myTeamIds.containsAll(newUserTeamIds)) {
access = true;
}
} else {
access = true;
}
}
} else if (actionName.equals("retrieveAllProducts")
|| actionName.equals("retrieveAllSAIterations")) {
// access matrix operations
access = false;
} else if (actionName.equals("storeNewIteration") || actionName.equals("storeNewProduct")) {
// these are operations available to everyone
access = true;
} else if ((actionName.equals("retrieveBranchMetrics")
|| actionName.equals("getStoryHierarchy"))
&& req.getParameterMap().containsKey("storyId")) {
Map params = req.getParameterMap();
int storyId = Integer.parseInt(((String[]) params.get("storyId"))[0]);
Story story = storyBusiness.retrieve(storyId);
if (story.getIteration() != null) {
access =
this.authorizationBusiness.isBacklogAccessible(story.getIteration().getId(), user);
}
if (!access && story.getBacklog() != null) {
access = this.authorizationBusiness.isBacklogAccessible(story.getBacklog().getId(), user);
}
} else {
// Default case: Try to find a backlog id of some kind to check.
Map params = req.getParameterMap();
int id = -1;
if (params.containsKey("iterationId"))
id = Integer.parseInt(((String[]) params.get("iterationId"))[0]);
else if (params.containsKey("backlogId"))
id = Integer.parseInt(((String[]) params.get("backlogId"))[0]);
else if (params.containsKey("productId"))
id = Integer.parseInt(((String[]) params.get("productId"))[0]);
else if (params.containsKey("projectId"))
id = Integer.parseInt(((String[]) params.get("projectId"))[0]);
else if (params.containsKey("taskId")) {
int taskId = Integer.parseInt(((String[]) params.get("taskId"))[0]);
Task task = taskBusiness.retrieve(taskId);
if (task.getIteration() != null) id = task.getIteration().getId();
else if (task.getStory().getIteration() != null)
id = task.getStory().getIteration().getId();
else id = task.getStory().getBacklog().getId(); // story in project/product w/a iteration
} else if (params.containsKey("storyId")) {
int storyId = Integer.parseInt(((String[]) params.get("storyId"))[0]);
Story story = storyBusiness.retrieve(storyId);
if (story.getIteration() != null) {
id = story.getIteration().getId();
} else {
id = story.getBacklog().getId();
}
}
boolean attemptTeam = params.containsKey("teamsChanged");
if (!attemptTeam) {
if (id != -1
&& !(id == 0 && actionName.equals("retrieveSubBacklogs") && params.size() == 1))
access = this.authorizationBusiness.isBacklogAccessible(id, user);
else
// Operations without ids must be allowed
access = true;
}
}
}
if (access) return invocation.invoke();
else return "noauth";
}
