implementing test for new projectidea springdata stuff... but new classes are confusing and missing things i think

This commit is contained in:
Fredrik Friis 2012-03-29 15:55:56 +09:00
parent 1ccfb582b8
commit 78fa7082f2

@ -0,0 +1,457 @@
package se.su.dsv.scipro.springdata;
import edu.emory.mathcs.backport.java.util.Arrays;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dao.interfaces.RoleDao;
import se.su.dsv.scipro.data.dao.interfaces.UserDao;
import se.su.dsv.scipro.data.dataobjects.*;
import se.su.dsv.scipro.match.dao.interfaces.MatchDao;
import se.su.dsv.scipro.match.dao.interfaces.ProjectIdeaDao.Params;
import se.su.dsv.scipro.match.dataobject.ApplicationPeriod;
import se.su.dsv.scipro.match.dataobject.Match;
import se.su.dsv.scipro.match.dataobject.Match.Status;
import se.su.dsv.scipro.match.dataobject.ProjectIdea;
import se.su.dsv.scipro.match.facade.ApplicationPeriodFacade;
import se.su.dsv.scipro.springdata.repos.ProjectClassRepo;
import se.su.dsv.scipro.springdata.repos.ProjectIdeaRepo;
import se.su.dsv.scipro.springdata.services.ProjectIdeaService;
import java.text.SimpleDateFormat;
import java.util.*;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(inheritLocations = false, locations = {
"classpath:test-applicationContext.xml"
})
public class TestProjectIdea {
@Autowired
private UserDao userDao;
@Autowired
private ProjectIdeaRepo projectIdeaRepo;
@Autowired
private ProjectIdeaService projectIdeaService;
@Autowired
private ProjectClassRepo projectClassRepo;
@Autowired
private RoleDao roleDao;
@Autowired
private ApplicationPeriodFacade applicationPeriodFacade;
@Autowired
private MatchDao matchDao;
private User student1;
private ProjectIdea projectIdea1;
private ProjectIdea projectIdea2;
private Student student1Author;
private Student student2Author;
private ProjectIdea projectIdea3;
private User employee1;
private Employee employee1Role;
SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
private Date date12Maj2010;
private Date date14Maj2010;
private Date date15Jun2010;
private Date date18Aug2010;
@Before
public void startTransaction() throws Exception {
student1 = new User();
student1 = userDao.save(student1);
Role student1Role = new Student();
student1Role.setUser(student1);
student1Role = roleDao.save(student1Role);
student1Author = (Student) student1Role;
User student2 = new User();
student2 = userDao.save(student2);
Role student2Role = new Student();
student2Role.setUser(student2);
student2Role = roleDao.save(student2Role);
student2Author = (Student) student2Role;
ProjectClass bachelor = new ProjectClass(ProjectClass.BACHELOR, "Bachelor",
"Bachelor degree thesis project");
bachelor = projectClassRepo.save(bachelor);
ProjectClass master = new ProjectClass(ProjectClass.MASTER, "Master",
"Master degree thesis project");
master = projectClassRepo.save(master);
Set<ProjectClass> projectClassSet = new HashSet<ProjectClass>();
projectClassSet.add(bachelor);
projectClassSet.add(master);
ApplicationPeriod applicationPeriod = applicationPeriodFacade.createApplicationPeriod(projectClassSet, "name1");
projectIdea1 = new ProjectIdea();
projectIdea1.setTitle("Project idea 1");
projectIdea1.getAuthors().add(student1Author);
projectIdea1.setProjectClass(bachelor);
projectIdea1.setApplicationPeriod(applicationPeriod);
projectIdea1 = projectIdeaService.save(projectIdea1);
projectIdeaRepo.
projectIdea2 = new ProjectIdea();
projectIdea2.setTitle("Idea 2");
projectIdea2.getAuthors().add(student1Author);
projectIdea2.setProjectClass(master);
projectIdea2.setApplicationPeriod(applicationPeriod);
projectIdea2 = projectIdeaDao.save(projectIdea2);
projectIdea3 = new ProjectIdea();
projectIdea3.setTitle("A Project 2");
projectIdea3.setProjectClass(bachelor);
projectIdea3.setApplicationPeriod(applicationPeriod);
projectIdea3 = projectIdeaDao.save(projectIdea3);
target = projectIdeaDao;
params = new Params();
rejected = new ArrayList<Status>();
rejected.add(Status.REJECTED);
unmatched = new ArrayList<Status>();
unmatched.add(Status.UNMATCHED);
published = new ArrayList<Status>();
published.add(Status.PUBLISHED);
date12Maj2010 = date.parse("2010-05-12");
date14Maj2010 = date.parse("2010-05-14");
date15Jun2010 = date.parse("2010-06-15");
date18Aug2010 = date.parse("2010-08-18");
}
@Test
@Transactional
@Rollback
public void testShouldReturnAllAuthorsProjectIdeasThatHaveNotEvolvedIntoAProject() {
projectIdea3.getAuthors().add(student1Author);
projectIdea2.setProject(project);
List<ProjectIdea> projectIdeas =
target.findActiveProjectIdeas(student1Author);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1,
projectIdea3 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldReturnOnlyAuthorsProject() {
projectIdea3.getAuthors().add(student2Author);
projectIdea2.setProject(project);
List<ProjectIdea> projectIdeas =
target.findActiveProjectIdeas(student1Author);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1 }),
projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldReturnAllProjectIdeasThatHaveNotEvolvedIntoAProject() {
projectIdea1.setProject(project);
List<ProjectIdea> projectIdeas = target.findUnmatchedProjectIdeas();
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2,
projectIdea3 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldReturnAllProjectIdeasThatHaveNotBeenMatched() {
matchDao.addPreApprovedMatch(student1, projectIdea2,
employee1Role);
List<ProjectIdea> projectIdeas = target.findUnmatchedProjectIdeas();
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1,
projectIdea3 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldReturnAllProjectIdeasThatHaveBeenRejected() {
Match match = matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
matchDao.changeStatus(employee1, match, Status.REJECTED);
// commented out old test below, its completely wrong
// List<ProjectIdea> projectIdeas = projectIdeaDao.findUnmatchedProjectIdeas();
// Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea2, projectIdea3 }), projectIdeas);
params.setStatuses(rejected);
List<ProjectIdea> projectIdeas = projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2}), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldOnlyTakeLastestStatusInConcern() {
Match match = matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
match = matchDao.changeStatus(employee1, match, Status.REJECTED);
matchDao.changeStatus(employee1, match, Status.CONFIRMED);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findUnmatchedProjectIdeas();
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1,
projectIdea3 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFindAllProjectIdeasThatHaveBeenRejected() {
Match match = matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
matchDao.changeStatus(employee1, match, Status.REJECTED);
params.setStatuses(rejected);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFindAllProjectIdeasForAProjectClass() {
params.setProjectClasses(masters);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFindProjectIdeasWhereTitleContainsIdea() {
params.setTitleContains("idea");
List<ProjectIdea> projectIdeas =
projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea2 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFindProjectSubmittedAfterADate() {
projectIdea1.setDateCreated(date12Maj2010);
projectIdea2.setDateCreated(date15Jun2010);
projectIdea3.setDateCreated(date18Aug2010);
params.setSubmittedAfter(date14Maj2010);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2, projectIdea3 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFindProjectSubmittedBeforeADate() {
projectIdea1.setDateCreated(date12Maj2010);
projectIdea2.setDateCreated(date15Jun2010);
projectIdea3.setDateCreated(date18Aug2010);
params.setSubmittedBefore(date15Jun2010);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea2 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFindProjectSubmittedBetweenDates() {
projectIdea1.setDateCreated(date12Maj2010);
projectIdea2.setDateCreated(date15Jun2010);
projectIdea3.setDateCreated(date18Aug2010);
params.setSubmittedBefore(date15Jun2010);
params.setSubmittedAfter(date14Maj2010);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testFindPendingProjectIdeasThatWasMatchedLongestTimeAgo() {
Match match = matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
match = matchDao.changeStatus(employee1, match, Status.PUBLISHED);
match.setDateCreated(date18Aug2010);
match = matchDao.addPreApprovedMatch(student1, projectIdea1, employee1Role);
match = matchDao.changeStatus(employee1, match, Status.PUBLISHED);
match.setDateCreated(date15Jun2010);
List<ProjectIdea> projectIdeas =
projectIdeaDao.findTopWaitingProjects(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea2 }), projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFilterBySupervisor() {
matchDao.addPreApprovedMatch(student1, projectIdea1, employee2Role);
matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
matchDao.addPreApprovedMatch(student1, projectIdea3, employee2Role);
params.setSupervisor(employee2Role);
List<ProjectIdea> projectIdeas =
target.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea3 }),
projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFilterBySupervisorAndStatus() {
Match match = matchDao.addPreApprovedMatch(student1, projectIdea1, employee1Role);
match = matchDao.changeStatus(employee1, match, Status.REJECTED);
matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
matchDao.addPreApprovedMatch(student1, projectIdea3, employee1Role);
params.setSupervisor(employee1Role);
params.setStatuses(rejected);
List<ProjectIdea> projectIdeas =
target.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1}),
projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldFilterByAuthor() {
projectIdea1.getAuthors().add(student1Author);
projectIdea2.getAuthors().add(student1Author);
projectIdea3.getAuthors().add(student2Author);
params.setAuthor(student1Author);
List<ProjectIdea> projectIdeas =
target.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea2 }),
projectIdeas);
}
// why should rejected ideas count as unmatched? makes no sense
// @Test
// @Transactional
// @Rollback
// public void testShouldCountRejectedAsUnmatched() {
// Match match = matchDao.addPreApprovedMatch(student1, projectIdea1, employee1Role);
// match = matchDao.changeStatus(employee1, match, Match.Status.REJECTED);
// matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
//
// params.setStatuses(unmatched);
// List<ProjectIdea> projectIdeas =
// target.findProjectIdeas(params);
// Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea3}),
// projectIdeas);
// }
@Test
@Transactional
@Rollback
public void testShouldBeAbleToCombineUnmatchedsLeftJoinWithOtherJoinQueriesWithoutException() {
Match match = matchDao.addPreApprovedMatch(student1, projectIdea1, employee2Role);
match = matchDao.changeStatus(employee1, match, Status.REJECTED);
matchDao.addPreApprovedMatch(student1, projectIdea2, employee1Role);
params.setSupervisor(employee1Role);
ArrayList<Status> statuses = new ArrayList<Status>();
statuses.addAll(unmatched);
statuses.addAll(published);
params.setStatuses(statuses);
List<ProjectIdea> projectIdeas =
target.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea2 }),
projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldNotReturnProjectIdeasThatHaveBeenTurnedIntoAProject() {
projectIdea2.setProject(project);
params.setProjectCreated(Boolean.FALSE);
List<ProjectIdea> projectIdeas =
target.findProjectIdeas(params);
Assert.assertEquals(Arrays.asList(new ProjectIdea[] { projectIdea1, projectIdea3 }),
projectIdeas);
}
@Test
@Transactional
@Rollback
public void testShouldContainReviewer() {
ProjectIdea pi = projectIdea1;
Employee reviewer = employee1Role;
pi.setSuggestedReviewer(reviewer);
pi = projectIdeaDao.save(pi);
Assert.assertTrue(pi.getSuggestedReviewer().equals(reviewer));
}
}