¿Existe una alternativa de Java a AutoFixture de Ploeh para.Net?

unit-testing mocking

Question

Estoy buscando una herramienta Java que pueda crear variables anónimas (variables cuyo valor no me importa) en mis pruebas, similar a AutoFixture en .Net. Aquí hay un enlace al archivo Léame de AutoFixture , que tiene buenos ejemplos de lo que hace.

Aquí hay un breve ejemplo tomado del mismo archivo Léame:

[TestMethod]
public void IntroductoryTest()
{
    // Fixture setup
    Fixture fixture = new Fixture();

    int expectedNumber = fixture.CreateAnonymous<int>();
    MyClass sut = fixture.CreateAnonymous<MyClass>();
    // Exercise system
    int result = sut.Echo(expectedNumber);
    // Verify outcome
    Assert.AreEqual<int>(expectedNumber, result, "Echo");
    // Teardown
}

¿Existe tal herramienta en el mundo de Java?

Editar:

Intenté QuickCheck y mientras conseguía hacer algo como lo que estaba buscando:

import net.java.quickcheck.Generator;
import net.java.quickcheck.generator.PrimitiveGenerators;
import net.java.quickcheck.generator.support.ObjectGeneratorImpl;

public class Main {

interface Test{
     String getTestValue();
}

public static void main(String[] args) {
    Generator<String> stringGen = PrimitiveGenerators.strings(5, 100);
    Generator<Integer> intGen = PrimitiveGenerators.integers(5, 20);

    ObjectGeneratorImpl<Test> g = new ObjectGeneratorImpl<>(Test.class);
    g.on(g.getRecorder().getTestValue()).returns(stringGen);


    for (int i = 0; i < intGen.next(); i++) {
        System.out.println("value of testValue is: " + g.next().getTestValue());
    }
}

}

La herramienta parece funcionar solo con interfaces. Si cambio la Prueba para que sea una clase y el método se convierta en un campo, el generador arroja una excepción que solo admite interfaces.

Espero sinceramente que haya algo mejor, especialmente porque la documentación está muy ausente.

Answer 1

Estoy usando github largo de Mockito .spy () para eso;)

Veamos un ejemplo de cómo hacer algo que sería trivial con AutoFixture y C #. La idea aquí es generar datos aleatorios en su objeto, excepto por algunos métodos específicos que necesitan tener valores específicos. Es interesante que no encontré ese lugar indicado. Esta técnica elimina la parte "Organizar" de sus pruebas unitarias para que sea una pequeña cantidad de líneas y, además, se centra en qué valores deben ser específicos para que pase esta prueba unitaria

public class SomeClass {
    public int id; //field I care
    public String name; // fields I don''t care
    public String description; //fields I don''t care

    public int getId(){
        return id;
    } 

    public void setId(int id){
        this.id = id;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public String getDescription(){
        return description;
    }

    public void setDescirption(String description){
        this.description = description;
    }
}



public static void main(String args[]){
    JFixture fixture = new JFixture();
    fixture.customise().circularDependencyBehaviour().omitSpecimen(); //omit circular dependencies
    fixture.customise().noResolutionBehaviour().omitSpecimen(); // omit methods that cannot be resolved
    SomeClass entity = fixture.create(SomeClass.class);
    SomeClass mock = Mockito.spy(entity);
    Mockito.when(mock.getId()).thenReturn(3213);

    System.out.println(mock.getId()); // always 3213
    System.out.println(mock.getName()); // random
    System.out.println(mock.getDescription()); //random
}

Esto imprime:

3213
name9a800265-d8ef-4be9-bd45-f0b62f791d9c
descriptiona9f9245f-eba1-4805-89e3-308ef69e7091

Answer 2

Hay una implementación Java de QuickCheck, que tiene API para generar datos de prueba:

http://java.net/projects/quickcheck/pages/Home

No estoy muy familiarizado con AutoFixture, y sospecho que QuickCheck es un tipo de marco de prueba ligeramente diferente, pero tal vez sea útil para resolver su problema específico.

Answer 3

Ivan

Comencé un proyecto centrado en la reimplementación de las características principales de AutoFixture en java . AutoFixture tiene ciertamente muchas características, así que necesito priorizar cuáles implementar primero y cuáles no preocuparme en absoluto. A medida que el proyecto acaba de comenzar, doy la bienvenida a las pruebas, los informes de defectos y las solicitudes de funciones.

Answer 4

ObjectGenerator es más de una característica experimental:

ObjectGenerator<Test> objects = PrimitiveGenerators.objects(Test.class);
objects.on(objects.getRecorder().getTestValue()).returns(PrimitiveGenerators.strings());

Test next = objects.next();
System.out.println(next.getTestValue());

Preferiría una implementación de generador simple:

class TestGenerator implements Generator<Test>{
    Generator<String> values = PrimitiveGenerators.strings();
    @Override public Test next() {
        return new TestImpl(values.next());
    }   
}

Answer 5

Prueba la fábrica de objetos. Es de código abierto en github . Puede crear objetos Java aleatorios en una sola línea de código. Y es altamente configurable.

Ejemplo:

ObjectFactory rof = new ReflectionObjectFactory();

String str = rof.create(String.class);
Customer cus = rof.create(Customer.class);

También está disponible en el repositorio central de Maven.

Answer 6

También hay JFixture, que está disponible en github y publicado para maven central .

Esto todavía está en desarrollo activo, y las solicitudes de características se están cumpliendo.

Answer 7

Sin embargo, otro QuickCheck para Java es otra herramienta que probablemente puedas echar un vistazo.

Está muy integrado con JUnit (admite pruebas con parámetros, anotaciones para configurar los objetos generados, etc.).

Tiene muchos generadores (todos de comprobación rápida, y algunos específicos de OOP, como interfaces, clases abstractas y generadores de singleton), y puede definir los suyos propios. También hay un generador basado en el constructor.

Actualmente está en estado alfa, pero si echas un vistazo a la página de descargas , verás una documentación básica.