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)

Recommended

Recommended

More Related Content

What's hot

What's hot (17)

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

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

Recently uploaded

Recently uploaded (20)

Writing Go(od) Tests (FOSDEM 2020)