Goblin

A Mocha like BDD testing framework written in Go that requires no additional dependencies. Requires no extensive documentation nor complicated steps to get it running.

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?

• Run tests as usual with go test
• Colorful reports and beautiful syntax
• 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
• Use Skip, SkipIf, and Resume to selectively skip 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() {
        // Passing Test
        g.It("Should add two numbers ", func() {
            g.Assert(1+1).Equal(2)
        })
        // Failing Test
        g.It("Should match equal numbers", func() {
            g.Assert(2).Equal(4)
        })
        // Pending Test
        g.It("Should substract two numbers")
        // Excluded Test
        g.Xit("Should add two numbers ", func() {
            g.Assert(3+1).Equal(4)
        })
    })
}

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"
    goblin "github.com/franela/goblin"
    . "github.com/onsi/gomega"
)

func Test(t *testing.T) {
    g := goblin.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))
        })
    })
}

How do I skip tests?

Goblin provides several different methods of marking tests to be skipped.

• g.Xit("test name", ...) - excludes a single test from running
• g.Skip("test name", ...) - alias for Xit
• g.Skip() - when called without arguments, skips all following tests until Resume is called, or end of the Describe block is reached
• g.Resume() - stops skipping remaining tests
• g.SkipIf(...) - skips all following tests if all passed args can be coerced to true (ish), also can take func () bool as an argument

If all the tests within a suite are skipped, the Before, After, etc., hooks will not be run, which is convenient for suites that conditionally skip based on availability of external services.

package foobar

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

func Test(t *testing.T) {
    g := Goblin(t)
    g.Describe("Numbers", func() {
        // SkipIf allows you to dynamically disable test suites, for example
        // integration tests, or those which require supporting services
        g.SkipIf(func () {
            return os.Getenv("SKIP_NUMBERS") != ""
        })

        // This will skip a single test
        g.Xit("Should add two numbers ", func() {
            g.Assert(1+1).Equal(2)
        })
        // This is an alias for Xit
        g.Skip("Should match equal numbers", func() {
            g.Assert(2).Equal(4)
        })
        // This will cause all the rest of the tests in the Describe block to be
        // skipped until a Resume() call is made
        g.Skip()
        // This is skipped
        g.It("Should substract two numbers", func (){
            g.Assert(4-2).Equal(2)
        })

        // This will stop skipping of any tests and blocks
        g.Resume()
        // This will be run
        g.It("Should add two numbers ", func() {
            g.Assert(3+1).Equal(4)
        })
    })
}

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

Contributing

We do have a couple of issues pending. Feel free to contribute and send us PRs (with tests please 😄).

Special Thanks

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