update example test for clarity

examples/hit-counter/server_test.go

@@ -8,6 +8,9 @@ import (
 	"github.com/jordanorelli/tea"
 )
 
+// testStartServer is a test that checks that the server can start. If this
+// test passes, we retain a reference to the server for future tests to
+// utilize.
 type testStartServer struct {
 	Server *httptest.Server `tea:"save"`
 }
@@ -23,14 +26,16 @@ func (test *testStartServer) After(t *testing.T) {
 	test.Server.Close()
 }
 
-type testRequest struct {
+// testHits sends a request to a hitcount server created in a previous test,
+// checking that the number of hits returned matches what we expect.
+type testHits struct {
 	Server *httptest.Server `tea:"load"`
 
 	path string
-	expect int
+	hits int
 }
 
-func (test *testRequest) Run(t *testing.T) {
+func (test *testHits) Run(t *testing.T) {
 	client := test.Server.Client()
 
 	res, err := client.Get(test.Server.URL + test.path)
@@ -44,50 +49,39 @@ func (test *testRequest) Run(t *testing.T) {
 		t.Fatalf("response at %s was not json: %v", test.path, err)
 	}
 
-	if body.Hits != test.expect {
-		t.Errorf("expected a count of %d but saw %d", test.expect, body.Hits)
+	if body.Hits != test.hits {
+		t.Errorf("expected a count of %d hits but saw %d instead", test.hits, body.Hits)
 	}
 }
 
 func TestServer(t *testing.T) {
-	type list []testRequest
+	// start with a root node that creates our test server
+	root := tea.New(&testStartServer{})
 
-	runSeries := func(node *tea.Tree, tests list) *tea.Tree {
-		for i := 0; i < len(tests); i++ {
-			node = node.Child(&tests[i])
-		}
-		return node
-	}
+	// add a child node: this test is run if the root test passes. If the root
+	// test is failed, this test and all of its descendents are logged as
+	// skipped.
+	one := root.Child(&testHits{path: "/alice", hits: 1})
 
-	runParallel := func(node *tea.Tree, tests list) {
-		for i := 0; i < len(tests); i++ {
-			node.Child(&tests[i])
-		}
-	}
+	// the effects of the first test create the initial state for the second test.
+	two := one.Child(&testHits{path: "/alice", hits: 2})
 
-	root := tea.New(&testStartServer{})
+	// since we have never visited /bob, we know that bob should only have one hit.
+	two.Child(&testHits{path: "/bob", hits: 1})
+
+	// but we could also run the exact same test off of the root, like so:
+	root.Child(&testHits{path: "/bob", hits: 1})
+
+	// since tests are values in tea, we can re-use the exact same test from
+	// different initial states by saving the test as a variable.
+	bob := &testHits{path: "/bob", hits: 1}
 
-	runSeries(root, list{
-		{path: "/users/alice", expect: 1},
-		{path: "/users/alice", expect: 2},
-		{path: "/users/alice", expect: 3},
-		{path: "/users/alice", expect: 4},
-	})
-
-	runSeries(root, list{
-		{path: "/users/bob", expect: 1},
-		{path: "/users/alice", expect: 1},
-		{path: "/users/alice", expect: 2},
-		{path: "/users/alice", expect: 3},
-		{path: "/users/bob", expect: 2},
-	})
-
-	runParallel(root, list{
-		{path: "/users/alice", expect: 1},
-		{path: "/users/alice", expect: 1},
-		{path: "/users/alice", expect: 1},
-		{path: "/users/alice", expect: 1},
-	})
+	// these two executions of the same test value are operating on different
+	// program states. Since they are not in the same sequence, they have no
+	// effect on one another, even though they're utilizing the same test
+	// value.
+	two.Child(bob)
+	root.Child(bob)
 
 	tea.Run(t, root)
 }