Test för event och projects

git-svn-id: svn://svn.dsv.su.se/scipro/scipro/trunk@107 73ecded7-942e-4092-bab0-0e58ef0ee984
This commit is contained in:
dan-kjel 2011-02-11 08:26:55 +00:00
parent ac45dae17d
commit 4fc7d63de6
4 changed files with 241 additions and 200 deletions

@ -25,9 +25,29 @@
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="projectEventDao" class="se.su.dsv.scipro.data.dao.jpa.ProjectEventDaoJPAImp">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="groupEventDao" class="se.su.dsv.scipro.data.dao.jpa.GroupEventDaoJPAImp">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="projectScheduleDao" class="se.su.dsv.scipro.data.dao.jpa.ProjectScheduleDaoJPAImp">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="projectDao" class="se.su.dsv.scipro.data.dao.jpa.ProjectDaoJPAImp">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="roleDao" class="se.su.dsv.scipro.data.dao.jpa.RoleDaoJPAImp">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<bean id="userDao" class="se.su.dsv.scipro.data.dao.jpa.UserDaoJPAImp">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
</beans>

@ -2,8 +2,11 @@ package se.su.dsv.scipro.dao.jpa;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;
import org.junit.Assert;
import org.junit.Before;
@ -16,9 +19,20 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import se.su.dsv.scipro.data.dao.interfaces.EventDao;
import se.su.dsv.scipro.data.dao.interfaces.GroupEventDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectEventDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectDao;
import se.su.dsv.scipro.data.dao.interfaces.ProjectScheduleDao;
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.Employee;
import se.su.dsv.scipro.data.dataobjects.Event;
import se.su.dsv.scipro.data.dataobjects.GroupEvent;
import se.su.dsv.scipro.data.dataobjects.ProjectEvent;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
/**
* @author Richard Wilkinson - richard.wilkinson@jweekend.com
@ -31,35 +45,160 @@ public class TestEventDaoJPA {
@Autowired
private EventDao eventDao;
@Autowired
private ProjectEventDao projectEventDao;
@Autowired
private GroupEventDao groupEventDao;
@Autowired
private ProjectScheduleDao projectScheduleDao;
protected Event event;
protected Event deletedEvent;
@Autowired
private ProjectDao projectDao;
protected ProjectSchedule schedule;
@Autowired
private RoleDao roleDao;
@Autowired
private UserDao userDao;
private User indEventUser;
private User groupEventCreatorUser;
private User projectUser1;
private User projectUser2;
private Project project1;
private Project project2;
protected ProjectEvent indEvent;
protected ProjectEvent deletedIndEvent;
protected ProjectEvent overDueIndEvent;
private GroupEvent groupEvent;
private GroupEvent deletedGroupEvent;
protected GroupEvent overDueGroupEvent;
@Before
public void startTransaction()
{
schedule = new ProjectSchedule();
schedule = projectScheduleDao.save(schedule);
public void startTransaction() {
indEventUser = new User();
indEventUser.setFirstName("indEventUser");
indEventUser = userDao.save(indEventUser);
event = new Event();
event.setTitle("Event Title");
event.setDescription("Event Description");
event.setDueDate(new Date(System.currentTimeMillis() + 100000));
event.setProjectSchedule(schedule);
event = eventDao.save(event);
Student indEventUserRole = new Student();
indEventUserRole.setUser(indEventUser);
indEventUserRole = (Student) roleDao.save(indEventUserRole);
deletedEvent = new Event();
deletedEvent.setTitle("Deleted Event title");
deletedEvent.setDescription("Deleted Event description");
deletedEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
deletedEvent.setDeleted(true);
deletedEvent.setProjectSchedule(schedule);
deletedEvent = eventDao.save(deletedEvent);
groupEventCreatorUser = new User();
groupEventCreatorUser.setFirstName("eventCreatorUser");
groupEventCreatorUser = userDao.save(groupEventCreatorUser);
Employee groupEventCreatorUserRole = new Employee();
groupEventCreatorUserRole.setUser(groupEventCreatorUser);
groupEventCreatorUserRole = (Employee) roleDao.save(groupEventCreatorUserRole);
projectUser1 = new User();
projectUser1.setFirstName("projectUser1");
projectUser1 = userDao.save(projectUser1);
Student projectUser1Role = new Student();
projectUser1Role.setUser(projectUser1);
projectUser1Role = (Student) roleDao.save(projectUser1Role);
projectUser2 = new User();
projectUser2.setFirstName("projectUser2");
projectUser2 = userDao.save(projectUser2);
Student projectUser2Role = new Student();
projectUser2Role.setUser(projectUser2);
projectUser2Role = (Student) roleDao.save(projectUser2Role);
project1 = new Project();
project1.setTitle("Project 1");
Set<Student> project1Part = new TreeSet<Student>();
project1Part.add(projectUser2Role);
project1Part.add(indEventUserRole);
project1.setProjectParticipants(project1Part);
project1 = projectDao.save(project1);
ProjectSchedule schedule1 = new ProjectSchedule();
schedule1.setProject(project1);
schedule1 = projectScheduleDao.save(schedule1);
project2 = new Project();
project2.setTitle("Project 2");
Set<Student> project2Part = new TreeSet<Student>();
project2Part.add(indEventUserRole);
project2Part.add(projectUser1Role);
project2.setProjectParticipants(project2Part);
project2 = projectDao.save(project2);
ProjectSchedule schedule2 = new ProjectSchedule();
schedule2.setProject(project2);
schedule2 = projectScheduleDao.save(schedule2);
indEvent = new ProjectEvent();
indEvent.setTitle("Individual event title");
indEvent.setDescription("Individual Event Description");
indEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
Set<Student> indEventStudents = new TreeSet<Student>();
indEventStudents.add(indEventUserRole);
indEvent.setParticipants(indEventStudents);
indEvent.setProjectSchedule(schedule1);
indEvent.setCreator(groupEventCreatorUserRole);
indEvent = projectEventDao.save(indEvent);
overDueIndEvent = new ProjectEvent();
overDueIndEvent.setTitle("overDueIndEvent event title");
overDueIndEvent.setDescription("Individual Event Description");
overDueIndEvent.setDueDate(new Date(System.currentTimeMillis() - 100000));
Set<Student> overDueIndEventStudents = new TreeSet<Student>();
overDueIndEventStudents.add(indEventUserRole);
overDueIndEvent.setParticipants(indEventStudents);
overDueIndEvent.setProjectSchedule(schedule1);
overDueIndEvent.setCreator(groupEventCreatorUserRole);
overDueIndEvent = projectEventDao.save(overDueIndEvent);
deletedIndEvent = new ProjectEvent();
deletedIndEvent.setTitle("Deleted Individual Event title");
deletedIndEvent.setDescription("Deleted Individual Event description");
deletedIndEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
deletedIndEvent.setDeleted(true);
Set<Student> indDeletedEventStudents = new TreeSet<Student>();
indDeletedEventStudents.add(indEventUserRole);
indEvent.setParticipants(indDeletedEventStudents);
deletedIndEvent.setProjectSchedule(schedule1);
deletedIndEvent.setCreator(groupEventCreatorUserRole);
deletedIndEvent = projectEventDao.save(deletedIndEvent);
groupEvent = new GroupEvent();
groupEvent.setTitle("Group event title");
groupEvent.setDescription("Group Event Description");
groupEvent.setDueDate(new Date(System.currentTimeMillis() + 100000));
groupEvent.addProjectSchedule(schedule1);
groupEvent.addProjectSchedule(schedule2);
groupEvent.setCreator(groupEventCreatorUserRole);
groupEvent = groupEventDao.save(groupEvent);
overDueGroupEvent = new GroupEvent();
overDueGroupEvent.setTitle("overDueGroupEvent event title");
overDueGroupEvent.setDescription("overDueGroupEvent Event Description");
overDueGroupEvent.setDueDate(new Date(System.currentTimeMillis() - 200000));
overDueGroupEvent.addProjectSchedule(schedule1);
overDueGroupEvent.addProjectSchedule(schedule2);
overDueGroupEvent.setCreator(groupEventCreatorUserRole);
overDueGroupEvent = groupEventDao.save(overDueGroupEvent);
deletedGroupEvent = new GroupEvent();
deletedGroupEvent.setTitle("Deleted group Event title");
deletedGroupEvent.setDescription("Deleted group Event description");
deletedGroupEvent.setDueDate(new Date(System.currentTimeMillis() + 200000));
deletedGroupEvent.setDeleted(true);
deletedGroupEvent.addProjectSchedule(schedule1);
deletedGroupEvent.addProjectSchedule(schedule2);
deletedGroupEvent.setCreator(groupEventCreatorUserRole);
deletedGroupEvent = groupEventDao.save(deletedGroupEvent);
}
@ -71,7 +210,10 @@ public class TestEventDaoJPA {
@Rollback
public void testFindAll() {
List<Event> events = new ArrayList<Event>();
events.add(event);
events.add(indEvent);
events.add(overDueIndEvent);
events.add(groupEvent);
events.add(overDueGroupEvent);
Assert.assertEquals(events, eventDao.findAll());
}
@ -81,7 +223,7 @@ public class TestEventDaoJPA {
@Test @Transactional
@Rollback
public void testCountAll() {
Assert.assertEquals(1, eventDao.countAll());
Assert.assertEquals(4, eventDao.countAll());
}
/**
@ -90,7 +232,10 @@ public class TestEventDaoJPA {
@Test @Transactional
@Rollback
public void testDelete() {
eventDao.delete(event);
eventDao.delete(indEvent);
eventDao.delete(groupEvent);
eventDao.delete(overDueGroupEvent);
eventDao.delete(overDueIndEvent);
Assert.assertEquals(0, eventDao.countAll());
}
@ -98,7 +243,10 @@ public class TestEventDaoJPA {
@Transactional
@Rollback
public void testLazyDelete() {
event = eventDao.lazyDelete(event);
indEvent = (ProjectEvent)eventDao.lazyDelete(indEvent);
groupEvent = (GroupEvent)eventDao.lazyDelete(groupEvent);
overDueGroupEvent = (GroupEvent)eventDao.lazyDelete(overDueGroupEvent);
overDueIndEvent = (ProjectEvent)eventDao.lazyDelete(overDueIndEvent);
Assert.assertEquals(0, eventDao.countAll());
}
@ -108,8 +256,10 @@ public class TestEventDaoJPA {
@Test @Transactional
@Rollback
public void testLoad() {
Event event2 = eventDao.load(event.getId());
Assert.assertEquals(event, event2);
Event event1 = eventDao.load(indEvent.getId());
Event event2 = eventDao.load(groupEvent.getId());
Assert.assertEquals(event1.getId(), indEvent.getId());
Assert.assertEquals(event2.getId(), groupEvent.getId());
}
/**
@ -125,7 +275,7 @@ public class TestEventDaoJPA {
@Transactional
@Rollback
public void testCountAllLazyDeleted() {
Assert.assertEquals(1, eventDao.countAllLazyDeleted());
Assert.assertEquals(2, eventDao.countAllLazyDeleted());
}
@Test
@ -133,8 +283,48 @@ public class TestEventDaoJPA {
@Rollback
public void testFindAllLazyDeteted() {
List<Event> events = new ArrayList<Event>();
events.add(deletedEvent);
events.add(deletedIndEvent);
events.add(deletedGroupEvent);
Assert.assertEquals(events, eventDao.findAllLazyDeleted());
}
@Test
@Transactional
@Rollback
public void testGetAllEventsByUserAndProject(){
ArrayList<Event> events = new ArrayList<Event>();
events.add(overDueGroupEvent);
events.add(overDueIndEvent);
events.add(indEvent);
events.add(groupEvent);
Assert.assertEquals(events, eventDao.getAllEventsByUserAndProject(indEventUser, project1));
}
@Test
@Transactional
@Rollback
public void testGetUpcomingEventsByUserAndProject(){
ArrayList<Event> events = new ArrayList<Event>();
events.add(indEvent);
events.add(groupEvent);
Assert.assertEquals(events, eventDao.getUpcomingEventsByUserAndProject(indEventUser, project1));
}
@Test
@Transactional
@Rollback
public void testCountOverDueEventsByUserAndProject(){
Assert.assertEquals(2, eventDao.countOverDueEventsByUserAndProject(indEventUser, project1));
}
@Test
@Transactional
@Rollback
public void testGetOverDueEventsByUserAndProject(){
ArrayList<Event> events = new ArrayList<Event>();
events.add(overDueGroupEvent);
events.add(overDueIndEvent);
Assert.assertEquals(events, eventDao.getOverDueEventsByUserAndProject(indEventUser, project1));
}
}

@ -31,174 +31,5 @@ import se.su.dsv.scipro.data.dataobjects.ProjectSchedule;
@ContextConfiguration
public class TestProjectScheduleDaoJPA {
@Autowired
private EventDao eventDao;
@Autowired
private ProjectScheduleDao projectScheduleDao;
@Autowired
private ProjectDao projectDao;
protected ProjectSchedule ps;
protected Project project;
protected Event oldDueDateEvent;
protected Event oldDoneDueDateEvent;
protected Event futureDueDateEvent;
protected Event oldDueDateDeletedEvent;
protected Event futureDueDateDeletedEvent;
@Before
public void startTransaction() {
project = new Project();
project = projectDao.save(project);
ps = new ProjectSchedule();
ps.setProject(project);
ps = projectScheduleDao.save(ps);
GregorianCalendar calBeforeToday = new GregorianCalendar();
calBeforeToday.add(Calendar.MONTH, -1);
GregorianCalendar calAfterToday = new GregorianCalendar();
calAfterToday.add(Calendar.MONTH, 1);
oldDueDateEvent = new Event();
oldDueDateEvent.setTitle("oldDueDateEvent title");
oldDueDateEvent.setDescription("oldDueDateEvent description");
oldDueDateEvent.setDueDate(calBeforeToday.getTime());
oldDueDateEvent.setProjectSchedule(ps);
oldDueDateEvent = eventDao.save(oldDueDateEvent);
oldDoneDueDateEvent = new Event();
oldDoneDueDateEvent.setTitle("oldDoneDueDateEvent title");
oldDoneDueDateEvent.setDescription("oldDoneDueDateEvent description");
oldDoneDueDateEvent.setDone(true);
oldDoneDueDateEvent.setDueDate(calBeforeToday.getTime());
oldDoneDueDateEvent.setProjectSchedule(ps);
oldDoneDueDateEvent = eventDao.save(oldDoneDueDateEvent);
futureDueDateEvent = new Event();
futureDueDateEvent.setTitle("futureDueDateEvent title");
futureDueDateEvent.setDescription("futureDueDateEvent description");
futureDueDateEvent.setDueDate(calAfterToday.getTime());
futureDueDateEvent.setProjectSchedule(ps);
futureDueDateEvent = eventDao.save(futureDueDateEvent);
oldDueDateDeletedEvent = new Event();
oldDueDateDeletedEvent.setTitle("oldDueDateDeletedEvent title");
oldDueDateDeletedEvent.setDescription("oldDueDateDeletedEvent description");
oldDueDateDeletedEvent.setDeleted(true);
oldDueDateDeletedEvent.setDueDate(calBeforeToday.getTime());
oldDueDateDeletedEvent.setProjectSchedule(ps);
oldDueDateDeletedEvent = eventDao.save(oldDueDateDeletedEvent);
futureDueDateDeletedEvent = new Event();
futureDueDateDeletedEvent.setTitle("futureDueDateDeletedEvent title");
futureDueDateDeletedEvent.setDescription("futureDueDateDeletedEvent description");
futureDueDateDeletedEvent.setDueDate(calAfterToday.getTime());
futureDueDateDeletedEvent.setDeleted(true);
futureDueDateDeletedEvent.setProjectSchedule(ps);
futureDueDateDeletedEvent = eventDao.save(futureDueDateDeletedEvent);
}
@Test
@Transactional
@Rollback
public void testFindAll(){
List<ProjectSchedule> list = new ArrayList<ProjectSchedule>();
list.add(ps);
Assert.assertEquals(list, projectScheduleDao.findAll());
}
@Test
@Transactional
@Rollback
public void testCountAll() {
Assert.assertEquals(1, projectScheduleDao.countAll());
}
@Test
@Transactional
@Rollback
public void testLoad() {
ProjectSchedule ps2 = projectScheduleDao.load(ps.getId());
Assert.assertEquals(ps, ps2);
}
@Test
@Transactional
@Rollback
public void testGetAllEventsByProjectSchedule(){
List<Event> notDeleted = new ArrayList<Event>();
notDeleted.add(oldDoneDueDateEvent);
notDeleted.add(oldDueDateEvent);
notDeleted.add(futureDueDateEvent);
List<Event> fromQuery = projectScheduleDao.getAllEventsByProjectSchedule(ps);
Assert.assertEquals(notDeleted, fromQuery);
}
@Test
@Transactional
@Rollback
public void testGetUpcomingEventsByProjectSchedule(){
List<Event> notDeleted = new ArrayList<Event>();
notDeleted.add(futureDueDateEvent);
List<Event> fromQuery = projectScheduleDao.getUpcomingEventsByProjectSchedule(ps, false);
Assert.assertEquals(notDeleted, fromQuery);
}
@Test
@Transactional
@Rollback
public void testGetUpcomingAndNotDoneEventsByProjectSchedule(){
System.out.println("ALSNGALSNG");
List<Event> notDeleted = new ArrayList<Event>();
notDeleted.add(oldDueDateEvent);
notDeleted.add(futureDueDateEvent);
List<Event> fromQuery = projectScheduleDao.getUpcomingEventsByProjectSchedule(ps, true);
Assert.assertEquals(notDeleted, fromQuery);
}
@Test
@Transactional
@Rollback
public void testGetOldEventsByProjectSchedule(){
List<Event> notDeleted = new ArrayList<Event>();
notDeleted.add(oldDueDateEvent);
notDeleted.add(oldDoneDueDateEvent);
List<Event> fromQuery = projectScheduleDao.getOldEventsByProjectSchedule(ps, null);
Assert.assertEquals(notDeleted, fromQuery);
}
@Test
@Transactional
@Rollback
public void testGetNotDoneOldEventsByProjectSchedule(){
List<Event> notDeleted = new ArrayList<Event>();
notDeleted.add(oldDueDateEvent);
List<Event> fromQuery = projectScheduleDao.getOldEventsByProjectSchedule(ps, false);
Assert.assertEquals(notDeleted, fromQuery);
}
@Test
@Transactional
@Rollback
public void testCountOverDueEvent(){
Assert.assertEquals(1, projectScheduleDao.countOverDueEvents(ps));
}
}

@ -86,7 +86,7 @@ public class TestUserDaoJPA {
}
/**
* Test method for {@link se.su.dsv.scipro.data.dao.jpa.AbstractDaoJPAImpl#load(java.io.Serializable)}.
* Test method for {@link se.su.dsv.scipro.data.dao.jpa.AbstractDaoJPAImp#load(java.io.Serializable)}.
*/
@Test @Transactional
@Rollback
@ -106,7 +106,7 @@ public class TestUserDaoJPA {
}
/**
* Test method for {@link se.su.dsv.scipro.data.dao.jpa.AbstractDaoJPAImpl#save(se.su.dsv.scipro.data.dataobjects.DomainObject)}.
* Test method for {@link se.su.dsv.scipro.data.dao.jpa.AbstractDaoJPAImp#save(se.su.dsv.scipro.data.dataobjects.DomainObject)}.
*/
@Test @Transactional
@Rollback