Popularity
5.8
Stable
Activity
0.0
Stable
264
9
26

Programming language: Go
License: MIT License
Tags: Testing     Testing Frameworks    
Latest version: v1.0.1

frisby alternatives and similar packages

Based on the "Testing Frameworks" category.
Alternatively, view frisby alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of frisby or a related project?

Add another 'Testing Frameworks' Package

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?
  2. Use as a load tester
    • like Locust.io
    • distributed
  3. UI
    • Dashboard
    • Analytics
    • Reports
    • Manage multiple instances
  4. 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!