Hamcrest Matchers，Guava谓词和Builder设计模式

最新推荐文章于 2022-10-24 23:38:43 发布
最新推荐文章于 2022-10-24 23:38:43 发布
阅读量132 收藏
点赞数
文章标签： 设计模式 java 单元测试 python 正则表达式

通常，在编码时，我们必须处理其中包含数十个字段的一些POJO对象。 很多时候，我们通过一个带有数十个参数的构造函数来初始化这些类，这以任何可能的想象的方式都是可怕的。 除此之外，使用这些构造函数的函数几乎不可测试。 让我们仔细研究一下使用Builder来改变这种情况，以及Hamcrest匹配器和Guava Predicates对它进行单元测试。 让我们开始看一下POJO类。

SomeBigPojo.java

package pl.grzejszczak.marcin.junit.matchers.pojo;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 21:05
 */
public class SomeBigPojo {
    private String stringField0;
    private Integer integerField0;
    private Boolean booleanField0;
    private String stringField1;
    private Integer integerField1;
    private Boolean booleanField1;
    private String stringField2;
    private Integer integerField2;
    private Boolean booleanField2;
    private String stringField3;
    private Integer integerField3;
    private Boolean booleanField3;
    private String stringField4;
    private Integer integerField4;
    private Boolean booleanField4;
    private String stringField5;
    private Integer integerField5;
    private Boolean booleanField5;
    private String stringField6;
    private Integer integerField6;
    private Boolean booleanField6;
    private String stringField7;
    private String stringField8;
    private String stringField9;

    public SomeBigPojo(String stringField0, Integer integerField0, Boolean booleanField0, String stringField1, Integer integerField1, Boolean booleanField1, String stringField2, Integer integerField2, Boolean booleanField2, String stringField3, Integer integerField3, Boolean booleanField3, String stringField4, Integer integerField4, Boolean booleanField4, String stringField5, Integer integerField5, Boolean booleanField5, String stringField6, Integer integerField6, Boolean booleanField6, String stringField7, String stringField8, String stringField9) {
        this.stringField0 = stringField0;
        this.integerField0 = integerField0;
        this.booleanField0 = booleanField0;
        this.stringField1 = stringField1;
        this.integerField1 = integerField1;
        this.booleanField1 = booleanField1;
        this.stringField2 = stringField2;
        this.integerField2 = integerField2;
        this.booleanField2 = booleanField2;
        this.stringField3 = stringField3;
        this.integerField3 = integerField3;
        this.booleanField3 = booleanField3;
        this.stringField4 = stringField4;
        this.integerField4 = integerField4;
        this.booleanField4 = booleanField4;
        this.stringField5 = stringField5;
        this.integerField5 = integerField5;
        this.booleanField5 = booleanField5;
        this.stringField6 = stringField6;
        this.integerField6 = integerField6;
        this.booleanField6 = booleanField6;
        this.stringField7 = stringField7;
        this.stringField8 = stringField8;
        this.stringField9 = stringField9;
    }

    public String getStringField0() {
        return stringField0;
    }

    public void setStringField0(String stringField0) {
        this.stringField0 = stringField0;
    }

    public Integer getIntegerField0() {
        return integerField0;
    }

    public void setIntegerField0(Integer integerField0) {
        this.integerField0 = integerField0;
    }

    public Boolean getBooleanField0() {
        return booleanField0;
    }

    public void setBooleanField0(Boolean booleanField0) {
        this.booleanField0 = booleanField0;
    }

    public String getStringField1() {
        return stringField1;
    }

    public void setStringField1(String stringField1) {
        this.stringField1 = stringField1;
    }

    public Integer getIntegerField1() {
        return integerField1;
    }

    public void setIntegerField1(Integer integerField1) {
        this.integerField1 = integerField1;
    }

    public Boolean getBooleanField1() {
        return booleanField1;
    }

    public void setBooleanField1(Boolean booleanField1) {
        this.booleanField1 = booleanField1;
    }

    public String getStringField2() {
        return stringField2;
    }

    public void setStringField2(String stringField2) {
        this.stringField2 = stringField2;
    }

    public Integer getIntegerField2() {
        return integerField2;
    }

    public void setIntegerField2(Integer integerField2) {
        this.integerField2 = integerField2;
    }

    public Boolean getBooleanField2() {
        return booleanField2;
    }

    public void setBooleanField2(Boolean booleanField2) {
        this.booleanField2 = booleanField2;
    }

    public String getStringField3() {
        return stringField3;
    }

    public void setStringField3(String stringField3) {
        this.stringField3 = stringField3;
    }

    public Integer getIntegerField3() {
        return integerField3;
    }

    public void setIntegerField3(Integer integerField3) {
        this.integerField3 = integerField3;
    }

    public Boolean getBooleanField3() {
        return booleanField3;
    }

    public void setBooleanField3(Boolean booleanField3) {
        this.booleanField3 = booleanField3;
    }

    public String getStringField4() {
        return stringField4;
    }

    public void setStringField4(String stringField4) {
        this.stringField4 = stringField4;
    }

    public Integer getIntegerField4() {
        return integerField4;
    }

    public void setIntegerField4(Integer integerField4) {
        this.integerField4 = integerField4;
    }

    public Boolean getBooleanField4() {
        return booleanField4;
    }

    public void setBooleanField4(Boolean booleanField4) {
        this.booleanField4 = booleanField4;
    }

    public String getStringField5() {
        return stringField5;
    }

    public void setStringField5(String stringField5) {
        this.stringField5 = stringField5;
    }

    public Integer getIntegerField5() {
        return integerField5;
    }

    public void setIntegerField5(Integer integerField5) {
        this.integerField5 = integerField5;
    }

    public Boolean getBooleanField5() {
        return booleanField5;
    }

    public void setBooleanField5(Boolean booleanField5) {
        this.booleanField5 = booleanField5;
    }

    public String getStringField6() {
        return stringField6;
    }

    public void setStringField6(String stringField6) {
        this.stringField6 = stringField6;
    }

    public Integer getIntegerField6() {
        return integerField6;
    }

    public void setIntegerField6(Integer integerField6) {
        this.integerField6 = integerField6;
    }

    public Boolean getBooleanField6() {
        return booleanField6;
    }

    public void setBooleanField6(Boolean booleanField6) {
        this.booleanField6 = booleanField6;
    }

    public String getStringField7() {
        return stringField7;
    }

    public void setStringField7(String stringField7) {
        this.stringField7 = stringField7;
    }

    public String getStringField8() {
        return stringField8;
    }

    public void setStringField8(String stringField8) {
        this.stringField8 = stringField8;
    }

    public String getStringField9() {
        return stringField9;
    }

    public void setStringField9(String stringField9) {
        this.stringField9 = stringField9;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append("SomeBigPojo");
        sb.append("{stringField0='").append(stringField0).append('\'');
        sb.append(", integerField0=").append(integerField0);
        sb.append(", booleanField0=").append(booleanField0);
        sb.append(", stringField1='").append(stringField1).append('\'');
        sb.append(", integerField1=").append(integerField1);
        sb.append(", booleanField1=").append(booleanField1);
        sb.append(", stringField2='").append(stringField2).append('\'');
        sb.append(", integerField2=").append(integerField2);
        sb.append(", booleanField2=").append(booleanField2);
        sb.append(", stringField3='").append(stringField3).append('\'');
        sb.append(", integerField3=").append(integerField3);
        sb.append(", booleanField3=").append(booleanField3);
        sb.append(", stringField4='").append(stringField4).append('\'');
        sb.append(", integerField4=").append(integerField4);
        sb.append(", booleanField4=").append(booleanField4);
        sb.append(", stringField5='").append(stringField5).append('\'');
        sb.append(", integerField5=").append(integerField5);
        sb.append(", booleanField5=").append(booleanField5);
        sb.append(", stringField6='").append(stringField6).append('\'');
        sb.append(", integerField6=").append(integerField6);
        sb.append(", booleanField6=").append(booleanField6);
        sb.append(", stringField7='").append(stringField7).append('\'');
        sb.append(", stringField8='").append(stringField8).append('\'');
        sb.append(", stringField9='").append(stringField9).append('\'');
        sb.append('}');
        return sb.toString();
    }
}

现在看一下为了摆脱庞大构造函数的使用而使用的builder类。 而且，您可以设置任何所需的内容，而无需为不需要的字段输入null。

SomeBigPojoBuilder.java

package pl.grzejszczak.marcin.junit.matchers.builder;

import pl.grzejszczak.marcin.junit.matchers.pojo.SomeBigPojo;

import static com.google.common.base.Preconditions.checkNotNull;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 21:08
 */
public class SomeBigPojoBuilder {
    /** A field with some default value */
    private String stringField0 = "defaultValueForString0";
    /** A field with some default value */
    private Integer integerField0 = 100;
    /** A field with some default value */
    private Boolean booleanField0 = true;
    private String stringField1;
    private Integer integerField1;
    private Boolean booleanField1;
    private String stringField2;
    private Integer integerField2;
    private Boolean booleanField2;
    private String stringField3;
    private Integer integerField3;
    private Boolean booleanField3;
    private String stringField4;
    private Integer integerField4;
    private Boolean booleanField4;
    private String stringField5;
    private Integer integerField5;
    private Boolean booleanField5;
    private String stringField6;
    private Integer integerField6;
    private Boolean booleanField6;
    private String stringField7;
    private String stringField8;
    private String stringField9;

    public SomeBigPojoBuilder setStringField0(String stringField0) {
        this.stringField0 = stringField0;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField0(Integer integerField0) {
        this.integerField0 = integerField0;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField0(Boolean booleanField0) {
        this.booleanField0 = booleanField0;
        return this;
    }

    public SomeBigPojoBuilder setStringField1(String stringField1) {
        this.stringField1 = stringField1;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField1(Integer integerField1) {
        this.integerField1 = integerField1;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField1(Boolean booleanField1) {
        this.booleanField1 = booleanField1;
        return this;
    }

    public SomeBigPojoBuilder setStringField2(String stringField2) {
        this.stringField2 = stringField2;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField2(Integer integerField2) {
        this.integerField2 = integerField2;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField2(Boolean booleanField2) {
        this.booleanField2 = booleanField2;
        return this;
    }

    public SomeBigPojoBuilder setStringField3(String stringField3) {
        this.stringField3 = stringField3;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField3(Integer integerField3) {
        this.integerField3 = integerField3;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField3(Boolean booleanField3) {
        this.booleanField3 = booleanField3;
        return this;
    }

    public SomeBigPojoBuilder setStringField4(String stringField4) {
        this.stringField4 = stringField4;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField4(Integer integerField4) {
        this.integerField4 = integerField4;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField4(Boolean booleanField4) {
        this.booleanField4 = booleanField4;
        return this;
    }

    public SomeBigPojoBuilder setStringField5(String stringField5) {
        this.stringField5 = stringField5;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField5(Integer integerField5) {
        this.integerField5 = integerField5;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField5(Boolean booleanField5) {
        this.booleanField5 = booleanField5;
        return this;
    }

    public SomeBigPojoBuilder setStringField6(String stringField6) {
        this.stringField6 = stringField6;
        return this;
    }

    public SomeBigPojoBuilder setIntegerField6(Integer integerField6) {
        this.integerField6 = integerField6;
        return this;
    }

    public SomeBigPojoBuilder setBooleanField6(Boolean booleanField6) {
        this.booleanField6 = booleanField6;
        return this;
    }

    public SomeBigPojoBuilder setStringField7(String stringField7) {
        this.stringField7 = stringField7;
        return this;
    }

    public SomeBigPojoBuilder setStringField8(String stringField8) {
        this.stringField8 = stringField8;
        return this;
    }

    public SomeBigPojoBuilder setStringField9(String stringField9) {
        this.stringField9 = stringField9;
        return this;
    }

    /**
     * Some function checking the state of our POJO
     */
    private void checkState(){
        checkNotNull(stringField1, "StringField1 must not be null!");
    }

    public SomeBigPojo createSomeBigPojoWithBuilder() {
        checkState();
        return new SomeBigPojo(stringField0, integerField0, booleanField0, stringField1, integerField1, booleanField1, stringField2, integerField2, booleanField2, stringField3, integerField3, booleanField3, stringField4, integerField4, booleanField4, stringField5, integerField5, booleanField5, stringField6, integerField6, booleanField6, stringField7, stringField8, stringField9);
    }
}

看一下checkState函数，该函数验证对象是否处于所需状态。 这样，如果某些条件不完整，我们可能不允许创建对象。 对于这种情况，我们使用番石榴的谓词– checkNotNull方法。

请注意，Builder模式背后的概念是将对象的创建委托给Builder。 实际上，在纯Builder设计模式实现中，我们将必须具有Director，对Builder的一些抽象以及这样的Builder的具体实现。 在我们的例子中，我们简化了这种模式–我使用了IntelliJ的重构选项。 要使它看起来更好，可以做的是从POJO中删除构造函数，并仅通过setter传递值（这实际上是我在我的一个项目中所做的事情）。 现在让我们看一些用法示例：

SomeServiceImpl.java

package pl.grzejszczak.marcin.junit.matchers.service;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import pl.grzejszczak.marcin.junit.matchers.builder.SomeBigPojoBuilder;
import pl.grzejszczak.marcin.junit.matchers.pojo.SomeBigPojo;

import static java.lang.String.format;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 21:25
 */
public class SomeServiceImpl implements SomeService {
    private static final Logger LOGGER = LoggerFactory.getLogger(SomeServiceImpl.class);

    /** Could be an abstraction of builders injected by a setter - possible to mock */
    private SomeBigPojoBuilder someBigPojoBuilder;

    /**
     * Hard to unit test
     */
    @Override
    public void someLogicForAPojoWithoutBuilder() {
        LOGGER.debug("SomeLogicForAPojoWithoutBuilder executed");
        SomeBigPojo someBigPojo = new SomeBigPojo("string", 1, false, "other string", 123, true, "something else", 321, false, "yet another string", 111, true, "something", 2, false, "More", 3, true, "String", 12, false, "some", "value", "ofString");
        // Any chance of knowing what is the value of stringField8 basing on the constructor?
        LOGGER.debug(format("StringField8 is equal [%s]%n", someBigPojo.getStringField8()));
        // Print the object
        LOGGER.debug(someBigPojo.toString());
    }

    @Override
    public void someLogicForAPojoWithBuilder() {
        LOGGER.debug("SomeLogicForAPojoWithBuilder executed");
        SomeBigPojo someBigPojo = someBigPojoBuilder
                .setStringField0("string")
                .setIntegerField0(1)
                .setBooleanField0(false)
                .setStringField1("other string")
                .setIntegerField1(123)
                .setBooleanField1(true)
                .setStringField2("something else")
                .setIntegerField2(321)
                .setBooleanField2(false)
                .setStringField3("yet another string")
                .setIntegerField3(111)
                .setBooleanField3(false)
                .setStringField4("something")
                .setIntegerField4(2)
                .setBooleanField4(false)
                .setStringField5("More")
                .setIntegerField5(3)
                .setBooleanField5(true)
                .setStringField6("String")
                .setIntegerField6(12)
                .setBooleanField6(false)
                .setStringField7("some")
                .setStringField8("value")
                .setStringField9("ofString")
                .createSomeBigPojoWithBuilder();
        // Looking at the builder now I guess it's obvious what the value of StringField8
        LOGGER.debug(format("StringField8 is equal [%s]%n", someBigPojo.getStringField8()));
        // Print the object
        LOGGER.debug(someBigPojo.toString());
    }

    @Override
    public void someLogicForAPojoWithBuilderBadArgument() {
        LOGGER.debug("someLogicForAPojoWithBuilderBadArgument executed");
        SomeBigPojo someBigPojo = someBigPojoBuilder
                .setStringField0("string")
                .setIntegerField0(1)
                .setBooleanField0(true)
                .setIntegerField1(123)
                .setBooleanField1(true)
                .setStringField2("something else")
                .setIntegerField2(321)
                .setBooleanField2(false)
                .setStringField3("yet another string")
                .setIntegerField3(111).setBooleanField3(false)
                .setStringField4("something")
                .setIntegerField4(2)
                .setBooleanField4(false)
                .setStringField5("More")
                .setIntegerField5(3)
                .setBooleanField5(true)
                .setStringField6("String")
                .setIntegerField6(12)
                .setBooleanField6(false)
                .setStringField7("some")
                .setStringField8("value")
                .setStringField9("ofString")
                .createSomeBigPojoWithBuilder();
        // Print the object - will we even see an output
        LOGGER.debug(someBigPojo.toString());
    }

    public void setSomeBigPojoBuilder(SomeBigPojoBuilder someBigPojoBuilder) {
        this.someBigPojoBuilder = someBigPojoBuilder;
    }
}

请注意，现在创建对象非常清楚，定义一个字段是否已设置也很容易。

让我们继续进行Hamcrest匹配器，这将帮助我们对班级进行单元测试。 我不会尝试完成100％的完整代码覆盖-这篇文章的目的是说明Hamcrest Matchers如何成为您的单元测试的补充。 通常单元测试还不清楚，看起来像这样：

SomeBigPojoBuilderNoMatchersAndNoRefactoringTest.java

package pl.grzejszczak.marcin.junit.matchers.builder;

import org.junit.Before;
import org.junit.Test;
import pl.grzejszczak.marcin.junit.matchers.pojo.SomeBigPojo;

import static junit.framework.Assert.assertTrue;
import static org.apache.commons.lang.StringUtils.isNumeric;
import static pl.grzejszczak.marcin.junit.matchers.pojo.SomePojoConstants.*;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 23:02
 */
public class SomeBigPojoBuilderNoMatchersAndNoRefactoringTest {

    private SomeBigPojoBuilder objectUnderTest;

    @Before
    public void setUp() {
        objectUnderTest = new SomeBigPojoBuilder();
    }

    @Test
    public void testCreateSomeBigPojoWithBuilder() throws Exception {
        SomeBigPojo someBigPojo = objectUnderTest
                .setBooleanField1(true)
                .setStringField0("1")
                .setStringField1("12")
                .setStringField2("123")
                .setStringField3("1234")
                .setStringField4("12345")
                .setStringField5("123456")
                .setStringField6("1234567")
                .setStringField7("12345678")
                .setStringField8("123456789")
                .setStringField9("1234567890")
                .createSomeBigPojoWithBuilder();

        isPojoProperlyBuilt(someBigPojo);
    }

    @Test(expected = AssertionError.class)
    public void testCreateSomeBigPojoWithBuilderWrongFields() throws Exception {
        SomeBigPojo someBigPojo = objectUnderTest
                .setStringField0("0")
                .setStringField1("Too long")
                .createSomeBigPojoWithBuilder();

        isPojoProperlyBuilt(someBigPojo);
    }

    private void isPojoProperlyBuilt(SomeBigPojo someBigPojo) {
        assertTrue(someBigPojo.getStringField0().length() == STRING_FIELD_0_LENGTH);
        assertTrue(isNumeric(someBigPojo.getStringField0()));

        assertTrue(someBigPojo.getStringField1().length() == STRING_FIELD_1_LENGTH);
        assertTrue(isNumeric(someBigPojo.getStringField0()));

        assertTrue(someBigPojo.getStringField2().length() == STRING_FIELD_2_LENGTH);
        assertTrue(isNumeric(someBigPojo.getStringField0()));

        assertTrue(someBigPojo.getStringField3().length() == STRING_FIELD_3_LENGTH);
        assertTrue(isNumeric(someBigPojo.getStringField0()));

        assertTrue(someBigPojo.getStringField4().length() == STRING_FIELD_4_LENGTH);
        assertTrue(isNumeric(someBigPojo.getStringField0()));

        assertTrue(someBigPojo.getStringField5().length() == STRING_FIELD_5_LENGTH);

        assertTrue(someBigPojo.getStringField6().length() == STRING_FIELD_6_LENGTH);

        assertTrue(someBigPojo.getStringField7().length() == STRING_FIELD_7_LENGTH);

        assertTrue(someBigPojo.getStringField8().length() == STRING_FIELD_8_LENGTH);

        assertTrue(someBigPojo.getStringField9().length() == STRING_FIELD_9_LENGTH);

    }
}

简单的重构可以使它们看起来更好……

SomeBigPojoBuilderNoMatchersTest.java

package pl.grzejszczak.marcin.junit.matchers.builder;

import org.junit.Before;
import org.junit.Test;
import pl.grzejszczak.marcin.junit.matchers.pojo.SomeBigPojo;

import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertTrue;
import static org.apache.commons.lang.StringUtils.isNumeric;
import static pl.grzejszczak.marcin.junit.matchers.pojo.SomePojoConstants.*;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 23:02
 */
public class SomeBigPojoBuilderNoMatchersTest {

    private SomeBigPojoBuilder objectUnderTest;

    @Before
    public void setUp() {
        objectUnderTest = new SomeBigPojoBuilder();
    }

    @Test
    public void testCreateSomeBigPojoWithBuilder() throws Exception {
        SomeBigPojo someBigPojo = objectUnderTest
                .setBooleanField1(true)
                .setStringField0("1")
                .setStringField1("12")
                .setStringField2("123")
                .setStringField3("1234")
                .setStringField4("12345")
                .setStringField5("123456")
                .setStringField6("1234567")
                .setStringField7("12345678")
                .setStringField8("123456789")
                .setStringField9("1234567890")
                .createSomeBigPojoWithBuilder();

        isPojoProperlyBuilt(someBigPojo);
    }

    @Test(expected = AssertionError.class)
    public void testCreateSomeBigPojoWithBuilderWrongFields() throws Exception {
        SomeBigPojo someBigPojo = objectUnderTest
                .setStringField0("0")
                .setStringField1("too long")
                .createSomeBigPojoWithBuilder();

        isPojoProperlyBuilt(someBigPojo);
    }

    private void isPojoProperlyBuilt(SomeBigPojo someBigPojo) {
        isOfGivenLength(someBigPojo.getStringField0(), STRING_FIELD_0_LENGTH);
        isFieldOfNumericValue(someBigPojo.getStringField0());

        isOfGivenLength(someBigPojo.getStringField1(), STRING_FIELD_1_LENGTH);
        isFieldOfNumericValue(someBigPojo.getStringField0());

        isOfGivenLength(someBigPojo.getStringField2(), STRING_FIELD_2_LENGTH);
        isFieldOfNumericValue(someBigPojo.getStringField0());

        isOfGivenLength(someBigPojo.getStringField3(), STRING_FIELD_3_LENGTH);
        isFieldOfNumericValue(someBigPojo.getStringField0());

        isOfGivenLength(someBigPojo.getStringField4(), STRING_FIELD_4_LENGTH);
        isFieldOfNumericValue(someBigPojo.getStringField0());

        isOfGivenLength(someBigPojo.getStringField5(), STRING_FIELD_5_LENGTH);

        isOfGivenLength(someBigPojo.getStringField6(), STRING_FIELD_6_LENGTH);

        isOfGivenLength(someBigPojo.getStringField7(), STRING_FIELD_7_LENGTH);

        isOfGivenLength(someBigPojo.getStringField8(), STRING_FIELD_8_LENGTH);

        isOfGivenLength(someBigPojo.getStringField9(), STRING_FIELD_9_LENGTH);

    }

    private void isOfGivenLength(String pojo, final Integer expectedLength) {
        assertNotNull(pojo);
        assertTrue(expectedLength == pojo.length());
    }

    private void isFieldOfNumericValue(String field) {
        assertTrue(isNumeric(field));
    }
}

看起来不错，不是吗？ 以及使用Matchers代替函数呢？

SomeBigPojoBuilderTest.kava

package pl.grzejszczak.marcin.junit.matchers.builder;

import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.junit.Before;
import org.junit.Test;
import pl.grzejszczak.marcin.junit.matchers.pojo.SomeBigPojo;

import static java.lang.String.format;
import static junit.framework.Assert.assertTrue;
import static org.apache.commons.lang.StringUtils.isNumeric;
import static org.junit.Assert.assertThat;
import static pl.grzejszczak.marcin.junit.matchers.pojo.SomePojoConstants.*;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 23:02
 */
public class SomeBigPojoBuilderTest {

    private SomeBigPojoBuilder objectUnderTest;

    @Before
    public void setUp(){
        objectUnderTest = new SomeBigPojoBuilder();
    }

    @Test
    public void testCreateSomeBigPojoWithBuilder() throws Exception {
        SomeBigPojo someBigPojo = objectUnderTest
                .setBooleanField1(true)
                .setStringField0("1")
                .setStringField1("12")
                .setStringField2("123")
                .setStringField3("1234")
                .setStringField4("12345")
                .setStringField5("123456")
                .setStringField6("1234567")
                .setStringField7("12345678")
                .setStringField8("123456789")
                .setStringField9("1234567890")
                .createSomeBigPojoWithBuilder();

        assertThat(someBigPojo, isPojoProperlyBuilt());
    }

    @Test(expected = AssertionError.class)
    public void testCreateSomeBigPojoWithBuilderWrongFields() throws Exception {
        SomeBigPojo someBigPojo = objectUnderTest
                .setStringField0("0")
                .setStringField1("Too long")
                .createSomeBigPojoWithBuilder();

        assertThat(someBigPojo, isPojoProperlyBuilt());
    }

    /**
     * Let us assume that there is a specific business case that we have to take into consideration regarding some particular field
     *
     * @return
     */
    private static Matcher isPojoProperlyBuilt() {

        return new BaseMatcher() {

            @Override
            public boolean matches(Object o) {
                assertTrue(o instanceof SomeBigPojo);
                SomeBigPojo someBigPojo = (SomeBigPojo) o;
                assertThat(someBigPojo.getStringField0(), isOfGivenLength(STRING_FIELD_0_LENGTH));
                assertThat(someBigPojo.getStringField0(), isFieldOfNumericValue());

                assertThat(someBigPojo.getStringField1(), isOfGivenLength(STRING_FIELD_1_LENGTH));
                assertThat(someBigPojo.getStringField1(), isFieldOfNumericValue());

                assertThat(someBigPojo.getStringField2(), isOfGivenLength(STRING_FIELD_2_LENGTH));
                assertThat(someBigPojo.getStringField2(), isFieldOfNumericValue());

                assertThat(someBigPojo.getStringField3(), isOfGivenLength(STRING_FIELD_3_LENGTH));
                assertThat(someBigPojo.getStringField3(), isFieldOfNumericValue());

                assertThat(someBigPojo.getStringField4(), isOfGivenLength(STRING_FIELD_4_LENGTH));
                assertThat(someBigPojo.getStringField4(), isFieldOfNumericValue());

                assertThat(someBigPojo.getStringField5(), isOfGivenLength(STRING_FIELD_5_LENGTH));

                assertThat(someBigPojo.getStringField6(), isOfGivenLength(STRING_FIELD_6_LENGTH));

                assertThat(someBigPojo.getStringField7(), isOfGivenLength(STRING_FIELD_7_LENGTH));

                assertThat(someBigPojo.getStringField8(), isOfGivenLength(STRING_FIELD_8_LENGTH));

                assertThat(someBigPojo.getStringField9(), isOfGivenLength(STRING_FIELD_9_LENGTH));

                return true;
            }

            @Override
            public void describeTo(Description description) {
                description.appendText("Lengths of fields are limited and the first 4 fields are numeric");
            }
        };
    }

    private static Matcher isOfGivenLength(final Integer expectedLength) {

        return new BaseMatcher() {

            public boolean matches(Object o) {
                assertTrue(o instanceof String);
                return expectedLength == String.valueOf(o).length();
            }

            public void describeTo(Description description) {
                description.appendText(format("String's length should be equal to [%d]", expectedLength));
            }
        };
    }

    private static Matcher isFieldOfNumericValue() {

        return new BaseMatcher() {

            public boolean matches(Object o) {
                assertTrue(o instanceof String);
                return isNumeric(String.valueOf(o));
            }

            public void describeTo(Description description) {
                description.appendText("The value of the field should be numeric");
            }
        };
    }
}

以下主要方法执行服务的功能： 

package pl.grzejszczak.marcin.junit.matchers;

import pl.grzejszczak.marcin.junit.matchers.builder.SomeBigPojoBuilder;
import pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl;

/**
 * Created with IntelliJ IDEA.
 * User: mgrzejszczak
 * Date: 03.01.13
 * Time: 22:38
 */
public class MatcherMain {
    public static void main(String[] args){
        SomeServiceImpl someService = new SomeServiceImpl();

        someService.setSomeBigPojoBuilder(new SomeBigPojoBuilder());
        someService.someLogicForAPojoWithoutBuilder();

        someService.setSomeBigPojoBuilder(new SomeBigPojoBuilder());
        someService.someLogicForAPojoWithBuilder();

        someService.setSomeBigPojoBuilder(new SomeBigPojoBuilder());
        someService.someLogicForAPojoWithBuilderBadArgument();
    }
}

日志是： 

pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:27 SomeLogicForAPojoWithoutBuilder executed
pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:30 StringField8 is equal [value]
 
pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:32 SomeBigPojo{stringField0='string', integerField0=1, booleanField0=false, stringField1='other string', integerField1=123, booleanField1=true, stringField2='something else', integerField2=321, booleanField2=false, stringField3='yet another string', integerField3=111, booleanField3=true, stringField4='something', integerField4=2, booleanField4=false, stringField5='More', integerField5=3, booleanField5=true, stringField6='String', integerField6=12, booleanField6=false, stringField7='some', stringField8='value', stringField9='ofString'}
pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:37 SomeLogicForAPojoWithBuilder executed
pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:65 StringField8 is equal [value]
 
pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:67 SomeBigPojo{stringField0='string', integerField0=1, booleanField0=false, stringField1='other string', integerField1=123, booleanField1=true, stringField2='something else', integerField2=321, booleanField2=false, stringField3='yet another string', integerField3=111, booleanField3=false, stringField4='something', integerField4=2, booleanField4=false, stringField5='More', integerField5=3, booleanField5=true, stringField6='String', integerField6=12, booleanField6=false, stringField7='some', stringField8='value', stringField9='ofString'}
pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl:72 someLogicForAPojoWithBuilderBadArgument executed
Exception in thread "main" java.lang.NullPointerException: StringField1 must not be null!
 at com.google.common.base.Preconditions.checkNotNull(Preconditions.java:208)
 at pl.grzejszczak.marcin.junit.matchers.builder.SomeBigPojoBuilder.checkState(SomeBigPojoBuilder.java:166)
 at pl.grzejszczak.marcin.junit.matchers.builder.SomeBigPojoBuilder.createSomeBigPojoWithBuilder
(SomeBigPojoBuilder.java:170)
 at pl.grzejszczak.marcin.junit.matchers.service.SomeServiceImpl.someLogicForAPojoWithBuilderBadArgument
(SomeServiceImpl.java:73)
 at pl.grzejszczak.marcin.junit.matchers.MatcherMain.main(MatcherMain.java:23)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at com.intellij.rt.execution.application.AppMain.main(AppMain.java:120)

在我看来，这看起来确实不错。 那你呢？ 可在此处找到源代码，代码太多。


翻译自: https://www.javacodegeeks.com/2013/04/hamcrest-matchers-guava-predicate-and-builder-design-pattern.html

dnc8371
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Guava 风格之 Builder
abc123maxiaolong的专栏
06-03 488
    喜欢用guava的原因之一就是喜欢guava的编码风格，guava的fluent风格的api使用起来非常清爽，其中内部实现就使用了Builder模式       1 在使用不可变集合ImmutableList时，可以直接初始化：     ImmutableList<String> strings = ImmutableList.of("1", "2");     ...
源码分析：Guava Cache的使用以及源码分析-Builder
maoyeqiu的专栏
06-22 661
Guava Cache是性能非常高的本地缓存，其他的还有ehcache等。相对于本地缓存还有分布式缓存，其实就是独立于业务的第三方应用，比如redis、memcahe或者自己弄个机器加大内存，把它当作另外一个集群的分布式缓存同样是可以的，但是要做到高可用不是一件简单的事情。另外，内存缓存有个不可避免的问题是易丢失，所以要持久化的就老老实实弄一个redis或者直接入库。这里主要记录是标题的内容，话不...
guava cache 源码分析 -- builder 模式
JellyfishMIX 的博客
10-24 399
guava cache 的 builder 模式，Product 类有两个，一个是 LocalCache，一个是 LocalLoadingCache。可以认为 build 出来的是对外暴露的 Product 类–LocalLoadingCache，LocalLoadingCache 使用了内部的 Product 类 LocalCache。stats 方法，返回此 cache 的累积统计信息的当前快照。asMap 方法，返回一个线程安全的 map，此 map 是 cache 的视图。
Builder 模式在 Guava 中的应用
鸭梨的博客
06-19 297
在项目开发中，我们经常用到缓存。它可以非常有效地提高访问速度。 常用的缓存系统有 Redis、Memcache 等。但是，如果要缓存的数据比较少，我们完全没必要在项目中独立部署一套缓存系统。毕竟系统都有一定出错的概率，项目中包含的系统越多，那组合起来，项目整体出错的概率就会升高，可用性就会降低。同时，多引入一个系统就要多维护一个系统，项目维护的成本就会变高。 取而代之，我们可以在系统内部构建一个内存缓存，跟系统集成在一起开发、部署。那如何构建内存缓存呢？我们可以基于 JDK 提供的类，比如 HashMap，
Google Guava 工具集__2__Cache 缓存使用
2.wa
08-27 2591
范例 01 LoadingCache<Key, Graph> graphs = CacheBuilder.newBuilder() 02         .maximumSize(1000) 03         .expireAfterWrite(10, TimeU
cactoos-matchers:优雅的面向对象的Hamcrest Matchers
04-06
cactoos-matchers是围绕hamcrest的Matchers的面向对象的包装。 原则 仙人掌匹配器背后的。 如何使用 该库依赖于和。 在获取最新版本： < groupId>org.llorllale < artifactId>cactoos-matchers ${version} 所...
mockito-hamcrest:Mockito和Hamcrest Matchers课程示例
05-13
Mockito和Hamcrest是Java开发中的两个非常重要的测试框架，它们在单元测试和集成测试中发挥着关键作用。Mockito是一个模拟对象库，允许开发者创建和配置模拟对象，以便在测试中隔离系统组件，而Hamcrest则是一个匹配...
这是 Hamcrest Matchers 的 PHP 端口
最新发布
03-01
Hamcrest 是一个匹配的库，最初是为 Java 编写的，但是 随后被移植到许多其他语言。hamcrest-php 是 Hamcrest 的官方 PHP 端口，基本上遵循字面意思 Hamcrest 的原始 Java API 的翻译，以及一些 例外情况，主要归因...
JUGF-TDD:JUGF讲座的材料“使用JUnit4和Hamcrest Matchers进行测试驱动的开发”
05-06
使用JUnit4和Hamcrest Matchers进行测试驱动的开发 这是我的演讲的材料，我于年8月下午6:30在的举行。 介绍 现在，单元测试已成为软件开发人员标准库的一部分。 和Erich Gamma等人对测试框架的开发产生了重大影响。 ...
verbose-hamcrest-matchers
05-10
本文将深入探讨"verbose-hamcrest-matchers"这个主题，揭示其背后的原理和应用场景，以及如何利用它提升我们的测试质量。 Hamcrest库的核心在于它的Matchers，它们是用于比较对象是否满足特定条件的类。这些条件...
导包：org.hamcrest.Matchers.equalTo报错解决方法
CSDN818的博客
03-21 2655
今天在学习SpringBoot写测试的时候，看网上案例导包org.hamcrest.Matchers.equalTo，一模一样啊，但我就是报错，我猜想肯定是我版本问题，是不是新版本的equalTo方法被封装到另一个包里了，但是那么多包，是哪个呢？好烦，一个一个导入，看能不能点出来equalTo方法来，果然，我换成下列包：org.hamcrest.CoreMatchers.equalTo;不报错，执...
matchers依赖_定制Hamcrest Matchers
最佳 Java 编程
06-23 295
matchers依赖 本文是我们名为“ 用Mockito测试 ”的学院课程的一部分。 在本课程中，您将深入了解Mockito的魔力。 您将了解有关“模拟”，“间谍”和“部分模拟”的信息，以及它们相应的存根行为。 您还将看到使用测试双打和对象匹配器进行验证的过程。 最后，讨论了使用Mockito的测试驱动开发（TDD），以了解该库如何适合TDD的概念。 在这里查看 ！ 在本教程中，我们将...
matchers依赖_Hamcrest Matchers教程
最佳 Java 编程
06-23 1911
matchers依赖 本文是我们名为“ 用Mockito测试 ”的学院课程的一部分。 在本课程中，您将深入了解Mockito的魔力。 您将了解有关“模拟”，“间谍”和“部分模拟”的信息，以及它们相应的存根行为。 您还将看到使用测试双打和对象匹配器进行验证的过程。 最后，讨论了使用Mockito的测试驱动开发（TDD），以了解该库如何适合TDD的概念。 在这里查看 ！ 在本教程中，我们将...
Guava CacheBuilder使用说明
weixin_34185512的博客
08-03 518
为什么80%的码农都做不了架构师？>>> ...
Matchers
在路上
09-17 727
Matchers is an external addition to the JUnit framework. Matchers were added by the framework called Hamcrest. JUnit 4.8.2 ships with Hamcrest internally, so you don't have to download it, and add it
Guava Cache 使用学习
热门推荐
汪小哥
02-05 5万+
Guava -Caache Guava缓存值CacheBuilder介绍-参考 Google -CachesExplained wiki 缓存框架Guava Cache部分源码分析 概述 缓存是日常开发中经常应用到的一种技术手段，合理的利用缓存可以极大的改善应用程序的性能。 Guava官方对Cache的描述连接 缓存在各种各样的用例中非常有用。例如，当计算或检索值很昂贵时，您应
Guava - 拯救垃圾代码，写出优雅高效，效率提升N倍！
m0_58479800的博客
07-20 501
杭州-梦想小镇 最近在看一个同学代码的时候，发现代码中大量使用了 Google 开源的 Guava 核心库中的内容，让代码简单清晰了不少，故学习分享出 Guava 中我认为最实用的功能。 Guava 项目是 Google 公司开源的 Java 核心库，它主要是包含一些在 Java 开发中经常使用到的功能，如数据校验、不可变集合、计数集合，集合增强操作、I/O、缓存、字符串操作等。并且 Guava 广泛用于 Google 内部的 Java 项目中，也被其他公司广泛使用，甚至在新版 JDK 中直接引入了 .
matchers依赖_Hamcrest Matchers的高级创建
最佳 Java 编程
06-18 343
matchers依赖 介绍 上一次 ，我讨论了Hamcrest Matcher是什么，如何使用以及如何制作。 在本文中，我将解释创建Hamcrest Matchers的更多高级步骤。 首先，我将分享如何使您的匹配器更易于类型安全，然后介绍无状态匹配器的一些技术，最后是如何减少测试类的大量静态导入。 我还将给出一些有关命名静态工厂方法的快速提示。 类型安全匹配器 您可能已经在上次开发的mat...
如何正确使用Hutool和Guava这两个丰富的工具集，自己学习测试，样例
诗和远方，任重道远
07-04 8710
一、Hutool 关于数据库的操作示例 1.1 连接数据库：加载 config/db.setting #=================================================================== # 数据库配置文件样例 # DsFactory默认读取的配置文件是config/db.setting # db.setting的配置包括两部分：基本连接信息和...
安卓无法import static org.hamcrest.Matchers.allOf;
06-08
在 Android 开发中，JUnit 和 Hamcrest 库的版本可能会导致 `import static org.hamcrest.Matchers.allOf` 无法正常工作。 以下是可能的解决方案： 1. 确保在 gradle 文件中正确引入了 JUnit 和 Hamcrest 库。例如： ``` dependencies { testImplementation 'junit:junit:4.13.2' testImplementation 'org.hamcrest:hamcrest-library:2.2' } ``` 2. 如果使用的是 Android Studio 4.1 或更高版本，则可以尝试将 `testImplementation` 更改为 `androidTestImplementation`。 3. 尝试使用 `import org.hamcrest.core.AllOf.allOf` 代替 `import static org.hamcrest.Matchers.allOf`。 4. 检查项目中的其他库和依赖项是否与 Hamcrest 库存在冲突。可以尝试使用 `./gradlew app:dependencies` 命令查看依赖项。 希望这些解决方案能够帮助你解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值