frisby

package module
Version: v0.0.0-...-b165562 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 4, 2017 License: MIT Imports: 11 Imported by: 34

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!

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
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()
		fmt.Println("url =", val)
	})
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
package main

import (
	"github.com/verdverm/frisby"
)

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

}
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
package main

import (
	"reflect"

	"github.com/verdverm/frisby"
)

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

}
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
package main

import (
	"github.com/verdverm/frisby"
)

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

}
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
package main

import (
	"github.com/verdverm/frisby"
)

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

}
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
package main

import (
	"github.com/verdverm/frisby"
)

func main() {
	frisby.Create("Test GET Go homepage").
		Get("http://golang.org").
		Send().
		ExpectStatus(400).
		ExpectContent("A string which won't be found").
		AddError("Manually Added Error").
		PrintReport()

}
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

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL