update example test for clarity

examples/g-counter/g_counter.go

@@ -1,47 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"sort"
-)
-
-type gcounter struct {
-	id     int
-	counts map[int]int
-}
-
-func (c gcounter) incr() { c.counts[c.id]++ }
-
-func (c gcounter) total() int {
-	var n int
-	for _, count := range c.counts {
-		n += count
-	}
-	return n
-}
-
-func (c gcounter) merge(other gcounter) {
-	for id, count := range other.counts {
-		if c.[id] < count {
-			c.[id] = count
-		}
-	}
-}
-
-type pair [2]int
-
-func (c gcounter) MarshalJSON() ([]byte, error) {
-	pairs := make([]pair, 0, len(c.counts))
-	for id, count := range c.counts {
-		pairs = append(pairs, pair{id, count})
-	}
-	sort.Slice(pairs, func(i, j int) bool { return pairs[i][0] < pairs[j][0] })
-	return json.Marshal(pairs)
-}
-
-func (c *gcounter) UnmarshalJSON(b []byte) error {
-	pairs := make([]pair, 0, len(c.counts))
-	if err := json.Unmarshal(b, &pairs); err != nil {
-		return err
-	}
-}

examples/g-counter/g_counter_test.go

@@ -1,71 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"testing"
-)
-
-func TestGCounterJSON(t *testing.T) {
-	t.Run("marshal", func(t *testing.T) {
-		type test struct {
-			counter gcounter
-			expect  string
-		}
-
-		tests := []test{
-			{
-				gcounter{1, map[int]int{1: 5, 3: 8}},
-				`[[1,5],[3,8]]`,
-			},
-			{
-				gcounter{8, map[int]int{3: 10, 7: 16, 12: 9, 2: 37}},
-				`[[2,37],[3,10],[7,16],[12,9]]`,
-			},
-		}
-
-		for _, test := range tests {
-			b, err := json.Marshal(test.counter)
-			if err != nil {
-				t.Errorf("marshal failed: %s", err)
-				continue
-			}
-			s := string(b)
-			if s != test.expect {
-				t.Errorf("expected json: %s received: %s", test.expect, s)
-			}
-		}
-	})
-
-	t.Run("unmarshal", func(t *testing.T) {
-		type test struct {
-			in     string
-			expect gcounter
-		}
-
-		tests := []test{
-			{
-				`[[1,5],[3,8]]`,
-				gcounter{1, map[int]int{1: 5, 3: 8}},
-			},
-			{
-				`[[2,37],[3,10],[7,16],[12,9]]`,
-				gcounter{8, map[int]int{3: 10, 7: 16, 12: 9, 2: 37}},
-			},
-		}
-
-		for _, test := range tests {
-			var c gcounter
-			if err := json.Unmarshal(test.in, &c); err != nil {
-				t.Errorf("unmarshal failed: %s", err)
-				continue
-			}
-
-			for id, count := range c.counts {
-				n := test.expect.counts[id]
-				if n != count {
-					t.Errorf("mismatched counts for id %d: expected %d, saw %d", id, count, n)
-				}
-			}
-		}
-	})
-}

examples/g-counter/main.go

@@ -1 +0,0 @@
-package main

examples/g-counter/server.go

@@ -1,78 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"sync"
-)
-
-type response struct {
-	OK   bool `json:"ok"`
-	Hits int  `json:"hits"`
-}
-
-// server implements a clustered http hit-counter server. Each path is given a
-// g-counter, and every node in the cluster acts as a read-write replica.
-type server struct {
-	sync.Mutex
-
-	// my own id
-	id int
-
-	// a mapping of peer servers id -> addr
-	peers map[int]string
-
-	// distributed counts
-	counters map[string]gcounter
-}
-
-func (s *server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	switch r.URL.Path {
-	case "/join":
-		s.join(w, r)
-	case "/sync":
-		s.sync(w, r)
-	default:
-		s.countHit(w, r)
-	}
-}
-
-func (s *server) countHit(w http.ResponseWriter, r *http.Request) {
-	hits := s.hit(r.URL.Path)
-
-	fmt.Printf("% 8d %s\n", hits, r.URL.Path)
-
-	w.Header().Add("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(response{OK: true, Hits: hits})
-}
-
-func (s *server) join(w http.ResponseWriter, r *http.Request) {
-	var body struct {
-		Addr string `json:"addr"`
-	}
-}
-
-func (s *server) sync(w http.ResponseWriter, r *http.Request) {
-}
-
-func (s *server) hit(path string) int {
-	s.Lock()
-	defer s.Unlock()
-
-	if s.counters == nil {
-		s.counters = map[string]gcounter{
-			gcounter{s.id, map[int]int{id: 1}},
-		}
-		return 1
-	}
-
-	c, ok := s.counters[path]
-	if !ok {
-		s.counters[path] = gcounter{s.id, map[int]int{id: 1}}
-		return 1
-	}
-
-	c.incr()
-	return c.total()
-}

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
+	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 {
+	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) {
-	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
-	}
 
-	runSiblings := 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},
-	})
-
-	runSiblings(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)
 }