README

frisby

Build Status GoDoc GitHub release

REST API testing framework inspired by frisby-js, written in Go

Proposals

I'm starting to work on frisby again with the following ideas:

  1. Read specification files
  • pyresttest
  • frisby.js
  • swagger spec
  • other?
  1. Use as a load tester
  • like Locust.io
  • distributed
  1. UI
  • Dashboard
  • Analytics
  • Reports
  • Manage multiple instances
  1. Backend
  • master/minions
  • db for analytics
  • api for UI / clients Goa
  • federation of minion groups?

Please comment on any issues or PRs related to these proposals. If you don't see an issue, PR, or idea; definitely add it!

Installation
go get -u github.com/verdverm/frisby
Basic Usage

First create a Frisby object:

// create an object with a given name (used in the report)
F := frisby.Create("Test successful user login").
    Get("https://golang.org")

Add any pre-flight data

F.SetHeader("Content-Type": "application/json").
	SetHeader("Accept", "application/json, text/plain, */*").
	SetJson([]string{"item1", "item2", "item3"})

There is also a Global object for setting repeated Pre-flight options.

frisby.Global.BasicAuth("username", "password").
	SetHeader("Authorization", "Bearer " + TOKEN)

Next send the request:

F.Send()

Then assert and inspect the response:

F.ExpectStatus(200).
    ExpectJson("nested.path.to.value", "sometext").
    ExpectJson("nested.path.to.object", golangObject).
    ExpectJson("nested.array.7.id", 23).
    ExpectJsonLength("nested.array", 8).
    AfterJson(func(F *frisby.Frisby, json *simplejson.Json, err error) {
		val, _ := json.Get("proxy").String()
		frisby.Global.SetProxy(val)
	})

Finally, print out a report of the tests

frisby.Global.PrintReport()

Check any error(s), however the global report prints any that occured as well

err := F.Error()

errs := F.Errors()
for _,e := range errs {
	fmt.Println("Error: ", e)
}
HTTP Method functions

Your basic HTTP verbs:

  • Get(url string)
  • Post(url string)
  • Put(url string)
  • Patch(url string)
  • Delete(url string)
  • Head(url string)
  • Options(url string)
Pre-flight functions

Functions called before Send()

You can also set theses on the frisby.Global object for persisting state over multiple requests.

( Most of these come from github.com/mozillazg/request)

  • BasicAuth(username,password string)
  • Proxy(url string)
  • SetHeader(key,value string)
  • SetHeaders(map[string]string)
  • SetCookies(key,value string)
  • SetCookiess(map[string]string)
  • SetDate(key,value string)
  • SetDates(map[string]string)
  • SetParam(key,value string)
  • SetParams(map[string]string)
  • SetJson(interface{})
  • SetFile(filename string)
Post-flight functions

Functions called after Send()

  • ExpectStatus(code int)
  • ExpectHeader(key, value string)
  • ExpectContent(content string)
  • ExpectJson(path string, value interface{})
  • ExpectJsonLength(path string, length int)
  • ExpectJsonType(path string, value_type reflect.Kind)
  • AfterContent( func(Frisby,[]byte,error) )
  • AfterText( func(Frisby,string,error) )
  • AfterJson( func(Frisby,simplejson.Json,error) )
  • PauseTest(t time.Duration)
  • PrintBody()
  • PrintReport()
  • PrintGoTestReport()
More examples

You can find a longer example here

package main

import (
	"fmt"
	"reflect"

	"github.com/bitly/go-simplejson"
	"github.com/verdverm/frisby"
)

func main() {
	fmt.Println("Frisby!\n")

	frisby.Create("Test GET Go homepage").
		Get("http://golang.org").
		Send().
		ExpectStatus(200).
		ExpectContent("The Go Programming Language")

	frisby.Create("Test GET Go homepage (which fails)").
		Get("http://golang.org").
		Send().
		ExpectStatus(400).
		ExpectContent("A string which won't be found")

	frisby.Create("Test POST").
		Post("http://httpbin.org/post").
		SetData("test_key", "test_value").
		Send().
		ExpectStatus(200)

	frisby.Create("Test ExpectJsonType").
		Post("http://httpbin.org/post").
		Send().
		ExpectStatus(200).
		ExpectJsonType("url", reflect.String)

	frisby.Create("Test ExpectJson").
		Post("http://httpbin.org/post").
		Send().
		ExpectStatus(200).
		ExpectJson("url", "http://httpbin.org/post").
		ExpectJson("headers.Accept", "*/*")

	frisby.Create("Test ExpectJsonLength (which fails)").
		Post("http://httpbin.org/post").
		SetJson([]string{"item1", "item2", "item3"}).
		Send().
		ExpectStatus(200).
		ExpectJsonLength("json", 4)

	frisby.Create("Test AfterJson").
		Post("http://httpbin.org/post").
		Send().
		ExpectStatus(200).
		AfterJson(func(F *frisby.Frisby, json *simplejson.Json, err error) {
		val, _ := json.Get("url").String()
		frisby.Global.SetProxy(val)
	})

	frisby.Global.PrintReport()
}

Sample Output

Frisby!

.......
For 7 requests made
  FAILED  [3/13]
      [Test ExpectJsonLength]
        -  Expect length to be 4, but got 3
      [Test GET Go homepage (which fails)]
        -  Expected Status 400, but got 200: "200 OK"
        -  Expected Body to contain "A string which won't be found", but it was missing

catch!

Expand ▾ Collapse ▴

Documentation

Index

Examples

Constants

View Source
const DefaultPathSeparator = "."

Variables

View Source
var Global global_data

Functions

This section is empty.

Types

type AfterContentFunc

type AfterContentFunc func(F *Frisby, content []byte, err error)

    function type used as argument to AfterContent()

    type AfterJsonFunc

    type AfterJsonFunc func(F *Frisby, json *simplejson.Json, err error)

      function type used as argument to AfterJson()

      type AfterTextFunc

      type AfterTextFunc func(F *Frisby, text string, err error)

        function type used as argument to AfterText()

        type ExpectFunc

        type ExpectFunc func(F *Frisby) (bool, string)

          ExpectFunc function type used as argument to Expect()

          type Frisby

          type Frisby struct {
          	Name   string
          	Url    string
          	Method string
          
          	Req           *request.Request
          	Resp          *request.Response
          	Errs          []error
          	ExecutionTime float64
          }

          func Create

          func Create(name string) *Frisby

            Creates a new Frisby object with the given name.

            The given name will be used if you call PrintReport()

            func (*Frisby) AddError

            func (F *Frisby) AddError(err_str string) *Frisby

              Manually add an error, if you need to

              func (*Frisby) AddFile

              func (F *Frisby) AddFile(filename string) *Frisby

                Add a file to the Form data for the coming request

                func (*Frisby) AddFileByKey

                func (F *Frisby) AddFileByKey(key, filename string) *Frisby

                  Add a file to the Form data for the coming request

                  func (*Frisby) AfterContent

                  func (F *Frisby) AfterContent(foo AfterContentFunc) *Frisby

                    AfterContent allows you to write your own functions for inspecting the body of the response. You are also provided with the Frisby object.

                    The function signiture is AfterContentFunc

                    type AfterContentFunc func(F *Frisby, content []byte, err error)
                    

                    func (*Frisby) AfterJson

                    func (F *Frisby) AfterJson(foo AfterJsonFunc) *Frisby

                      AfterJson allows you to write your own functions for inspecting the body of the response. You are also provided with the Frisby object.

                      The function signiture is AfterJsonFunc

                      type AfterJsonFunc func(F *Frisby, json *simplejson.Json, err error)
                      

                      simplejson docs: https://github.com/bitly/go-simplejson

                      Example
                      Output:
                      
                      url = http://httpbin.org/post
                      

                      func (*Frisby) AfterText

                      func (F *Frisby) AfterText(foo AfterTextFunc) *Frisby

                        AfterText allows you to write your own functions for inspecting the body of the response. You are also provided with the Frisby object.

                        The function signiture is AfterTextFunc

                        type AfterTextFunc func(F *Frisby, text string, err error)
                        

                        func (*Frisby) BasicAuth

                        func (F *Frisby) BasicAuth(user, passwd string) *Frisby

                          Set BasicAuth values for the coming request

                          func (*Frisby) Delete

                          func (F *Frisby) Delete(url string) *Frisby

                            Set the HTTP method to DELETE for the given URL

                            func (*Frisby) Error

                            func (F *Frisby) Error() error

                              Get the most recent error for the Frisby object

                              This function should be called last

                              func (*Frisby) Errors

                              func (F *Frisby) Errors() []error

                                Get all errors for the Frisby object

                                This function should be called last

                                func (*Frisby) Expect

                                func (F *Frisby) Expect(foo ExpectFunc) *Frisby

                                  Expect Checks according to the given function, which allows you to describe any kind of assertion.

                                  func (*Frisby) ExpectContent

                                  func (F *Frisby) ExpectContent(content string) *Frisby

                                    Checks the response body for the given string

                                    func (*Frisby) ExpectHeader

                                    func (F *Frisby) ExpectHeader(key, value string) *Frisby

                                      Checks for header and if values match

                                      func (*Frisby) ExpectJson

                                      func (F *Frisby) ExpectJson(path string, value interface{}) *Frisby

                                        ExpectJson uses the reflect.DeepEqual to compare the response JSON and the supplied JSON for structural and value equality

                                        path can be a dot joined field names. ex: 'path.to.subobject.field'

                                        Example
                                        Output:
                                        
                                        Pass  [Test ExpectJson]
                                        

                                        func (*Frisby) ExpectJsonLength

                                        func (F *Frisby) ExpectJsonLength(path string, length int) *Frisby

                                          ExpectJsonLength checks if the JSON at path is an array and has the correct length

                                          path can be a dot joined field names. ex: 'path.to.subobject.field'

                                          func (*Frisby) ExpectJsonType

                                          func (F *Frisby) ExpectJsonType(path string, val_type reflect.Kind) *Frisby

                                            ExpectJsonType checks if the types of the response JSON and the supplied JSON match

                                            path can be a dot joined field names. ex: 'path.to.subobject.field'

                                            Example
                                            Output:
                                            
                                            Pass  [Test ExpectJsonType]
                                            

                                            func (*Frisby) ExpectStatus

                                            func (F *Frisby) ExpectStatus(code int) *Frisby

                                              Checks the response status code

                                              func (*Frisby) Get

                                              func (F *Frisby) Get(url string) *Frisby

                                                Set the HTTP method to GET for the given URL

                                                Example
                                                Output:
                                                
                                                Pass  [Test GET Go homepage]
                                                

                                                func (*Frisby) Head

                                                func (F *Frisby) Head(url string) *Frisby

                                                  Set the HTTP method to HEAD for the given URL

                                                  func (*Frisby) Options

                                                  func (F *Frisby) Options(url string) *Frisby

                                                    Set the HTTP method to OPTIONS for the given URL

                                                    func (*Frisby) Patch

                                                    func (F *Frisby) Patch(url string) *Frisby

                                                      Set the HTTP method to PATCH for the given URL

                                                      func (*Frisby) PauseTest

                                                      func (F *Frisby) PauseTest(t time.Duration) *Frisby

                                                        Pause your testrun for a defined amount of seconds

                                                        func (*Frisby) Post

                                                        func (F *Frisby) Post(url string) *Frisby

                                                          Set the HTTP method to POST for the given URL

                                                          Example
                                                          Output:
                                                          
                                                          Pass  [Test POST]
                                                          

                                                          func (*Frisby) PrintBody

                                                          func (F *Frisby) PrintBody() *Frisby

                                                            Prints the body of the response

                                                            func (*Frisby) PrintGoTestReport

                                                            func (F *Frisby) PrintGoTestReport() *Frisby

                                                              Prints a report for the Frisby Object in go_test format

                                                              If there are any errors, they will all be printed as well

                                                              func (*Frisby) PrintReport

                                                              func (F *Frisby) PrintReport() *Frisby

                                                                Prints a report for the Frisby Object

                                                                If there are any errors, they will all be printed as well

                                                                Example
                                                                Output:
                                                                
                                                                FAIL  [Test GET Go homepage]
                                                                        -  Expected Status 400, but got 200: "200 OK"
                                                                        -  Expected Body to contain "A string which won't be found", but it was missing
                                                                        -  Manually Added Error
                                                                

                                                                func (*Frisby) Put

                                                                func (F *Frisby) Put(url string) *Frisby

                                                                  Set the HTTP method to PUT for the given URL

                                                                  func (*Frisby) Send

                                                                  func (F *Frisby) Send() *Frisby

                                                                    Send the actual request to the URL

                                                                    func (*Frisby) SetCookie

                                                                    func (F *Frisby) SetCookie(key, value string) *Frisby

                                                                      Set a Cookie value for the coming request

                                                                      func (*Frisby) SetCookies

                                                                      func (F *Frisby) SetCookies(cookies map[string]string) *Frisby

                                                                        Set several Cookie values for the coming request

                                                                        func (*Frisby) SetData

                                                                        func (F *Frisby) SetData(key, value string) *Frisby

                                                                          Set a Form data for the coming request

                                                                          func (*Frisby) SetDatas

                                                                          func (F *Frisby) SetDatas(datas map[string]string) *Frisby

                                                                            Set several Form data for the coming request

                                                                            func (*Frisby) SetHeader

                                                                            func (F *Frisby) SetHeader(key, value string) *Frisby

                                                                              Set a Header value for the coming request

                                                                              func (*Frisby) SetHeaders

                                                                              func (F *Frisby) SetHeaders(headers map[string]string) *Frisby

                                                                                Set several Headers for the coming request

                                                                                func (*Frisby) SetJson

                                                                                func (F *Frisby) SetJson(json interface{}) *Frisby

                                                                                  Set the JSON body for the coming request

                                                                                  func (*Frisby) SetParam

                                                                                  func (F *Frisby) SetParam(key, value string) *Frisby

                                                                                    Set a url Param for the coming request

                                                                                    func (*Frisby) SetParams

                                                                                    func (F *Frisby) SetParams(params map[string]string) *Frisby

                                                                                      Set several url Param for the coming request

                                                                                      func (*Frisby) SetProxy

                                                                                      func (F *Frisby) SetProxy(url string) *Frisby

                                                                                        Set Proxy URL for the coming request

                                                                                        Directories

                                                                                        Path Synopsis