Come posso confrontare POJO per i loro campi in modo riflessivo

Question

Sono fondamentalmente alla ricerca di un framework di testing unitario, che possa essere utilizzato per confrontare POJO che non sovrascrivano i metodi equals e hascode. Ho dato un'occhiata a JUnit, Test NG e Mockito ma non sembrano risolvere lo scopo.

Ad esempio si consideri il codice qui sotto:

public class CarBean { 

    private String brand; 
    private String color; 

    public CarBean(){ 
    } 

    public CarBean (String brand, String color){ 
     this.brand= brand; 
     this.color= color; 
    } 

    /** 
    * @return the brand 
    */ 
    public String getBrand() { 
     return brand; 
    } 

    /** 
    * @param the brand to set 
    */ 
    public void setBrand(String brand) { 
     this.brand= brand; 
    } 

    /** 
    * @return the color 
    */ 
    public String getColor() { 
     return color; 
    } 

    /** 
    * @param the color to set 
    */ 
    public void setColor(String color) { 
     this.color= color; 
    } 
} 

Il POJO CarBean rappresenta una vera e propria world car. Ha due parametri, marca e colore. Ora, supponiamo di avere due oggetti auto come di seguito:

CarBean car1 = new CarBean("Ford","Black"); 
CarBean car2 = new CarBean("Ford","Black"); 

Entrambi gli oggetti hanno gli stessi valori di parametro. Ma quando si confronta questo con eguali, restituisce false:

car1.equals(car2); // This returns false 

Ora ho bisogno di unit test un metodo che restituisce oggetto CarBean. In questo scenario, avrei bisogno di confrontare gli attributi carbean uno per uno o avrei bisogno di implementare i metodi equals() e hashcode().

Quindi la mia domanda è: esiste già un framework di test delle unità in grado di gestirlo?

Answer 1

Unitils sembra risolvere lo scopo per me. Le seguenti API possono confrontare gli oggetti in modo riflessivo. Si può confrontare anche se gli attributi di un POJO stessi sono definiti dall'utente POJO:

import static org.unitils.reflectionassert.ReflectionAssert.*; 

// Exact field-by-field comparison 
assertReflectionEquals(new Person("John", "Doe", new Address("New street", 5, "Brussels")), 
           new Person("John", "Doe", new Address("New street", 5, "Brussels")); 

// Ignore Null/0 values in the expected object 
assertReflectionEquals(new Person("John", null, new Address("New street", 0, null)), 
           new Person("John", "Doe", new Address("New street", 5, "Brussels"), 
           ReflectionComparatorMode.IGNORE_DEFAULTS); 

// Ignore collection order 
assertReflectionEquals(Arrays.asList(new Person("John"), new Person("Jane")), 
           new Person[] {new Person("Jane"), new Person("John")}, 
           ReflectionComparatorMode.LENIENT_ORDER); 

// Ignore null/0 values + collection order 
assertLenientEquals(Arrays.asList(new Person("John"), null), 
           new Person[] {new Person("Jane", "Doe"), new Person("John", "Doe")}); 

// Check only the firstName property 
assertPropertyLenientEquals("firstName", Arrays.asList("John", "Jane"), 
           new Person[] {new Person("Jane", "Doe"), new Person("John", "Doe")}); 

Ulteriori informazioni sul sito Unitils Cookbook

Answer 2

Dal momento che questo sarebbe probabilmente essere implementato usando riflessione "riflessione è uguale a" è un termine di ricerca ragionevole, e in effetti Google trova:

http://www.unitils.org/tutorial-reflectionassert.html

Answer 3

Nulla vi impedisce di scrivere il proprio confronto

Utilizzando JUnit :

scrivere un metodo statico che prende 2 oggetti e fa le affermazioni che si desidera:

public static void sameBrandAndColor(Car expected, Car actual){ 
    assertEquals(expected.getBrand(), actual.getBrand()); 
    assertEquals(expected.getColor(), actual.getColor()); 
} 

Quindi nei test basta invece chiamare il metodo di confronto.

@Test 
public void test(){ 
    ... 
    sameBrandAndColor(car1, car2); 
} 

Answer 4

Questo tipo di riflessione è integrato nel Hamcrest come SamePropertyValuesAs, che confronta proprietà del bean-nome (getFoo, Isbar) al posto dei campi che probabilmente li alimentano. Il supporto di Core Hamcrest è incorporato in JUnit, quindi devi solo aggiungere la libreria di Hamcrest che include il matcher SamePropertyValuesAs.

assertThat(car1, samePropertyValuesAs(car2)); 

Answer 5

Override toString() metodo nella classe POJO come di seguito

@Override 
public String toString() { 
    return "brand: " + this.brand + ",color: " + this.color; 
} 


car1.toString().equals(car2.toString()); //It will return true 

Nel caso in cui tu abbia grandi numeri di parametro ti suggerisco di andare con il codice seguente:

public static boolean comparePOJO(Object obj1, Object obj2) { 
    return new Gson().toJson(obj1).equals(new Gson().toJson(obj2)); 
} 
comparePOJO(car1,car2); //It will return true