DMC/scipro
7
0
Fork 0
Code Issues24 Pull Requests2 Actions Projects1 Releases Wiki Activity

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

Browse Source
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
configuration
TestDeployConfiguration.java
springdata
TestNewIdea.javaTestPeerReview.javaTestProject.java
fitnesse/src/test/java/se/su/dsv/scipro/fitnesse
FitnesseSpringConfiguration.java
fixtures
ChecklistAdministrator.java

128
core/src/test/java/se/su/dsv/scipro/configuration/TestDeployConfiguration.java

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

112
core/src/test/java/se/su/dsv/scipro/springdata/TestNewIdea.java

@ -1,7 +1,7 @@
package se.su.dsv.scipro.springdata; package se.su.dsv.scipro.springdata;
import junit.framework.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; 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.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional; 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.ApplicationPeriod;
import se.su.dsv.scipro.match.dataobject.NewIdea; import se.su.dsv.scipro.match.dataobject.NewIdea;
import se.su.dsv.scipro.match.dataobject.NewIdea.Type; 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;
import se.su.dsv.scipro.match.dataobject.NewMatch.Status; import se.su.dsv.scipro.match.dataobject.NewMatch.Status;
import se.su.dsv.scipro.match.facade.ApplicationPeriodFacade; 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.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.ParseException;
import java.text.SimpleDateFormat; 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) @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(inheritLocations = false, locations = { @ContextConfiguration(inheritLocations = false, locations = {
@ -83,7 +99,7 @@ public class TestNewIdea {
area = areaService.save(area); area = areaService.save(area);
supervisorUser = newUser(); supervisorUser = newUser();
supervisorUser2 = newUser(); supervisorUser2 = newUser();
authorUser1 = newUser(); authorUser1 = newUser();
authorUser2 = newUser(); authorUser2 = newUser();
@ -132,14 +148,14 @@ public class TestNewIdea {
@Transactional @Transactional
@Rollback @Rollback
public void testFindAuthorIdeas() { public void testFindAuthorIdeas() {
List<NewIdea> noIdeas = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent(); List<NewIdea> noIdeas = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent();
Assert.assertTrue(noIdeas.isEmpty()); Assert.assertTrue(noIdeas.isEmpty());
addBachelorStudents(matchedStudentBachelor); addBachelorStudents(matchedStudentBachelor);
List<NewIdea> oneIdea = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent(); List<NewIdea> oneIdea = ideaService.findAuthorIdeas(author1, new PageRequest(0, 10)).getContent();
Assert.assertEquals(1, oneIdea.size()); Assert.assertEquals(1, oneIdea.size());
Assert.assertEquals(Arrays.asList(new NewIdea[]{matchedStudentBachelor}), oneIdea); Assert.assertEquals(Arrays.asList(new NewIdea[]{matchedStudentBachelor}), oneIdea);
} }
@Test @Test
@ -161,7 +177,7 @@ public class TestNewIdea {
@Transactional @Transactional
@Rollback @Rollback
public void testIdeaParticipations() { public void testIdeaParticipations() {
NewIdeaParticipation participation = new NewIdeaParticipation(); NewIdeaParticipation participation = new NewIdeaParticipation();
participation.setStudent(author1); participation.setStudent(author1);
participation.setIdea(unmatchedStudentBachelor); participation.setIdea(unmatchedStudentBachelor);
participation.setConfirmed(false); participation.setConfirmed(false);
@ -189,49 +205,49 @@ public class TestNewIdea {
} }
private void addBachelorStudents(NewIdea idea) { private void addBachelorStudents(NewIdea idea) {
NewIdeaParticipation ip1 = new NewIdeaParticipation(); NewIdeaParticipation ip1 = new NewIdeaParticipation();
ip1.setStudent(author1); ip1.setStudent(author1);
ip1.setIdea(idea); ip1.setIdea(idea);
ip1.setDateCreated(date("2012-11-15")); ip1.setDateCreated(date("2012-11-15"));
ip1.setConfirmed(true); ip1.setConfirmed(true);
author1.addNewIdeaParticipation(ip1); author1.addNewIdeaParticipation(ip1);
NewIdeaParticipation ip2 = new NewIdeaParticipation(); NewIdeaParticipation ip2 = new NewIdeaParticipation();
ip2.setStudent(author2); ip2.setStudent(author2);
ip2.setIdea(idea); ip2.setIdea(idea);
ip2.setDateCreated(date("2012-11-15")); ip2.setDateCreated(date("2012-11-15"));
ip2.setConfirmed(true); ip2.setConfirmed(true);
author2.addNewIdeaParticipation(ip2); author2.addNewIdeaParticipation(ip2);
} }
private NewIdea newIdea(ProjectClass pc, ApplicationPeriod ap, Employee supervisor, Status status, ResearchArea area, Type type, Language language) { private NewIdea newIdea(ProjectClass pc, ApplicationPeriod ap, Employee supervisor, Status status, ResearchArea area, Type type, Language language) {
NewIdea idea = new NewIdea(); NewIdea idea = new NewIdea();
idea.setProjectClass(pc); idea.setProjectClass(pc);
idea.setApplicationPeriod(ap); idea.setApplicationPeriod(ap);
idea.setTitle("Title"); idea.setTitle("Title");
idea.setDescription("desc"); idea.setDescription("desc");
idea.setPrerequisites("prereqs"); idea.setPrerequisites("prereqs");
idea.setResearchArea(area); idea.setResearchArea(area);
idea.setType(type); idea.setType(type);
idea.setLanguage(language); idea.setLanguage(language);
if(type.equals(Type.STUDENT)) if (type.equals(Type.STUDENT))
idea.setCreator(authorUser1); idea.setCreator(authorUser1);
else else
idea.setCreator(supervisorUser); idea.setCreator(supervisorUser);
idea = ideaService.save(idea); idea = ideaService.save(idea);
NewMatch match = createMatch(idea, status, supervisor); NewMatch match = createMatch(idea, status, supervisor);
idea = match.getIdea(); idea = match.getIdea();
idea.setMatch(match); idea.setMatch(match);
return idea; return idea;
} }
private NewMatch createMatch(NewIdea idea, Status status, Employee supervisor) { private NewMatch createMatch(NewIdea idea, Status status, Employee supervisor) {
NewMatch match = new NewMatch(); NewMatch match = new NewMatch();
match.setIdea(idea); match.setIdea(idea);
match.setStatus(status); match.setStatus(status);
match.setChangedBy(supervisorUser); match.setChangedBy(supervisorUser);
match.setSupervisor(supervisor); match.setSupervisor(supervisor);
return matchService.save(match); return matchService.save(match);
} }
private Student newStudent(final User user) { private Student newStudent(final User user) {

255
core/src/test/java/se/su/dsv/scipro/springdata/TestPeerReview.java

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

87
core/src/test/java/se/su/dsv/scipro/springdata/TestProject.java

@ -1,7 +1,7 @@
package se.su.dsv.scipro.springdata; package se.su.dsv.scipro.springdata;
import junit.framework.Assert; import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; 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.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional; 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.ProjectStatus;
import se.su.dsv.scipro.data.enums.ProjectTeamMemberRoles; 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.Arrays;
import java.util.List; import java.util.List;
@ -24,8 +33,8 @@ import java.util.List;
}) })
public class TestProject { public class TestProject {
@Autowired @Autowired
private ProjectService projectService; private ProjectService projectService;
@Autowired @Autowired
private UserService userService; private UserService userService;
@Autowired @Autowired
@ -104,74 +113,74 @@ public class TestProject {
@Transactional @Transactional
@Rollback @Rollback
public void testGetProjectsByUser() { public void testGetProjectsByUser() {
List<Project> projectsFromService = projectService.getProjectsByUser(authorUser); List<Project> projectsFromService = projectService.getProjectsByUser(authorUser);
List<Project> projectsCreated = Arrays.asList(new Project[]{project1, project2}); List<Project> projectsCreated = Arrays.asList(new Project[]{project1, project2});
Assert.assertEquals(2, projectsFromService.size()); Assert.assertEquals(2, projectsFromService.size());
Assert.assertEquals(projectsCreated, projectsFromService); Assert.assertEquals(projectsCreated, projectsFromService);
} }
@Test @Test
@Transactional @Transactional
@Rollback @Rollback
public void testGetProjectsByUserAndStatus() { public void testGetProjectsByUserAndStatus() {
List<Project> inactiveProjectsFromService = projectService.getProjectsByUserAndStatus(authorUser, ProjectStatus.INACTIVE); List<Project> inactiveProjectsFromService = projectService.getProjectsByUserAndStatus(authorUser, ProjectStatus.INACTIVE);
List<Project> inactiveProjectsCreated = Arrays.asList(new Project[]{project2}); List<Project> inactiveProjectsCreated = Arrays.asList(new Project[]{project2});
Assert.assertEquals(1, inactiveProjectsFromService.size()); Assert.assertEquals(1, inactiveProjectsFromService.size());
Assert.assertEquals(inactiveProjectsCreated, inactiveProjectsFromService); Assert.assertEquals(inactiveProjectsCreated, inactiveProjectsFromService);
} }
@Test @Test
@Transactional @Transactional
@Rollback @Rollback
public void testGetHeadSupervisorBachelorProjects() { public void testGetHeadSupervisorBachelorProjects() {
//Make sure status filtering works //Make sure status filtering works
List<Project> bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.INACTIVE, null, ""); List<Project> bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.INACTIVE, null, "");
Assert.assertTrue(bachelorsFromService.size()==0); Assert.assertTrue(bachelorsFromService.size() == 0);
List<Project> activeBachelorsCreated = Arrays.asList(new Project[]{project1}); List<Project> activeBachelorsCreated = Arrays.asList(new Project[]{project1});
bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, null, ""); bachelorsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, null, "");
Assert.assertEquals(1, bachelorsFromService.size()); Assert.assertEquals(1, bachelorsFromService.size());
Assert.assertEquals(activeBachelorsCreated, bachelorsFromService); Assert.assertEquals(activeBachelorsCreated, bachelorsFromService);
} }
@Test @Test
@Transactional @Transactional
@Rollback @Rollback
public void testGetHeadSupervisorProjectsByAuthor() { public void testGetHeadSupervisorProjectsByAuthor() {
List<Project> authorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, null, null, author1, ""); List<Project> authorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, null, null, author1, "");
List<Project> authorProjectsCreated = Arrays.asList(new Project[]{project1, project2}); List<Project> authorProjectsCreated = Arrays.asList(new Project[]{project1, project2});
Assert.assertEquals(2, authorProjectsFromService.size()); Assert.assertEquals(2, authorProjectsFromService.size());
Assert.assertEquals(authorProjectsCreated, authorProjectsFromService); Assert.assertEquals(authorProjectsCreated, authorProjectsFromService);
List<Project> authorBachelorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, author1, ""); List<Project> authorBachelorProjectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, null, author1, "");
List<Project> authorBachelorProjectsCreated = Arrays.asList(new Project[]{project1}); List<Project> authorBachelorProjectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(authorBachelorProjectsCreated, authorBachelorProjectsFromService); Assert.assertEquals(authorBachelorProjectsCreated, authorBachelorProjectsFromService);
} }
@Test @Test
@Transactional @Transactional
@Rollback @Rollback
public void testGetHeadSupervisorProjectsByAuthorAndTitle() { public void testGetHeadSupervisorProjectsByAuthorAndTitle() {
List<Project> projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Tester"); List<Project> projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Tester");
Assert.assertEquals(0, projectsFromService.size()); Assert.assertEquals(0, projectsFromService.size());
projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Proj"); projectsFromService = projectService.getSupervisorProjectsForPeer(employeeUser, bachelor, ProjectStatus.ACTIVE, author1, "Proj");
List<Project> projectsCreated = Arrays.asList(new Project[]{project1}); List<Project> projectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(1, projectsFromService.size()); Assert.assertEquals(1, projectsFromService.size());
Assert.assertEquals(projectsCreated, projectsFromService); Assert.assertEquals(projectsCreated, projectsFromService);
} }
@Test @Test
@Transactional @Transactional
@Rollback @Rollback
public void testGetTeamMemberProjects(){ public void testGetTeamMemberProjects() {
List<Project> coSupervisorProjectsFromService = projectService.getTeamMemberProjectsForPeer(coSupervisorUser, ProjectTeamMemberRoles.CO_SUPERVISOR, null, null, null, ""); List<Project> coSupervisorProjectsFromService = projectService.getTeamMemberProjectsForPeer(coSupervisorUser, ProjectTeamMemberRoles.CO_SUPERVISOR, null, null, null, "");
Assert.assertTrue(coSupervisorProjectsFromService.size()==0); Assert.assertTrue(coSupervisorProjectsFromService.size() == 0);
List<Project> reviewerProjectsFromService = projectService.getTeamMemberProjectsForPeer(reviewerUser, ProjectTeamMemberRoles.REVIEWER, null, null, null, ""); List<Project> reviewerProjectsFromService = projectService.getTeamMemberProjectsForPeer(reviewerUser, ProjectTeamMemberRoles.REVIEWER, null, null, null, "");
List<Project> reviewerProjectsCreated = Arrays.asList(new Project[]{project1}); List<Project> reviewerProjectsCreated = Arrays.asList(new Project[]{project1});
Assert.assertEquals(reviewerProjectsCreated, reviewerProjectsFromService); Assert.assertEquals(reviewerProjectsCreated, reviewerProjectsFromService);
} }
} }

16
fitnesse/src/test/java/se/su/dsv/scipro/fitnesse/FitnesseSpringConfiguration.java

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

25
fitnesse/src/test/java/se/su/dsv/scipro/fitnesse/fixtures/ChecklistAdministrator.java

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