Writing Go(od) Tests (FOSDEM 2020)

Writing Go(od) Tests
Nikki Attea
Software Engineer
Sensu Inc

Hi, I’m Nikki.
@nikkixdev
www.nikki.dev
github.com/sensu/sensu-go
- 🏐🏖
- 🍷🍺
- 🐶🐶

Why Golang?
● Statically and structurally typed
● Compiled language with large standard library
● Self-contained
● Concurrent and asynchronous

Testing implications
● Statically and structurally typed
● Compiled language with large standard library
● Self-contained
● Concurrent and asynchronous

run all tests in this directory:
go test
run a single test against a fully qualiﬁed package name:
go test -v -run TestSubtotal github.com/nikkixdev/beer/api
run all tests with tags, timeout, and race detector:
go test -tags=integration -race -timeout=60s -v -run ./...
run all tests with code coverage:
go test -cover

main.go -> main_test.go
func TestXxx(t *testing.T) {
}

// Cart represents a shopping cart.
type Cart struct {
Cases []*Case
}
// Case represents a case of beer.
type Case struct {
Count int
Beer *Beer
Price float64
}
// Beer represents a type of beer.
type Beer struct {
Brand string
Name string
Ounces float64
}
// AddCase adds a case of beer to the
shopping cart.
func (c *Cart) AddCase(beerCase *Case) {
c.Cases = append(c.Cases, beerCase)
}
// FixtureBeer creates a Beer fixture for
use in test.
func FixtureBeer(brand string, name string,
ounces float64) *Beer {
return &Beer{
Brand: brand,
Name: name,
Ounces: ounces,
}
}

func TestAddCaseTesting(t *testing.T) {
cart := NewCart()
if len(cart.Cases) != 0 {
t.Fatal("expected empty cart")
}
blueLight := FixtureBeer("Labatt", "Blue Light", 12.0)
cart.AddCase(FixtureCase(6, blueLight, 10.99))
if len(cart.Cases) != 1 {
t.Fatal("expected 1 case in cart")
}
}

func TestAddCaseAssert(t *testing.T) {
cart := NewCart()
assert.Equal(t, 0, len(cart.Cases), "expected empty cart")
assert.Equal(t, 1, len(cart.Cases))
}

func TestSubtotal(t *testing.T) {
cart := NewCart()
duvelHop := FixtureBeer("Duvel", "Tripel Hop", 11.0)
cart.AddCase(FixtureCase(4, duvelHop, 14.99))
assert.Equal(t, 40.0, cart.Subtotal())
}

// Subtotal calculates the subtotal of the shopping cart.
func (c *Cart) Subtotal() float64 {
var subtotal float64
for _, beerCase := range c.Cases {
subtotal += beerCase.Price
}
return subtotal
}

func TestSubtotal(t *testing.T) {
cart := NewCart()
duvelHop := FixtureBeer("Duvel", "Tripel Hop", 11.0)
cart.AddCase(FixtureCase(4, duvelHop, 14.99))
assert.Equal(t, 39.98, cart.Subtotal())
}

func TestSubtotalSuite(t *testing.T) {
testCases := []struct {
name string
cart *Cart
subtotal float64
}{
{
name: "Empty cart",
cart: &Cart{},
subtotal: 0,
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
assert.Equal(t, tc.subtotal, tc.cart.Subtotal())
})
}
}

{
name: "Party time",
cart: &Cart{Cases: []*Case{
FixtureCase(4, FixtureBeer("Duvel", "Tripel Hop", 11.0), 14.99),
FixtureCase(30, FixtureBeer("Labatt", "Blue Light", 12.0), 24.99),
FixtureCase(30, FixtureBeer("Labatt", "Blue Light", 12.0), 24.99),
}},
subtotal: 64.97,
},
{
name: "Negative",
cart: &Cart{Cases: []*Case{
FixtureCase(4, FixtureBeer("Duvel", "Tripel Hop", 11.0), -14),
FixtureCase(30, FixtureBeer("Labatt", "Blue Light", 12.0), 24),
}},
subtotal: 10.00,
},

httptest.NewServer(http.Handler)

// ProcessPayment sends the total to an external payment api.
func ProcessPayment(total float64) ([]byte, error) {
b, _ := json.Marshal(total)
resp, err := http.Post("https://www.pay-me.com",
"application/json", bytes.NewBuffer(b))
if err != nil {
return nil, err
}
defer resp.Body.Close()
return ioutil.ReadAll(resp.Body)
}

func ProcessPayment(paymentServer string, total float64)
([]byte, error) {
resp, err := http.Post(paymentServer, "application/json",
bytes.NewBuffer(b))
if err != nil {
return nil, err
}
}

testCases := []struct {
name string
handler http.HandlerFunc
expectedError error
expectedBody []byte
}{
{
name: "OK",
handler: func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`OK`))
w.WriteHeader(http.StatusOK)
},
expectedError: nil,
expectedBody: []byte(`OK`),
},
{
name: "Internal server error",
handler: func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
},
expectedError: fmt.Errorf("payment server error: %d", http.StatusInternalServerError),
},
}

for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
ts := httptest.NewServer(http.HandlerFunc(tc.handler))
defer ts.Close()
body, err := ProcessPayment(ts.URL, 21.11)
assert.Equal(t, tc.expectedError, err)
assert.Equal(t, tc.expectedBody, body)
})
}

func ProcessPayment(paymentServer string, total float64)
([]byte, error) {
resp, err := http.Post(paymentServer, "application/json",
bytes.NewBuffer(b))
if err != nil {
return nil, err
}
if resp.StatusCode >= 400 {
return nil, fmt.Errorf("payment server error: %d",
resp.StatusCode)
}
}

context.Background() vs. context.TODO()

var (
background = new(emptyCtx)
todo = new(emptyCtx)
)
// Background returns a non-nil, empty Context. It is never canceled, has no
// values, and has no deadline. It is typically used by the main function,
// initialization, and tests, and as the top-level Context for incoming
// requests.
func Background() Context {
return background
}
// TODO returns a non-nil, empty Context. Code should use context.TODO when
// it's unclear which Context to use or it is not yet available (because the
// surrounding function has not yet been extended to accept a Context
// parameter).
func TODO() Context {
return todo
}

// Subscription represents a shopping cart.
type Subscription struct {
Cart *Cart
Interval time.Duration
messageChan chan interface{}
}
// startSubscriptionTimer starts a timer and fires the cart to the
// order handler when the order is ready.
func (s *Subscription) startSubscriptionTimer(ctx context.Context) {
ticker := time.NewTicker(s.Interval)
defer ticker.Stop()
for {
select {
case <-ctx.Done():
return
case <-ticker.C:
s.messageChan <- s.Cart
}
}
}

func TestStartSubscriptionTimer(t *testing.T) {
cart1 := &Cart{Cases: []*Case{FixtureCase(4, FixtureBeer("Duvel", "Tripel Hop", 11.0), 14)}}
cart2 := &Cart{Cases: []*Case{FixtureCase(30, FixtureBeer("Labatt", "Blue Light", 12.0), 24)}}
subscription := &Subscription{
Cart: cart1,
Interval: time.Duration(1) * time.Second,
messageChan: make(chan interface{}),
}
go subscription.startSubscriptionTimer(context.Background())
msg := <-subscription.messageChan
order, ok := msg.(*Cart)
if !ok {
t.Fatal("received invalid message on message channel")
}
assert.Equal(t, cart1, order)
subscription.Cart = cart2
msg = <-subscription.messageChan
order, ok = msg.(*Cart)
if !ok {
t.Fatal("received invalid message on message channel")
}
assert.Equal(t, cart2, order)
}

// startOrderHandler listens to the message channel and handles incoming orders.
func (o *OrderHandler) startOrderHandler(ctx context.Context) {
for {
msg, ok := <-o.messageChan
if !ok {
logger.Debug("message channel closed")
return
}
cart, ok := msg.(*Cart)
if ok {
if err := o.PlaceOrder(ctx, cart); err != nil {
logger.WithError(err).Error("error placing order")
continue
}
logger.Info("successfully placed order")
continue
}
logger.WithField("msg", msg).Errorf("received invalid message on message channel")
}
}

func TestStartOrderHandler(t *testing.T) {
handler := &OrderHandler{
messageChan: make(chan interface{}),
}
go handler.startOrderHandler(context.Background())
assert.Equal(t, 0, len(handler.ProcessedOrders))
handler.messageChan <- FixtureCart()
handler.messageChan <- FixtureCart()
handler.messageChan <- FixtureCase(30, FixtureBeer("Labatt", "Blue Light",
12.0), 24)
assert.Equal(t, 2, len(handler.ProcessedOrders))
}

race conditions & race detection

$ go test -run TestStartSubscriptionTimer -race
==================
WARNING: DATA RACE
Read at 0x00c00000e5e0 by goroutine 9:
github.com/nikkixdev/beer.(*Subscription).startSubscriptionTimer()
/Users/nikkixdev/go/src/github.com/nikkixdev/beer/main.go:123 +0xb7
Previous write at 0x00c00000e5e0 by goroutine 8:
github.com/nikkixdev/beer.TestStartSubscriptionTimer()
/Users/nikkixdev/go/src/github.com/nikkixdev/beer/main_test.go:138 +0x582
testing.tRunner()
/usr/local/go/src/testing/testing.go:909 +0x199
Goroutine 9 (running) created at:
github.com/nikkixdev/beer.TestStartSubscriptionTimer()
/Users/nikkixdev/go/src/github.com/nikkixdev/beer/main_test.go:130 +0x4cf
testing.tRunner()
/usr/local/go/src/testing/testing.go:909 +0x199
==================
--- FAIL: TestStartSubscriptionTimer (2.01s)
testing.go:853: race detected during execution of test
FAIL
exit status 1
FAIL github.com/nikkixdev/beer 2.387s

main.go L123
s.messageChan <- s.Cart
main_test.go L138
subscription.Cart = cart2

type Subscription struct {
cart *Cart
interval time.Duration
messageChan chan interface{}
mu sync.Mutex
}
// GetCart safely retrieves the subscriptions shopping cart.
func (s *Subscription) GetCart() *Cart {
s.mu.Lock()
defer s.mu.Unlock()
return s.cart
}
// SetCart safely sets the subscriptions shopping cart.
func (s *Subscription) SetCart(c *Cart) {
s.mu.Lock()
defer s.mu.Unlock()
s.cart = c
}

$ go test -run ./... -race
PASS
ok github.com/nikkixdev/beer 3.113s

Thanks for listening!
@nikkixdev
www.nikki.dev
github.com/nikkixdev/beer-testing
Resources
Go docs:
golang.org
Special thanks for the gopher illustrations:
● github.com/ashleymcnamara/gophers
● github.com/marcusolsson/gophers
● github.com/MariaLetta/free-gophers-pack

Writing Go(od) Tests (FOSDEM 2020)

More Related Content

What's hot (17)

Similar to Writing Go(od) Tests (FOSDEM 2020) (20)

Recently uploaded (20)

Writing Go(od) Tests (FOSDEM 2020)