Building a Basic Web Application | Part-03

<dependencies>
    ...
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <version>1.4.196</version>
    </dependency>
</dependencies>

@Configuration
@EnableJpaAuditing
public class RepoConfig {

}

spring.jpa.hibernate.ddl-auto=create
spring.jpa.properties.hibernate.format_sql=true
spring.jpa.properties.hibernate.show_sql=true

spring.datasource.driver-class-name=org.h2.Driver
spring.datasource.url=jdbc:h2:~/retroboard
spring.datasource.username=sa
spring.datasource.password=

• Uses spring.jpa.hibernate.ddl-auto to set automatically generate Data Definition Language (DDL) SQL
• Uses spring.jpa.properties.hibernate.format_sql to format SQL generated in a visually pleasing manner
• Uses spring.jpa.properties.hibernate.show_sql to show the SQL generated
• Uses spring.datasource.driver-class-name to set org.h2.Driver as the database driver

• Uses spring.datasource.url to set the JDBC URL
• Uses spring.datasource.username to set the username for the H2 database
• Uses spring.datasource.password to set the password for the H2 database

In order to successfully populate the createdUser property, the AuditAware interface needs to be implemented to supply the username and needs to be registered as a Spring Component. More on this in the Using Spring Security for authentication and authorization section.

Implementing the domain model Comment class using JPA annotations will look like the following:

@Entity
@Table(name = "rb_comment")
@EntityListeners(AuditingEntityListener.class)
@Data
public class Comment {

@Id
    @GeneratedValue
private Long id;

    private String comment;

@Enumerated(EnumType.STRING)
private CommentType type;

@CreatedDate
private Timestamp createdDate;

@CreatedBy
private String createdBy;

}

In the preceding code, the @Entity annotation is used to mark the Comment class as a JPA entity so that it will be eligible to be used in JPA persistence environment. The @Table annotation is used to mention the table name to which the Comment class needs to be mapped. The @EntityListeners annotation is used with the AuditingEntityListener implementation to dynamically populate the createdDate and createdBy properties annotated with @CreatedDate and @CreatedBy in the Comment domain model when persisting the comment entry into the table. The @Data annotation is from the Lombok library and used to mark a POJO as a class that will hold data. This means getters, setters, the equals method, the hashCode method, and the toString method will be generated for that class.

The @Id annotation marks the ID property as the identity field of the entity, whereas @GeneratedValue marks it as an auto-generated value. The @Enumerated annotation with value EnumType.STRING on the type property is used to notify JPA that the value of the enum CommentType needs to be persisted as a String type in the database.

Implementing the domain model User will look like the following:

@Entity
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

@Id
@GeneratedValue
private Long id;

    private String username;

    private String password;

    private String role;

}

Implementation of Spring Data JPA repositories

With the domain model implemented successfully, the JpaRepository for those can be implemented using Spring Data JPA. The specialty here is that there is no need to implement anything. Just writing an interface that extends from the JpaRepository interface will be sufficient to expose methods to find one, find all, save, delete, and so on. The following code shows CommentRepository:

public interface CommentRepository extends JpaRepository<Comment, Long> {

@Query("SELECT c FROM Comment c WHERE year(c.createdDate) = ?1 AND
     month(c.createdDate) = ?2 AND 
    day(c.createdDate) = ?3")
    List<Comment> findByCreatedYearAndMonthAndDay(int year, int month,
     int day);

}

Since a list of comments for a specific date needs to retrieved to be shown in the frontend, a custom method with a @Query annotation is added to the CommentRepository interface. This annotation is responsible for using a database-independent SQL query to filter out data from the database.

The following code shows UserRepository:

public interface UserRepository extends JpaRepository<User, Long> {

    User findByUsername(String username);
}

Testing Spring Data JPA repositories

Testing is an important part of software engineering and with Spring Boot 2.0 @DataJpaTest is introduced to ease the testing of JPA repositories. This annotation will use an embedded database for testing and will auto-configure TestEntityManager to verify the JPA Repository operations.

The following is the test for CommentRepository:

@RunWith(SpringRunner.class)
@DataJpaTest
public class CommentRepoTest {

@Autowired
private TestEntityManager testEntityManager;

@Autowired
private CommentRepository commentRepository;

@Test
public void
findByCreatedYearAndMonthAndDay_HappyPath_ShouldReturn1Comment() {
// Given
Comment comment = new Comment();
comment.setComment("Test");
comment.setType(CommentType.PLUS);
comment.setCreatedDate(new Timestamp(System.currentTimeMillis()));
testEntityManager.persist(comment);
testEntityManager.flush();

// When
LocalDate now = LocalDate.now();
List<Comment> comments = 
         commentRepository.findByCreatedYearAndMonthAndDay(now.getYear(), 
         now.getMonth().getValue(), now.getDayOfMonth());

// Then
assertThat(comments).hasSize(1);
assertThat(comments.get(0)).hasFieldOrPropertyWithValue("comment",
"Test");
}

@Test
public void save_HappyPath_ShouldSave1Comment() {
// Given
Comment comment = new Comment();
comment.setComment("Test");
comment.setType(CommentType.PLUS);
comment.setCreatedDate(new Timestamp(System.currentTimeMillis()));

// When
Comment saved = commentRepository.save(comment);

// Then
assertThat(testEntityManager.find(Comment.class,
saved.getId())).isEqualTo(saved);
}
}

The preceding test case uses a TestEntityManager private member auto-wired (auto-wiring private members should be kept to the minimum as it is not a best practice) to the JUnit test and persists Comment by flushing it to the temporary persistence using the TestEntityManager.flush method and then, in one test, tests whether it can be successfully retrieved using the CommentRepository.findByCreatedYearAndMonthAndDay method. Furthermore, in the next test, it tests whether it could successfully save a Comment.

The following is the test for UserRepository:

@RunWith(SpringRunner.class)
@DataJpaTest
public class UserRepoTest {

@Autowired
private TestEntityManager testEntityManager;

@Autowired
private UserRepository userRepository;

@Test
public void findByUsername_HappyPath_ShouldReturn1User() throws 
    Exception {
// Given
User user = new User();
user.setUsername("shazin");
user.setPassword("shaz980");
user.setRole("USER");
testEntityManager.persist(user);
testEntityManager.flush();

// When
User actual = userRepository.findByUsername("shazin");

// Then
assertThat(actual).isEqualTo(user);
}

@Test
public void save_HappyPath_ShouldSave1User() throws Exception {
// Given
User user = new User();
user.setUsername("shazin");
user.setPassword("shaz980");
user.setRole("USER");

// When
User actual = userRepository.save(user);

// Then
assertThat(actual).isNotNull();
assertThat(actual.getId()).isNotNull();
}
}

In order to ease the testing of database development via Spring Boot Devtools, a dependency can be used that will provide a GUI to visualize the tables created with the data when an embedded database such as H2 is used. This can be seen from the following code:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

With this Spring Boot Devtools enabled after the Spring Boot application’s startup, accessing the http://<host>:<port>/h2-console (the port will be the same port as the Spring Boot application) URL will display the following H2 database console for ease of development:

After clicking the Connect button with the correct parameters, the following screen with database tables and users will be displayed:

It is a good practice to encapsulate business logic inside Service methods so that controllers and repositories are loosely coupled. The following Service is written to encapsulate business logic for Comment:

@Service
@Transactional(readOnly = true)
public class CommentService {

private static final Logger LOGGER = LoggerFactory.getLogger(CommentService.class);

 private final CommentRepository commentRepository;

 public CommentService(CommentRepository commentRepository) {
this.commentRepository = commentRepository;
}

@Transactional(rollbackFor = Exception.class)
public List<Comment> saveAll(List<Comment> comments) {
LOGGER.info("Saving {}", comments);
 return commentRepository.saveAll(comments);
}

public List<Comment> getAllCommentsForToday() {
 LocalDate localDate = LocalDate.now();
 return commentRepository.findByCreatedYearAndMonthAndDay(localDate.getYear(), 
 localDate.getMonth().getValue(), localDate.getDayOfMonth());
}
}

The CommentService method in the preceding code is annotated with the @Service stereotype annotation to mark it as a Spring service. Also, it has the @Transactional annotation (learn more about Spring Transaction in the reference documentation). The CommentRepository will be auto-wired using the CommentService constructor argument. Another notable thing is that the CommentService.saveAll method is annotated with the @Transactional annotation with rollbackFor set to the Exception class. This means that any code inside that method will be enclosed inside a transaction and, if an exception is thrown, JpaTransactionManager will roll back the changes it made in the database within that transaction.

Likewise, the following UserService is used for User:

@Service
@Transactional(readOnly = true)
public class UserService implements UserDetailsService {

private final UserRepository userRepository;

 public UserService(UserRepository userRepository) {
this.userRepository = userRepository;
}

@Override
public UserDetails loadUserByUsername(String username) throws 
 UsernameNotFoundException {
 User user = userRepository.findByUsername(username);

 if(user == null) {
throw new UsernameNotFoundException(username);
}

return new 
 org.springframework.security.core.userdetails.User(user.getUsername(), user.getPassword(), 
 Arrays.asList(new SimpleGrantedAuthority(user.getRole())));
}

@Transactional(rollbackFor = Exception.class)
public User create(User user) {
return userRepository.save(user);
}
}

Services with business logic need to be tested for their correct functionality. In order to do this, Services like the following one can be used:

@RunWith(SpringRunner.class)
public class CommentServiceTest {

@MockBean
private CommentRepository commentRepository;

    private CommentService commentService;

@Before
public void init() {
commentService = new CommentService(commentRepository);
}

@Test
public void 
       getAllCommentsForToday_HappyPath_ShouldReturn1Comment() {
// Given
Comment comment = new Comment();
comment.setComment("Test");
comment.setType(CommentType.PLUS);
comment.setCreatedDate(new 
            Timestamp(System.currentTimeMillis()));
List<Comment> comments = Arrays.asList(comment);
LocalDate now = LocalDate.now();


        when(commentRepository.findByCreatedYearAndMonthAndDay(now.getYear(), now.getMonth().getValue(), 
         now.getDayOfMonth())).thenReturn(comments);

// When
List<Comment> actualComments = 
         commentService.getAllCommentsForToday();

// Then
verify(commentRepository, 
          times(1)).findByCreatedYearAndMonthAndDay(now.getYear(), 
          now.getMonth().getValue(), now.getDayOfMonth());
assertThat(comments).isEqualTo(actualComments);
}

@Test
public void saveAll_HappyPath_ShouldSave2Comments() {
// Given
Comment comment = new Comment();
comment.setComment("Test Plus");
comment.setType(CommentType.PLUS);
comment.setCreatedBy("Shazin");
comment.setCreatedDate(new 
          Timestamp(System.currentTimeMillis()));

Comment comment2 = new Comment();
comment2.setComment("Test Star");
comment2.setType(CommentType.STAR);
comment2.setCreatedBy("Shahim");
comment2.setCreatedDate(new  
          Timestamp(System.currentTimeMillis()));
List<Comment> comments = Arrays.asList(comment, comment2);
when(commentRepository.saveAll(comments)).thenReturn(comments);

// When
List<Comment> saved = commentService.saveAll(comments);

// Then
assertThat(saved).isNotEmpty();
verify(commentRepository, times(1)).saveAll(comments);

}
}

In the preceding test case for CommentService, CommentRepository is annotated with @MockBean, as testing of its functionality has already been done in the JPA repository testing. During Service, test mocking is done using the Mockito library to just mock repository method invocations and verify the correct invocation.

The following is the service test case for UserService:

@RunWith(SpringRunner.class)
public class UserServiceTest {

@MockBean
private UserRepository userRepository;

    private UserService userService;

@Before
public void init() {
this.userService = new UserService(userRepository);
}

@Test
public void getAllCommentsForToday_HappyPath_ShouldReturn1Comment() {
// Given
User user = new User();
user.setUsername("shazin");
user.setPassword("sha908");
user.setRole("USER");

when(userRepository.findByUsername("shazin")).thenReturn(user);

// When
UserDetails actual = userService.loadUserByUsername("shazin");

// Then
verify(userRepository, times(1)).findByUsername("shazin");
}

}

In the preceding test case, the UserRepository.findByUsername method is mocked to return a given user and finally verify whether that method is invoked exactly once.