Exclusions

Table of Contents

You can exclude Unit members (i.e. fields and methods) to skip them during certain assertions. Excluded members should not make an assertion fail due to it being skipped. Exclusions can be set using member signatures or with predicates.

Restrictions: members such as Object methods equals, hashCode and toString will not be skipped when an assertion is performing tests regarding these methods.

For more information about exclusion, see:

Given unit for the sake of documentation:

public class NeedsExclusion {
    private String fieldMissingFromToString;
    private String stringField;
    private String fieldMissingSetter;
    private String fieldMissingGetter;
    private String fieldBrokenGetter;

    public String getFieldMissingFromToString() {
        return fieldMissingFromToString;
    }

    public void setFieldMissingFromToString(String fieldMissingFromToString) {
        this.fieldMissingFromToString = fieldMissingFromToString;
    }

    public String getStringField() {
        return stringField;
    }

    public void setStringField(String stringField) {
        this.stringField = stringField;
    }

    public String getFieldMissingSetter() {
        return fieldMissingSetter;
    }

    public void setFieldMissingGetter(String fieldMissingGetter) {
        this.fieldMissingGetter = fieldMissingGetter;
    }

    public String getFieldBrokenGetter() {
        return null;
    }

    public void setFieldBrokenGetter(String fieldBrokenGetter) {
        this.fieldBrokenGetter = fieldBrokenGetter;
    }

    @Override
    public boolean equals(Object object) {
        if (this == object) return true;
        if (object == null || getClass() != object.getClass()) return false;
        NeedsExclusion that = (NeedsExclusion) object;
        return Objects.equals(fieldMissingFromToString, that.fieldMissingFromToString)
                && Objects.equals(stringField, that.stringField) && Objects.equals(fieldMissingSetter,
                that.fieldMissingSetter) && Objects.equals(fieldMissingGetter, that.fieldMissingGetter)
                && Objects.equals(fieldBrokenGetter, that.fieldBrokenGetter);
    }

    @Override
    public int hashCode() {
        return Objects.hash(fieldMissingFromToString, stringField, fieldMissingSetter, fieldMissingGetter,
                fieldBrokenGetter);
    }

    @Override
    public String toString() {
        return "NeedsExclusion{" +
                "stringField='" + stringField + '\'' +
                ", fieldMissingSetter='" + fieldMissingSetter + '\'' +
                ", fieldMissingGetter='" + fieldMissingGetter + '\'' +
                ", fieldBrokenGetter='" + fieldBrokenGetter + '\'' +
                '}';
    }
}

Excluding using unique signature

A field has no signature other than its case-sensitive name, for methods it’s their name and parameter list.

@Test
void givenPojoWithProblematicMembers_whenTheyAreExcluded_thenPassesAssertion() {
    Junisert.assertThatPojo(NeedsExclusion.class)
            .excludingField("fieldMissingFromToString")
            .excludingField("fieldMissingSetter")
            .excludingField("fieldMissingGetter")
            .excludingMethod("getFieldBrokenGetter")
            .isWellImplemented();
}

Excluding using predicates 

@Test
void givenPojoWithProblematicMembers_whenTheyAreExcluded_thenPassesAssertion() {
    Junisert.assertThatPojo(NeedsExclusion.class)
            .excludingField(field -> field.getName().toLowerCase().contains("missing"))
            .excludingMethod(method -> method.getName().equals("getFieldBrokenGetter"))
            .isWellImplemented();

    Exclusion exclusion = Exclusion.exclude()
            .fieldMatching(field -> field.getName().toLowerCase().contains("missing"))
            .methodMatching(method -> method.getName().equals("getFieldBrokenGetter"))
            .build();
    
    Junisert.assertThatPojo(NeedsExclusion.class)
            .excluding(exclusion)
            .isWellImplemented();
}