Pruebas unitarias de servicios

es/uva/inf/tfg/ginquin/smellswisdom/services/UserServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class UserServiceTest {
+
+	@Test
+	public void test() {
+		fail("Not yet implemented");
+	}
+
+}

pom.xml

@@ -131,12 +131,8 @@
 			<artifactId>hibernate-core</artifactId>
 			<version>5.2.10.Final</version>
 		</dependency>
-		<!--  
-		<dependency>
-			<groupId>org.hibernate</groupId>
-			<artifactId>hibernate-search-orm</artifactId>
-			<version>5.8.2.Final</version>
-		</dependency> -->
+		<!-- <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-search-orm</artifactId> 
+			<version>5.8.2.Final</version> </dependency> -->
 		<dependency>
 			<groupId>org.postgresql</groupId>
 			<artifactId>postgresql</artifactId>
@@ -158,6 +154,22 @@
 			<version>4.2.3</version>
 		</dependency>
 
+		<!-- Pruebas -->
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.12</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>org.mockito</groupId>
+			<artifactId>mockito-core</artifactId>
+			<version>2.21.0</version>
+			<scope>test</scope>
+		</dependency>
+
+
 		<!-- extra -->
 		<dependency>
 			<groupId>commons-logging</groupId>

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/controller/ConfirmRegistrationController.java

@@ -49,7 +49,7 @@ public class ConfirmRegistrationController extends SelectorComposer<Component> {
 			return;
 		}
 		user.setEnabled(true);
-		userService.enableRegisteredUser(user);
+		userService.updateUser(user);
 	}
 
 }

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/repository/ArticleDao.java

@@ -140,7 +140,8 @@ public class ArticleDao {
 	private EntityManager emCopy;
 	
 	@Transactional(value="transactionManagerCopy")
-	public void saveArticle(Article article) {
+	public Article saveArticle(Article article) {
 		emCopy.persist(article);
+		return article;
 	}
 }

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/repository/EvidenceDao.java

@@ -17,7 +17,6 @@ import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 
 import es.uva.inf.tfg.ginquin.smellswisdom.domain.Article;
-import es.uva.inf.tfg.ginquin.smellswisdom.domain.Project;
 import es.uva.inf.tfg.ginquin.smellswisdom.domain.Validationevidence;
 
 @Repository
@@ -55,22 +54,6 @@ public class EvidenceDao {
 		return validationEvidences;
 	}
 	
-	@Transactional(value="transactionManager", readOnly = true)
-	public List<Validationevidence> findByProject(Project project) {
-		TypedQuery<Validationevidence> query = em.createQuery("SELECT distinct v from Validationevidence v INNER JOIN v.projects p WHERE p=:project",
-				Validationevidence.class);
-		query.setParameter("project", project);
-
-		List<Validationevidence> validationEvidences = null;
-		try {
-			validationEvidences = query.getResultList();
-		} catch (Exception e) {
-			validationEvidences = null;
-			e.printStackTrace();
-		}
-		return validationEvidences;
-	}
-	
 	@SuppressWarnings("unchecked")
 	@Transactional(value="transactionManager", readOnly = true)
 	public Map<String, Integer> getStatiticsTypeofValidation() {

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/repository/InstitutionDao.java

@@ -31,40 +31,6 @@ public class InstitutionDao {
 	public Institution getInstitutionByID(Integer institution_id) {
 		return em.find(Institution.class, institution_id);
 	}
-	/*
-	@Transactional(value="transactionManager",readOnly=true)
-	public List<Institution> getInstitutionsByAcronym(String keyWord) {
-		FullTextEntityManager fullTextEntityManager = org.hibernate.search.jpa.Search.getFullTextEntityManager(em);
-
-		try {
-			fullTextEntityManager.createIndexer().startAndWait();
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
-
-		Query simpleQueryStringQuery = getQueryBuilder().
-				keyword().onFields("acronym")
-				.matching(keyWord).createQuery();
-
-		@SuppressWarnings("unchecked")
-		List<Institution> results = getJpaQuery(simpleQueryStringQuery).getResultList();
-		return results;
-		
-	}
-	
-	private FullTextQuery getJpaQuery(org.apache.lucene.search.Query luceneQuery) {
-
-		FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(em);
-
-		return fullTextEntityManager.createFullTextQuery(luceneQuery, Institution.class);
-	}
-
-	private QueryBuilder getQueryBuilder() {
-
-		FullTextEntityManager fullTextEntityManager = Search.getFullTextEntityManager(em);
-
-		return fullTextEntityManager.getSearchFactory().buildQueryBuilder().forEntity(Institution.class).get();
-	}*/
 	
 	@PersistenceContext(unitName="jpaDataCopy")
 	@Qualifier(value="entityManagerFactoryCopy")

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/ArticleService.java

@@ -43,6 +43,6 @@ public interface ArticleService {
 	/**
 	 * Permite guardar un article
 	 */
-	void saveArticle(Article article);
+	Article saveArticle(Article article);
 
 }

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/EvidenceService.java

@@ -4,7 +4,6 @@ import java.util.List;
 import java.util.Map;
 
 import es.uva.inf.tfg.ginquin.smellswisdom.domain.Article;
-import es.uva.inf.tfg.ginquin.smellswisdom.domain.Project;
 import es.uva.inf.tfg.ginquin.smellswisdom.domain.Validationevidence;
 
 public interface EvidenceService {
@@ -29,13 +28,6 @@ public interface EvidenceService {
 	 */
 	List<Validationevidence> getEvidencesByArticle(Article article);
 	
-	/**
-	 * Obtiene las evidences del project.
-	 * @param project project del que se quiere saber sus evidences.
-	 * @return evidences del project.
-	 */
-	List<Validationevidence> getEvidencesByProject(Project project);
-	
 	/**
 	 * Permite obtener la distribución de los tipos de validación.
 	 * @return datos de los tipos de validación.

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/UserService.java

@@ -55,9 +55,9 @@ public interface UserService {
 	void removeVerificationToken(User user);
 	
 	/**
-	 * Permite activar un cliente.
-	 * @param user usuario a activar.
+	 * Permite actualizar un usuario.
+	 * @param user usuario a actualizar.
 	 */
-	User enableRegisteredUser(User user);
+	User updateUser(User user);
 	
 }

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/impl/ArticleServiceImpl.java

@@ -46,8 +46,8 @@ public class ArticleServiceImpl implements ArticleService{
 	}
 
 	@Override
-	public void saveArticle(Article article) {
-		dao.saveArticle(article);
+	public Article saveArticle(Article article) {
+		return dao.saveArticle(article);
 	}
 
 

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/impl/AuthorinstitutionServiceImpl.java

@@ -23,7 +23,7 @@ public class AuthorinstitutionServiceImpl implements AuthorinstitutionService {
 
 	@Override
 	public Authorinstitution updateAuthorinstitution(Authorinstitution authorInstitution) {
-		return updateAuthorinstitution(authorInstitution);
+		return dao.updateAuthorinstitution(authorInstitution);
 	}
 	
 	

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/impl/EvidenceServiceImpl.java

@@ -9,7 +9,6 @@ import org.springframework.context.annotation.ScopedProxyMode;
 import org.springframework.stereotype.Service;
 
 import es.uva.inf.tfg.ginquin.smellswisdom.domain.Article;
-import es.uva.inf.tfg.ginquin.smellswisdom.domain.Project;
 import es.uva.inf.tfg.ginquin.smellswisdom.domain.Validationevidence;
 import es.uva.inf.tfg.ginquin.smellswisdom.repository.EvidenceDao;
 import es.uva.inf.tfg.ginquin.smellswisdom.services.EvidenceService;
@@ -37,11 +36,6 @@ public class EvidenceServiceImpl implements EvidenceService {
 		return dao.findByArticle(article);
 	}
 
-	@Override
-	public List<Validationevidence> getEvidencesByProject(Project project) {
-		return dao.findByProject(project);
-	}
-
 	@Override
 	public Map<String, Integer> getStatiticsTypeofValidation() {
 		return dao.getStatiticsTypeofValidation();

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/impl/ProjectsmellServiceImpl.java

@@ -47,7 +47,7 @@ public class ProjectsmellServiceImpl implements ProjectsmellService {
 
 	@Override
 	public Projectsmell updateProjectsmell(Projectsmell projectsmell) {
-		return updateProjectsmell(projectsmell);
+		return dao.updateProjectsmell(projectsmell);
 	}
 
 

src/main/java/es/uva/inf/tfg/ginquin/smellswisdom/services/impl/UserServiceImpl.java

@@ -55,7 +55,7 @@ public class UserServiceImpl  implements UserService,Serializable{
 
 	@Override
 	public void deleteUsuario(User user) {
-		userDao.delete(user);;
+		userDao.delete(user);
 	}
 
 	@Override
@@ -71,7 +71,7 @@ public class UserServiceImpl  implements UserService,Serializable{
 	}
 	
 	@Override
-	public User enableRegisteredUser(User user) {
+	public User updateUser(User user) {
 		return userDao.update(user);
 	}
 

src/test/java/es/uva/inf/tfg/ginquin/smellswisdom/services/ApproachServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Approach;
+import es.uva.inf.tfg.ginquin.smellswisdom.repository.ApproachDao;
+import es.uva.inf.tfg.ginquin.smellswisdom.services.impl.ApproachServiceImpl;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ApproachServiceTest {
+
+	@Mock
+	private ApproachDao approachDao;
+	
+	@InjectMocks
+	private ApproachServiceImpl approachService;
+	
+	private List<Approach>  listApproach;
+	
+	private Approach approach;
+	private Approach approach2;
+	private Approach approach3;
+	
+	private Map<Integer,Map<String,Integer>> statiticsApproaches;
+	
+	private Map<String,Integer> statiticsDegreeOfAutomation;
+	
+	private Map<String,Integer> statiticsRelatedActivity;
+	
+	private Map<String,Integer> statiticsTypeofArtefacts;
+
+	
+
+	@Before
+	public void setUp() {
+		listApproach = new ArrayList<Approach>();
+		
+		approach = new Approach();
+		approach.setApproachId(1);
+		approach2 = new Approach();
+		approach2.setApproachId(2);
+		approach3 = new Approach();
+		approach3.setApproachId(3);
+		
+		HashMap< String, Integer> map = new HashMap<String, Integer>();
+		map.put("CombinationofApproach", 1);
+		map.put("Metrics based", 2);
+		map.put("Logical/Rule based", 3);
+		map.put("Machine learning based", 4);
+		
+		HashMap< String, Integer> map2 = new HashMap<String, Integer>();
+		map.put("CombinationofApproach", 1);
+		map.put("Metrics based", 2);
+		map.put("Logical/Rule based", 3);
+		map.put("Visualization based", 4);
+		
+		statiticsApproaches = new HashMap<>();
+		statiticsApproaches.put(2004, map);
+		statiticsApproaches.put(2009, map2);
+	    
+		statiticsDegreeOfAutomation = new HashMap<String, Integer>();
+		statiticsDegreeOfAutomation.put("manual guideline", 1);
+		statiticsDegreeOfAutomation.put("semi automatic", 2);
+		statiticsDegreeOfAutomation.put("computer aided", 3);
+		statiticsDegreeOfAutomation.put("fully automatic", 5);
+
+	    
+		statiticsRelatedActivity = new HashMap<String, Integer>();
+		statiticsRelatedActivity.put("SmellDetection", 1);
+		statiticsRelatedActivity.put("SmellPrioritization", 2);
+		statiticsRelatedActivity.put("SmellSpecification", 3);
+		statiticsRelatedActivity.put("SmellImpactAnalysis", 5);
+
+		statiticsTypeofArtefacts = new HashMap<String, Integer>();
+		statiticsTypeofArtefacts.put("Executable or Binary Code", 1);
+		statiticsTypeofArtefacts.put("Communication Diagram", 2);
+		statiticsTypeofArtefacts.put("Process Diagram", 3);
+		statiticsTypeofArtefacts.put("Ontology", 5);
+		
+		MockitoAnnotations.initMocks(this);
+	}
+	
+	@Test
+	public void testGetApproaches() {
+		Mockito.when(approachDao.queryAll()).thenReturn(listApproach);
+
+		List<Approach> found = approachService.getApproaches();
+
+		assertEquals(found, listApproach);
+	}
+
+	@Test
+	public void testGetApproach() {
+		Integer id = 1;
+		Mockito.when(approachDao.getApproach(id)).thenReturn(approach);
+
+		Approach found = approachService.getApproach(id);
+
+		assertEquals(found, approach);
+	}
+
+	@Test
+	public void testGetStatiticsApproaches() {
+		Mockito.when(approachDao.getStatiticsApproaches()).thenReturn(statiticsApproaches);	
+		
+		Map<Integer,Map<String, Integer>> result = approachService.getStatiticsApproaches();
+		
+		assertEquals(result, statiticsApproaches);
+	}
+
+	@Test
+	public void testGetStatiticsDegreeOfAutomation() {
+		Mockito.when(approachDao.getStatiticsDegreeOfAutomation()).thenReturn(statiticsDegreeOfAutomation);	
+		
+		Map<String, Integer> result = approachService.getStatiticsDegreeOfAutomation();
+		
+		assertEquals(result, statiticsDegreeOfAutomation);
+	}
+
+	@Test
+	public void testGetStatiticsRelatedActivity() {
+		Mockito.when(approachDao.getStatiticsRelatedActivity()).thenReturn(statiticsRelatedActivity);	
+		
+		Map<String, Integer> result = approachService.getStatiticsRelatedActivity();
+		
+		assertEquals(result, statiticsRelatedActivity);
+	}
+
+	@Test
+	public void testGetStatiticsTypeofArtefacts() {
+		Mockito.when(approachDao.getStatiticsTypeofArtefacts()).thenReturn(statiticsTypeofArtefacts);	
+		
+		Map<String, Integer> result = approachService.getStatiticsTypeofArtefacts();
+		
+		assertEquals(result, statiticsTypeofArtefacts);
+	}
+
+}

src/test/java/es/uva/inf/tfg/ginquin/smellswisdom/services/ArticleServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Article;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.PublicationType;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Smell;
+import es.uva.inf.tfg.ginquin.smellswisdom.repository.ArticleDao;
+import es.uva.inf.tfg.ginquin.smellswisdom.services.impl.ArticleServiceImpl;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ArticleServiceTest {
+
+	@Mock
+	private ArticleDao articleDao;
+
+	@InjectMocks
+	private ArticleServiceImpl articleService;
+
+	private List<Article> listArticle;
+
+	private Smell smell;
+	private List<Article> listArticles;
+
+	private List<Article> listNArticles;
+
+	private List<Article> listSearch;
+	private List<Article> listSearch2;
+	private List<Article> listSearch3;
+	private List<Article> listSearch4;
+	private List<Article> listSearch5;
+	private List<Article> listSearch6;
+	private List<Article> listSearch7;
+
+	private Article article;
+	private Article article2;
+	private Article article3;
+	private Article article4;
+
+	@Before
+	public void setUp() {
+
+		listArticle = new ArrayList<Article>();
+
+		listArticles = new ArrayList<Article>();
+
+		listNArticles = new ArrayList<Article>();
+		
+		listSearch = new ArrayList<Article>();
+		listSearch2 = new ArrayList<Article>();
+		listSearch3 = new ArrayList<Article>();
+		listSearch4 = new ArrayList<Article>();
+		listSearch5 = new ArrayList<Article>();
+		listSearch6 = new ArrayList<Article>();
+		listSearch7 = new ArrayList<Article>();
+
+		smell = new Smell();
+		smell.setSmellId(1);
+
+		article = new Article();
+		article.setArticleId(1);
+		article.setTitle("ConcernReCS Finding Code Smells in Software Aspectization");
+		article.setType(PublicationType.Conference);
+		article.setYear(2012);
+
+		article2 = new Article();
+		article2.setArticleId(2);
+		article2.setTitle("DECOR A Method for the Specification and Detection of Code and Design Smells");
+		article2.setType(PublicationType.Journal);
+		article2.setYear(2010);
+		article2.addSmell(smell);
+
+		article3 = new Article();
+		article3.setArticleId(3);
+		article3.setTitle("Assessing the impact of bad smells using historical information");
+		article3.setType(PublicationType.Workshop);
+		article3.setYear(2007);
+		article3.addSmell(smell);
+
+		article4 = new Article();
+		article4.setArticleId(4);
+		article4.setTitle("Detection of SOA Antipatterns");
+		article4.setType(PublicationType.Workshop);
+		article4.setYear(2012);
+
+		listArticle.add(article);
+		listArticle.add(article2);
+		listArticle.add(article3);
+		listArticle.add(article4);
+
+		listArticles.add(article2);
+		listArticles.add(article3);
+
+		listNArticles.add(article);
+		listNArticles.add(article2);
+		listNArticles.add(article4);
+		
+		listSearch.add(article);
+		listSearch.add(article2);
+		
+		listSearch2.add(article3);
+		listSearch2.add(article4);
+		
+		listSearch3.add(article);
+		listSearch3.add(article4);
+		
+		listSearch4.add(article4);
+		
+		listSearch5.add(article2);
+		
+		listSearch6.add(article3);
+		
+		listSearch7.add(article);
+		
+		MockitoAnnotations.initMocks(this);
+	}
+
+	@Test
+	public void testGetArticles() {
+		Mockito.when(articleDao.queryAll()).thenReturn(listArticle);
+
+		List<Article> found = articleService.getArticles();
+
+		assertEquals(found, listArticle);
+	}
+
+	@Test
+	public void testGetArticle() {
+		Integer id = 1;
+
+		Mockito.when(articleDao.getArticle(id)).thenReturn(article);
+
+		Article found = articleService.getArticle(id);
+
+		assertEquals(found, article);
+	}
+
+	@Test
+	public void testGetArticlesBySmell() {
+		Mockito.when(articleDao.findArticlesBySmell(smell)).thenReturn(listArticles);
+
+		List<Article> found = articleService.getArticlesBySmell(smell);
+
+		assertEquals(found, listArticles);
+		assertEquals(found, new ArrayList<Article>(smell.getArticles()));
+	}
+
+	@Test
+	public void testGetNRecentArticles() {
+		int n = 3;
+
+		Mockito.when(articleDao.getNRecentArticles(n)).thenReturn(listNArticles);
+
+		List<Article> found = articleService.getNRecentArticles(n);
+
+		assertEquals(found, listNArticles);
+		assertEquals(found.size(), n);
+	}
+
+	@Test
+	public void testSearchArticles() {
+		// recupera los articulos por título.
+		String keyWord = "smells";
+		PublicationType type = null;
+		int year = 0;
+		int caso = 1;
+
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch);
+
+		List<Article> found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch);
+		
+		// recupera los articulos por tipo.
+		keyWord = "";
+		type = PublicationType.Workshop;
+		year = 0;
+		caso = 2;
+
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch2);
+
+		found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch2);
+		
+		//recupera los articulos por año.
+		keyWord = "";
+		type = null;
+		year = 2012;
+		caso = 3;
+
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch3);
+
+		found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch3);
+		
+		//recupera los articulos por título y tipo.
+		keyWord = "detection";
+		type = PublicationType.Workshop;
+		year = 0;
+		caso = 4;
+		
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch4);
+
+		found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch4);
+		
+		//recupera los articulos por título y año.
+		keyWord = "code smells";
+		type = null;
+		year = 2010;
+		caso = 5;
+		
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch5);
+
+		found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch5);
+		
+		//recupera los articulos por tipo y año.
+		keyWord = "";
+		type = PublicationType.Workshop;
+		year = 2007;
+		caso = 6;
+		
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch6);
+
+		found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch6);
+		
+		
+		//recupera los articulos por título, tipo y año.
+		keyWord = "code smells";
+		type = PublicationType.Conference;
+		year = 2012;
+		caso = 7;
+		
+		Mockito.when(articleDao.searchGlobalArticles(keyWord, type, year, caso)).thenReturn(listSearch7);
+
+		found = articleService.searchArticles(keyWord, type, year, caso);
+
+		assertEquals(found, listSearch7);
+		
+	}
+
+	@Test
+	public void testSaveArticle() {
+		Mockito.when(articleDao.saveArticle(Mockito.any(Article.class))).thenReturn(article2);
+
+		Article creeated = articleService.saveArticle(article2);
+
+		assertEquals(creeated, article2);
+	}
+
+}

src/test/java/es/uva/inf/tfg/ginquin/smellswisdom/services/ArticletoolServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Article;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Articletool;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.ArticletoolPK;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Tool;
+import es.uva.inf.tfg.ginquin.smellswisdom.repository.ArticletoolDao;
+import es.uva.inf.tfg.ginquin.smellswisdom.services.impl.ArticletoolServiceImpl;
+
+@RunWith(MockitoJUnitRunner.class)
+public class ArticletoolServiceTest {
+	
+	@Mock
+	private ArticletoolDao articleToolDao;
+	
+	@InjectMocks
+	private ArticletoolServiceImpl articleToolService;
+	
+	private List<Articletool> listArticleTools;
+	
+	//Para articles
+	private List<Articletool> listArticleTool;
+	private List<Articletool> listArticleTool2;
+	private List<Articletool> listArticleTool3;
+	
+	//Para tools
+	private List<Articletool> listArticleTool4;
+	private List<Articletool> listArticleTool5;
+	private List<Articletool> listArticleTool6;
+	
+	private Tool tool;
+	private Tool tool2;
+	private Tool tool3;
+	
+	private Article article;
+	private Article article2;
+	private Article article3;
+	
+	private Articletool articletool;
+	private Articletool articletool2;
+	private Articletool articletool3;
+	private Articletool articletool4;
+	
+	@Before
+	public void setUp() {
+		
+		listArticleTools = new ArrayList<Articletool>();
+		
+		tool = new Tool();
+		tool.setToolId(1);
+		tool2 = new Tool();
+		tool2.setToolId(2);
+		tool3 = new Tool();
+		tool3.setToolId(3);
+		
+		article = new Article();
+		article.setArticleId(1);
+		article2 = new Article();
+		article2.setArticleId(2);
+		article3 = new Article();
+		article3.setArticleId(3);
+	    
+		articletool = new Articletool();
+		articletool.setArticle(article);
+		articletool.setTool(tool);
+	    
+		articletool2 = new Articletool();
+		articletool2.setArticle(article);
+		articletool2.setTool(tool2);
+	    
+		articletool3 = new Articletool();
+		articletool3.setArticle(article2);
+		articletool3.setTool(tool3);
+	    
+		articletool4 = new Articletool();
+		articletool4.setArticle(article3);
+		articletool4.setTool(tool3);
+		
+		article.addArticleTool(articletool);
+	    tool.addArticletools(articletool);
+	    
+	    article.addArticleTool(articletool2);
+	    tool2.addArticletools(articletool2);
+	    
+	    article2.addArticleTool(articletool3);
+	    tool3.addArticletools(articletool3);
+	    
+	    article3.addArticleTool(articletool4);
+	    tool3.addArticletools(articletool4);
+	    
+	    listArticleTools.add(articletool);
+	    listArticleTools.add(articletool2);
+	    listArticleTools.add(articletool3);
+	    listArticleTools.add(articletool4);
+	    
+		
+		//Para article
+	    listArticleTool = new ArrayList<Articletool>();
+	    listArticleTool.add(articletool);
+	    listArticleTool.add(articletool2);
+	    
+	    listArticleTool2 = new ArrayList<Articletool>();
+	    listArticleTool2.add(articletool3);
+	    
+	    listArticleTool3 = new ArrayList<Articletool>();
+	    listArticleTool3.add(articletool4);
+	    
+	    //Para tools
+	    listArticleTool4 = new ArrayList<Articletool>();
+	    listArticleTool4.add(articletool);
+	    
+	    listArticleTool5 = new ArrayList<Articletool>();
+	    listArticleTool5.add(articletool2);
+	    
+	    listArticleTool6 = new ArrayList<Articletool>();
+	    listArticleTool6.add(articletool3);
+	    listArticleTool6.add(articletool4);
+	    
+	    MockitoAnnotations.initMocks(this);
+	}
+
+	@Test
+	public void testGetArticletools() {
+		Mockito.when(articleToolDao.queryAll()).thenReturn(listArticleTools);	
+		
+		List<Articletool> found = articleToolService.getArticletools();
+		
+		assertEquals(found, listArticleTools);
+	}
+
+	@Test
+	public void testGetArticleTool() {
+		ArticletoolPK id = new ArticletoolPK();
+		id.setArticle(article);;
+		id.setTool(tool2);
+		
+		Mockito.when(articleToolDao.getArticletool(id)).thenReturn(articletool);	
+		
+		Articletool found = articleToolService.getArticleTool(id);
+		
+		assertEquals(found, articletool);
+	}
+
+	@Test
+	public void testGetArticleToolsByArticle() {
+		Mockito.when(articleToolDao.findByArticle(article)).thenReturn(listArticleTool);	
+		
+		List<Articletool> found = articleToolService.getArticleToolsByArticle(article);
+		
+		assertEquals(found, listArticleTool);
+		assertEquals(found, article.getArticletools());
+	}
+
+	@Test
+	public void testGetArticleToolsByTool() {
+		Mockito.when(articleToolDao.findByTool(tool3)).thenReturn(listArticleTool6);	
+		
+		List<Articletool> found = articleToolService.getArticleToolsByTool(tool3);
+		
+		assertEquals(found, listArticleTool6);
+		assertEquals(found, tool3.getArticletools());
+	}
+
+	@Test
+	public void testFindArticletoolBdAux() {
+		ArticletoolPK id = new ArticletoolPK();
+		id.setArticle(article);
+		id.setTool(tool);
+		
+		Mockito.when(articleToolDao.findArticletoolBdAux(id)).thenReturn(articletool);	
+		
+		Articletool found = articleToolService.findArticletoolBdAux(id);
+		
+		assertEquals(found, articletool);
+	}
+
+	@Test
+	public void testSaveArticletool() {
+		Mockito.when(articleToolDao.saveArticletool(Mockito.any(Articletool.class))).thenReturn(articletool2);
+		
+		Articletool creeated = articleToolService.saveArticletool(articletool2);
+		
+		assertEquals(creeated, articletool2);
+	}
+
+	@Test
+	public void testUpdateArticletool() {
+		Mockito.when(articleToolDao.updateArticletool(Mockito.any(Articletool.class))).thenReturn(articletool3);
+		
+		Articletool updated = articleToolService.updateArticletool(articletool3);
+		
+		assertEquals(updated, articletool3);
+	}
+
+}

src/test/java/es/uva/inf/tfg/ginquin/smellswisdom/services/AuthorServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Author;
+import es.uva.inf.tfg.ginquin.smellswisdom.repository.AuthorDao;
+import es.uva.inf.tfg.ginquin.smellswisdom.services.impl.AuthorServiceImpl;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AuthorServiceTest {
+	
+	@Mock
+	private AuthorDao authorDao;
+
+	@InjectMocks
+	private AuthorServiceImpl authorService;
+	
+	private List<Author> listAuthor;
+	
+	private Author author;
+	private Author author2;
+	private Author author3;
+	
+	@Before
+	public void setUp() {
+		
+		listAuthor = new ArrayList<Author>();
+		
+		author = new Author();
+		author.setAuthorId(1);
+		author2 = new Author();
+		author2.setAuthorId(2);
+		author3 = new Author();
+		author3.setAuthorId(3);
+	    
+		listAuthor.add(author);
+		listAuthor.add(author2);
+		listAuthor.add(author3);
+	    
+	    MockitoAnnotations.initMocks(this);
+	}
+
+	@Test
+	public void testGetAuthors() {
+		Mockito.when(authorDao.getAllAuthors()).thenReturn(listAuthor);	
+		
+		List<Author> found = authorService.getAuthors();
+		
+		assertEquals(found, listAuthor);
+	}
+
+	@Test
+	public void testGetAuthorById() {
+		Integer id = 1;
+		
+		Mockito.when(authorDao.getAuthorByID(id)).thenReturn(author);	
+		
+		Author found = authorService.getAuthorById(id);
+		
+		assertEquals(found, author);
+	}
+
+	@Test
+	public void testSaveAuthor() {
+		Mockito.when(authorDao.saveAuthor(Mockito.any(Author.class))).thenReturn(author2);
+		
+		Author creeated = authorService.saveAuthor(author2);
+		
+		assertEquals(creeated, author2);
+	}
+
+	@Test
+	public void testUpdateAuthor() {
+		Mockito.when(authorDao.updateAuthor(Mockito.any(Author.class))).thenReturn(author3);
+		
+		Author updated = authorService.updateAuthor(author3);
+		
+		assertEquals(updated, author3);
+	}
+
+}

src/test/java/es/uva/inf/tfg/ginquin/smellswisdom/services/AuthorinstitutionServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Article;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Author;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Authorinstitution;
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Institution;
+import es.uva.inf.tfg.ginquin.smellswisdom.repository.AuthorinstitutionDao;
+import es.uva.inf.tfg.ginquin.smellswisdom.services.impl.AuthorinstitutionServiceImpl;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AuthorinstitutionServiceTest {
+	
+	@Mock
+	private AuthorinstitutionDao authorinstitutionDao;
+	
+	@InjectMocks
+	private AuthorinstitutionServiceImpl authorinstitutionService;
+	
+
+	private Authorinstitution authorinstitution;
+	private Authorinstitution authorinstitution2;
+	
+	private Author author;
+	private Author author2;
+	
+	private Institution institution;
+	private Institution institution2;
+	
+	private Article article;
+	private Article article2;
+	
+	@Before
+	public void setUp() {
+		
+		author = new  Author();
+		author.setAuthorId(1);
+		author2 = new  Author();
+		author2.setAuthorId(2);
+		
+		institution = new Institution();
+		institution.setInstitutionId(1);
+		institution2 = new Institution();
+		institution2.setInstitutionId(2);
+		
+		article = new  Article();
+		article.setArticleId(1);
+		article2 = new  Article();
+		article2.setArticleId(2);
+		
+		authorinstitution = new Authorinstitution();
+		authorinstitution.setArticle(article);
+		authorinstitution.setAuthor(author);
+		authorinstitution.setInstitution(institution);
+		
+		authorinstitution2 = new Authorinstitution();
+		authorinstitution2.setArticle(article2);
+		authorinstitution2.setAuthor(author2);
+		authorinstitution2.setInstitution(institution2);
+		
+		article.addAuthorinstitutions(authorinstitution);
+		article2.addAuthorinstitutions(authorinstitution2);
+		
+		MockitoAnnotations.initMocks(this);
+		
+	}
+
+	@Test
+	public void testSaveAuthorinstitution() {
+		Mockito.when(authorinstitutionDao.saveAuthorInstitution(Mockito.any(Authorinstitution.class))).thenReturn(authorinstitution);
+		
+		Authorinstitution creeated = authorinstitutionService.saveAuthorinstitution(authorinstitution);
+		
+		assertEquals(creeated, authorinstitution);
+	}
+
+	@Test
+	public void testUpdateAuthorinstitution() {
+		Mockito.when(authorinstitutionDao.updateAuthorinstitution(Mockito.any(Authorinstitution.class))).thenReturn(authorinstitution2);
+		
+		Authorinstitution updated = authorinstitutionService.updateAuthorinstitution(authorinstitution2);
+		
+		assertEquals(updated, authorinstitution2);
+	}
+
+}

src/test/java/es/uva/inf/tfg/ginquin/smellswisdom/services/AuthorityServiceTest.java

+package es.uva.inf.tfg.ginquin.smellswisdom.services;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import es.uva.inf.tfg.ginquin.smellswisdom.domain.Authority;
+import es.uva.inf.tfg.ginquin.smellswisdom.repository.AuthorityDao;
+import es.uva.inf.tfg.ginquin.smellswisdom.services.impl.AuthorityServiceImpl;
+
+@RunWith(MockitoJUnitRunner.class)
+public class AuthorityServiceTest {
+	
+	@Mock
+	private AuthorityDao authorityDao;
+	
+	@InjectMocks
+	private AuthorityServiceImpl  authorityService;
+	
+	private List<Authority> listAuthority;
+	
+	private Authority authority;
+	private Authority authority2;
+	
+	@Before
+	public void setUp() {
+		
+		listAuthority = new ArrayList<Authority>();
+		
+		authority = new Authority();
+		authority.setAuthority("ROLE_USER");
+		authority2 = new Authority();
+		authority2.setAuthority("ROLE_ADMIN");
+	    
+		listAuthority.add(authority);
+		listAuthority.add(authority2);
+	    
+	    MockitoAnnotations.initMocks(this);
+	}
+
+	@Test
+	public void testGetAuthorities() {
+		Mockito.when(authorityDao.queryAll()).thenReturn(listAuthority);	
+		
+		List<Authority> found = authorityService.getAuthorities();
+		
+		assertEquals(found, listAuthority);
+	}
+
+	@Test
+	public void testGet() {
+		String id ="ROLE_USER";
+		
+		Mockito.when(authorityDao.get(id)).thenReturn(authority);	
+		
+		Authority found = authorityService.get(id);
+		
+		assertEquals(found, authority);
+	}
+
+}