Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/hofstadter-io/frisby
API testing framework inspired by frisby-js
https://github.com/hofstadter-io/frisby
api-testing-framework frisby frisby-js golang testing
Last synced: about 2 months ago
JSON representation
API testing framework inspired by frisby-js
- Host: GitHub
- URL: https://github.com/hofstadter-io/frisby
- Owner: hofstadter-io
- License: mit
- Created: 2015-09-15T14:35:58.000Z (over 9 years ago)
- Default Branch: master
- Last Pushed: 2020-03-03T23:49:00.000Z (almost 5 years ago)
- Last Synced: 2024-04-23T07:16:29.406Z (8 months ago)
- Topics: api-testing-framework, frisby, frisby-js, golang, testing
- Language: Go
- Size: 42 KB
- Stars: 277
- Watchers: 11
- Forks: 27
- Open Issues: 12
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
- awesome-go-extra - frisby - js|271|28|12|2015-09-15T14:35:58Z|2020-03-03T23:49:00Z| (Testing / Testing Frameworks)
README
# frisby
[](https://travis-ci.org/verdverm/frisby)
[](https://godoc.org/github.com/verdverm/frisby)
[](https://github.com/verdverm/frisby)
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
2. Backend
- master/minions
- db for analytics
- api for UI / clients [Goa](http://goa.domain)
- 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
```shell
go get -u github.com/verdverm/frisby
```
### Basic Usage
First create a Frisby object:
```go
// 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
```go
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.
```go
frisby.Global.BasicAuth("username", "password").
SetHeader("Authorization", "Bearer " + TOKEN)
```
Next send the request:
```go
F.Send()
```
Then assert and inspect the response:
```go
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
```go
frisby.Global.PrintReport()
```
Check any error(s), however the global report prints any that occured as well
`err := F.Error()`
```go
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](https://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](https://github.com/verdverm/pomopomo/tree/master/test/api)
```go
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
```
