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

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

@@ -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 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
-	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;
-	}
+    }
 }

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

@@ -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();
+        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
@@ -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();
+        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) {
-    	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) {
-    	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) {
         Student student = new Student();
         student.setUser(user);

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

@@ -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
+    @Autowired
-	private ProjectService projectService;
+    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);
+        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
     @Transactional
     @Rollback
     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
     @Transactional
     @Rollback
     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
     @Transactional
     @Rollback
     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
     @Transactional
     @Rollback
     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
     @Transactional
     @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
-    @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);
+    @Test
-    	reviewList = peerReviewService.findAll(params, new PageRequest(0, 10)).getContent();
+    @Transactional
-    	Assert.assertEquals(Arrays.asList(new PeerReview[]{review1,review2,review3}), reviewList);
+    @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();
+        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);
 //        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();
+        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
     @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();
+        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
     @Transactional
     @Rollback
     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
-    
+
     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) {
-    	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);
     }
 }

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

@@ -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
+    @Autowired
-	private ProjectService projectService;
+    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> 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
     @Transactional
     @Rollback
     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
     @Transactional
     @Rollback
     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
     @Transactional
     @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
     @Transactional
     @Rollback
     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
     @Transactional
     @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);
     }
 }

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.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);

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

@@ -26,21 +26,16 @@ public class ChecklistAdministrator extends AbstractFixture {
     private ProjectClassService projectClassService;
 
     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;
     }
 }