Contract test by using composition

EmployeeRepositoryContractTest.kt

class EmployeeRepositoryContractTest {

    @ParameterizedTest(name = "Find all: {arguments}")
    @ArgumentsSource(EmployeeRepositoryTestFactoryArgumentsProvider::class)
    internal fun `find all`(factory: EmployeeRepositoryTestFactory) {
        val employeeRepository = factory.withData()

        val employees = employeeRepository.findAll()

        assertThat(employees).containsExactlyInAnyOrder(
            ONE_EMPLOYEE,
            ANOTHER_EMPLOYEE
        )
    }

    @ParameterizedTest(name = "No Employee: {arguments}")
    @ArgumentsSource(EmployeeRepositoryTestFactoryArgumentsProvider::class)
    internal fun `no employee`(factory: EmployeeRepositoryTestFactory) {
        val employeeRepository = factory.noData()

        val employees = employeeRepository.findAll()

        assertThat(employees).isEmpty()
    }

    @ParameterizedTest(name = "Unexpected error: {arguments}")
    @ArgumentsSource(EmployeeRepositoryTestFactoryArgumentsProvider::class)
    internal fun `unexpected error occurred`(factory: EmployeeRepositoryTestFactory) {
        val employeeRepository = factory.failing()

        assertThrows<EmployeeRepositoryException> {
            employeeRepository.findAll()
        }
    }

    class EmployeeRepositoryTestFactoryArgumentsProvider: ArgumentsProvider {
        override fun provideArguments(context: ExtensionContext?): Stream<out Arguments> =
            Stream.of(
                Arguments.of(InMemory()),
                Arguments.of(FromFile())
            )
        }

    interface EmployeeRepositoryTestFactory{

        fun withData(): EmployeeRepository

        fun noData(): EmployeeRepository

        fun failing(): EmployeeRepository
    }

    class InMemory : EmployeeRepositoryTestFactory {
        override fun withData(): EmployeeRepository  =
            InMemoryEmployeeRepository(listOf(ONE_EMPLOYEE, ANOTHER_EMPLOYEE))

        override fun noData(): EmployeeRepository =
            InMemoryEmployeeRepository(emptyList())

        override fun failing(): EmployeeRepository =
            InMemoryEmployeeRepository(employees = emptyList(), fail = true)
    }

    class FromFile: EmployeeRepositoryTestFactory {
        override fun withData(): EmployeeRepository =
            FromFileEmployeeRepository(Path.of("src", "test", "resources", "employees.csv"))

        override fun noData(): EmployeeRepository =
            FromFileEmployeeRepository(Path.of("src", "test", "resources", "empty_employees.csv"))

        override fun failing(): EmployeeRepository =
            FromFileEmployeeRepository(Path.of("not-exising-path"))
    }

    companion object {
        private val ONE_EMPLOYEE = Employee(
            "John",
            LocalDate.of(1982, Month.OCTOBER, 8),
            "john.doe@foobar.com"
        )
        private val ANOTHER_EMPLOYEE = Employee(
            "Mary",
            LocalDate.of(1975, Month.SEPTEMBER, 11),
            "mary.ann@foobar.com"
        )
    }
}