diff --git a/server/src/main/java/com/usatiuk/tjv/y/server/entity/Person.java b/server/src/main/java/com/usatiuk/tjv/y/server/entity/Person.java index 64c299b..c3309fa 100644 --- a/server/src/main/java/com/usatiuk/tjv/y/server/entity/Person.java +++ b/server/src/main/java/com/usatiuk/tjv/y/server/entity/Person.java @@ -50,12 +50,12 @@ public class Person { @JoinTable(name = "person_follows", joinColumns = @JoinColumn(name = "follower"), inverseJoinColumns = @JoinColumn(name = "followee")) - private Collection following; + private Collection following = new ArrayList<>(); @ManyToMany(mappedBy = "following") - private Collection followers; + private Collection followers = new ArrayList<>(); @ManyToMany(mappedBy = "members") - private Collection chats; + private Collection chats = new ArrayList<>(); } diff --git a/server/src/test/java/com/usatiuk/tjv/y/server/repository/PersonRepositoryTest.java b/server/src/test/java/com/usatiuk/tjv/y/server/repository/PersonRepositoryTest.java new file mode 100644 index 0000000..541234c --- /dev/null +++ b/server/src/test/java/com/usatiuk/tjv/y/server/repository/PersonRepositoryTest.java @@ -0,0 +1,21 @@ +package com.usatiuk.tjv.y.server.repository; + +import com.usatiuk.tjv.y.server.entity.Person; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; + +@DataJpaTest +public class PersonRepositoryTest { + @Autowired + private PersonRepository personRepository; + + @Test + void findByUsernameOrUuidTest() { + var person = personRepository.save(new Person().setUsername("u1").setFullName("fn").setPassword("pass")); + + Assertions.assertEquals(person, personRepository.findByUsernameOrId("u1").get()); + Assertions.assertEquals(person, personRepository.findByUsernameOrId(person.getUuid()).get()); + } +} diff --git a/server/src/test/java/com/usatiuk/tjv/y/server/service/PersonServiceImplIntegrationTest.java b/server/src/test/java/com/usatiuk/tjv/y/server/service/PersonServiceImplIntegrationTest.java new file mode 100644 index 0000000..c9888f4 --- /dev/null +++ b/server/src/test/java/com/usatiuk/tjv/y/server/service/PersonServiceImplIntegrationTest.java @@ -0,0 +1,159 @@ +package com.usatiuk.tjv.y.server.service; + +import com.usatiuk.tjv.y.server.dto.PersonCreateTo; +import com.usatiuk.tjv.y.server.dto.converters.PersonMapper; +import com.usatiuk.tjv.y.server.entity.Person; +import com.usatiuk.tjv.y.server.repository.PersonRepository; +import org.junit.jupiter.api.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.security.access.AccessDeniedException; +import org.springframework.security.core.context.SecurityContextHolder; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.security.test.context.support.TestExecutionEvent; +import org.springframework.security.test.context.support.WithUserDetails; +import org.springframework.test.jdbc.JdbcTestUtils; +import org.springframework.transaction.annotation.Transactional; + +import java.util.ArrayList; +import java.util.List; + +import static org.junit.jupiter.api.TestInstance.Lifecycle.PER_CLASS; + +@SpringBootTest +@TestInstance(PER_CLASS) +@Transactional +public class PersonServiceImplIntegrationTest { + @Autowired + private PersonServiceImpl personService; + @Autowired + private PersonRepository personRepository; + @Autowired + private JdbcTemplate jdbcTemplate; + @Autowired + private PasswordEncoder passwordEncoder; + @Autowired + private PersonMapper personMapper; + + protected static final String person1Password = "p1p"; + protected Person person1; + protected static final String person2Password = "p2p"; + protected Person person2; + protected static final String person3Password = "p3p"; + protected Person person3; + + @BeforeAll + void setup() { + person1 = personRepository.save( + new Person() + .setUsername("person1") + .setFullName("Person 1") + .setPassword(passwordEncoder.encode(person1Password))); + person2 = personRepository.save( + new Person() + .setUsername("person2") + .setFullName("Person 2") + .setPassword(passwordEncoder.encode(person2Password)).setFollowing(new ArrayList<>(List.of(person1)))); + person3 = personRepository.save( + new Person() + .setUsername("person3") + .setFullName("Person 3") + .setPassword(passwordEncoder.encode(person3Password)) + .setFollowing(List.of(person2, person1))); + } + + @AfterAll + void erase() { + JdbcTestUtils.deleteFromTables(jdbcTemplate, "person_follows", "chat_person", "post", "message", "chat", "person"); + } + + @Test + @WithUserDetails(value = "person1", setupBefore = TestExecutionEvent.TEST_EXECUTION) + void shouldAddFollowing() { + var auth = SecurityContextHolder.getContext().getAuthentication(); + + Assertions.assertEquals(0, personService.getFollowing(auth).size()); + personService.addFollower(auth, person2.getUuid()); + Assertions.assertIterableEquals(List.of(personMapper.makeDto(person2)), personService.getFollowing(auth)); + } + + @Test + @WithUserDetails(value = "person2", setupBefore = TestExecutionEvent.TEST_EXECUTION) + void shouldRemoveFollowing() { + var auth = SecurityContextHolder.getContext().getAuthentication(); + + Assertions.assertEquals(1, personService.getFollowing(auth).size()); + personService.removeFollower(auth, person1.getUuid()); + Assertions.assertEquals(0, personService.getFollowing(auth).size()); + } + + @Test + void firstSignedUpShouldBeAdmin() { + personService.signup(new PersonCreateTo("newadmin", "full name admin", "adminpass")); + var created = personService.readByUsername("newadmin"); + Assertions.assertTrue(created.isAdmin()); + Assertions.assertTrue(personService.getAdmins().contains(created)); + + personService.signup(new PersonCreateTo("newnotadmin", "full name notadmin", "notadminpass")); + var created2 = personService.readByUsername("newnotadmin"); + Assertions.assertFalse(created2.isAdmin()); + Assertions.assertFalse(personService.getAdmins().contains(created2)); + } + + @Nested + @TestInstance(PER_CLASS) + @Transactional + class AdminTests { + + @BeforeAll + void setup() { + personRepository.save(person1.setAdmin(true)); + } + + @AfterAll + void teardown() { + personRepository.save(person1.setAdmin(false)); + } + + @Test + @WithUserDetails(value = "person1", setupBefore = TestExecutionEvent.TEST_EXECUTION) + void shouldAddRemoveAdminIfAdmin() { + personService.addAdmin(person2.getUuid()); + var updatedP2 = personService.readByUsername(person2.getUsername()); + Assertions.assertTrue(updatedP2.isAdmin()); + Assertions.assertTrue(personService.getAdmins().contains(updatedP2)); + + personService.removeAdmin(person2.getUuid()); + updatedP2 = personService.readByUsername(person2.getUsername()); + Assertions.assertFalse(updatedP2.isAdmin()); + Assertions.assertFalse(personService.getAdmins().contains(updatedP2)); + } + + @Test + @WithUserDetails(value = "person2", setupBefore = TestExecutionEvent.TEST_EXECUTION) + void shouldNotAddRemoveAdminIfNotAdmin() { + Assertions.assertThrows(AccessDeniedException.class, () -> + personService.addAdmin(person2.getUuid()) + ); + var updatedP = personService.readByUsername(person2.getUsername()); + Assertions.assertFalse(updatedP.isAdmin()); + Assertions.assertFalse(personService.getAdmins().contains(updatedP)); + + Assertions.assertThrows(AccessDeniedException.class, () -> + personService.addAdmin(person3.getUuid()) + ); + var updatedP3 = personService.readByUsername(person3.getUsername()); + Assertions.assertFalse(updatedP3.isAdmin()); + Assertions.assertFalse(personService.getAdmins().contains(updatedP3)); + + Assertions.assertThrows(AccessDeniedException.class, () -> + personService.removeAdmin(person1.getUuid()) + ); + var updatedP1 = personService.readByUsername(person1.getUsername()); + Assertions.assertTrue(updatedP1.isAdmin()); + Assertions.assertTrue(personService.getAdmins().contains(updatedP1)); + } + + } +}