Merge pull request #52 from SelimHorri/test

Test

Author: SelimHorri

src/test/java/tn/cita/app/repository/CredentialRepositoryTest.java

@@ -0,0 +1,55 @@
+package tn.cita.app.repository;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.autoconfigure.orm.jpa.AutoConfigureDataJpa;
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+
+import tn.cita.app.container.AbstractTestSharedMySQLContainer;
+import tn.cita.app.domain.entity.Credential;
+
+@DataJpaTest(showSql = true)
+@AutoConfigureDataJpa
+class CredentialRepositoryTest extends AbstractTestSharedMySQLContainer {
+	
+	@Autowired
+	private CredentialRepository credentialRepository;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		
+	}
+	
+	@Test
+	void givenValidUsername_whenFindCredentialByUsernameIgnoringCase_thenCredentialShouldBeFound() {
+		
+		final var username = "selimhorri";
+		final var optionalCredential = this.credentialRepository.findByUsernameIgnoreCase(username.toUpperCase());
+		
+		assertThat(optionalCredential).isNotNull();
+		assertThat(optionalCredential.isPresent()).isTrue();
+		assertThat(optionalCredential.get()).isNotNull();
+		assertThat(optionalCredential.get()).isInstanceOf(Credential.class);
+		assertThat(optionalCredential.get().getUsername()).isEqualTo(username);
+		assertThat(optionalCredential.get().getCustomer()).isNull();
+	}
+	
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+

src/test/java/tn/cita/app/service/impl/AuthenticationServiceImplTest.java

@@ -0,0 +1,77 @@
+package tn.cita.app.service.impl;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertThrows;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.security.core.userdetails.UserDetailsService;
+
+import tn.cita.app.dto.request.LoginRequest;
+import tn.cita.app.exception.wrapper.IllegalCredentialsException;
+import tn.cita.app.service.AuthenticationService;
+import tn.cita.app.util.JwtUtil;
+
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+class AuthenticationServiceImplTest {
+	
+	@Autowired
+	private JwtUtil jwtUtil;
+	
+	@Autowired
+	private UserDetailsService userDetailsService;
+	
+	@Autowired
+	private AuthenticationService authenticationService;
+	private LoginRequest loginRequest;
+	// private LoginResponse loginResponse;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		
+		loginRequest = new LoginRequest("selimhorri", "0000");
+	}
+	
+	@Test
+	void givenValidLoginRequest_whenCredentialsAreValid_thenLoginResponseShouldProcessed() {
+		
+		final var expectedLoginResponse = this.authenticationService.login(this.loginRequest);
+		assertThat(expectedLoginResponse).isNotNull();
+		assertThat(expectedLoginResponse.getUsername()).isEqualTo(loginRequest.getUsername());
+		
+		final var validateToken = this.jwtUtil.validateToken(expectedLoginResponse.getJwtToken(), 
+				this.userDetailsService.loadUserByUsername(loginRequest.getUsername()));
+		assertThat(validateToken).isTrue();
+	}
+	
+	@Test
+	void givenInvalidLoginRequest_whenCredentialsAreInvalid_thenShouldThrowIllegalCredentialsException() {
+		this.loginRequest = new LoginRequest("selimhorri", "1111");
+		final var illegalCredentialsException = assertThrows(IllegalCredentialsException.class, () -> this.authenticationService.login(this.loginRequest));
+		assertThat(illegalCredentialsException).isNotNull();
+		assertThat(illegalCredentialsException.getMessage()).isEqualTo("Bad credentials");
+	}
+	
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/test/java/tn/cita/app/service/impl/CredentialServiceImplTest.java

@@ -0,0 +1,98 @@
+package tn.cita.app.service.impl;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.Mockito.when;
+
+import java.util.Optional;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import tn.cita.app.domain.UserRoleBasedAuthority;
+import tn.cita.app.domain.entity.Credential;
+import tn.cita.app.domain.entity.Employee;
+import tn.cita.app.exception.wrapper.CredentialNotFoundException;
+import tn.cita.app.repository.CredentialRepository;
+import tn.cita.app.service.CredentialService;
+
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+class CredentialServiceImplTest {
+	
+	@MockBean
+	private CredentialRepository credentialRepository;
+	
+	@Autowired
+	private PasswordEncoder passwordEncoder;
+	
+	@Autowired
+	private CredentialService credentialService;
+	private Credential credential;
+	
+	@BeforeEach
+	void setUp() throws Exception {
+		
+		final var username = "selimhorri";
+		this.credential = Credential.builder()
+				.id(null)
+				.username(username)
+				.password(this.passwordEncoder.encode("0000"))
+				.userRoleBasedAuthority(UserRoleBasedAuthority.EMPLOYEE)
+				.isEnabled(true)
+				.employee(
+						Employee.builder()
+							.firstname("Selim")
+							.lastname("Horri")
+							.build())
+				.build();
+		
+		when(this.credentialRepository.findByUsernameIgnoreCase(username))
+				.thenReturn(Optional.of(this.credential));
+	}
+	
+	@Test
+	void givenValidUsername_whenFindCredentialByUsername_thenCredentialShouldBeFound() {
+		
+		final var credentialDtoExpected = this.credentialService.findByUsername(this.credential.getUsername());
+		
+		assertThat(credentialDtoExpected).isNotNull();
+		assertThat(credentialDtoExpected.getUsername()).isEqualTo(this.credential.getUsername());
+		assertThat(credentialDtoExpected.getPassword()).isEqualTo(this.credential.getPassword());
+		assertThat(credentialDtoExpected.getIsEnabled()).isTrue();
+	}
+	
+	@Test
+	void givenInvalidUsername_whenFindCredentialByUsername_thenCredentialNotFoundExceptionShouldBeThrown() {
+		
+		final var newUsername = this.credential.getUsername() + "iii";
+		final var credentialNotFoundException = assertThrows(CredentialNotFoundException.class, 
+				() -> this.credentialService.findByUsername(newUsername));
+		
+		assertThat(credentialNotFoundException).isNotNull();
+		assertThat(credentialNotFoundException.getMessage()).startsWith("Credential ");
+		assertThat(credentialNotFoundException.getMessage()).endsWith(" not found");
+		assertThat(credentialNotFoundException.getMessage()).isEqualTo(String
+				.format("Credential with username %s not found", newUsername));
+	}
+	
+	
+	
+}
+
+
+
+
+
+
+
+
+
+
+
+
+