Uno de los conceptos más desconocidos, pero a su vez más vividos, por los programadores es el «flaky test». Este concepto viene a referirse a la debilidad que tienen nuestros tests ya que son inestables y frágiles a cualquier cambio externo. Es decir, que el test se puede comportar diferente en cada ejecución presentando diferentes resultados (exitoso o fallido) sin haber realizado cambios en el código o en el test.

Imagina que tienes un caso de uso que matricula a un estudiante con un curso determinado.

class EnrollmentStudentUseCase
{
    private EnrollmentRepositoryInterface $enrollmentRepository;
    private CourseApi $courseApi;

    public function __construct(
        EnrollmentRepositoryInterface $enrollmentRepository,
        CourseApi $courseApi
    ) {
        $this->enrollmentRepository = $enrollmentRepository;
        $this->courseApi = $courseApi;
    }

    public function make(
        EnrollmentId $id,
        EnrollmentStudentId $studentId,
        EnrollmentCourseId $courseId
    ): void {
        $course = $this->courseApi->findByCourseId($courseId);

        $enrollment = Enrollment::make(
            $id,
            $studentId,
            $courseId,
            $course->title()
        );

        $this->enrollmentRepository->save($enrollment);
    }
}

Prueba unitaria

final class EnrollmentStudentUseCaseTest extends MockeryTestCase
{
    /** @test */
    public function it_should_enroll_student(): void
    {
        list($id, $title, $studentId, $courseId) = EnrollmentFaker::createValueObjectOne();
        $enrollmentRepositoryInterfaceMock = $this->createEnrollmentRepositoryInterfaceMock();
        $courseApi = new CourseApi();
        $enrollmentMaker = new EnrollmentStudentUseCase($enrollmentRepositoryInterfaceMock, $courseApi);

        $enrollmentMaker->make($id, $studentId, $courseId);
    }

    private function createEnrollmentRepositoryInterfaceMock(): EnrollmentRepositoryInterface
    {
        $mock = \Mockery::mock(EnrollmentRepositoryInterface::class);

        $mock->shouldReceive('save')->once()->withArgs([Enrollment::class])->andReturnNull();

        return $mock;
    }
}

El test depende de un servicio externo (CourseApi), si este servicio es bastante inestable el test fallará. Con lo cual, tendremos un flaky test. Una forma de resolver esto es mockeando la dependencia que tiene el caso de uso.

A continuación dejo una lista de cosas que pueden hacer que nuestro tests se conviertan en un flaky test.

• Timeouts

• Asynchronous Waits

• Cache

• Order dependency

• Time of day