From 1cb8a2661b5effe6d5b33b6719ef24c8b5c55cce Mon Sep 17 00:00:00 2001 From: raj1802 Date: Wed, 16 Oct 2024 13:10:50 +0530 Subject: [PATCH 1/3] added unit tests for get and create skills methods --- .../unitTests/SkillsApiUnitTests.java | 156 ++++++++++++++++++ 1 file changed, 156 insertions(+) create mode 100644 skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java diff --git a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java new file mode 100644 index 00000000..a34933fd --- /dev/null +++ b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java @@ -0,0 +1,156 @@ +package com.RDS.skilltree.unitTests; + +import com.RDS.skilltree.dtos.RdsGetUserDetailsResDto; +import com.RDS.skilltree.enums.SkillTypeEnum; +import com.RDS.skilltree.exceptions.SkillAlreadyExistsException; +import com.RDS.skilltree.models.JwtUser; +import com.RDS.skilltree.models.Skill; +import com.RDS.skilltree.repositories.SkillRepository; +import com.RDS.skilltree.services.SkillService; +import com.RDS.skilltree.services.SkillServiceImplementation; +import com.RDS.skilltree.services.external.RdsService; +import com.RDS.skilltree.viewmodels.CreateSkillViewModel; +import com.RDS.skilltree.viewmodels.RdsUserViewModel; +import com.RDS.skilltree.viewmodels.SkillViewModel; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.springframework.security.core.Authentication; +import org.springframework.security.core.context.SecurityContext; +import org.springframework.security.core.context.SecurityContextHolder; + +import java.util.Arrays; +import java.util.List; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + +public class SkillsApiUnitTests { + + @Mock + private SkillRepository skillRepository; + + @Mock + private RdsService rdsService; + + @Mock + private SecurityContext securityContext; + + @Mock + private Authentication authentication; + + @InjectMocks + private SkillServiceImplementation skillService; // Class containing the getAll() method + + @BeforeEach + public void setup() { + MockitoAnnotations.openMocks(this); // Initialize mocks + } + + @Test + @DisplayName("Test the getAll() method returns all the created skills, where the skills return in a sorted order based on skill-Id.") + public void getAllSkillsHappyFlow() + { + + Skill skill1 = new Skill(); + skill1.setId(1); + skill1.setName("Java"); + skill1.setType(SkillTypeEnum.ATOMIC); + + Skill skill2 = new Skill(); + skill2.setId(2); + skill2.setName("Spring Boot"); + skill2.setType(SkillTypeEnum.ATOMIC); + + + // Mock the repository's behavior + when(skillRepository.findAll()).thenReturn(Arrays.asList(skill1, skill2)); + + // Act: Call the method to be tested + List result = skillService.getAll(); + + // Assert: Verify the result + assertEquals(2, result.size()); + assertEquals("Java", result.get(0).getName()); + assertEquals("Spring Boot", result.get(1).getName()); + + // Verify that the repository was called once + verify(skillRepository, times(1)).findAll(); + } + + + @Test + public void testCreateSkill_Success() { + // Arrange: Mock request and setup mocks + CreateSkillViewModel createSkill = new CreateSkillViewModel(); + createSkill.setName("python"); + createSkill.setType(SkillTypeEnum.ATOMIC); + + RdsUserViewModel viewModel = new RdsUserViewModel(); + viewModel.setId("123"); + + RdsGetUserDetailsResDto userDetails = new RdsGetUserDetailsResDto(); + userDetails.setUser(viewModel); + + + Skill skillEntity = new Skill(); + skillEntity.setId(5); + skillEntity.setName("python"); + skillEntity.setType(SkillTypeEnum.ATOMIC); + skillEntity.setCreatedBy(userDetails.getUser().getId()); + + SkillViewModel expectedViewModel = SkillViewModel.toViewModel(skillEntity); + + // Mock behavior + when(skillRepository.existsByName("python")).thenReturn(false); + + when(skillRepository.saveAndFlush(any(Skill.class))).thenReturn(skillEntity); + + // Act: Call the method + SkillViewModel actualViewModel = skillService.create(createSkill); + + // Assert: Verify the result + assertNotNull(actualViewModel); + assertEquals(expectedViewModel.getId(), actualViewModel.getId()); + assertEquals(expectedViewModel.getName(), actualViewModel.getName()); + assertEquals(expectedViewModel.getType(), actualViewModel.getType()); + + // Verify that the repository and service were called correctly + verify(skillRepository, times(1)).existsByName("python"); + verify(skillRepository, times(1)).saveAndFlush(any(Skill.class)); + + } + + + @Test + public void testCreateSkill_AlreadyExists() { + // Arrange + CreateSkillViewModel createSkill = new CreateSkillViewModel(); + createSkill.setName("python"); + createSkill.setType(SkillTypeEnum.ATOMIC); + + // Mock behavior + when(skillRepository.existsByName("python")).thenReturn(true); + + // Act & Assert: Verify that exception is thrown + SkillAlreadyExistsException exception = assertThrows( + SkillAlreadyExistsException.class, + () -> skillService.create(createSkill), + "Skill with name "+createSkill.getName()+"already exists" + ); + + assertEquals("Skill with name python already exists", exception.getMessage()); + + // Verify repository was called once, but saveAndFlush wasn't called + verify(skillRepository, times(1)).existsByName("python"); + verify(skillRepository, never()).saveAndFlush(any(Skill.class)); + } + + + + +} From cd2a2ede014095879a24f8577f5b94ae4c77ac12 Mon Sep 17 00:00:00 2001 From: raj1802 Date: Tue, 22 Oct 2024 13:25:48 +0530 Subject: [PATCH 2/3] unit tests addition --- .../unitTests/EndorsementsApiUnitTests.java | 97 ++++++++++++ .../unitTests/SkillsApiUnitTests.java | 139 +++++++++++++++++- 2 files changed, 233 insertions(+), 3 deletions(-) create mode 100644 skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java diff --git a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java new file mode 100644 index 00000000..6f1053df --- /dev/null +++ b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java @@ -0,0 +1,97 @@ +package com.RDS.skilltree.unitTests; + +import com.RDS.skilltree.dtos.RdsGetUserDetailsResDto; +import com.RDS.skilltree.models.Endorsement; +import com.RDS.skilltree.models.Skill; +import com.RDS.skilltree.repositories.EndorsementRepository; +import com.RDS.skilltree.services.EndorsementServiceImplementation; +import com.RDS.skilltree.services.external.RdsService; +import com.RDS.skilltree.viewmodels.EndorsementViewModel; +import com.RDS.skilltree.viewmodels.RdsUserViewModel; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import java.util.ArrayList; +import java.util.List; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.when; + + +public class EndorsementsApiUnitTests { + + @Mock + private EndorsementRepository endorsementRepository; + + @Mock + private RdsService rdsService; + + @InjectMocks + private EndorsementServiceImplementation endorsementService; + + @BeforeEach + public void setup() { + MockitoAnnotations.openMocks(this); // Initialize mocks + + } + + + @Test + @DisplayName("To test getAllEndorsementsBySkillId() method") + public void testGetAllEndorsementsBySkillId() + { + List endorsements = new ArrayList<>(); + + Integer skillId =1; + + //initializing a skill + Skill skill1 = new Skill(); + skill1.setId(skillId); + skill1.setName("python"); + + + //initializing an endorsement + Endorsement endorsement1 = new Endorsement(); + endorsement1.setId(1); + endorsement1.setSkill(skill1); + endorsement1.setEndorserId("456"); + endorsement1.setEndorseId("123"); + endorsement1.setMessage("Please approve my endorsement for this skill"); + + endorsements.add(endorsement1); + + RdsGetUserDetailsResDto rdsGetUserDetailsResDto1 = new RdsGetUserDetailsResDto(); + RdsUserViewModel rdsUserViewModel1= new RdsUserViewModel(); + rdsUserViewModel1.setId("123"); + rdsGetUserDetailsResDto1.setUser(rdsUserViewModel1); + + + RdsGetUserDetailsResDto rdsGetUserDetailsResDto2 = new RdsGetUserDetailsResDto(); + RdsUserViewModel rdsUserViewModel2= new RdsUserViewModel(); + rdsUserViewModel2.setId("456"); + rdsGetUserDetailsResDto2.setUser(rdsUserViewModel2); + + + + //Mock behaviour + when(endorsementRepository.findBySkillId(skillId)).thenReturn(endorsements); + when(rdsService.getUserDetails(endorsement1.getEndorseId())).thenReturn(rdsGetUserDetailsResDto1); + when(rdsService.getUserDetails(endorsement1.getEndorserId())).thenReturn(rdsGetUserDetailsResDto2); + + + //Act + + List endorsmentsBySkillId = endorsementService.getAllEndorsementsBySkillId(skillId); + + assert(endorsmentsBySkillId.size() == 1); + assertEquals("456", endorsmentsBySkillId.get(0).getEndorser().getId()); + assertEquals("123", endorsmentsBySkillId.get(0).getEndorse().getId()); + assertEquals("python", endorsmentsBySkillId.get(0).getSkill().getName()); + + + } + + +} diff --git a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java index a34933fd..aea8d09f 100644 --- a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java +++ b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java @@ -1,16 +1,26 @@ package com.RDS.skilltree.unitTests; import com.RDS.skilltree.dtos.RdsGetUserDetailsResDto; +import com.RDS.skilltree.dtos.SkillRequestsDto; import com.RDS.skilltree.enums.SkillTypeEnum; +import com.RDS.skilltree.enums.UserRoleEnum; +import com.RDS.skilltree.enums.UserSkillStatusEnum; +import com.RDS.skilltree.exceptions.NoEntityException; import com.RDS.skilltree.exceptions.SkillAlreadyExistsException; +import com.RDS.skilltree.models.Endorsement; import com.RDS.skilltree.models.JwtUser; import com.RDS.skilltree.models.Skill; +import com.RDS.skilltree.models.UserSkills; +import com.RDS.skilltree.repositories.EndorsementRepository; import com.RDS.skilltree.repositories.SkillRepository; +import com.RDS.skilltree.repositories.UserSkillRepository; import com.RDS.skilltree.services.SkillService; import com.RDS.skilltree.services.SkillServiceImplementation; import com.RDS.skilltree.services.external.RdsService; +import com.RDS.skilltree.utils.GenericResponse; import com.RDS.skilltree.viewmodels.CreateSkillViewModel; import com.RDS.skilltree.viewmodels.RdsUserViewModel; +import com.RDS.skilltree.viewmodels.SkillRequestsWithUserDetailsViewModel; import com.RDS.skilltree.viewmodels.SkillViewModel; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -23,6 +33,7 @@ import org.springframework.security.core.context.SecurityContext; import org.springframework.security.core.context.SecurityContextHolder; +import java.util.ArrayList; import java.util.Arrays; import java.util.List; @@ -35,20 +46,29 @@ public class SkillsApiUnitTests { private SkillRepository skillRepository; @Mock - private RdsService rdsService; + private UserSkillRepository userSkillRepository; + + @Mock - private SecurityContext securityContext; + private RdsService rdsService; @Mock private Authentication authentication; + @Mock + private SkillRequestsWithUserDetailsViewModel skillRequestsWithUserDetailsViewModel; + @InjectMocks private SkillServiceImplementation skillService; // Class containing the getAll() method @BeforeEach public void setup() { MockitoAnnotations.openMocks(this); // Initialize mocks + + SecurityContext securityContext = mock(SecurityContext.class); + SecurityContextHolder.setContext(securityContext); + when(securityContext.getAuthentication()).thenReturn(authentication); } @Test @@ -84,12 +104,18 @@ public void getAllSkillsHappyFlow() @Test + @DisplayName("Test the create() skill method, which returns the created skill data") public void testCreateSkill_Success() { // Arrange: Mock request and setup mocks CreateSkillViewModel createSkill = new CreateSkillViewModel(); createSkill.setName("python"); createSkill.setType(SkillTypeEnum.ATOMIC); + // Mock JwtUser with rdsUserId and role + JwtUser jwtUser = new JwtUser("123", UserRoleEnum.USER); + + + RdsUserViewModel viewModel = new RdsUserViewModel(); viewModel.setId("123"); @@ -106,10 +132,19 @@ public void testCreateSkill_Success() { SkillViewModel expectedViewModel = SkillViewModel.toViewModel(skillEntity); // Mock behavior - when(skillRepository.existsByName("python")).thenReturn(false); + when(authentication.getPrincipal()).thenReturn(jwtUser);// Return mock JwtUser + when(rdsService.getUserDetails(jwtUser.getRdsUserId())).thenReturn(userDetails); // Use rdsUserId when(skillRepository.saveAndFlush(any(Skill.class))).thenReturn(skillEntity); + + + + + when(skillRepository.existsByName("python")).thenReturn(false); + + + // Act: Call the method SkillViewModel actualViewModel = skillService.create(createSkill); @@ -127,6 +162,7 @@ public void testCreateSkill_Success() { @Test + @DisplayName("Test the create() skill method, when an already present skill is being added") public void testCreateSkill_AlreadyExists() { // Arrange CreateSkillViewModel createSkill = new CreateSkillViewModel(); @@ -150,6 +186,103 @@ public void testCreateSkill_AlreadyExists() { verify(skillRepository, never()).saveAndFlush(any(Skill.class)); } + //To be modified + + + +@Test +@DisplayName("To Test the approveRejectSkillRequest() method, when action is approved") +public void testApproveRejectSkillRequest(){ + + // Arrange + Integer skillId = 1; + String endorseId = "123"; + UserSkillStatusEnum action = UserSkillStatusEnum.APPROVED; + + Skill skill1 = new Skill(); + skill1.setId(1); + + List existingSkillRequest = new ArrayList<>(); + UserSkills userSkill1 = new UserSkills(); + userSkill1.setId("1"); + userSkill1.setUserId("123"); + userSkill1.setStatus(UserSkillStatusEnum.PENDING); + userSkill1.setSkill(skill1); + existingSkillRequest.add(userSkill1); + + when(userSkillRepository.findByUserIdAndSkillId(userSkill1.getUserId(), skill1.getId())).thenReturn(existingSkillRequest); + when(userSkillRepository.save(userSkill1)).thenReturn(userSkill1); + + + // Act: Call the method + GenericResponse response= skillService.approveRejectSkillRequest(skillId,endorseId,action); + +// Assert + assertNotNull(response); + assertEquals("approved", response.getMessage()); // Depending on the action + assertEquals(UserSkillStatusEnum.APPROVED, userSkill1.getStatus()); + + +} + + @Test + @DisplayName("To Test the approveRejectSkillRequest() method, when action is rejected") + public void testApproveRejectSkillRequest_Reject() { + // Arrange + Integer skillId = 2; + String endorseId = "456"; + UserSkillStatusEnum action = UserSkillStatusEnum.REJECTED; + + Skill skill1 = new Skill(); + skill1.setId(2); + + UserSkills mockSkillRequest = new UserSkills(); + mockSkillRequest.setSkill(skill1); + mockSkillRequest.setUserId(endorseId); + mockSkillRequest.setStatus(UserSkillStatusEnum.PENDING); + + List existingSkillRequest = new ArrayList<>(); + existingSkillRequest.add(mockSkillRequest); + + // Mock repository behavior + when(userSkillRepository.findByUserIdAndSkillId(endorseId, skillId)).thenReturn(existingSkillRequest); + when(userSkillRepository.save(mockSkillRequest)).thenReturn(mockSkillRequest); + + // Act + GenericResponse response = skillService.approveRejectSkillRequest(skillId, endorseId, action); + + // Assert + assertNotNull(response); + assertEquals("rejected", response.getMessage()); // Depending on the action + assertEquals(UserSkillStatusEnum.REJECTED, mockSkillRequest.getStatus()); + + // Verify that the save method was called + verify(userSkillRepository, times(1)).save(mockSkillRequest); + } + + @Test + @DisplayName("To Test the approveRejectSkillRequest() method, when no skill requests are present") + public void testApproveRejectSkillRequest_NoEntityException() { + // Arrange + Integer skillId = 3; + String endorseId = "789"; + UserSkillStatusEnum action = UserSkillStatusEnum.APPROVED; + + // Mock repository behavior for no entity found + when(userSkillRepository.findByUserIdAndSkillId(endorseId, skillId)).thenReturn(new ArrayList<>()); + + // Act & Assert + assertThrows(NoEntityException.class, () -> { + skillService.approveRejectSkillRequest(skillId, endorseId, action); + }); + + // Verify that the save method was never called + verify(userSkillRepository, never()).save(any(UserSkills.class)); + } + + + + From 73d1e227dce29a9a4e4d792d55bf8211926d1c35 Mon Sep 17 00:00:00 2001 From: raj1802 Date: Tue, 29 Oct 2024 11:40:18 +0530 Subject: [PATCH 3/3] Fix formatting issues in unitTests --- .../unitTests/EndorsementsApiUnitTests.java | 60 +++---- .../unitTests/SkillsApiUnitTests.java | 154 +++++++----------- 2 files changed, 86 insertions(+), 128 deletions(-) diff --git a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java index 6f1053df..bcd1814c 100644 --- a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java +++ b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/EndorsementsApiUnitTests.java @@ -1,5 +1,8 @@ package com.RDS.skilltree.unitTests; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.when; + import com.RDS.skilltree.dtos.RdsGetUserDetailsResDto; import com.RDS.skilltree.models.Endorsement; import com.RDS.skilltree.models.Skill; @@ -8,51 +11,41 @@ import com.RDS.skilltree.services.external.RdsService; import com.RDS.skilltree.viewmodels.EndorsementViewModel; import com.RDS.skilltree.viewmodels.RdsUserViewModel; +import java.util.ArrayList; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; -import java.util.ArrayList; -import java.util.List; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.mockito.Mockito.when; - public class EndorsementsApiUnitTests { - @Mock - private EndorsementRepository endorsementRepository; + @Mock private EndorsementRepository endorsementRepository; - @Mock - private RdsService rdsService; + @Mock private RdsService rdsService; - @InjectMocks - private EndorsementServiceImplementation endorsementService; + @InjectMocks private EndorsementServiceImplementation endorsementService; @BeforeEach public void setup() { - MockitoAnnotations.openMocks(this); // Initialize mocks - + MockitoAnnotations.openMocks(this); // Initialize mocks } - @Test @DisplayName("To test getAllEndorsementsBySkillId() method") - public void testGetAllEndorsementsBySkillId() - { + public void testGetAllEndorsementsBySkillId() { List endorsements = new ArrayList<>(); - Integer skillId =1; + Integer skillId = 1; - //initializing a skill + // initializing a skill Skill skill1 = new Skill(); skill1.setId(skillId); skill1.setName("python"); - - //initializing an endorsement + // initializing an endorsement Endorsement endorsement1 = new Endorsement(); endorsement1.setId(1); endorsement1.setSkill(skill1); @@ -63,35 +56,30 @@ public void testGetAllEndorsementsBySkillId() endorsements.add(endorsement1); RdsGetUserDetailsResDto rdsGetUserDetailsResDto1 = new RdsGetUserDetailsResDto(); - RdsUserViewModel rdsUserViewModel1= new RdsUserViewModel(); + RdsUserViewModel rdsUserViewModel1 = new RdsUserViewModel(); rdsUserViewModel1.setId("123"); rdsGetUserDetailsResDto1.setUser(rdsUserViewModel1); - RdsGetUserDetailsResDto rdsGetUserDetailsResDto2 = new RdsGetUserDetailsResDto(); - RdsUserViewModel rdsUserViewModel2= new RdsUserViewModel(); + RdsUserViewModel rdsUserViewModel2 = new RdsUserViewModel(); rdsUserViewModel2.setId("456"); rdsGetUserDetailsResDto2.setUser(rdsUserViewModel2); - - - //Mock behaviour + // Mock behaviour when(endorsementRepository.findBySkillId(skillId)).thenReturn(endorsements); - when(rdsService.getUserDetails(endorsement1.getEndorseId())).thenReturn(rdsGetUserDetailsResDto1); - when(rdsService.getUserDetails(endorsement1.getEndorserId())).thenReturn(rdsGetUserDetailsResDto2); + when(rdsService.getUserDetails(endorsement1.getEndorseId())) + .thenReturn(rdsGetUserDetailsResDto1); + when(rdsService.getUserDetails(endorsement1.getEndorserId())) + .thenReturn(rdsGetUserDetailsResDto2); + // Act - //Act + List endorsmentsBySkillId = + endorsementService.getAllEndorsementsBySkillId(skillId); - List endorsmentsBySkillId = endorsementService.getAllEndorsementsBySkillId(skillId); - - assert(endorsmentsBySkillId.size() == 1); + assert (endorsmentsBySkillId.size() == 1); assertEquals("456", endorsmentsBySkillId.get(0).getEndorser().getId()); assertEquals("123", endorsmentsBySkillId.get(0).getEndorse().getId()); assertEquals("python", endorsmentsBySkillId.get(0).getSkill().getName()); - - } - - } diff --git a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java index aea8d09f..e3511a10 100644 --- a/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java +++ b/skill-tree/src/test/java/com/RDS/skilltree/unitTests/SkillsApiUnitTests.java @@ -1,20 +1,19 @@ package com.RDS.skilltree.unitTests; +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.Mockito.*; + import com.RDS.skilltree.dtos.RdsGetUserDetailsResDto; -import com.RDS.skilltree.dtos.SkillRequestsDto; import com.RDS.skilltree.enums.SkillTypeEnum; import com.RDS.skilltree.enums.UserRoleEnum; import com.RDS.skilltree.enums.UserSkillStatusEnum; import com.RDS.skilltree.exceptions.NoEntityException; import com.RDS.skilltree.exceptions.SkillAlreadyExistsException; -import com.RDS.skilltree.models.Endorsement; import com.RDS.skilltree.models.JwtUser; import com.RDS.skilltree.models.Skill; import com.RDS.skilltree.models.UserSkills; -import com.RDS.skilltree.repositories.EndorsementRepository; import com.RDS.skilltree.repositories.SkillRepository; import com.RDS.skilltree.repositories.UserSkillRepository; -import com.RDS.skilltree.services.SkillService; import com.RDS.skilltree.services.SkillServiceImplementation; import com.RDS.skilltree.services.external.RdsService; import com.RDS.skilltree.utils.GenericResponse; @@ -22,49 +21,37 @@ import com.RDS.skilltree.viewmodels.RdsUserViewModel; import com.RDS.skilltree.viewmodels.SkillRequestsWithUserDetailsViewModel; import com.RDS.skilltree.viewmodels.SkillViewModel; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.mockito.InjectMocks; import org.mockito.Mock; -import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.springframework.security.core.Authentication; import org.springframework.security.core.context.SecurityContext; import org.springframework.security.core.context.SecurityContextHolder; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; - -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.Mockito.*; - public class SkillsApiUnitTests { - @Mock - private SkillRepository skillRepository; + @Mock private SkillRepository skillRepository; - @Mock - private UserSkillRepository userSkillRepository; + @Mock private UserSkillRepository userSkillRepository; + @Mock private RdsService rdsService; + @Mock private Authentication authentication; - @Mock - private RdsService rdsService; - - @Mock - private Authentication authentication; - - @Mock - private SkillRequestsWithUserDetailsViewModel skillRequestsWithUserDetailsViewModel; + @Mock private SkillRequestsWithUserDetailsViewModel skillRequestsWithUserDetailsViewModel; @InjectMocks private SkillServiceImplementation skillService; // Class containing the getAll() method @BeforeEach public void setup() { - MockitoAnnotations.openMocks(this); // Initialize mocks + MockitoAnnotations.openMocks(this); // Initialize mocks SecurityContext securityContext = mock(SecurityContext.class); SecurityContextHolder.setContext(securityContext); @@ -72,9 +59,9 @@ public void setup() { } @Test - @DisplayName("Test the getAll() method returns all the created skills, where the skills return in a sorted order based on skill-Id.") - public void getAllSkillsHappyFlow() - { + @DisplayName( + "Test the getAll() method returns all the created skills, where the skills return in a sorted order based on skill-Id.") + public void getAllSkillsHappyFlow() { Skill skill1 = new Skill(); skill1.setId(1); @@ -86,7 +73,6 @@ public void getAllSkillsHappyFlow() skill2.setName("Spring Boot"); skill2.setType(SkillTypeEnum.ATOMIC); - // Mock the repository's behavior when(skillRepository.findAll()).thenReturn(Arrays.asList(skill1, skill2)); @@ -102,7 +88,6 @@ public void getAllSkillsHappyFlow() verify(skillRepository, times(1)).findAll(); } - @Test @DisplayName("Test the create() skill method, which returns the created skill data") public void testCreateSkill_Success() { @@ -114,15 +99,12 @@ public void testCreateSkill_Success() { // Mock JwtUser with rdsUserId and role JwtUser jwtUser = new JwtUser("123", UserRoleEnum.USER); - - RdsUserViewModel viewModel = new RdsUserViewModel(); viewModel.setId("123"); RdsGetUserDetailsResDto userDetails = new RdsGetUserDetailsResDto(); userDetails.setUser(viewModel); - Skill skillEntity = new Skill(); skillEntity.setId(5); skillEntity.setName("python"); @@ -133,18 +115,13 @@ public void testCreateSkill_Success() { // Mock behavior - when(authentication.getPrincipal()).thenReturn(jwtUser);// Return mock JwtUser - when(rdsService.getUserDetails(jwtUser.getRdsUserId())).thenReturn(userDetails); // Use rdsUserId + when(authentication.getPrincipal()).thenReturn(jwtUser); // Return mock JwtUser + when(rdsService.getUserDetails(jwtUser.getRdsUserId())) + .thenReturn(userDetails); // Use rdsUserId when(skillRepository.saveAndFlush(any(Skill.class))).thenReturn(skillEntity); - - - - when(skillRepository.existsByName("python")).thenReturn(false); - - // Act: Call the method SkillViewModel actualViewModel = skillService.create(createSkill); @@ -157,10 +134,8 @@ public void testCreateSkill_Success() { // Verify that the repository and service were called correctly verify(skillRepository, times(1)).existsByName("python"); verify(skillRepository, times(1)).saveAndFlush(any(Skill.class)); - } - @Test @DisplayName("Test the create() skill method, when an already present skill is being added") public void testCreateSkill_AlreadyExists() { @@ -173,11 +148,11 @@ public void testCreateSkill_AlreadyExists() { when(skillRepository.existsByName("python")).thenReturn(true); // Act & Assert: Verify that exception is thrown - SkillAlreadyExistsException exception = assertThrows( - SkillAlreadyExistsException.class, - () -> skillService.create(createSkill), - "Skill with name "+createSkill.getName()+"already exists" - ); + SkillAlreadyExistsException exception = + assertThrows( + SkillAlreadyExistsException.class, + () -> skillService.create(createSkill), + "Skill with name " + createSkill.getName() + "already exists"); assertEquals("Skill with name python already exists", exception.getMessage()); @@ -186,44 +161,41 @@ public void testCreateSkill_AlreadyExists() { verify(skillRepository, never()).saveAndFlush(any(Skill.class)); } - //To be modified - - - -@Test -@DisplayName("To Test the approveRejectSkillRequest() method, when action is approved") -public void testApproveRejectSkillRequest(){ - - // Arrange - Integer skillId = 1; - String endorseId = "123"; - UserSkillStatusEnum action = UserSkillStatusEnum.APPROVED; - - Skill skill1 = new Skill(); - skill1.setId(1); + // To be modified - List existingSkillRequest = new ArrayList<>(); - UserSkills userSkill1 = new UserSkills(); - userSkill1.setId("1"); - userSkill1.setUserId("123"); - userSkill1.setStatus(UserSkillStatusEnum.PENDING); - userSkill1.setSkill(skill1); - existingSkillRequest.add(userSkill1); + @Test + @DisplayName("To Test the approveRejectSkillRequest() method, when action is approved") + public void testApproveRejectSkillRequest() { - when(userSkillRepository.findByUserIdAndSkillId(userSkill1.getUserId(), skill1.getId())).thenReturn(existingSkillRequest); - when(userSkillRepository.save(userSkill1)).thenReturn(userSkill1); + // Arrange + Integer skillId = 1; + String endorseId = "123"; + UserSkillStatusEnum action = UserSkillStatusEnum.APPROVED; + Skill skill1 = new Skill(); + skill1.setId(1); - // Act: Call the method - GenericResponse response= skillService.approveRejectSkillRequest(skillId,endorseId,action); + List existingSkillRequest = new ArrayList<>(); + UserSkills userSkill1 = new UserSkills(); + userSkill1.setId("1"); + userSkill1.setUserId("123"); + userSkill1.setStatus(UserSkillStatusEnum.PENDING); + userSkill1.setSkill(skill1); + existingSkillRequest.add(userSkill1); -// Assert - assertNotNull(response); - assertEquals("approved", response.getMessage()); // Depending on the action - assertEquals(UserSkillStatusEnum.APPROVED, userSkill1.getStatus()); + when(userSkillRepository.findByUserIdAndSkillId(userSkill1.getUserId(), skill1.getId())) + .thenReturn(existingSkillRequest); + when(userSkillRepository.save(userSkill1)).thenReturn(userSkill1); + // Act: Call the method + GenericResponse response = + skillService.approveRejectSkillRequest(skillId, endorseId, action); -} + // Assert + assertNotNull(response); + assertEquals("approved", response.getMessage()); // Depending on the action + assertEquals(UserSkillStatusEnum.APPROVED, userSkill1.getStatus()); + } @Test @DisplayName("To Test the approveRejectSkillRequest() method, when action is rejected") @@ -245,11 +217,13 @@ public void testApproveRejectSkillRequest_Reject() { existingSkillRequest.add(mockSkillRequest); // Mock repository behavior - when(userSkillRepository.findByUserIdAndSkillId(endorseId, skillId)).thenReturn(existingSkillRequest); + when(userSkillRepository.findByUserIdAndSkillId(endorseId, skillId)) + .thenReturn(existingSkillRequest); when(userSkillRepository.save(mockSkillRequest)).thenReturn(mockSkillRequest); // Act - GenericResponse response = skillService.approveRejectSkillRequest(skillId, endorseId, action); + GenericResponse response = + skillService.approveRejectSkillRequest(skillId, endorseId, action); // Assert assertNotNull(response); @@ -269,21 +243,17 @@ public void testApproveRejectSkillRequest_NoEntityException() { UserSkillStatusEnum action = UserSkillStatusEnum.APPROVED; // Mock repository behavior for no entity found - when(userSkillRepository.findByUserIdAndSkillId(endorseId, skillId)).thenReturn(new ArrayList<>()); + when(userSkillRepository.findByUserIdAndSkillId(endorseId, skillId)) + .thenReturn(new ArrayList<>()); // Act & Assert - assertThrows(NoEntityException.class, () -> { - skillService.approveRejectSkillRequest(skillId, endorseId, action); - }); + assertThrows( + NoEntityException.class, + () -> { + skillService.approveRejectSkillRequest(skillId, endorseId, action); + }); // Verify that the save method was never called verify(userSkillRepository, never()).save(any(UserSkills.class)); } - - - - - - - }