an example

examples/incr/README.md

@@ -0,0 +1,21 @@
+increment test
+=
+
+This is an example of an increment test. This is the example used in the
+Goconvey docs, so I use it as an example to show how patterns that people have
+seen before may be expressed in tea.
+
+The same tests are written using different testing tools. Build flags are used
+to control which of the testing frameworks is being used. The reason we use
+build flags here is because some of the examples are not expressible in some
+of the other testing frameworks; those examples exist to show how something
+might unexpectedly fail in one framework but work in tea.
+
+Files beginning with `std_` are written using only the standard library
+testing framework on its own. Files beginning with `convey_` are written using
+Goconvey, a BDD framework. Files beginning with `tea_` are written using tea.
+
+- `go test -tags std` runs the standard library tests
+- `go test -tags convey` runs the Goconvey tests
+- `go test` runs the tea tests. This is the default since we want to give
+  examples of how to use tea; the tea tests should be runnable with simply `go test`

examples/incr/convey_test.go

@@ -0,0 +1,46 @@
+// +build convey
+
+package incr
+
+import (
+	. "github.com/smartystreets/goconvey/convey"
+	"testing"
+)
+
+func TestOnce(t *testing.T) {
+	Convey("Given some integer with a starting value", t, func() {
+		x := 1
+
+		Convey("When the integer is incremented", func() {
+			x++
+
+			Convey("The value should be greater by one", func() {
+				So(x, ShouldEqual, 2)
+			})
+		})
+	})
+}
+
+func TestTwice(t *testing.T) {
+	Convey("Given some integer with a starting value", t, func() {
+		x := 1
+
+		Convey("When the integer is incremented", func() {
+			x++
+
+			Convey("The value should be greater by one", func() {
+				So(x, ShouldEqual, 2)
+			})
+		})
+
+		// the name has to be updated, if you try to use the name twice, Convey
+		// explodes.
+		Convey("When the integer is incremented again", func() {
+			x++
+
+			Convey("The value should be greater by one", func() {
+				So(x, ShouldEqual, 2)
+			})
+		})
+	})
+}

examples/incr/std_test.go

@@ -0,0 +1,37 @@
+// +build std
+
+package incr
+
+import (
+	"testing"
+)
+
+func TestOnce(t *testing.T) {
+	x := 1
+
+	t.Run("increment", func(t *testing.T) {
+		x++
+		if x != 2 {
+			t.Errorf("expected x to be 2, is %d instead", x)
+		}
+	})
+}
+
+func TestTwice(t *testing.T) {
+	x := 1
+
+	t.Run("increment", func(t *testing.T) {
+		x++
+		if x != 2 {
+			t.Errorf("expected x to be 2, is %d instead", x)
+		}
+	})
+
+	// this fails, because both subtests close over the same x.
+	t.Run("increment", func(t *testing.T) {
+		x++
+		if x != 2 {
+			t.Errorf("expected x to be 2, is %d instead", x)
+		}
+	})
+}

examples/incr/tea_test.go

@@ -0,0 +1,39 @@
+// +build !convey,!std
+
+package incr
+
+import (
+	"github.com/jordanorelli/tea"
+	"testing"
+)
+
+type testInt struct {
+	X int `tea:"save"`
+}
+
+func (testInt) Run(t *testing.T) {}
+
+type testIncr struct {
+	X      int `tea:"load"`
+	expect int
+}
+
+func (test *testIncr) Run(t *testing.T) {
+	test.X++
+	if test.X != test.expect {
+		t.Errorf("expected X to be %d, is %d instead", test.expect, test.X)
+	}
+}
+
+func TestOnce(t *testing.T) {
+	root := tea.New(&testInt{X: 1})
+	root.Child(&testIncr{expect: 2})
+	tea.Run(t, root)
+}
+
+func TestTwice(t *testing.T) {
+	root := tea.New(&testInt{X: 1})
+	root.Child(&testIncr{expect: 2})
+	root.Child(&testIncr{expect: 2})
+	tea.Run(t, root)
+}