goblin

README

Goblin

A Mocha like BDD testing framework for Go

No extensive documentation nor complicated steps to get it running

Run tests as usual with go test

Colorful reports and beautiful syntax

Why Goblin?

Inspired by the flexibility and simplicity of Node BDD and frustrated by the rigorousness of Go way of testing, we wanted to bring a new tool to write self-describing and comprehensive code.

What do I get with it?

• Preserve the exact same syntax and behaviour as Node's Mocha
• Nest as many Describe and It blocks as you want
• Use Before, BeforeEach, After and AfterEach for setup and teardown your tests
• No need to remember confusing parameters in Describe and It blocks
• Use a declarative and expressive language to write your tests
• Plug different assertion libraries (Gomega supported so far)
• Skip your tests the same way as you would do in Mocha
• Automatic terminal support for colored outputs
• Two line setup is all you need to get up running

How do I use it?

Since go test is not currently extensive, you will have to hook Goblin to it. You do that by adding a single test method in your test file. All your goblin tests will be implemented inside this function.

package foobar

import (
    "testing"
    . "github.com/franela/goblin"
)

func Test(t *testing.T) {
    g := Goblin(t)
    g.Describe("Numbers", func() {
        g.It("Should add two numbers ", func() {
            g.Assert(1+1).Equal(2)
        })
        g.It("Should match equal numbers", func() {
            g.Assert(2).Equal(4)
        })
        g.It("Should substract two numbers")
    })
}

Ouput will be something like:

Nice and easy, right?

Can I do asynchronous tests?

Yes! Goblin will help you to test asynchronous things, like goroutines, etc. You just need to add a done parameter to the handler function of your It. This handler function should be called when your test passes.

  ...
  g.Describe("Numbers", func() {
      g.It("Should add two numbers asynchronously", func(done Done) {
          go func() {
              g.Assert(1+1).Equal(2)
              done()
          }()
      })
  })
  ...

Goblin will wait for the done call, a Fail call or any false assertion.

How do I use it with Gomega?

Gomega is a nice assertion framework. But it doesn't provide a nice way to hook it to testing frameworks. It should just panic instead of requiring a fail function. There is an issue about that here. While this is being discussed and hopefully fixed, the way to use Gomega with Goblin is:

package foobar

import (
    "testing"
    . "github.com/franela/goblin"
    . "github.com/onsi/gomega"
)

func Test(t *testing.T) {
    g := Goblin(t)

    //special hook for gomega
    RegisterFailHandler(func(m string, _ ...int) { g.Fail(m) })

    g.Describe("lala", func() {
        g.It("lslslslsls", func() {
            Expect(1).To(Equal(10))
        })
    })
}

FAQ:

How do I run specific tests?

If -goblin.run=$REGES is supplied to the go test command then only tests that match the supplied regex will run

TODO:

We do have a couple of issues pending we'll be addressing soon. But feel free to contribute and send us PRs (with tests please 😄).

Contributions:

Special thanks to Leandro Reox (Leitan) for the goblin logo.

Documentation

Index

• func ResolveStack(skip int) []string
• type Assertion
  • func (a *Assertion) Eql(dst interface{})
  • func (a *Assertion) Equal(dst interface{})
  • func (a *Assertion) IsFalse(messages ...string)
  • func (a *Assertion) IsTrue(messages ...string)
• type Describe
• type DetailedReporter
  • func (r *DetailedReporter) SetTextFancier(f TextFancier)
• type Done
• type Failure
• type G
  • func Goblin(t *testing.T, arguments ...string) *G
  • func (g *G) After(h func())
  • func (g *G) AfterEach(h func())
  • func (g *G) Assert(src interface{}) *Assertion
  • func (g *G) Before(h func())
  • func (g *G) BeforeEach(h func())
  • func (g *G) Describe(name string, h func())
  • func (g *G) Errorf(format string, args ...interface{})
  • func (g *G) Fail(error interface{})
  • func (g *G) Failf(format string, args ...interface{})
  • func (g *G) It(name string, h ...interface{})
  • func (g *G) SetReporter(r Reporter)
  • func (g *G) Timeout(time time.Duration)
• type It
• type Monochrome
  • func (self *Monochrome) Cyan(text string) string
  • func (self *Monochrome) Gray(text string) string
  • func (self *Monochrome) Green(text string) string
  • func (self *Monochrome) Red(text string) string
  • func (self *Monochrome) WithCheck(text string) string
• type Reporter
• type Runnable
• type TerminalFancier
  • func (self *TerminalFancier) Cyan(text string) string
  • func (self *TerminalFancier) Gray(text string) string
  • func (self *TerminalFancier) Green(text string) string
  • func (self *TerminalFancier) Red(text string) string
  • func (self *TerminalFancier) WithCheck(text string) string
• type TextFancier

Functions

func ResolveStack

func ResolveStack(skip int) []string

Types

type Assertion

type Assertion struct {
	// contains filtered or unexported fields
}

func (*Assertion) Eql

func (a *Assertion) Eql(dst interface{})

func (*Assertion) Equal

func (a *Assertion) Equal(dst interface{})

func (*Assertion) IsFalse

func (a *Assertion) IsFalse(messages ...string)

func (*Assertion) IsTrue

func (a *Assertion) IsTrue(messages ...string)

type Describe

type Describe struct {
	// contains filtered or unexported fields
}

type DetailedReporter

type DetailedReporter struct {
	// contains filtered or unexported fields
}

func (*DetailedReporter) SetTextFancier

func (r *DetailedReporter) SetTextFancier(f TextFancier)

type Done

type Done func(error ...interface{})

type Failure

type Failure struct {
	// contains filtered or unexported fields
}

type G

type G struct {
	// contains filtered or unexported fields
}

func Goblin

func Goblin(t *testing.T, arguments ...string) *G

func (*G) After

func (g *G) After(h func())

func (*G) AfterEach

func (g *G) AfterEach(h func())

func (*G) Assert

func (g *G) Assert(src interface{}) *Assertion

func (*G) Before

func (g *G) Before(h func())

func (*G) BeforeEach

func (g *G) BeforeEach(h func())

func (*G) Describe

func (g *G) Describe(name string, h func())

func (*G) Errorf

func (g *G) Errorf(format string, args ...interface{})

Alias of Failf

func (*G) Fail

func (g *G) Fail(error interface{})

func (*G) Failf

func (g *G) Failf(format string, args ...interface{})

func (*G) It

func (g *G) It(name string, h ...interface{})

func (*G) SetReporter

func (g *G) SetReporter(r Reporter)

func (*G) Timeout

func (g *G) Timeout(time time.Duration)

type It

type It struct {
	// contains filtered or unexported fields
}

type Monochrome

type Monochrome struct {
}

func (*Monochrome) Cyan

func (self *Monochrome) Cyan(text string) string

func (*Monochrome) Gray

func (self *Monochrome) Gray(text string) string

func (*Monochrome) Green

func (self *Monochrome) Green(text string) string

func (*Monochrome) Red

func (self *Monochrome) Red(text string) string

func (*Monochrome) WithCheck

func (self *Monochrome) WithCheck(text string) string

type Reporter

type Reporter interface {
	// contains filtered or unexported methods
}

type Runnable

type Runnable interface {
	// contains filtered or unexported methods
}

type TerminalFancier

type TerminalFancier struct {
}

func (*TerminalFancier) Cyan

func (self *TerminalFancier) Cyan(text string) string

func (*TerminalFancier) Gray

func (self *TerminalFancier) Gray(text string) string

func (*TerminalFancier) Green

func (self *TerminalFancier) Green(text string) string

func (*TerminalFancier) Red

func (self *TerminalFancier) Red(text string) string

func (*TerminalFancier) WithCheck

func (self *TerminalFancier) WithCheck(text string) string

type TextFancier

type TextFancier interface {
	Red(text string) string
	Gray(text string) string
	Cyan(text string) string
	Green(text string) string
	WithCheck(text string) string
}