Trying to find bug... Also changed to new junit package name in som places

This commit is contained in:
Dan Lagnöhed 2013-10-03 11:04:01 +02:00
parent 13712ec86c
commit a417d85fa9
6 changed files with 415 additions and 388 deletions
core/src/test/java/se/su/dsv/scipro
fitnesse/src/test/java/se/su/dsv/scipro/fitnesse

@ -1,7 +1,7 @@
package se.su.dsv.scipro.configuration;
import junit.framework.Assert;
import org.apache.commons.io.IOUtils;
import org.junit.Assert;
import org.junit.Ignore;
import org.junit.Test;
import org.xml.sax.InputSource;
@ -10,7 +10,11 @@ import se.su.dsv.scipro.util.xml.MutableNamespaceContext;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.io.*;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringWriter;
/**
* Assert that deploy configuration is upheld before build can be completed.
@ -19,76 +23,76 @@ import java.io.*;
*/
public class TestDeployConfiguration {
private static String persistenceXmlPath = "META-INF" + File.separator + "persistence.xml";
private static String repositoryContext = "META-INF" + File.separator + "repositoryContext.xml";
private static String baseRepository = "META-INF" + File.separator + "base-repository.xml";
private static String webXmlPath = "src" + File.separator + "main" + File.separator + "webapp" + File.separator + "WEB-INF" + File.separator + "web.xml";
private static final String applicationContextPath = "applicationContext.xml";
private static String persistenceXmlPath = "META-INF" + File.separator + "persistence.xml";
private static String repositoryContext = "META-INF" + File.separator + "repositoryContext.xml";
private static String baseRepository = "META-INF" + File.separator + "base-repository.xml";
private static String webXmlPath = "src" + File.separator + "main" + File.separator + "webapp" + File.separator + "WEB-INF" + File.separator + "web.xml";
private static final String applicationContextPath = "applicationContext.xml";
@Test
public void testJackrabbitPath() throws XPathExpressionException, IOException {
InputSource persistenceXml = getInputSource(repositoryContext);
Assert.assertEquals("/jackrabbit",
XPathFactory.newInstance().newXPath().evaluate(
"(//*[@name='jcrRepository']/@value)[1]",
persistenceXml));
@Test
public void testJackrabbitPath() throws XPathExpressionException, IOException {
InputSource persistenceXml = getInputSource(repositoryContext);
Assert.assertEquals("/jackrabbit",
XPathFactory.newInstance().newXPath().evaluate(
"(//*[@name='jcrRepository']/@value)[1]",
persistenceXml));
}
}
@Test
@Test
@Ignore
public void testJackrabbitBasePath() throws XPathExpressionException, IOException {
InputSource persistenceXml = getInputSource(baseRepository);
Assert.assertEquals("/jackrabbit",
XPathFactory.newInstance().newXPath().evaluate(
"(//*[@name='path']/@value)[1]",
persistenceXml));
public void testJackrabbitBasePath() throws XPathExpressionException, IOException {
InputSource persistenceXml = getInputSource(baseRepository);
Assert.assertEquals("/jackrabbit",
XPathFactory.newInstance().newXPath().evaluate(
"(//*[@name='path']/@value)[1]",
persistenceXml));
}
}
@Test
public void testExternalAuthCfg() throws XPathExpressionException, IOException {
InputSource applicationContextXml = getInputSource(applicationContextPath);
XPath xPath = getApplicationContextXPath();
Assert.assertEquals("true", xPath.evaluate("/beanNS:beans/beanNS:bean[@id='applicationSettings']/beanNS:property[@name='acceptExternalAuthentication']/@value", applicationContextXml));
}
@Test
public void testExternalAuthCfg() throws XPathExpressionException, IOException {
InputSource applicationContextXml = getInputSource(applicationContextPath);
XPath xPath = getApplicationContextXPath();
Assert.assertEquals("true", xPath.evaluate("/beanNS:beans/beanNS:bean[@id='applicationSettings']/beanNS:property[@name='acceptExternalAuthentication']/@value", applicationContextXml));
}
@Test
public void testExternalAuthenticationCfg() throws XPathExpressionException, IOException {
InputSource applicationContextXml = getInputSource(applicationContextPath);
XPath xPath = getApplicationContextXPath();
Assert.assertEquals("true", xPath.evaluate("/beanNS:beans/beanNS:bean[@id='applicationSettings']/beanNS:property[@name='acceptExternalAuthentication']/@value", applicationContextXml));
}
@Test
public void testExternalAuthenticationCfg() throws XPathExpressionException, IOException {
InputSource applicationContextXml = getInputSource(applicationContextPath);
XPath xPath = getApplicationContextXPath();
Assert.assertEquals("true", xPath.evaluate("/beanNS:beans/beanNS:bean[@id='applicationSettings']/beanNS:property[@name='acceptExternalAuthentication']/@value", applicationContextXml));
}
@Test
public void testRemoteLookupImplCfg() throws XPathExpressionException, IOException {
InputSource applicationContextXml = getInputSource(applicationContextPath);
XPath xPath = getApplicationContextXPath();
Assert.assertEquals("se.su.dsv.scipro.io.impl.ExternalImporterDaisyImpl", xPath.evaluate("/beanNS:beans/beanNS:bean[@id='externalImporter']/@class", applicationContextXml));
}
@Test
public void testRemoteLookupImplCfg() throws XPathExpressionException, IOException {
InputSource applicationContextXml = getInputSource(applicationContextPath);
XPath xPath = getApplicationContextXPath();
Assert.assertEquals("se.su.dsv.scipro.io.impl.ExternalImporterDaisyImpl", xPath.evaluate("/beanNS:beans/beanNS:bean[@id='externalImporter']/@class", applicationContextXml));
}
private InputSource getInputSource(String filePath) throws IOException {
String theString = readResourceAsString(filePath);
InputStream is = new ByteArrayInputStream(theString.getBytes());
return new InputSource(is);
}
private InputSource getInputSource(String filePath) throws IOException {
String theString = readResourceAsString(filePath);
InputStream is = new ByteArrayInputStream(theString.getBytes());
return new InputSource(is);
}
private static String readResourceAsString(String filePath) throws IOException {
return readResourceAsString(filePath, "UTF-8");
}
private static String readResourceAsString(String filePath) throws IOException {
return readResourceAsString(filePath, "UTF-8");
}
private static String readResourceAsString(String filePath, String charset) throws IOException {
InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
StringWriter writer = new StringWriter();
IOUtils.copy(in, writer, charset);
return writer.toString();
}
private static String readResourceAsString(String filePath, String charset) throws IOException {
InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
StringWriter writer = new StringWriter();
IOUtils.copy(in, writer, charset);
return writer.toString();
}
private XPath getApplicationContextXPath() {
XPath xPath = XPathFactory.newInstance().newXPath();
MutableNamespaceContext mnc = new MutableNamespaceContext();
mnc.setMapping("beanNS", "http://www.springframework.org/schema/beans");
xPath.setNamespaceContext(mnc);
return xPath;
}
private XPath getApplicationContextXPath() {
XPath xPath = XPathFactory.newInstance().newXPath();
MutableNamespaceContext mnc = new MutableNamespaceContext();
mnc.setMapping("beanNS", "http://www.springframework.org/schema/beans");
xPath.setNamespaceContext(mnc);
return xPath;
}
}

@ -1,7 +1,7 @@
package se.su.dsv.scipro.springdata;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -11,7 +11,12 @@ 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.dataobjects.*;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.Language;
import se.su.dsv.scipro.data.dataobjects.ProjectClass;
import se.su.dsv.scipro.data.dataobjects.ResearchArea;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.match.dataobject.ApplicationPeriod;
import se.su.dsv.scipro.match.dataobject.NewIdea;
import se.su.dsv.scipro.match.dataobject.NewIdea.Type;
@ -19,12 +24,23 @@ import se.su.dsv.scipro.match.dataobject.NewIdeaParticipation;
import se.su.dsv.scipro.match.dataobject.NewMatch;
import se.su.dsv.scipro.match.dataobject.NewMatch.Status;
import se.su.dsv.scipro.match.facade.ApplicationPeriodFacade;
import se.su.dsv.scipro.springdata.services.*;
import se.su.dsv.scipro.springdata.services.LanguageService;
import se.su.dsv.scipro.springdata.services.NewIdeaService;
import se.su.dsv.scipro.springdata.services.NewIdeaService.FilterParams;
import se.su.dsv.scipro.springdata.services.NewMatchService;
import se.su.dsv.scipro.springdata.services.ProjectClassService;
import se.su.dsv.scipro.springdata.services.ResearchAreaService;
import se.su.dsv.scipro.springdata.services.RoleService;
import se.su.dsv.scipro.springdata.services.UserService;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(inheritLocations = false, locations = {
@ -76,14 +92,14 @@ public class TestNewIdea {
swedish = languageService.save(swedish);
english = new Language("English");
english = languageService.save(english);
area = new ResearchArea();
area.setTitle("Test area");
area.setIdentifier(new Long(1));
area = areaService.save(area);
supervisorUser = newUser();
supervisorUser2 = newUser();
supervisorUser2 = newUser();
authorUser1 = newUser();
authorUser2 = newUser();
@ -96,7 +112,7 @@ public class TestNewIdea {
unmatchedStudentMaster = newIdea(master, masterPeriod, supervisor2, Status.UNMATCHED, area, Type.SUPERVISOR, swedish);
matchedStudentBachelor = newIdea(bachelor, bachelorPeriod, supervisor, Status.MATCHED, area, Type.STUDENT, english);
matchedStudentMaster = newIdea(master, masterPeriod, supervisor2, Status.MATCHED, area, Type.STUDENT, english);
}
@ -119,10 +135,10 @@ public class TestNewIdea {
Assert.assertTrue(allIdeas.containsAll(Arrays.asList(new NewIdea[]{unmatchedStudentBachelor, matchedStudentBachelor, unmatchedStudentMaster, matchedStudentMaster})));
// Assert.assertEquals(Arrays.asList(new NewIdea[]{unmatchedStudentBachelor, matchedStudentBachelor, unmatchedStudentMaster, matchedStudentMaster}), allIdeas);
levelSet.clear();
params.setLevels(levelSet);
List<NewIdea> noIdeas = ideaService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertTrue(noIdeas.isEmpty());
@ -132,14 +148,14 @@ public class TestNewIdea {
@Transactional
@Rollback
public void testFindAuthorIdeas() {
List<NewIdea> noIdeas = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent();
Assert.assertTrue(noIdeas.isEmpty());
addBachelorStudents(matchedStudentBachelor);
List<NewIdea> oneIdea = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent();
Assert.assertEquals(1, oneIdea.size());
Assert.assertEquals(Arrays.asList(new NewIdea[]{matchedStudentBachelor}), oneIdea);
List<NewIdea> noIdeas = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent();
Assert.assertTrue(noIdeas.isEmpty());
addBachelorStudents(matchedStudentBachelor);
List<NewIdea> oneIdea = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent();
Assert.assertEquals(1, oneIdea.size());
Assert.assertEquals(Arrays.asList(new NewIdea[]{matchedStudentBachelor}), oneIdea);
}
@Test
@ -161,7 +177,7 @@ public class TestNewIdea {
@Transactional
@Rollback
public void testIdeaParticipations() {
NewIdeaParticipation participation = new NewIdeaParticipation();
NewIdeaParticipation participation = new NewIdeaParticipation();
participation.setStudent(author1);
participation.setIdea(unmatchedStudentBachelor);
participation.setConfirmed(false);
@ -189,51 +205,51 @@ public class TestNewIdea {
}
private void addBachelorStudents(NewIdea idea) {
NewIdeaParticipation ip1 = new NewIdeaParticipation();
ip1.setStudent(author1);
ip1.setIdea(idea);
ip1.setDateCreated(date("2012-11-15"));
ip1.setConfirmed(true);
author1.addNewIdeaParticipation(ip1);
NewIdeaParticipation ip2 = new NewIdeaParticipation();
ip2.setStudent(author2);
ip2.setIdea(idea);
ip2.setDateCreated(date("2012-11-15"));
ip2.setConfirmed(true);
author2.addNewIdeaParticipation(ip2);
NewIdeaParticipation ip1 = new NewIdeaParticipation();
ip1.setStudent(author1);
ip1.setIdea(idea);
ip1.setDateCreated(date("2012-11-15"));
ip1.setConfirmed(true);
author1.addNewIdeaParticipation(ip1);
NewIdeaParticipation ip2 = new NewIdeaParticipation();
ip2.setStudent(author2);
ip2.setIdea(idea);
ip2.setDateCreated(date("2012-11-15"));
ip2.setConfirmed(true);
author2.addNewIdeaParticipation(ip2);
}
private NewIdea newIdea(ProjectClass pc, ApplicationPeriod ap, Employee supervisor, Status status, ResearchArea area, Type type, Language language) {
NewIdea idea = new NewIdea();
idea.setProjectClass(pc);
idea.setApplicationPeriod(ap);
idea.setTitle("Title");
idea.setDescription("desc");
idea.setPrerequisites("prereqs");
idea.setResearchArea(area);
idea.setType(type);
idea.setLanguage(language);
if(type.equals(Type.STUDENT))
idea.setCreator(authorUser1);
else
idea.setCreator(supervisorUser);
idea = ideaService.save(idea);
NewMatch match = createMatch(idea, status, supervisor);
idea = match.getIdea();
idea.setMatch(match);
return idea;
NewIdea idea = new NewIdea();
idea.setProjectClass(pc);
idea.setApplicationPeriod(ap);
idea.setTitle("Title");
idea.setDescription("desc");
idea.setPrerequisites("prereqs");
idea.setResearchArea(area);
idea.setType(type);
idea.setLanguage(language);
if (type.equals(Type.STUDENT))
idea.setCreator(authorUser1);
else
idea.setCreator(supervisorUser);
idea = ideaService.save(idea);
NewMatch match = createMatch(idea, status, supervisor);
idea = match.getIdea();
idea.setMatch(match);
return idea;
}
private NewMatch createMatch(NewIdea idea, Status status, Employee supervisor) {
NewMatch match = new NewMatch();
match.setIdea(idea);
match.setStatus(status);
match.setChangedBy(supervisorUser);
match.setSupervisor(supervisor);
return matchService.save(match);
NewMatch match = new NewMatch();
match.setIdea(idea);
match.setStatus(status);
match.setChangedBy(supervisorUser);
match.setSupervisor(supervisor);
return matchService.save(match);
}
private Student newStudent(final User user) {
Student student = new Student();
student.setUser(user);

@ -1,7 +1,7 @@
package se.su.dsv.scipro.springdata;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -12,12 +12,21 @@ 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.dataobjects.*;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectClass;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.ProjectStatus;
import se.su.dsv.scipro.peer.data.dataobjects.PeerRequest;
import se.su.dsv.scipro.peer.data.dataobjects.PeerReview;
import se.su.dsv.scipro.peer.enums.RequestStatus;
import se.su.dsv.scipro.springdata.services.*;
import se.su.dsv.scipro.springdata.services.PeerRequestService;
import se.su.dsv.scipro.springdata.services.PeerReviewService;
import se.su.dsv.scipro.springdata.services.ProjectClassService;
import se.su.dsv.scipro.springdata.services.ProjectService;
import se.su.dsv.scipro.springdata.services.RoleService;
import se.su.dsv.scipro.springdata.services.UserService;
import java.text.ParseException;
import java.text.SimpleDateFormat;
@ -32,8 +41,8 @@ import java.util.Locale;
})
public class TestPeerReview {
@Autowired
private ProjectService projectService;
@Autowired
private ProjectService projectService;
@Autowired
private UserService userService;
@Autowired
@ -61,14 +70,14 @@ public class TestPeerReview {
bachelor = projectClassService.save(bachelor);
master = new ProjectClass(ProjectClass.MASTER, "Master", "Master degree thesis project");
master = projectClassService.save(master);
employeeUser = new User();
employeeUser = userService.save(employeeUser);
reviewer = new User();
reviewer = userService.save(reviewer);
requester = new User();
requester = userService.save(requester);
reviewerRole = newStudent(reviewer);
requesterRole = newStudent(requester);
@ -81,157 +90,157 @@ public class TestPeerReview {
bachelorProject = newProject(bachelor, requesterRole, headSupervisor, ProjectStatus.ACTIVE);
request1 = newRequest(requesterRole, requesterProject, "Request 1", null);
request2 = newRequest(requesterRole, requesterProject, "Request 2", null);
request3 = newRequest(requesterRole, requesterProject, "Request 3", null);
request4 = newRequest(requesterRole, requesterProject, "Request 4", RequestStatus.WAITING);
review1 = newReview(reviewerRole, reviewerProject, request1, RequestStatus.FINISHED, false, true);
review2 = newReview(reviewerRole, reviewerProject, request2, RequestStatus.FINISHED, false, true);
review3 = newReview(reviewerRole, reviewerProject, request3, RequestStatus.TAKEN, false, false);
request2 = newRequest(requesterRole, requesterProject, "Request 2", null);
request3 = newRequest(requesterRole, requesterProject, "Request 3", null);
request4 = newRequest(requesterRole, requesterProject, "Request 4", RequestStatus.WAITING);
review1 = newReview(reviewerRole, reviewerProject, request1, RequestStatus.FINISHED, false, true);
review2 = newReview(reviewerRole, reviewerProject, request2, RequestStatus.FINISHED, false, true);
review3 = newReview(reviewerRole, reviewerProject, request3, RequestStatus.TAKEN, false, false);
}
@Test
@Transactional
@Rollback
public void testFindCompletedReviewsByAuthorAndProject() {
List<PeerReview> completedReviews = peerReviewService.findCompletedReviews(reviewerRole, reviewerProject);
Assert.assertEquals(2, completedReviews.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2}), completedReviews);
List<PeerReview> completedReviews = peerReviewService.findCompletedReviews(reviewerRole, reviewerProject);
Assert.assertEquals(2, completedReviews.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2}), completedReviews);
}
@Test
@Transactional
@Rollback
public void testFindInProgressReviewsByAuthorAndProject() {
List<PeerReview> inProgressReviews = peerReviewService.findInProgressReviews(reviewerRole, reviewerProject);
Assert.assertEquals(1, inProgressReviews.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), inProgressReviews);
List<PeerReview> inProgressReviews = peerReviewService.findInProgressReviews(reviewerRole, reviewerProject);
Assert.assertEquals(1, inProgressReviews.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), inProgressReviews);
}
@Test
@Transactional
@Rollback
public void testFindReceivedCompletedReviewsByProject() {
List<PeerReview> receivedCompleted = peerReviewService.findReceivedCompletedReviews(requesterProject);
Assert.assertEquals(2, receivedCompleted.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2}), receivedCompleted);
List<PeerReview> receivedCompleted = peerReviewService.findReceivedCompletedReviews(requesterProject);
Assert.assertEquals(2, receivedCompleted.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2}), receivedCompleted);
}
@Test
@Transactional
@Rollback
public void testFindReceivedInProgressReviewsByProject() {
List<PeerReview> receivedInProgress = peerReviewService.findReceivedInProgressReviews(requesterProject);
Assert.assertEquals(1, receivedInProgress.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), receivedInProgress);
List<PeerReview> receivedInProgress = peerReviewService.findReceivedInProgressReviews(requesterProject);
Assert.assertEquals(1, receivedInProgress.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), receivedInProgress);
}
@Test
@Transactional
@Rollback
public void testCountAbortedReviewsByAuthorAndProject(){
Long abortedCount = peerReviewService.countAbortedReviews(reviewerProject, reviewerRole);
Long l = new Long(0);
Assert.assertEquals(l, abortedCount);
review3.setAborted(true);
abortedCount = peerReviewService.countAbortedReviews(reviewerProject, reviewerRole);
Long l2 = new Long(1);
Assert.assertEquals(l2, abortedCount);
public void testCountAbortedReviewsByAuthorAndProject() {
Long abortedCount = peerReviewService.countAbortedReviews(reviewerProject, reviewerRole);
Long l = new Long(0);
Assert.assertEquals(l, abortedCount);
review3.setAborted(true);
abortedCount = peerReviewService.countAbortedReviews(reviewerProject, reviewerRole);
Long l2 = new Long(1);
Assert.assertEquals(l2, abortedCount);
}
@Test
@Transactional
@Rollback
public void testFindAwaitingRequestsByProject(){
List<PeerRequest> awaitingRequests = peerRequestService.findAwaitingRequests(requesterProject);
Assert.assertEquals(1, awaitingRequests.size());
Assert.assertEquals(Arrays.asList(new PeerRequest[]{request4}), awaitingRequests);
}
@Test
@Transactional
@Rollback
public void testCountAllAbortedReviews(){
Long allAborted = peerReviewService.countAllAborted();
Long expected = new Long(0);
Assert.assertEquals(expected, allAborted);
review2.setAborted(true);
review2.setSubmitted(false);
review3.setAborted(true);
allAborted = peerReviewService.countAllAborted();
expected = new Long(2);
Assert.assertEquals(expected, allAborted);
}
@Test
@Transactional
@Rollback
public void testCountAllInProgressReviews(){
Long allInProgress = peerReviewService.countAllInProgress();
Long expected = new Long(1);
Assert.assertEquals(expected, allInProgress);
review3.setSubmitted(true);
allInProgress = peerReviewService.countAllInProgress();
expected = new Long(0);
Assert.assertEquals(expected, allInProgress);
}
@Test
@Transactional
@Rollback
public void testCountAllCompletedReviews(){
Long allCompleted = peerReviewService.countAllCompleted();
Long expected = new Long(2);
Assert.assertEquals(expected, allCompleted);
review3.setSubmitted(true);
allCompleted = peerReviewService.countAllCompleted();
expected = new Long(3);
Assert.assertEquals(expected, allCompleted);
}
@Test
@Transactional
@Rollback
public void testCountAllReviewsByStudent(){
Long allReviewsByStudent = peerReviewService.countAllReviewsByStudent(reviewerRole);
Long expected = new Long(3);
Assert.assertEquals(expected, allReviewsByStudent);
}
@Test
@Transactional
@Rollback
public void testFindAllWithParams(){
PeerReviewService.FilterParams params = new PeerReviewService.FilterParams();
params.setAuthor(reviewerRole);
List<PeerReview> reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2,review3}), reviewList);
review3.setReviewer(requesterRole);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2}), reviewList);
params.setAuthor(null);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2,review3}), reviewList);
@Test
@Transactional
@Rollback
public void testFindAwaitingRequestsByProject() {
List<PeerRequest> awaitingRequests = peerRequestService.findAwaitingRequests(requesterProject);
Assert.assertEquals(1, awaitingRequests.size());
Assert.assertEquals(Arrays.asList(new PeerRequest[]{request4}), awaitingRequests);
}
@Test
@Transactional
@Rollback
public void testCountAllAbortedReviews() {
Long allAborted = peerReviewService.countAllAborted();
Long expected = new Long(0);
Assert.assertEquals(expected, allAborted);
review2.setAborted(true);
review2.setSubmitted(false);
review3.setAborted(true);
allAborted = peerReviewService.countAllAborted();
expected = new Long(2);
Assert.assertEquals(expected, allAborted);
}
@Test
@Transactional
@Rollback
public void testCountAllInProgressReviews() {
Long allInProgress = peerReviewService.countAllInProgress();
Long expected = new Long(1);
Assert.assertEquals(expected, allInProgress);
review3.setSubmitted(true);
allInProgress = peerReviewService.countAllInProgress();
expected = new Long(0);
Assert.assertEquals(expected, allInProgress);
}
@Test
@Transactional
@Rollback
public void testCountAllCompletedReviews() {
Long allCompleted = peerReviewService.countAllCompleted();
Long expected = new Long(2);
Assert.assertEquals(expected, allCompleted);
review3.setSubmitted(true);
allCompleted = peerReviewService.countAllCompleted();
expected = new Long(3);
Assert.assertEquals(expected, allCompleted);
}
@Test
@Transactional
@Rollback
public void testCountAllReviewsByStudent() {
Long allReviewsByStudent = peerReviewService.countAllReviewsByStudent(reviewerRole);
Long expected = new Long(3);
Assert.assertEquals(expected, allReviewsByStudent);
}
@Test
@Transactional
@Rollback
public void testFindAllWithParams() {
PeerReviewService.FilterParams params = new PeerReviewService.FilterParams();
params.setAuthor(reviewerRole);
List<PeerReview> reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2, review3}), reviewList);
review3.setReviewer(requesterRole);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2}), reviewList);
params.setAuthor(null);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2, review3}), reviewList);
// params.setIncludeAborted(false);
// params.setIncludeCompleted(false);
// params.setIncludeInProgress(true);
params.setReviewStatus(PeerReview.ReviewStatus.INPROGRESS);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), reviewList);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), reviewList);
// review3.setAborted(true);
// params.setIncludeInProgress(false);
// params.setIncludeAborted(true);
@ -239,97 +248,97 @@ public class TestPeerReview {
params.setReviewStatus(PeerReview.ReviewStatus.ABORTED);
review3.setAborted(true);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), reviewList);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review3}), reviewList);
}
@Test
@Transactional
@Rollback
public void testReviewParamsDateFiltering() throws ParseException {
PeerReviewService.FilterParams params = new PeerReviewService.FilterParams();
PeerReviewService.FilterParams params = new PeerReviewService.FilterParams();
SimpleDateFormat date = new SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH);
Date january12 = date.parse("2012-01-12");
Date february15 = date.parse("2012-02-15");
Date march21 = date.parse("2012-03-21");
Date april05 = date.parse("2012-04-05");
Date may02 = date.parse("2012-05-02");
Date march27 = date.parse("2012-03-27");
review1.setDateCreated(february15);
review2.setDateCreated(march21);
review3.setDateCreated(may02);
params.setCreatedAfter(january12);
params.setCreatedBefore(april05);
List<PeerReview> reviewList = peerReviewService.findAll(params, new PageRequest(0,10)).getContent();
List<PeerReview> reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(2, reviewList.size());
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2}), reviewList);
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2}), reviewList);
review3.setDateCreated(march27);
reviewList = peerReviewService.findAll(params, new PageRequest(0,10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2,review3}), reviewList);
reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
Assert.assertEquals(Arrays.asList(new PeerReview[]{review1, review2, review3}), reviewList);
}
@Test
@Transactional
@Rollback
public void testFindByStatusAndProjectClass() {
Page<PeerRequest> requestPage = peerRequestService.findByStatusAndProjectClass(RequestStatus.WAITING, master, new PageRequest(0,8));
List<PeerRequest> requestList = requestPage.getContent();
Assert.assertEquals(1, requestList.size());
Assert.assertEquals(Arrays.asList(new PeerRequest[]{request4}), requestList);
request3.setStatus(RequestStatus.WAITING);
request4.setProject(bachelorProject);
requestPage = peerRequestService.findByStatusAndProjectClass(RequestStatus.WAITING, master, new PageRequest(0,8));
requestList = requestPage.getContent();
Assert.assertEquals(Arrays.asList(new PeerRequest[]{request3}), requestList);
Page<PeerRequest> requestPage = peerRequestService.findByStatusAndProjectClass(RequestStatus.WAITING, master, new PageRequest(0, 8));
List<PeerRequest> requestList = requestPage.getContent();
Assert.assertEquals(1, requestList.size());
Assert.assertEquals(Arrays.asList(new PeerRequest[]{request4}), requestList);
request3.setStatus(RequestStatus.WAITING);
request4.setProject(bachelorProject);
requestPage = peerRequestService.findByStatusAndProjectClass(RequestStatus.WAITING, master, new PageRequest(0, 8));
requestList = requestPage.getContent();
Assert.assertEquals(Arrays.asList(new PeerRequest[]{request3}), requestList);
}
//Helper methods for setting up test objects
private PeerReview newReview(final Student reviewer, final Project project, PeerRequest request, final RequestStatus status, boolean aborted, boolean submitted) {
PeerReview review = new PeerReview();
review.setReviewer(reviewer);
review.setProject(project);
review.setComment("Hi there!");
review.setPeerRequest(request);
request.setStatus(status);
request = peerRequestService.save(request);
review.setSubmitted(submitted);
review.setAborted(aborted);
return peerReviewService.save(review);
PeerReview review = new PeerReview();
review.setReviewer(reviewer);
review.setProject(project);
review.setComment("Hi there!");
review.setPeerRequest(request);
request.setStatus(status);
request = peerRequestService.save(request);
review.setSubmitted(submitted);
review.setAborted(aborted);
return peerReviewService.save(review);
}
private PeerRequest newRequest(final Student requester, final Project project, final String comment, final RequestStatus status){
PeerRequest request = new PeerRequest();
request.setComment(comment);
request.setRequester(requester);
request.setProject(project);
if(status!=null)
request.setStatus(status);
return peerRequestService.save(request);
private PeerRequest newRequest(final Student requester, final Project project, final String comment, final RequestStatus status) {
PeerRequest request = new PeerRequest();
request.setComment(comment);
request.setRequester(requester);
request.setProject(project);
if (status != null)
request.setStatus(status);
return peerRequestService.save(request);
}
private Student newStudent(final User user) {
Student student = new Student();
student.setUser(user);
return (Student) roleService.save(student);
Student student = new Student();
student.setUser(user);
return (Student) roleService.save(student);
}
private Project newProject(final ProjectClass pc, final Student role, final Employee headSupervisor, final ProjectStatus status){
Project newProject = new Project();
newProject.setProjectClass(pc);
newProject.setTitle("Project title");
newProject.setHeadSupervisor(headSupervisor);
newProject.addProjectParticipant(role);
newProject.setProjectStatus(status);
return projectService.save(newProject);
private Project newProject(final ProjectClass pc, final Student role, final Employee headSupervisor, final ProjectStatus status) {
Project newProject = new Project();
newProject.setProjectClass(pc);
newProject.setTitle("Project title");
newProject.setHeadSupervisor(headSupervisor);
newProject.addProjectParticipant(role);
newProject.setProjectStatus(status);
return projectService.save(newProject);
}
}

@ -1,7 +1,7 @@
package se.su.dsv.scipro.springdata;
import junit.framework.Assert;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@ -10,10 +10,19 @@ 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.dataobjects.*;
import se.su.dsv.scipro.data.dataobjects.Employee;
import se.su.dsv.scipro.data.dataobjects.Project;
import se.su.dsv.scipro.data.dataobjects.ProjectClass;
import se.su.dsv.scipro.data.dataobjects.ProjectFollower;
import se.su.dsv.scipro.data.dataobjects.Student;
import se.su.dsv.scipro.data.dataobjects.User;
import se.su.dsv.scipro.data.enums.ProjectStatus;
import se.su.dsv.scipro.data.enums.ProjectTeamMemberRoles;
import se.su.dsv.scipro.springdata.services.*;
import se.su.dsv.scipro.springdata.services.ProjectClassService;
import se.su.dsv.scipro.springdata.services.ProjectFollowerService;
import se.su.dsv.scipro.springdata.services.ProjectService;
import se.su.dsv.scipro.springdata.services.RoleService;
import se.su.dsv.scipro.springdata.services.UserService;
import java.util.Arrays;
import java.util.List;
@ -24,8 +33,8 @@ import java.util.List;
})
public class TestProject {
@Autowired
private ProjectService projectService;
@Autowired
private ProjectService projectService;
@Autowired
private UserService userService;
@Autowired
@ -51,7 +60,7 @@ public class TestProject {
master = new ProjectClass(ProjectClass.MASTER, "Master", "Master degree thesis project");
master = projectClassService.save(master);
employeeUser = new User();
employeeUser = userService.save(employeeUser);
reviewerUser = new User();
@ -64,19 +73,19 @@ public class TestProject {
author1 = new Student();
author1.setUser(authorUser);
author1 = (Student) roleService.save(author1);
headSupervisor = new Employee();
headSupervisor.setUser(employeeUser);
headSupervisor = (Employee) roleService.save(headSupervisor);
reviewerRole = new Employee();
reviewerRole.setUser(reviewerUser);
reviewerRole = (Employee) roleService.save(reviewerRole);
coSupervisorRole = new Employee();
coSupervisorRole.setUser(coSupervisorUser);
coSupervisorRole = (Employee) roleService.save(coSupervisorRole);
project1 = new Project();
project1.setProjectClass(bachelor);
project1.setTitle("Project 1");
@ -84,94 +93,94 @@ public class TestProject {
project1.addProjectParticipant(author1);
project1.setProjectStatus(ProjectStatus.ACTIVE);
project1 = projectService.save(project1);
project2 = new Project();
project2.setProjectClass(master);
project2.setTitle("Tester 2");
project2.setHeadSupervisor(headSupervisor);
project2.addProjectParticipant(author1);
project2.setProjectStatus(ProjectStatus.INACTIVE);
project2 = projectService.save(project2);
project2 = projectService.save(project2);
reviewer = new ProjectFollower();
reviewer.setFollower(reviewerRole);
reviewer.setProject(project1);
reviewer.setProjectRole(ProjectTeamMemberRoles.REVIEWER);
reviewer = projectFollowerService.save(reviewer);
reviewer = projectFollowerService.save(reviewer);
}
@Test
@Transactional
@Rollback
public void testGetProjectsByUser() {
List<Project> projectsFromService = projectService.getProjectsByUser(authorUser);
List<Project> projectsCreated = Arrays.asList(new Project[]{project1, project2});
Assert.assertEquals(2, projectsFromService.size());
Assert.assertEquals(projectsCreated, projectsFromService);
List<Project> projectsFromService = projectService.getProjectsByUser(authorUser);
List<Project> projectsCreated = Arrays.asList(new Project[]{project1, project2});
Assert.assertEquals(2, projectsFromService.size());
Assert.assertEquals(projectsCreated, projectsFromService);
}
@Test
@Transactional
@Rollback
public void testGetProjectsByUserAndStatus() {
List<Project> inactiveProjectsFromService = projectService.getProjectsByUserAndStatus(authorUser, ProjectStatus.INACTIVE);
List<Project> inactiveProjectsCreated = Arrays.asList(new Project[]{project2});
Assert.assertEquals(1, inactiveProjectsFromService.size());
Assert.assertEquals(inactiveProjectsCreated, inactiveProjectsFromService);
List<Project> inactiveProjectsFromService = projectService.getProjectsByUserAndStatus(authorUser, ProjectStatus.INACTIVE);
List<Project> inactiveProjectsCreated = Arrays.asList(new Project[]{project2});
Assert.assertEquals(1, inactiveProjectsFromService.size());
Assert.assertEquals(inactiveProjectsCreated, inactiveProjectsFromService);
}
@Test
@Transactional
@Rollback
public void testGetHeadSupervisorBachelorProjects() {
//Make sure status filtering works
List<Project> bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.INACTIVE, null, "");
Assert.assertTrue(bachelorsFromService.size()==0);
List<Project> activeBachelorsCreated = Arrays.asList(new Project[]{project1});
bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, null, "");
Assert.assertEquals(1, bachelorsFromService.size());
Assert.assertEquals(activeBachelorsCreated, bachelorsFromService);
//Make sure status filtering works
List<Project> bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.INACTIVE, null, "");
Assert.assertTrue(bachelorsFromService.size() == 0);
List<Project> activeBachelorsCreated = Arrays.asList(new Project[]{project1});
bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, null, "");
Assert.assertEquals(1, bachelorsFromService.size());
Assert.assertEquals(activeBachelorsCreated, bachelorsFromService);
}
@Test
@Transactional
@Rollback
public void testGetHeadSupervisorProjectsByAuthor() {
List<Project> authorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, null, null, author1, "");
List<Project> authorProjectsCreated = Arrays.asList(new Project[]{project1, project2});
Assert.assertEquals(2, authorProjectsFromService.size());
Assert.assertEquals(authorProjectsCreated, authorProjectsFromService);
List<Project> authorBachelorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, author1, "");
List<Project> authorBachelorProjectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(authorBachelorProjectsCreated, authorBachelorProjectsFromService);
public void testGetHeadSupervisorProjectsByAuthor() {
List<Project> authorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, null, null, author1, "");
List<Project> authorProjectsCreated = Arrays.asList(new Project[]{project1, project2});
Assert.assertEquals(2, authorProjectsFromService.size());
Assert.assertEquals(authorProjectsCreated, authorProjectsFromService);
List<Project> authorBachelorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, author1, "");
List<Project> authorBachelorProjectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(authorBachelorProjectsCreated, authorBachelorProjectsFromService);
}
@Test
@Transactional
@Rollback
public void testGetHeadSupervisorProjectsByAuthorAndTitle() {
List<Project> projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Tester");
Assert.assertEquals(0, projectsFromService.size());
projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Proj");
List<Project> projectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(1, projectsFromService.size());
Assert.assertEquals(projectsCreated, projectsFromService);
List<Project> projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Tester");
Assert.assertEquals(0, projectsFromService.size());
projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Proj");
List<Project> projectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(1, projectsFromService.size());
Assert.assertEquals(projectsCreated, projectsFromService);
}
@Test
@Transactional
@Rollback
public void testGetTeamMemberProjects(){
List<Project> coSupervisorProjectsFromService = projectService.getTeamMemberProjectsForPeer(coSupervisorUser, ProjectTeamMemberRoles.CO_SUPERVISOR, null, null, null, "");
Assert.assertTrue(coSupervisorProjectsFromService.size()==0);
List<Project> reviewerProjectsFromService = projectService.getTeamMemberProjectsForPeer(reviewerUser, ProjectTeamMemberRoles.REVIEWER, null, null, null, "");
List<Project> reviewerProjectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(reviewerProjectsCreated, reviewerProjectsFromService);
public void testGetTeamMemberProjects() {
List<Project> coSupervisorProjectsFromService = projectService.getTeamMemberProjectsForPeer(coSupervisorUser, ProjectTeamMemberRoles.CO_SUPERVISOR, null, null, null, "");
Assert.assertTrue(coSupervisorProjectsFromService.size() == 0);
List<Project> reviewerProjectsFromService = projectService.getTeamMemberProjectsForPeer(reviewerUser, ProjectTeamMemberRoles.REVIEWER, null, null, null, "");
List<Project> reviewerProjectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(reviewerProjectsCreated, reviewerProjectsFromService);
}
}

@ -7,10 +7,11 @@ import org.springframework.dao.support.PersistenceExceptionTranslator;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
import org.springframework.jndi.JndiObjectFactoryBean;
import org.springframework.orm.hibernate4.HibernateExceptionTranslator;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaDialect;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import se.su.dsv.scipro.io.http.DaisyAPI;
@ -31,15 +32,6 @@ public class FitnesseSpringConfiguration {
return new EmbeddedDatabaseBuilder().setType(EmbeddedDatabaseType.HSQL).build();
}
private DataSource dataSource() throws NamingException {
JndiObjectFactoryBean jndi = new JndiObjectFactoryBean();
jndi.setJndiName("java:comp/env/jdbc/defaultDS");
jndi.setDefaultObject(fallbackDataSource());
jndi.setExpectedType(DataSource.class);
jndi.afterPropertiesSet();
return (DataSource) jndi.getObject();
}
@Bean(name = "DaisyApi")
public DaisyAPI getDaisyApi() {
return new DaisyAPIImpl();
@ -57,13 +49,15 @@ public class FitnesseSpringConfiguration {
@Bean(name = "scipro")
public EntityManagerFactory entityManagerFactory() throws NamingException {
HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
adapter.setDatabase(Database.HSQL);
Properties jpaProperties = new Properties();
jpaProperties.setProperty("hibernate.hbm2ddl.auto", "update");
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
factory.setJpaVendorAdapter(adapter);
factory.setDataSource(dataSource());
factory.setDataSource(fallbackDataSource());
factory.setJpaDialect(new HibernateJpaDialect());
factory.setPersistenceUnitName("testPersistenceUnit");
factory.setPackagesToScan("se.su.dsv.scipro");
factory.setJpaProperties(jpaProperties);

@ -26,21 +26,16 @@ public class ChecklistAdministrator extends AbstractFixture {
private ProjectClassService projectClassService;
public boolean createChecklist(String name) {
CheckList checkList = null;
try {
ProjectClass projectClass = new ProjectClass();
projectClass.setName(SOME_NAME);
projectClass.setCode(SOME_CODE);
projectClass = projectClassService.save(projectClass);
Project project = new Project();
project.setTitle(SOME_TITLE);
project.setProjectClass(projectClass);
project = projectService.save(project);
checkList = CheckList.builder().name(name).project(project).build();
checkList = checklistService.save(checkList);
} catch (Exception e) {
e.printStackTrace();
}
ProjectClass projectClass = new ProjectClass();
projectClass.setName(SOME_NAME);
projectClass.setCode(SOME_CODE);
projectClass = projectClassService.save(projectClass);
Project project = new Project();
project.setTitle(SOME_TITLE);
project.setProjectClass(projectClass);
project = projectService.save(project);
CheckList checkList = CheckList.builder().name(name).project(project).build();
checkList = checklistService.save(checkList);
return checkList != null;
}
}