如何使用spock检查深层对象是否相等。
假设我们有一个超级简单的测试，可以与相同的人物对象进行比较
def "A persons test"() {
setup:
def person1 = new Person("Foo", new Address("Bar"))
def person2 = new Person("Foo", new Address("Bar"))
expect:
person1 == person2
}
测试失败
Condition not satisfied:
person1 == person2
| | |
| | Person@6bedbc4d
| false
Person@57af006c
这看起来像是一种断言平等的非常自然的方式。
开始使用spock的一个主要原因是避免编写大量的hamcrest样板匹配器代码。
答案 0 :(得分：5)
Spock没有用于执行深度对象比较的内置机制，因为定义对象相等性超出了任何测试框架的范围。你可以做各种各样的事情。
如果您的类（Person和Address）都是Groovy类，则可以使用equals注释生成hashCode和@EqualsAndHashCode个方法，例如：
import groovy.transform.EqualsAndHashCode
import groovy.transform.TupleConstructor
import spock.lang.Specification
class PersonSpec extends Specification {
def "a person test"() {
setup:
def person1 = new Person("Foo", new Address("Bar"))
def person2 = new Person("Foo", new Address("Bar"))
expect:
person1 == person2
}
@TupleConstructor
@EqualsAndHashCode
static class Person {
String name
Address address
}
@TupleConstructor
@EqualsAndHashCode
static class Address {
String city
}
}
这只是在Groovy中实现这两种方法的一种方便的替代方法。
如果您想将这两个对象与==运算符进行比较，那么您必须在两个类中定义equals和hashCode方法，例如：
public final class Person {
private final String name;
private final Address address;
public Person(String name, Address address) {
this.name = name;
this.address = address;
}
public String getName() {
return name;
}
public Address getAddress() {
return address;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
if (name != null ? !name.equals(person.name) : person.name != null) return false;
return address != null ? address.equals(person.address) : person.address == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + (address != null ? address.hashCode() : 0);
return result;
}
static class Address {
private final String city;
public Address(String city) {
this.city = city;
}
public String getCity() {
return city;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Address address = (Address) o;
return city != null ? city.equals(address.city) : address.city == null;
}
@Override
public int hashCode() {
return city != null ? city.hashCode() : 0;
}
}
}
在此示例中，两个方法都是使用IntelliJ IDEA“Generate equals and hashCode”命令定义的。
如果您不想手动定义这两个方法（因为您必须记住在修改类字段时必须记住更改它们），那么您可以使用类似于Groovy注释的Lombok's @EqualsAndHashCode annotation，但是适用于任何Java类。
equals和hashCode方法嗯，在这种情况下，您可以尝试各种各样的事情：
您可以尝试逐个比较两个对象，例如：
class PersonSpec extends Specification {
def "a person test"() {
setup:
def person1 = new Person("Foo", new Address("Bar"))
def person2 = new Person("Foo", new Address("Bar"))
expect:
person1.name == person2.name
and:
person1.address.city == person2.address.city
}
@TupleConstructor
static class Person {
String name
Address address
}
@TupleConstructor
static class Address {
String city
}
}
您可以尝试使用第三方工具，例如Unitils reflection assertion
这可能听起来很奇怪，但您可以比较两个对象的JSON表示，例如：
import groovy.json.JsonOutput
import groovy.transform.TupleConstructor
import spock.lang.Specification
class PersonSpec extends Specification {
def "a person test"() {
setup:
def person1 = new Person("Foo", new Address("Bar"))
def person2 = new Person("Foo", new Address("Bar"))
expect:
new JsonOutput().toJson(person1) == new JsonOutput().toJson(person2)
}
@TupleConstructor
static class Person {
String name
Address address
}
@TupleConstructor
static class Address {
String city
}
}
无论如何，我肯定建议以这种或那种方式定义equals和hashCode，并简单地使用==运算符。希望它有所帮助。
答案 1 :(得分：0)
看来，你需要纠正覆盖你的equals和hashcode方法。 在Groovy中，它可以非常轻松地完成，您需要使用@Canonical注释。它为您提供的不仅仅是equals和hashcode，还可以买到。
答案 2 :(得分：-1)
您可以利用Groovy简洁的地图比较语法：
person1.properties == person2.properties
仅适用于简单的平面对象，不适用于嵌套的对象。您可以像这样修改它：
person1.properties << ['address': person1.address.properties] == person2.properties << ['address': person2.address.properties]
...但是JSON解决方案在那时更优雅。