Assert List contains only one instance of a class using AssertJ

Question

Could I somehow use AssertJ to assert a List has only one instance of a (sub)class?

public class A {}
public class B extends A {}
public class C extends A {}

@Test
public void test() {
  List<A> list = new ArrayList<A>();
  list.add(new B());

  Assertions.assertThat(list).containsOnlyOnce(B.class);
}

Gabor

whats wrong with your current code? – Gametogenesis

AssertJ's containsOnlyOnce method does not accept Class as it's argument. (unless the list was a list of Class.) – Gabor

Answer 1

You need to define a Condition.

Following will assert that list contains only a single object reference of type B.class.

Condition condition = new Condition() {
    @Override
    public boolean matches(Object o) {
        return o.getClass() == B.class;
    }};

Assertions.assertThat(list).areExactly(1, condition);

It will fail for following cases:

list.add(new B());
list.add(new B());

and also for

B b = new B();
list.add(b);
list.add(b);

Using the Java 8 Stream API it can be achieved like

long countOfClassB = list.stream().filter(t -> t instanceof B).count();
Assertions.assertThat(countOfClassB).isEqualTo(1L);

Allfired

Answer 2

There is a method hasOnlyElementsOfType(Class), which verifies that all elements in the Iterable have the specified type (including subclasses of the given type).

The solution could look like:

assertThat(list).hasOnlyElementsOfType(B.class).hasSize(1);

Seidler

Welcome to Stack Overflow! While you may have solved this user's problem, code-only answers are not very helpful to users who come to this question in the future. Please edit your answer to explain why your code solves the original problem – Ansate

The call to hasSize(1) is not needed as hasOnlyElementsOfType already checks this. – Theomorphic

hasOnlyElementsOfType() checks only type of the items, but items can be more then one. @Theomorphic – Crossroads

Thank you @MarcinGołębski, you are right. It only checks for not 0, but indeed we want to be sure it is exactly 1. – Theomorphic

Answer 3

I would use AssertJ extracting feature as is:

assertThat(list).extracting("class")
                .containsOnlyOnce(B.class);

Juna

Castigliola this is an amazing answer. Thanks for the lib. – Beheld

Answer 4

The problem with your code is that the type of list is A, but the type of the element you're trying to verify with containsOnlyOnce is Class<B>.

You need to use corresponding types. For example, you can extract the classes in the list:

Stream<Class<?>> classes = list.stream().map(x -> x.getClass());
Assertions.assertThat(classes).containsOnlyOnce(B.class);

Uncloak