add properties ${propertySimpleType} and ${propertyAssertType} so we can generate nicer navigation assertion methods

[jstrachan]

there's a back ground issue from our project here:
fabric8io/fabric8#5925

the general idea is we want to generate helper methods in the generated Assert classes to aid navigation through deeply nested models. The background is the Kubernetes model is very deeply nested.

For a complex model where you want to write assertions like:

assertThat(foo.getBar().getThing()).isNotNull()

the problem is the getBar() could return null as could the getThing().

So we wanna do this instead...

assertThat(foo).bar().thing().isNotNull();

where each property method bar() and thing() are kinda like the hasBar() function thats generated OOTB, only it returns the assertThat() of the value. So the last assertion - .isNotNull() could be anything really; isEqualTo() or whatever.

e.g. we generate functions like this:

class FooAssert ... {

   public BarAssert bar() {
      isNotNull();

      return (BarAssert) assertThat(actual.getBar()).describedAs(toString() + ".bar");
  }
}

I've managed to implement the above in our project using the extensible templates (thanks for that!) - but to do so I needed to add the above 2 properties to the templates. Actually as of writing only the 2nd one is required but figured I may as well submit a PR for both ;)

[jstrachan]

BTW here's a little example of some nested navigations then assertions along with the generated output:
fabric8io/fabric8#5925 (comment)

[PascalSchumacher]

I really like the idea.

I recently created a quick prototype (assertj/assertj#631) that is a bit similar and that would allow to navigate from a list to its size and back:

List<Integer> ints = Arrays.asList(1, 2, 3);
assertThat(ints).size().isGreaterThan(0).isLessThanOrEqualTo(3).returnToList().contains(1).doesNotContain(4);

Of course for generated assertions on domain classes this seems even more useful.

[jstrachan]

Yeah, I love the size() method on ListAssert! It'd be nice to have first(),
last() and item(index) too! Though it would need to know the assertion type
of the elementType of the List-.

Doing something similar to allow navigation to a Map size() or entry would
be great too!

On Monday, 11 April 2016, Pascal Schumacher notifications@github.com
wrote:

I really like the idea.

I recently created a quick prototype (assertj/assertj#631
assertj/assertj#631) that is a
bit similar and that would allow to navigate from a list to its size and
back:

List ints = Arrays.asList(1, 2, 3);
assertThat(ints).size().isGreaterThan(0).isLessThanOrEqualTo(3).returnToList().contains(1).doesNotContain(4);

Of course for generated assertions on domain classes this seems even more
useful.

—
You are receiving this because you authored the thread.
Reply to this email directly or view it on GitHub
#67 (comment)

James

Red Hat

Twitter: @jstrachan
Email: james.strachan@gmail.com
Medium: https://medium.com/@jstrachan/
Blog: http://macstrac.blogspot.com/

fabric8: http:/ http://fusesource.com//fabric8.io/
hawtio: http:/ http://fusesource.com//hawt.io/

Open Source DevOps and Integration

[PascalSchumacher]

Yeah element assertions would be great, but I believe type-erasure makes that impossible.

I think the closest we can get to that with java 8 is something like: assertThat(jedis).hasOnlyOneElementMatching(jedi -> jedi.name.equals("Yo! da"));
(taken form assertj/assertj#518)

[jstrachan]

BTW here's the template I use to generate the nested navigations:
https://github.com/jstrachan/fabric8/blob/5f99b82696856e9c5614ff5a728adfbeaab96751/components/kubernetes-assertions/src/main/assertj-templates/navigation_template.txt

I had to override the abstract class template so that I could add a few imports too - it might be nice one day to make that easier to parameterise maybe:
https://github.com/jstrachan/fabric8/blob/5f99b82696856e9c5614ff5a728adfbeaab96751/components/kubernetes-assertions/src/main/assertj-templates/custom_abstract_assertion_class_template.txt#L11

[jstrachan]

@PascalSchumacher awesome, I've managed to get ListAssert based element navigations working! About to submit a further PR shortly!

Here's a sneak peak at a test using it (PodList has a property called items which is a List<Pod>)

    @Test
    public void testNavigationListAssertions() throws Exception {
        final String id1 = "abc";
        final String id2 = "def";
        Map<String, String> labels1 = new HashMap<>();
        labels1.put("foo", "bar");
        Map<String, String> labels2 = new HashMap<>();
        labels2.put("whatnot", "cheese");

        final Pod pod1 = new Pod();
        pod1.setMetadata(new ObjectMeta());
        pod1.getMetadata().setName(id1);
        pod1.getMetadata().setLabels(labels1);

        final Pod pod2 = new Pod();
        pod2.setMetadata(new ObjectMeta());
        pod2.getMetadata().setName(id2);
        pod2.getMetadata().setLabels(labels2);


        final PodList emptyPodList = new PodList();
        final PodList podList = new PodList();
        podList.setItems(new ArrayList<Pod>(Arrays.asList(pod1, pod2)));

        assertThat(emptyPodList).describedAs("emptyPodList").items().isEmpty();
        assertThat(podList).describedAs("podListWith2Items").items().first().metadata().name().isEqualTo(id1);
        assertThat(podList).describedAs("podListWith2Items").items().last().metadata().name().isEqualTo(id2);

        assertAssertionError(new Block() {
            @Override
            public void invoke() throws Exception {
                assertThat(podList).describedAs("podListWith2Items").items().item(-1).isNotNull();
            }
        });

        assertAssertionError(new Block() {
            @Override
            public void invoke() throws Exception {
                assertThat(podList).describedAs("podListWith2Items").items().item(2).isNotNull();
            }
        });

        assertAssertionError(new Block() {
            @Override
            public void invoke() throws Exception {
                assertThat(podList).describedAs("podListWith2Items").items().first().metadata().name().isEqualTo("shouldNotMatch");
            }
        });
    }

Then some example failed assertion messages:

Caught expected assertion failure: org.junit.ComparisonFailure: [podListWith2Items.items.first().metadata.name] expected:<"[shouldNotMatch]"> but was:<"[abc]">
Caught expected assertion failure: java.lang.AssertionError: [podListWith2Items.items.index]
Expecting:
 <-1>
to be greater than or equal to:
 <0>
Caught expected assertion failure: java.lang.AssertionError: [podListWith2Items.items.index]
Expecting:
 <2>
to be less than:
 <2>

[joel-costigliola]

I like the idea, I'll review the PR in the next few weeks.

[jstrachan]

@PascalSchumacher @joel-costigliola I've just made another patch to the PR to also add ${elementAssertType} as an expression value so that we can generate navigation based List assert methods.

e.g. here's my current version of

            <iterableAssertion>has_elements_assertion_template_for_iterable.txt</iterableAssertion>

which is:

  /**
   * Navigates to the property ${property} so that assertions can be done on it
   */
  public NavigationListAssert<${elementType}, ${elementAssertType}> ${property_safe}() ${throws} {
    isNotNull();

    // return the assertion for the property
    AssertFactory<${elementType}, ${elementAssertType}> assertFactory = new AssertFactory<${elementType}, ${elementAssertType}>() {
      public ${elementAssertType} createAssert(${elementType} t) {
        return (${elementAssertType}) assertThat(t);
      }
    };
    NavigationListAssert<${elementType}, ${elementAssertType}> answer = new NavigationListAssert<${elementType}, ${elementAssertType}>(actual.get${Property}(), assertFactory);
    answer.describedAs(io.fabric8.kubernetes.assertions.Assertions.joinDescription(this, "${property}"));
    return answer;
  }

which is used to generate the items() method in the above test case. The generated code is:

  /**
   * Navigates to the property items so that assertions can be done on it
   */
  public NavigationListAssert<Pod, PodAssert> items()  {
    isNotNull();

    // return the assertion for the property
    AssertFactory<Pod, PodAssert> assertFactory = new AssertFactory<Pod, PodAssert>() {
      public PodAssert createAssert(Pod t) {
        return (PodAssert) assertThat(t);
      }
    };
    NavigationListAssert<Pod, PodAssert> answer = new NavigationListAssert<Pod, PodAssert>(actual.getItems(), assertFactory);
    answer.describedAs(io.fabric8.kubernetes.assertions.Assertions.joinDescription(this, "items"));
    return answer;
  }

For now I've added classes NavigationListAssert, AssertFactory and helper method io.fabric8.kubernetes.assertions.Assertions.joinDescription() to my project; I'm about to raise a PR against assertj-core to add those classes into the core library; so folks can use a version of the above template to get navigation based lists in their generated assert classes.

Incidentally whats nice about NavigationListAssert (which extends ListAssert<T>) is its got all the previously generated methods as before all in a single wrapper class so we generate only 1 method for a list property rather than 4 or 5; plus we add first(), last(), item(index) methods too along with all the methods from ListAssert being available too.

[PascalSchumacher]

@jstrachan awesome, the error message examples are great 👍

I guess there is also a helpful error message when some element of the "path" is null?

[jstrachan]

@PascalSchumacher absolutely :)

This test:

    @Test
    public void testNullNavigations() throws Exception {
        final Pod pod = new Pod();
        pod.setMetadata(null);

        assertAssertionError(new Block() {
            @Override
            public void invoke() throws Exception {
                assertThat(pod).metadata().name().isEqualTo("cheese");
            }
        });
    }

generates:

Caught expected assertion failure: java.lang.AssertionError: [Pod.metadata] 
Expecting actual not to be null

So the path thats null is clearly described; so when you have multiple navigations on one line, the error message describes exactly which path was null (rather than getting a NPE with a line number - meaning you have to refactor the code or enter the debugger to figure out what was null! :)

[PascalSchumacher]

great :)

[jstrachan]

BTW I've submitted a PR for the NavigationListAssert class (the main implementation behind the list based navigations) here so its available in the assertj-core:
assertj/assertj#641

or it can be used stand alone too (though its a little more clumsy to use):
assertj/assertj#641 (comment)