https://github.com/manveru/gobdd

BDD in Go
https://github.com/manveru/gobdd

Last synced: 2 months ago
JSON representation

BDD in Go

• Host: GitHub
• URL: https://github.com/manveru/gobdd
• Owner: manveru
• Created: 2012-03-01T11:00:45.000Z (almost 13 years ago)
• Default Branch: master
• Last Pushed: 2013-12-10T09:25:15.000Z (about 11 years ago)
• Last Synced: 2024-06-18T21:56:54.257Z (7 months ago)
• Language: Go
• Homepage: http://degutis.org
• Size: 107 KB
• Stars: 5
• Watchers: 3
• Forks: 2
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# BDD testing for Go

It's pretty cool.

## Installation

	make test # assurance that it works

	make install # installs to your $GOROOT

## Usage

Create a gotest-style file (ie, *_test.go) containing the following:

	package my_cool_app

	

	import . "gobdd"

	func init() {

	  defer PrintSpecReport()

  

	  type MyGreatTestType struct {

	    Name string

	    Age int

	  }

  

	  MyNil := func() *MyGreatTestType {

	    return nil

	  }

  

	  MyNonNil := func() *MyGreatTestType {

	    return &MyGreatTestType{}

	  }

  

	  var anObject *MyGreatTestType

  

	  Describe("matchers", func() {

    

	    BeforeEach(func() {

	      // this is run at this level and every describe within it, however deeply nested

	      anObject = new(MyGreatTestType)

	      anObject.Name = "john"

	      anObject.Age = 23

	    })

    

	    Describe("not equals", func() {

      

	      It("matches on simple objects", func() {

	        Expect(&MyGreatTestType{"john", 23}, ToNotEqual, anObject)

	        Expect("foo", ToEqual, "foo")

	        Expect("foo", ToNotEqual, "bar")

	      })

      

	      It("matches for typed-nil", func() {

	        Expect(MyNil(), ToBeNil)

	        Expect(MyNonNil(), ToNotBeNil)

	      })

      

	      It("matches for nil", func() {

	        Expect(nil, ToBeNil)

	        Expect(true, ToNotBeNil)

	      })

      

	    })

    

	    Describe("deep equals matcher", func() {

      

	      It("matches what equals does not", func() {

	        Expect(&MyGreatTestType{"john", 23}, ToDeepEqual, anObject)

	        Expect("foo", ToDeepEqual, "foo")

	      })

      

	    })

    

	    Describe("exception-rescuing matchers", func() {

      

	      It("is super cool", func() {

	        Expect(func() { panic("foobar!") }, ToPanicWith, "foobar!")

	        Expect(func() {}, ToNotPanic)

	      })

      

	    })

    

	  })

	}

Next, add the following lines to *only one* of your *_test.go files:

	import "testing"

	func TestEverything(t *testing.T) {}

Then, to run the tests, use either of these:

	make test

	gotest

(It's just the same as running tests using the built-in testing framework.)

## Writing your own matchers

	func ToBeTruthy(obj interface{}) (string, bool) {

	  if obj != true {

	    return fmt.Sprintf(

			"expected: true\n"+

			"     got: %v\n", obj), false

	  }

	  return "", true

	}

Your custom matchers may take any number of arguments of any type your heart so desires. For example:

	func ToBeInside(obj interface{}, array []string) (string, bool) {

	  found := false

  

	  for _, v := range array {

	    if obj == v { found = true }

	  }

  

	  if !found {

	    return fmt.Sprintf(

			"expected to find: %v\n"+

			"        in array: %v\n", obj, array), false

	  }

	  return "", true

	}

will then work with `Expect("foo", ToBeInside, []string{"foo"})`

## License

Public domain