From 6430d30437e32cdcd8bf456039397a8f315bb26f Mon Sep 17 00:00:00 2001 From: Pekka Helenius Date: Fri, 16 Oct 2020 21:12:25 +0300 Subject: [PATCH] Add database tests Signed-off-by: Pekka Helenius --- .../model/auth/AuthRepositoriesTest.java | 344 +++++++++++++++++ .../model/book/BookRepositoriesTest.java | 351 ++++++++++++++++++ 2 files changed, 695 insertions(+) create mode 100644 bookstore/src/test/java/com/fjordtek/bookstore/model/auth/AuthRepositoriesTest.java create mode 100644 bookstore/src/test/java/com/fjordtek/bookstore/model/book/BookRepositoriesTest.java diff --git a/bookstore/src/test/java/com/fjordtek/bookstore/model/auth/AuthRepositoriesTest.java b/bookstore/src/test/java/com/fjordtek/bookstore/model/auth/AuthRepositoriesTest.java new file mode 100644 index 0000000..dacbafb --- /dev/null +++ b/bookstore/src/test/java/com/fjordtek/bookstore/model/auth/AuthRepositoriesTest.java @@ -0,0 +1,344 @@ +// Pekka Helenius , Fjordtek 2020 + +package com.fjordtek.bookstore.model.auth; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.security.SecureRandom; + +import javax.validation.ConstraintViolationException; + +import org.junit.Test; +import org.junit.jupiter.api.MethodOrderer.Alphanumeric; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.orm.jpa.JpaSystemException; +import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; +import org.springframework.security.crypto.password.PasswordEncoder; +import org.springframework.test.context.junit4.SpringRunner; + +/** + * + * TODO: N/A + * + * @author Pekka Helenius + */ + +@RunWith(SpringRunner.class) +@DataJpaTest +@TestMethodOrder(Alphanumeric.class) +public class AuthRepositoriesTest { + + @Autowired + private RoleRepository roleRepository; + + @Autowired + private UserRepository userRepository; + + @Autowired + private UserRoleRepository userRoleRepository; + + private PasswordEncoder passwordEncoder = new BCryptPasswordEncoder(14, new SecureRandom()); + + ////////////////////////////// + + @Test + public void testA_CreateRole() { + Role roleA = roleRepository.save(new Role("TEST")); + assertThat(roleA).isNotNull(); + } + + @Test + public void testB_CreateRoleWithoutNameShouldFail() { + assertThrows( + ConstraintViolationException.class, () -> { + roleRepository.save(new Role()); + roleRepository.findAll().forEach(System.out::print); + } + ); + } + + @Test + public void testC_CreateRoleDuplicateNameShouldFail() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + + roleRepository.save(new Role("FOO")); + roleRepository.save(new Role("FOO")); + + roleRepository.findAll().forEach(System.out::print); + }); + } + + @Test + public void testD_DeleteUnusedRole() { + + Role roleA = roleRepository.save(new Role("FOO")); + Long id = roleA.getId(); + roleRepository.delete(roleA); + + assertThat(roleRepository.findById(id)).isEmpty(); + + } + + @Test + public void testE_ChangeRoleName() { + + String nameA = "FOO"; + String nameB = "BAR"; + + Role roleA = roleRepository.save(new Role(nameA)); + roleA.setName(nameB); + roleRepository.save(roleA); + + assertThat(roleA.getName().equals(nameA)).isEqualTo(false); + + //System.out.println(roleRepository.findById(roleA.getId()).get().getName()); + + } + + ////////////////////////////// + + @Test + public void testF_CreateUser() { + User userA = userRepository.save(new User( + "foo", + passwordEncoder.encode("bar"), + "foo.bar@fjordtek.com" + ) + ); + + assertThat(userA).isNotNull(); + } + + @Test + public void testG__CreateUserWithEmptyPasswordShouldFail() { + + /* + * NOTE: null password must be forced for empty/blank passwords + * if sign up form is implemented. + * BCryptPasswordEncoder encode method checks for null value only + * and throws exception accordingly. It does not work on empty + * ("") values. + * + */ + + assertThrows( + IllegalArgumentException.class, () -> { + userRepository.save(new User( + "bar", + passwordEncoder.encode(null), + "bar@fjordtek.com" + ) + ); + }); + + } + + @Test + public void testH__CreateUserWithInvalidEmailShouldFail() { + + assertThrows( + ConstraintViolationException.class, () -> { + userRepository.save(new User( + "foo", + passwordEncoder.encode("bar is foo"), + "bar//foobar.com" + ) + ); + userRepository.findAll().forEach(System.out::print); + }); + + assertThrows( + ConstraintViolationException.class, () -> { + userRepository.save(new User( + "foo", + passwordEncoder.encode("bar is foo"), + "bar||foobar.com" + ) + ); + userRepository.findAll().forEach(System.out::print); + }); + } + + @Test + public void testI_CreateUserWithEmptyUsernameShouldFail() { + + assertThrows( + ConstraintViolationException.class, () -> { + userRepository.save(new User( + "", + passwordEncoder.encode("bar is foo"), + "bar@foobar.com" + ) + ); + userRepository.findAll().forEach(System.out::print); + }); + + } + + @Test + public void testJ_CreateUserDuplicateUsernamesShouldFail() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + + userRepository.save(new User( + "foo", + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + + userRepository.save(new User( + "foo", + passwordEncoder.encode("bar"), + "bar@bar.com" + ) + ); + + userRepository.findAll().forEach(System.out::print); + }); + + } + + @Test + public void testK_DeleteExistingUser() { + + User userA = userRepository.save(new User( + "foo", + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + Long id = userA.getId(); + userRepository.delete(userA); + + assertThat(userRepository.findById(id)).isEmpty(); + + } + + @Test + public void testL_ChangeUserName() { + + String nameA = "foo"; + String nameB = "bar"; + + User userA = userRepository.save(new User( + nameA, + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + userA.setUsername(nameB); + userRepository.save(userA); + + assertThat(userA.getUsername().equals(nameA)).isEqualTo(false); + + //System.out.println(userRepository.findById(userA.getId()).get().getUsername()); + + } + + ////////////////////////////// + + @Test + public void testK_JoinAddExistingRoleAndUser() { + + User userA = userRepository.save(new User( + "foo", + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + Role roleA = new Role("FOO"); + + UserRole userRoleA = new UserRole(userA, roleA); + userRoleRepository.save(userRoleA); + + assertThat(userRoleA).isNotNull(); + + } + + @Test + public void testL_JoinSetRoleNullKeepUserShouldFail() { + + assertThrows( + JpaSystemException.class, () -> { + + User userA = userRepository.save(new User( + "foo", + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + + userRepository.save(userA); + userRoleRepository.save(new UserRole(userA, null)); + }); + + } + + @Test + public void testM_JoinSetUserNullKeepRoleShouldFail() { + + assertThrows( + JpaSystemException.class, () -> { + Role roleA = new Role("FOO"); + + roleRepository.save(roleA); + userRoleRepository.save(new UserRole(null, roleA)); + }); + + } + + @Test + public void testN_JoinAddDuplicatePrimaryKeyShouldFail() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + + User userA = userRepository.save(new User( + "foo", + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + Role roleA = new Role("FOO"); + + userRepository.save(userA); + roleRepository.save(roleA); + + userRoleRepository.save(new UserRole(userA, roleA)); + userRoleRepository.save(new UserRole(userA, roleA)); + }); + + } + + @Test + public void testO_JoinDeleteExistingRoleAndUser() { + + User userA = userRepository.save(new User( + "foo", + passwordEncoder.encode("foo"), + "foo@foo.com" + ) + ); + Role roleA = new Role("FOO"); + + userRepository.save(userA); + roleRepository.save(roleA); + UserRole userRoleA = new UserRole(userA, roleA); + userRoleRepository.save(userRoleA); + + userRoleRepository.deleteByCompositeId(userA.getId(), roleA.getId()); + + assertThat(userRoleRepository.findByCompositeId(userA.getId(), roleA.getId())).isNull(); + + } + +} diff --git a/bookstore/src/test/java/com/fjordtek/bookstore/model/book/BookRepositoriesTest.java b/bookstore/src/test/java/com/fjordtek/bookstore/model/book/BookRepositoriesTest.java new file mode 100644 index 0000000..bf5f3d0 --- /dev/null +++ b/bookstore/src/test/java/com/fjordtek/bookstore/model/book/BookRepositoriesTest.java @@ -0,0 +1,351 @@ +// Pekka Helenius , Fjordtek 2020 + +package com.fjordtek.bookstore.model.book; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.math.BigDecimal; + +import javax.validation.ConstraintViolationException; + +import org.junit.Test; +import org.junit.jupiter.api.MethodOrderer.Alphanumeric; +import org.junit.jupiter.api.TestMethodOrder; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.orm.jpa.JpaSystemException; +import org.springframework.test.context.junit4.SpringRunner; + +/** + * + * TODO: N/A + * + * @author Pekka Helenius + */ + +@RunWith(SpringRunner.class) +@DataJpaTest +@TestMethodOrder(Alphanumeric.class) +public class BookRepositoriesTest { + + @Autowired + private BookRepository bookRepository; + + @Autowired + private BookHashRepository bookHashRepository; + + @Autowired + private AuthorRepository authorRepository; + + @Autowired + private CategoryRepository categoryRepository; + + ////////////////////////////// + + @Test + public void testA_CreateAuthor() { + Author authorA = authorRepository.save(new Author("Foo", "Bar")); + assertThat(authorA).isNotNull(); + } + + @Test + public void testB_CreateAuthorWithoutFirstName() { + Author authorA = authorRepository.save(new Author(null, "Bar")); + assertThat(authorA).isNotNull(); + } + + @Test + public void testC_CreateAuthorWithoutLastName() { + Author authorA = authorRepository.save(new Author("Foo", null)); + assertThat(authorA).isNotNull(); + } + + @Test + public void testD_CreateAuthorDuplicateNameShouldPass() { + authorRepository.save(new Author("Foo", "Bar")); + authorRepository.save(new Author("Foo", "Bar")); + + int savedAuthorsCount = + authorRepository + .findByFirstNameIgnoreCaseContainingAndLastNameIgnoreCaseContaining( + "Foo", "Bar" + ).size(); + + assertThat(savedAuthorsCount).isEqualTo(2); + } + + ////////////////////////////// + + @Test + public void testE_CreateCategory() { + Category categoryA = categoryRepository.save(new Category("FOO")); + assertThat(categoryA).isNotNull(); + } + + @Test + public void testF_CreateCategoryWithoutNameShouldFail() { + + assertThrows( + ConstraintViolationException.class, () -> { + categoryRepository.save(new Category(null)); + categoryRepository.findAll().forEach(System.out::print); + }); + + } + + @Test + public void testG_CreateCategoryDuplicateNameShouldFail() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + categoryRepository.save(new Category("BAR")); + categoryRepository.save(new Category("BAR")); + + categoryRepository.findAll().forEach(System.out::print); + }); + + } + + ////////////////////////////// + + @Test + public void testH_CreateBookWithAuthor() { + + Author authorA = authorRepository.save(new Author("Fan", "Tasy")); + + Book bookA = bookRepository.save(new Book( + "Bloody Chamber", + authorA, + 1979, + "4343434-14", + new BigDecimal("18.00"), + null, + true + ) + ); + + assertThat(bookRepository.findById(bookA.getId())).isNotNull(); + } + + @Test + public void testI_CreateNewBookWithoutAuthor() { + + Book bookA = bookRepository.save(new Book( + "Bloody Chamber", + null, + 1979, + "4343434-15", + new BigDecimal("18.00"), + null, + true + ) + ); + + assertThat(bookRepository.findById(bookA.getId())).isNotNull(); + + } + + @Test + public void testJ_CreateBookWithCategory() { + + Category categoryA = categoryRepository.save(new Category("Technology")); + + Book bookA = bookRepository.save(new Book( + "Innovations in the era of information technology", + null, + 1954, + "7575757-15", + new BigDecimal("43.22"), + categoryA, + true + ) + ); + + assertThat(bookRepository.findById(bookA.getId())).isNotNull(); + + } + /* + @Test + public void testK_CreateBookWithoutCategory() { + + } + */ + ////////////////////////////// + + @Test + public void testL_ExistingBookIsbnIsUnique() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + + bookRepository.save(new Book( + "Exoplanets and Earth", + null, + 2009, + "7575757-15", + new BigDecimal("43.22"), + null, + true + ) + ); + + bookRepository.save(new Book( + "Interstellar research for astrobiological life", + null, + 2006, + "7575757-15", + new BigDecimal("11.99"), + null, + false + ) + ); + + bookRepository.findAll().forEach(System.out::print); + }); + + } + + ////////////////////////////// + + @Test + public void testM_BookHashCanBeCreated() { + + Book bookA = new Book( + "Exoplanets and Earth", + null, + 2009, + "9191919-15", + new BigDecimal("43.22"), + null, + true + ); + + BookHash bookHashA = new BookHash(); + bookHashA.setBook(bookA); + bookA.setBookHash(bookHashA); + + bookRepository.save(bookA); + bookHashRepository.save(bookHashA); + + assertThat(bookA).isNotNull(); + assertThat(bookHashA).isNotNull(); + + assertThat(bookHashA.getBookId() == bookA.getId()).isEqualTo(true); + assertThat(bookHashA.getHashId().length() == 32).isEqualTo(true); + + assertThat(bookHashA.getHashId().toString().matches("^[a-z0-9]*$")).isEqualTo(true); + + assertThat(bookHashRepository.findByBookId(bookA.getId())).isNotNull(); + assertThat(bookHashRepository.findByHashId(bookHashA.getHashId())).isNotNull(); + } + + @Test + public void testN_BookHashCanSetNewBookHashId() { + + Book bookA = new Book( + "Exoplanets and Earth", + null, + 2009, + "9191919-16", + new BigDecimal("43.22"), + null, + true + ); + + BookHash bookHashA = new BookHash(); + bookHashA.setBook(bookA); + bookA.setBookHash(bookHashA); + + bookRepository.save(bookA); + bookHashRepository.save(bookHashA); + + String hashIdA = bookHashA.getHashId(); + bookHashA.setHashId(); + String hashIdB = bookHashA.getHashId(); + + bookHashRepository.save(bookHashA); + + assertThat(bookHashA.getHashId().equals(hashIdA)).isEqualTo(false); + + } + + @Test + public void testO_BookHashCanNotDeleteBookId() { + + assertThrows( + JpaSystemException.class, () -> { + Book bookA = new Book( + "Exoplanets and Earth", + null, + 2009, + "9191919-17", + new BigDecimal("43.22"), + null, + true + ); + + BookHash bookHashA = new BookHash(); + bookHashA.setBook(bookA); + bookA.setBookHash(bookHashA); + + bookRepository.save(bookA); + + bookHashA.setBookId(null); + bookHashRepository.save(bookHashA); + bookHashRepository.findAll().forEach(System.out::print); + }); + + } + + ////////////////////////////// + + @Test + public void testP_DeleteAuthorBookHasAuthorConstraintShouldFail() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + Author authorA = authorRepository.save(new Author("Hor", "Ror")); + + bookRepository.save(new Book( + "Twisted adventures in Elvenwood treehouse", + authorA, + 2006, + "7575757-15", + new BigDecimal("11.99"), + null, + false + ) + ); + + authorRepository.delete(authorA); + bookRepository.findAll().forEach(System.out::print); + }); + } + + @Test + public void testQ_DeleteCategoryBookHasCategoryConstraintShouldFail() { + + assertThrows( + DataIntegrityViolationException.class, () -> { + Category categoryA = categoryRepository.save(new Category("Mystery")); + + bookRepository.save(new Book( + "Ruins of Rkund", + null, + 2009, + "7575757-15", + new BigDecimal("11.99"), + categoryA, + true + ) + ); + + categoryRepository.delete(categoryA); + bookRepository.findAll().forEach(System.out::print); + }); + } + +} \ No newline at end of file