Integration Tests With Testcontainers

package com.example.demo.repository;

import com.example.demo.entity.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {

    User findByUsername(String username);
}

package com.example.demo.entity;

import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private long id;
    @Column(unique = true)
    private String username;
    @Column(unique = true)
    private String email;
    @JsonIgnore
    private String password;
    private String firstName;
    private String lastName;
    private String phoneNumber;
}

package com.example.demo.repository;

import com.example.demo.entity.User;
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.util.TestPropertyValues;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;

import static org.junit.jupiter.api.Assertions.*;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@ContextConfiguration(initializers = UserRepositoryTest.Initializer.class)
class UserRepositoryTest {

    @Autowired
    private UserRepository userRepository;
    
    @Test
    void findByUsername() {

        User john = User.builder()
                .username("johnsmith")
                .email("johnsmith@example.com")
                .password("john-some-secret-password")
                .firstName("John")
                .build();

        User savedUser = userRepository.save(john);

        assertEquals(1, savedUser.getId());
        assertEquals(john, userRepository.getOne(1L));
        assertEquals(john, userRepository.findByUsername("johnsmith"));

        User anna = User.builder()
                .username("annasmith")
                .email("annasmith@example.com")
                .password("anna-some-secret-password")
                .firstName("Anna")
                .build();

        savedUser = userRepository.save(anna);

        assertEquals(2, savedUser.getId());
        assertEquals(anna, userRepository.getOne(2L));
        assertEquals(anna, userRepository.findByUsername("annasmith"));
    }

    public static class Initializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

        @Container
        private static MySQLContainer<?> mysql = new MySQLContainer<>("mysql:8");

        static {
            mysql.start();
        }

        @Override
        public void initialize(ConfigurableApplicationContext applicationContext) {

            TestPropertyValues.of(
                    "spring.jpa.hibernate.ddl-auto=none",
                    "spring.datasource.initialization-mode=always",
                    "spring.datasource.platform=mysql",
                    "spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true",
                    "spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver",
                    "spring.datasource.url=" + mysql.getJdbcUrl(),
                    "spring.datasource.username=" + mysql.getUsername(),
                    "spring.datasource.password=" + mysql.getPassword(),
                    "spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQLDialect",
                    "spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true",
                    "spring.liquibase.change-log=classpath:/db/changelog/db.changelog-master.xml",
                    "spring.liquibase.contexts=test",
                    "logging.level.liquibase=INFO"
            ).applyTo(applicationContext);
        }
    }
}