Compare commits

...

1 Commits

Author SHA1 Message Date
Jordan Orelli 7363c4b2c4 update example test for clarity 4 years ago

@ -8,6 +8,9 @@ import (
"github.com/jordanorelli/tea" "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 { type testStartServer struct {
Server *httptest.Server `tea:"save"` Server *httptest.Server `tea:"save"`
} }
@ -23,14 +26,16 @@ func (test *testStartServer) After(t *testing.T) {
test.Server.Close() 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"` Server *httptest.Server `tea:"load"`
path string path string
expect int hits int
} }
func (test *testRequest) Run(t *testing.T) { func (test *testHits) Run(t *testing.T) {
client := test.Server.Client() client := test.Server.Client()
res, err := client.Get(test.Server.URL + test.path) 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) t.Fatalf("response at %s was not json: %v", test.path, err)
} }
if body.Hits != test.expect { if body.Hits != test.hits {
t.Errorf("expected a count of %d but saw %d", test.expect, body.Hits) t.Errorf("expected a count of %d hits but saw %d instead", test.hits, body.Hits)
} }
} }
func TestServer(t *testing.T) { 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 { // add a child node: this test is run if the root test passes. If the root
for i := 0; i < len(tests); i++ { // test is failed, this test and all of its descendents are logged as
node = node.Child(&tests[i]) // skipped.
} one := root.Child(&testHits{path: "/alice", hits: 1})
return node
}
runParallel := func(node *tea.Tree, tests list) { // the effects of the first test create the initial state for the second test.
for i := 0; i < len(tests); i++ { two := one.Child(&testHits{path: "/alice", hits: 2})
node.Child(&tests[i])
}
}
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{ // these two executions of the same test value are operating on different
{path: "/users/alice", expect: 1}, // program states. Since they are not in the same sequence, they have no
{path: "/users/alice", expect: 2}, // effect on one another, even though they're utilizing the same test
{path: "/users/alice", expect: 3}, // value.
{path: "/users/alice", expect: 4}, two.Child(bob)
}) root.Child(bob)
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},
})
tea.Run(t, root) tea.Run(t, root)
} }

Loading…
Cancel
Save