Thursday, June 13, 2024
HomeSoftware DevelopmentCheck-Driving HTML Templates

Check-Driving HTML Templates


After a decade or extra the place Single-Web page-Functions generated by
JavaScript frameworks have
change into the norm
, we see that server-side rendered HTML is changing into
standard once more, additionally because of libraries equivalent to HTMX or Turbo. Writing a wealthy net UI in a
historically server-side language like Go or Java is not simply potential,
however a really engaging proposition.

We then face the issue of the way to write automated assessments for the HTML
components of our net functions. Whereas the JavaScript world has advanced highly effective and refined methods to check the UI,
ranging in dimension from unit-level to integration to end-to-end, in different
languages we would not have such a richness of instruments obtainable.

When writing an internet utility in Go or Java, HTML is usually generated
by way of templates, which comprise small fragments of logic. It’s actually
potential to check them not directly by way of end-to-end assessments, however these assessments
are gradual and costly.

We will as a substitute write unit assessments that use CSS selectors to probe the
presence and proper content material of particular HTML parts inside a doc.
Parameterizing these assessments makes it simple so as to add new assessments and to obviously
point out what particulars every take a look at is verifying. This method works with any
language that has entry to an HTML parsing library that helps CSS
selectors; examples are offered in Go and Java.

Stage 1: checking for sound HTML

The primary factor we wish to verify is that the HTML we produce is
principally sound. I do not imply to verify that HTML is legitimate based on the
W3C; it could be cool to do it, nevertheless it’s higher to start out with a lot easier and quicker checks.
For example, we would like our assessments to
break if the template generates one thing like

<div>foo</p>

Let’s examine the way to do it in phases: we begin with the next take a look at that
tries to compile the template. In Go we use the usual html/template bundle.

Go

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    _ = templ
  }

In Java, we use jmustache
as a result of it is quite simple to make use of; Freemarker or
Velocity are different frequent selections.

Java

  @Check
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
  }

If we run this take a look at, it would fail, as a result of the index.tmpl file does
not exist. So we create it, with the above damaged HTML. Now the take a look at ought to cross.

Then we create a mannequin for the template to make use of. The appliance manages a todo-list, and
we are able to create a minimal mannequin for demonstration functions.

Go

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    mannequin := todo.NewList()
    _ = templ
    _ = mannequin
  }

Java

  @Check
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
      var mannequin = new TodoList();
  }

Now we render the template, saving the ends in a bytes buffer (Go) or as a String (Java).

Go

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    mannequin := todo.NewList()
    var buf bytes.Buffer
    err := templ.Execute(&buf, mannequin)
    if err != nil {
      panic(err)
    }
  }

Java

  @Check
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
      var mannequin = new TodoList();
  
      var html = template.execute(mannequin);
  }

At this level, we wish to parse the HTML and we count on to see an
error, as a result of in our damaged HTML there’s a div aspect that
is closed by a p aspect. There may be an HTML parser within the Go
customary library, however it’s too lenient: if we run it on our damaged HTML, we do not get an
error. Fortunately, the Go customary library additionally has an XML parser that may be
configured to parse HTML (because of this Stack Overflow reply)

Go

  func Test_wellFormedHtml(t *testing.T) {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    mannequin := todo.NewList()
    
    // render the template right into a buffer
    var buf bytes.Buffer
    err := templ.Execute(&buf, mannequin)
    if err != nil {
      panic(err)
    }
  
    // verify that the template could be parsed as (lenient) XML
    decoder := xml.NewDecoder(bytes.NewReader(buf.Bytes()))
    decoder.Strict = false
    decoder.AutoClose = xml.HTMLAutoClose
    decoder.Entity = xml.HTMLEntity
    for {
      _, err := decoder.Token()
      swap err {
      case io.EOF:
        return // We're performed, it is legitimate!
      case nil:
        // do nothing
      default:
        t.Fatalf("Error parsing html: %s", err)
      }
    }
  }

supply

This code configures the HTML parser to have the precise stage of leniency
for HTML, after which parses the HTML token by token. Certainly, we see the error
message we wished:

--- FAIL: Test_wellFormedHtml (0.00s)
    index_template_test.go:61: Error parsing html: XML syntax error on line 4: surprising finish aspect </p>

In Java, a flexible library to make use of is jsoup:

Java

  @Check
  void indexIsSoundHtml() {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream("/index.tmpl")));
      var mannequin = new TodoList();
  
      var html = template.execute(mannequin);
  
      var parser = Parser.htmlParser().setTrackErrors(10);
      Jsoup.parse(html, "", parser);
      assertThat(parser.getErrors()).isEmpty();
  }

supply

And we see it fail:

java.lang.AssertionError: 
Anticipating empty however was:<[<1:13>: Unexpected EndTag token [</p>] when in state [InBody],

Success! Now if we copy over the contents of the TodoMVC
template
to our index.tmpl file, the take a look at passes.

The take a look at, nonetheless, is simply too verbose: we extract two helper features, in
order to make the intention of the take a look at clearer, and we get

Go

  func Test_wellFormedHtml(t *testing.T) {
    mannequin := todo.NewList()
  
    buf := renderTemplate("index.tmpl", mannequin)
  
    assertWellFormedHtml(t, buf)
  }

supply

Java

  @Check
  void indexIsSoundHtml() {
      var mannequin = new TodoList();
  
      var html = renderTemplate("/index.tmpl", mannequin);
  
      assertSoundHtml(html);
  }

supply

Stage 2: testing HTML construction

What else ought to we take a look at?

We all know that the seems of a web page can solely be examined, finally, by a
human how it’s rendered in a browser. Nonetheless, there’s usually
logic in templates, and we would like to have the ability to take a look at that logic.

One is likely to be tempted to check the rendered HTML with string equality,
however this system fails in apply, as a result of templates comprise a variety of
particulars that make string equality assertions impractical. The assertions
change into very verbose, and when studying the assertion, it turns into tough
to grasp what it’s that we’re making an attempt to show.

What we’d like
is a way to say that some components of the rendered HTML
correspond to what we count on, and to ignore all the main points we do not
care about.
A method to do that is by operating queries with the CSS selector language:
it’s a highly effective language that permits us to pick the
parts that we care about from the entire HTML doc. As soon as we now have
chosen these parts, we (1) rely that the variety of aspect returned
is what we count on, and (2) that they comprise the textual content or different content material
that we count on.

The UI that we’re speculated to generate seems like this:

There are a number of particulars which are rendered dynamically:

  1. The variety of gadgets and their textual content content material change, clearly
  2. The type of the todo-item modifications when it is accomplished (e.g., the
    second)
  3. The “2 gadgets left” textual content will change with the variety of non-completed
    gadgets
  4. One of many three buttons “All”, “Energetic”, “Accomplished” will probably be
    highlighted, relying on the present url; as an illustration if we resolve that the
    url that exhibits solely the “Energetic” gadgets is /energetic, then when the present url
    is /energetic, the “Energetic” button must be surrounded by a skinny crimson
    rectangle
  5. The “Clear accomplished” button ought to solely be seen if any merchandise is
    accomplished

Every of this issues could be examined with the assistance of CSS selectors.

It is a snippet from the TodoMVC template (barely simplified). I
haven’t but added the dynamic bits, so what we see right here is static
content material, offered for example:

index.tmpl

  <part class="todoapp">
    <ul class="todo-list">
      <!-- These are right here simply to point out the construction of the record gadgets -->
      <!-- Checklist gadgets ought to get the category `accomplished` when marked as accomplished -->
      <li class="accomplished">  
        <div class="view">
          <enter class="toggle" sort="checkbox" checked>
          <label>Style JavaScript</label> 
          <button class="destroy"></button>
        </div>
      </li>
      <li>
        <div class="view">
          <enter class="toggle" sort="checkbox">
          <label>Purchase a unicorn</label> 
          <button class="destroy"></button>
        </div>
      </li>
    </ul>
    <footer class="footer">
      <!-- This must be `0 gadgets left` by default -->
      <span class="todo-count"><robust>0</robust> merchandise left</span> 
      <ul class="filters">
        <li>
          <a class="chosen" href="#/">All</a> 
        </li>
        <li>
          <a href="#/energetic">Energetic</a>
        </li>
        <li>
          <a href="#/accomplished">Accomplished</a>
        </li>
      </ul>
      <!-- Hidden if no accomplished gadgets are left ↓ -->
      <button class="clear-completed">Clear accomplished</button> 
    </footer>
  </part>  

supply

By trying on the static model of the template, we are able to deduce which
CSS selectors can be utilized to determine the related parts for the 5 dynamic
options listed above:

function CSS selector
All of the gadgets ul.todo-list li
Accomplished gadgets ul.todo-list li.accomplished
Gadgets left span.todo-count
Highlighted navigation hyperlink ul.filters a.chosen
Clear accomplished button button.clear-completed

We will use these selectors to focus our assessments on simply the issues we wish to take a look at.

Testing HTML content material

The primary take a look at will search for all of the gadgets, and show that the info
arrange by the take a look at is rendered appropriately.

func Test_todoItemsAreShown(t *testing.T) {
  mannequin := todo.NewList()
  mannequin.Add("Foo")
  mannequin.Add("Bar")

  buf := renderTemplate(mannequin)

  // assert there are two <li> parts contained in the <ul class="todo-list"> 
  // assert the primary <li> textual content is "Foo"
  // assert the second <li> textual content is "Bar"
}

We want a method to question the HTML doc with our CSS selector; an excellent
library for Go is goquery, that implements an API impressed by jQuery.
In Java, we maintain utilizing the identical library we used to check for sound HTML, particularly
jsoup. Our take a look at turns into:

Go

  func Test_todoItemsAreShown(t *testing.T) {
    mannequin := todo.NewList()
    mannequin.Add("Foo")
    mannequin.Add("Bar")
  
    buf := renderTemplate("index.tmpl", mannequin)
  
    // parse the HTML with goquery
    doc, err := goquery.NewDocumentFromReader(bytes.NewReader(buf.Bytes()))
    if err != nil {
      // if parsing fails, we cease the take a look at right here with t.FatalF
      t.Fatalf("Error rendering template %s", err)
    }
  
    // assert there are two <li> parts contained in the <ul class="todo-list">
    choice := doc.Discover("ul.todo-list li")
    assert.Equal(t, 2, choice.Size())
  
    // assert the primary <li> textual content is "Foo"
    assert.Equal(t, "Foo", textual content(choice.Nodes[0]))
  
    // assert the second <li> textual content is "Bar"
    assert.Equal(t, "Bar", textual content(choice.Nodes[1]))
  }
  
  func textual content(node *html.Node) string {
    // A bit of mess resulting from the truth that goquery has
    // a .Textual content() technique on Choice however not on html.Node
    sel := goquery.Choice{Nodes: []*html.Node{node}}
    return strings.TrimSpace(sel.Textual content())
  }

supply

Java

  @Check
  void todoItemsAreShown() throws IOException {
      var mannequin = new TodoList();
      mannequin.add("Foo");
      mannequin.add("Bar");
  
      var html = renderTemplate("/index.tmpl", mannequin);
  
      // parse the HTML with jsoup
      Doc doc = Jsoup.parse(html, "");
  
      // assert there are two <li> parts contained in the <ul class="todo-list">
      var choice = doc.choose("ul.todo-list li");
      assertThat(choice).hasSize(2);
  
      // assert the primary <li> textual content is "Foo"
      assertThat(choice.get(0).textual content()).isEqualTo("Foo");
  
      // assert the second <li> textual content is "Bar"
      assertThat(choice.get(1).textual content()).isEqualTo("Bar");
  }

supply

If we nonetheless have not modified the template to populate the record from the
mannequin, this take a look at will fail, as a result of the static template
todo gadgets have completely different textual content:

Go

  --- FAIL: Test_todoItemsAreShown (0.00s)
      index_template_test.go:44: First record merchandise: need Foo, received Style JavaScript
      index_template_test.go:49: Second record merchandise: need Bar, received Purchase a unicorn

Java

  IndexTemplateTest > todoItemsAreShown() FAILED
      org.opentest4j.AssertionFailedError:
      Anticipating:
       <"Style JavaScript">
      to be equal to:
       <"Foo">
      however was not.

We repair it by making the template use the mannequin information:

Go

  <ul class="todo-list">
    {{ vary .Gadgets }}
      <li>
        <div class="view">
          <enter class="toggle" sort="checkbox">
          <label>{{ .Title }}</label>
          <button class="destroy"></button>
        </div>
      </li>
    {{ finish }}
  </ul>

supply

Java – jmustache

  <ul class="todo-list">
    {{ #allItems }}
    <li>
      <div class="view">
        <enter class="toggle" sort="checkbox">
        <label>{{ title }}</label>
        <button class="destroy"></button>
      </div>
    </li>
    {{ /allItems }}
  </ul>

supply

Check each content material and soundness on the identical time

Our take a look at works, however it’s a bit verbose, particularly the Go model. If we will have extra
assessments, they are going to change into repetitive and tough to learn, so we make it extra concise by extracting a helper perform for parsing the html. We additionally take away the
feedback, because the code must be clear sufficient

Go

  func Test_todoItemsAreShown(t *testing.T) {
    mannequin := todo.NewList()
    mannequin.Add("Foo")
    mannequin.Add("Bar")
  
    buf := renderTemplate("index.tmpl", mannequin)
  
    doc := parseHtml(t, buf)
    choice := doc.Discover("ul.todo-list li")
    assert.Equal(t, 2, choice.Size())
    assert.Equal(t, "Foo", textual content(choice.Nodes[0]))
    assert.Equal(t, "Bar", textual content(choice.Nodes[1]))
  }
  
  func parseHtml(t *testing.T, buf bytes.Buffer) *goquery.Doc {
    doc, err := goquery.NewDocumentFromReader(bytes.NewReader(buf.Bytes()))
    if err != nil {
      // if parsing fails, we cease the take a look at right here with t.FatalF
      t.Fatalf("Error rendering template %s", err)
    }
    return doc
  }

Java

  @Check
  void todoItemsAreShown() throws IOException {
      var mannequin = new TodoList();
      mannequin.add("Foo");
      mannequin.add("Bar");
  
      var html = renderTemplate("/index.tmpl", mannequin);
  
      var doc = parseHtml(html);
      var choice = doc.choose("ul.todo-list li");
      assertThat(choice).hasSize(2);
      assertThat(choice.get(0).textual content()).isEqualTo("Foo");
      assertThat(choice.get(1).textual content()).isEqualTo("Bar");
  }
  
  non-public static Doc parseHtml(String html) {
      return Jsoup.parse(html, "");
  }

A lot better! At the very least for my part. Now that we extracted the parseHtml helper, it is
a good suggestion to verify for sound HTML within the helper:

Go

  func parseHtml(t *testing.T, buf bytes.Buffer) *goquery.Doc {
    assertWellFormedHtml(t, buf)
    doc, err := goquery.NewDocumentFromReader(bytes.NewReader(buf.Bytes()))
    if err != nil {
      // if parsing fails, we cease the take a look at right here with t.FatalF
      t.Fatalf("Error rendering template %s", err)
    }
    return doc
  }

supply

Java

  non-public static Doc parseHtml(String html) {
      var parser = Parser.htmlParser().setTrackErrors(10);
      var doc = Jsoup.parse(html, "", parser);
      assertThat(parser.getErrors()).isEmpty();
      return doc;
  }

supply

And with this, we are able to do away with the primary take a look at that we wrote, as we are actually testing for sound HTML on a regular basis.

The second take a look at

Now we’re in an excellent place for testing extra rendering logic. The
second dynamic function in our record is “Checklist gadgets ought to get the category
accomplished when marked as accomplished”. We will write a take a look at for this:

Go

  func Test_completedItemsGetCompletedClass(t *testing.T) {
    mannequin := todo.NewList()
    mannequin.Add("Foo")
    mannequin.AddCompleted("Bar")
  
    buf := renderTemplate("index.tmpl", mannequin)
  
    doc := parseHtml(t, buf)
    choice := doc.Discover("ul.todo-list li.accomplished")
    assert.Equal(t, 1, choice.Measurement())
    assert.Equal(t, "Bar", textual content(choice.Nodes[0]))
  }

supply

Java

  @Check
  void completedItemsGetCompletedClass() {
      var mannequin = new TodoList();
      mannequin.add("Foo");
      mannequin.addCompleted("Bar");
  
      var html = renderTemplate("/index.tmpl", mannequin);
  
      Doc doc = Jsoup.parse(html, "");
      var choice = doc.choose("ul.todo-list li.accomplished");
      assertThat(choice).hasSize(1);
      assertThat(choice.textual content()).isEqualTo("Bar");
  }

supply

And this take a look at could be made inexperienced by including this little bit of logic to the
template:

Go

  <ul class="todo-list">
    {{ vary .Gadgets }}
      <li class="{{ if .IsCompleted }}accomplished{{ finish }}">
        <div class="view">
          <enter class="toggle" sort="checkbox">
          <label>{{ .Title }}</label>
          <button class="destroy"></button>
        </div>
      </li>
    {{ finish }}
  </ul>

supply

Java – jmustache

  <ul class="todo-list">
    {{ #allItems }}
    <li class="{{ #isCompleted }}accomplished{{ /isCompleted }}">
      <div class="view">
        <enter class="toggle" sort="checkbox">
        <label>{{ title }}</label>
        <button class="destroy"></button>
      </div>
    </li>
    {{ /allItems }}
  </ul>

supply

So little by little, we are able to take a look at and add the assorted dynamic options
that our template ought to have.

Make it simple so as to add new assessments

The primary of the 20 suggestions from the superb discuss by Russ Cox on Go
Testing
is “Make it simple so as to add new take a look at circumstances“. Certainly, in Go there
is a bent to make most assessments parameterized, for this very purpose.
Alternatively, whereas Java has
good assist
for parameterized assessments
with JUnit 5, they are not used as a lot.

Since our present two assessments have the identical construction, we
might issue them right into a single parameterized take a look at.

A take a look at case for us will encompass:

  • A reputation (in order that we are able to produce clear error messages when the take a look at
    fails)
  • A mannequin (in our case a todo.Checklist)
  • A CSS selector
  • A listing of textual content matches that we anticipate finding once we run the CSS
    selector on the rendered HTML.

So that is the info construction for our take a look at circumstances:

Go

  var testCases = []struct {
    identify     string
    mannequin    *todo.Checklist
    selector string
    matches  []string
  }{
    {
      identify: "all todo gadgets are proven",
      mannequin: todo.NewList().
        Add("Foo").
        Add("Bar"),
      selector: "ul.todo-list li",
      matches:  []string{"Foo", "Bar"},
    },
    {
      identify: "accomplished gadgets get the 'accomplished' class",
      mannequin: todo.NewList().
        Add("Foo").
        AddCompleted("Bar"),
      selector: "ul.todo-list li.accomplished",
      matches:  []string{"Bar"},
    },
  }

supply

Java

  report TestCase(String identify,
                  TodoList mannequin,
                  String selector,
                  Checklist<String> matches) {
      @Override
      public String toString() {
          return identify;
      }
  }
  
  public static TestCase[] indexTestCases() {
      return new TestCase[]{
              new TestCase(
                      "all todo gadgets are proven",
                      new TodoList()
                              .add("Foo")
                              .add("Bar"),
                      "ul.todo-list li",
                      Checklist.of("Foo", "Bar")),
              new TestCase(
                      "accomplished gadgets get the 'accomplished' class",
                      new TodoList()
                              .add("Foo")
                              .addCompleted("Bar"),
                      "ul.todo-list li.accomplished",
                      Checklist.of("Bar")),
      };
  }

supply

And that is our parameterized take a look at:

Go

  func Test_indexTemplate(t *testing.T) {
    for _, take a look at := vary testCases {
      t.Run(take a look at.identify, func(t *testing.T) {
        buf := renderTemplate("index.tmpl", take a look at.mannequin)
  
        assertWellFormedHtml(t, buf)
        doc := parseHtml(t, buf)
        choice := doc.Discover(take a look at.selector)
        require.Equal(t, len(take a look at.matches), len(choice.Nodes), "surprising # of matches")
        for i, node := vary choice.Nodes {
          assert.Equal(t, take a look at.matches[i], textual content(node))
        }
      })
    }
  }

supply

Java

  @ParameterizedTest
  @MethodSource("indexTestCases")
  void testIndexTemplate(TestCase take a look at) {
      var html = renderTemplate("/index.tmpl", take a look at.mannequin);
  
      var doc = parseHtml(html);
      var choice = doc.choose(take a look at.selector);
      assertThat(choice).hasSize(take a look at.matches.dimension());
      for (int i = 0; i < take a look at.matches.dimension(); i++) {
          assertThat(choice.get(i).textual content()).isEqualTo(take a look at.matches.get(i));
      }
  }

supply

We will now run our parameterized take a look at and see it cross:

Go

  $ go take a look at -v
  === RUN   Test_indexTemplate
  === RUN   Test_indexTemplate/all_todo_items_are_shown
  === RUN   Test_indexTemplate/completed_items_get_the_'accomplished'_class
  --- PASS: Test_indexTemplate (0.00s)
      --- PASS: Test_indexTemplate/all_todo_items_are_shown (0.00s)
      --- PASS: Test_indexTemplate/completed_items_get_the_'accomplished'_class (0.00s)
  PASS
  okay    tdd-html-templates  0.608s

Java

  $ ./gradlew take a look at
  
  > Job :take a look at
  
  IndexTemplateTest > testIndexTemplate(TestCase) > [1] all todo gadgets are proven PASSED
  IndexTemplateTest > testIndexTemplate(TestCase) > [2] accomplished gadgets get the 'accomplished' class PASSED

Word how, by giving a reputation to our take a look at circumstances, we get very readable take a look at output, each on the terminal and within the IDE:

Having rewritten our two previous assessments in desk type, it is now tremendous simple so as to add
one other. That is the take a look at for the “x gadgets left” textual content:

Go

  {
    identify: "gadgets left",
    mannequin: todo.NewList().
      Add("One").
      Add("Two").
      AddCompleted("Three"),
    selector: "span.todo-count",
    matches:  []string{"2 gadgets left"},
  },

supply

Java

  new TestCase(
      "gadgets left",
      new TodoList()
              .add("One")
              .add("Two")
              .addCompleted("Three"),
      "span.todo-count",
      Checklist.of("2 gadgets left")),

supply

And the corresponding change within the html template is:

Go

  <span class="todo-count"><robust>{{len .ActiveItems}}</robust> gadgets left</span>

supply

Java – jmustache

  <span class="todo-count"><robust>{{activeItemsCount}}</robust> gadgets left</span>

supply

The above change within the template requires a supporting technique within the mannequin:

Go

  sort Merchandise struct {
    Title       string
    IsCompleted bool
  }
  
  sort Checklist struct {
    Gadgets []*Merchandise
  }
  
  func (l *Checklist) ActiveItems() []*Merchandise {
    var consequence []*Merchandise
    for _, merchandise := vary l.Gadgets {
      if !merchandise.IsCompleted {
        consequence = append(consequence, merchandise)
      }
    }
    return consequence
  }

supply

Java

  public class TodoList {
      non-public last Checklist<TodoItem> gadgets = new ArrayList<>();
      // ...
      public lengthy activeItemsCount() {
          return gadgets.stream().filter(TodoItem::isActive).rely();
      }
  }

supply

We have invested a little bit effort in our testing infrastructure, in order that including new
take a look at circumstances is less complicated. Within the subsequent part, we’ll see that the necessities
for the subsequent take a look at circumstances will push us to refine our take a look at infrastructure additional.

Making the desk extra expressive, on the expense of the take a look at code

We are going to now take a look at the “All”, “Energetic” and “Accomplished” navigation hyperlinks at
the underside of the UI (see the image above),
and these depend upon which url we’re visiting, which is
one thing that our template has no method to discover out.

At present, all we cross to our template is our mannequin, which is a todo-list.
It isn’t right so as to add the presently visited url to the mannequin, as a result of that’s
person navigation state, not utility state.

So we have to cross extra data to the template past the mannequin. A simple manner
is to cross a map, which we assemble in our
renderTemplate perform:

Go

  func renderTemplate(mannequin *todo.Checklist, path string) bytes.Buffer {
    templ := template.Should(template.ParseFiles("index.tmpl"))
    var buf bytes.Buffer
    information := map[string]any{
      "mannequin": mannequin,
      "path":  path,
    }
    err := templ.Execute(&buf, information)
    if err != nil {
      panic(err)
    }
    return buf
  }

Java

  non-public String renderTemplate(String templateName, TodoList mannequin, String path) {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream(templateName)));
      var information = Map.of(
              "mannequin", mannequin,
              "path", path
      );
      return template.execute(information);
  }

And correspondingly our take a look at circumstances desk has yet another area:

Go

  var testCases = []struct {
    identify     string
    mannequin    *todo.Checklist
    path     string
    selector string
    matches  []string
  }{
    {
      identify: "all todo gadgets are proven",
      mannequin: todo.NewList().
        Add("Foo").
        Add("Bar"),
      selector: "ul.todo-list li",
      matches:  []string{"Foo", "Bar"},
    },
  // ... the opposite circumstances
    {
      identify:     "highlighted navigation hyperlink: All",
      path:     "/",
      selector: "ul.filters a.chosen",
      matches:  []string{"All"},
    },
    {
      identify:     "highlighted navigation hyperlink: Energetic",
      path:     "/energetic",
      selector: "ul.filters a.chosen",
      matches:  []string{"Energetic"},
    },
    {
      identify:     "highlighted navigation hyperlink: Accomplished",
      path:     "/accomplished",
      selector: "ul.filters a.chosen",
      matches:  []string{"Accomplished"},
    },
  }

Java

  report TestCase(String identify,
                  TodoList mannequin,
                  String path,
                  String selector,
                  Checklist<String> matches) {
      @Override
      public String toString() {
          return identify;
      }
  }
  
  public static TestCase[] indexTestCases() {
      return new TestCase[]{
              new TestCase(
                      "all todo gadgets are proven",
                      new TodoList()
                              .add("Foo")
                              .add("Bar"),
                      "/",
                      "ul.todo-list li",
                      Checklist.of("Foo", "Bar")),
              // ... the earlier circumstances
              new TestCase(
                      "highlighted navigation hyperlink: All",
                      new TodoList(),
                      "/",
                      "ul.filters a.chosen",
                      Checklist.of("All")),
              new TestCase(
                      "highlighted navigation hyperlink: Energetic",
                      new TodoList(),
                      "/energetic",
                      "ul.filters a.chosen",
                      Checklist.of("Energetic")),
              new TestCase(
                      "highlighted navigation hyperlink: Accomplished",
                      new TodoList(),
                      "/accomplished",
                      "ul.filters a.chosen",
                      Checklist.of("Accomplished")),
      };
  }

We discover that for the three new circumstances, the mannequin is irrelevant;
whereas for the earlier circumstances, the trail is irrelevant. The Go syntax permits us
to initialize a struct with simply the fields we’re eager about, however Java doesn’t have
an identical function, so we’re pushed to cross further data, and this makes the take a look at circumstances
desk more durable to grasp.

A developer would possibly take a look at the primary take a look at case and marvel if the anticipated conduct relies upon
on the trail being set to "/", and is likely to be tempted so as to add extra circumstances with
a special path. In the identical manner, when studying the
highlighted navigation hyperlink take a look at circumstances, the developer would possibly marvel if the
anticipated conduct is determined by the mannequin being set to an empty todo record. In that case, one would possibly
be led so as to add irrelevant take a look at circumstances for the highlighted hyperlink with non-empty todo-lists.

We wish to optimize for the time of the builders, so it is worthwhile to keep away from including irrelevant
information to our take a look at case. In Java we’d cross null for the
irrelevant fields, however there’s a greater manner: we are able to use
the builder sample,
popularized by Joshua Bloch.
We will rapidly write one for the Java TestCase report this fashion:

Java

  report TestCase(String identify,
                  TodoList mannequin,
                  String path,
                  String selector,
                  Checklist<String> matches) {
      @Override
      public String toString() {
          return identify;
      }
  
      public static last class Builder {
          String identify;
          TodoList mannequin;
          String path;
          String selector;
          Checklist<String> matches;
  
          public Builder identify(String identify) {
              this.identify = identify;
              return this;
          }
  
          public Builder mannequin(TodoList mannequin) {
              this.mannequin = mannequin;
              return this;
          }
  
          public Builder path(String path) {
              this.path = path;
              return this;
          }
  
          public Builder selector(String selector) {
              this.selector = selector;
              return this;
          }
  
          public Builder matches(String ... matches) {
              this.matches = Arrays.asList(matches);
              return this;
          }
  
          public TestCase construct() {
              return new TestCase(identify, mannequin, path, selector, matches);
          }
      }
  }

Hand-coding builders is a little bit tedious, however doable, although there are
automated methods to put in writing them.
Now we are able to rewrite our Java take a look at circumstances with the Builder, to
obtain higher readability:

Java

  public static TestCase[] indexTestCases() {
      return new TestCase[]{
              new TestCase.Builder()
                      .identify("all todo gadgets are proven")
                      .mannequin(new TodoList()
                              .add("Foo")
                              .add("Bar"))
                      .selector("ul.todo-list li")
                      .matches("Foo", "Bar")
                      .construct(),
              // ... different circumstances
              new TestCase.Builder()
                      .identify("highlighted navigation hyperlink: Accomplished")
                      .path("/accomplished")
                      .selector("ul.filters a.chosen")
                      .matches("Accomplished")
                      .construct(),
      };
  }

So, the place are we with our assessments? At current, they fail for the flawed purpose: null-pointer exceptions
because of the lacking mannequin and path values.
To be able to get our new take a look at circumstances to fail for the precise purpose, particularly that the template does
not but have logic to spotlight the proper hyperlink, we should
present default values for mannequin and path. In Go, we are able to do that
within the take a look at technique:

Go

  func Test_indexTemplate(t *testing.T) {
    for _, take a look at := vary testCases {
      t.Run(take a look at.identify, func(t *testing.T) {
        if take a look at.mannequin == nil {
          take a look at.mannequin = todo.NewList()
        }
        buf := renderTemplate(take a look at.mannequin, take a look at.path)
        // ... identical as earlier than 
      })
    }
  }

supply

In Java, we are able to present default values within the builder:

Java

  public static last class Builder {
      String identify;
      TodoList mannequin = new TodoList();
      String path = "/";
      String selector;
      Checklist<String> matches;
      // ...
  }

supply

With these modifications, we see that the final two take a look at circumstances, those for the highlighted hyperlink Energetic
and Accomplished fail, for the anticipated purpose that the highlighted hyperlink doesn’t change:

Go

  === RUN   Test_indexTemplate/highlighted_navigation_link:_Active
      index_template_test.go:82: 
            Error Hint:  .../tdd-templates/go/index_template_test.go:82
            Error:        Not equal: 
                          anticipated: "Energetic"
                          precise  : "All"
  === RUN   Test_indexTemplate/highlighted_navigation_link:_Completed
      index_template_test.go:82: 
            Error Hint:  .../tdd-templates/go/index_template_test.go:82
            Error:        Not equal: 
                          anticipated: "Accomplished"
                          precise  : "All"

Java

  IndexTemplateTest > testIndexTemplate(TestCase) > [5] highlighted navigation hyperlink: Energetic FAILED
      org.opentest4j.AssertionFailedError:
      Anticipating:
       <"All">
      to be equal to:
       <"Energetic">
      however was not.
  
  IndexTemplateTest > testIndexTemplate(TestCase) > [6] highlighted navigation hyperlink: Accomplished FAILED
      org.opentest4j.AssertionFailedError:
      Anticipating:
       <"All">
      to be equal to:
       <"Accomplished">
      however was not.

To make the assessments cross, we make these modifications to the template:

Go

  <ul class="filters">
    <li>
      <a class="{{ if eq .path "/" }}chosen{{ finish }}" href="#/">All</a>
    </li>
    <li>
      <a class="{{ if eq .path "/energetic" }}chosen{{ finish }}" href="#/energetic">Energetic</a>
    </li>
    <li>
      <a class="{{ if eq .path "/accomplished" }}chosen{{ finish }}" href="#/accomplished">Accomplished</a>
    </li>
  </ul>

supply

Java – jmustache

  <ul class="filters">
    <li>
      <a class="{{ #pathRoot }}chosen{{ /pathRoot }}" href="#/">All</a>
    </li>
    <li>
      <a class="{{ #pathActive }}chosen{{ /pathActive }}" href="#/energetic">Energetic</a>
    </li>
    <li>
      <a class="{{ #pathCompleted }}chosen{{ /pathCompleted }}" href="#/accomplished">Accomplished</a>
    </li>
  </ul>

supply

Because the Mustache template language doesn’t enable for equality testing, we should change the
information handed to the template in order that we execute the equality assessments earlier than rendering the template:

Java

  non-public String renderTemplate(String templateName, TodoList mannequin, String path) {
      var template = Mustache.compiler().compile(
              new InputStreamReader(
                      getClass().getResourceAsStream(templateName)));
      var information = Map.of(
              "mannequin", mannequin,
              "pathRoot", path.equals("/"),
              "pathActive", path.equals("/energetic"),
              "pathCompleted", path.equals("/accomplished")
      );
      return template.execute(information);
  }

supply

And with these modifications, all of our assessments now cross.

To recap this part, we made the take a look at code a little bit bit extra difficult, in order that the take a look at
circumstances are clearer: this can be a superb tradeoff!

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments