assert

package module
v0.15.0 Latest Latest
Warning

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

 Go to latest Published: Jul 25, 2022 License: MIT Imports: 15 Imported by: 0

README

OpenAPI - Assert

Build Status Codecov branch Go Reference Go Report Card License

Description

openapi-assert is a Go package that provides a affordable way to validate http requests and responses data throught OpenAPI Schema Specification (Swagger) and the project was inspired by PHP Swagger Assertions. It has the following features:

  • Assert request and response media types
  • Assert request and response headers
  • Assert request query strings
  • Assert request and response body.
  • Assert the entire http request and response object.

Requirements

OpenAPI Assert requires Go 1.11 or later.

Instalation

Use go get.

$ go get github.com/faabiosr/openapi-assert

Then import the package into your own code:

import "github.com/faabiosr/openapi-assert"

Usage

The package provides methods that allow you to assert raw data using swagger files.

See it in action:

package main

import (
    "log"
    "net/http"

    assert "github.com/faabiosr/openapi-assert"
)

func main() {
    doc, err := assert.LoadFromURI("http://petstore.swagger.io/v2/swagger.json")

    if err != nil {
        log.Fatal(err)
    }

    assert := assert.New(doc)

    log.Println(
        assert.RequestMediaType("text/html", "/pet", http.MethodPost),
    )

    log.Println(
        assert.RequestMediaType("image/gif", "/v2/pet", http.MethodPost),
    )
}

Asserting http request object using the swagger schema file:

package main

import (
	"fmt"
	"log"
	"net/http"

	assert "github.com/faabiosr/openapi-assert"
)

func main() {
	doc, err := assert.LoadFromURI("http://petstore.swagger.io/v2/swagger.json")

	if err != nil {
		log.Fatal(err)
	}

	assert := assert.New(doc)

	http.HandleFunc("/v2/pet", func(w http.ResponseWriter, r *http.Request) {
		err := assert.Request(r)

		fmt.Fprint(w, err)
	})

	log.Fatal(
		http.ListenAndServe("127.0.0.1:9000", nil),
	)
}

Asserting http response object using the swagger schema file:

package main

import (
	"log"
	"net/http"

	assert "github.com/faabiosr/openapi-assert"
)

func main() {
	doc, err := assert.LoadFromURI("http://petstore.swagger.io/v2/swagger.json")

	if err != nil {
		log.Fatal(err)
	}

	assert := assert.New(doc)

	res, err := http.Get("https://petstore.swagger.io/v2/pet/111111422")

	if err != nil {
		log.Fatal(err)
	}

	log.Println(assert.Response(res))
}

Examples

Development

Requirements
Makefile
# Clean up
$ make clean

# Download project dependencies
$ make configure

# Run tests and generates html coverage file
$ make cover

# Format all go files
$ make fmt

# GolangCI-Lint
$ make lint

# Run tests
$make test

License

This project is released under the MIT licence. See LICENSE for more details.

Documentation

Overview

Package assert provides methods that allow you to assert raw data using swagger files.

Example Usage

See it in action: 

package main

import (
    "log"
    "net/http"

    assert "github.com/faabiosr/openapi-assert"
)

func main() {
    doc, err := assert.LoadFromURI("http://petstore.swagger.io/v2/swagger.json")

    if err != nil {
        log.Fatal(err)
    }

    assert := assert.New(doc)

    log.Println(
        assert.RequestMediaType("text/html", "/pet", http.MethodPost),
    )

    log.Println(
        assert.RequestMediaType("image/gif", "/v2/pet", http.MethodPost),
    )
}

Asserting http request object using the swagger schema file: 

package main

import (
    "fmt"
    "log"
    "net/http"

    assert "github.com/faabiosr/openapi-assert"
)

func main() {
    doc, err := assert.LoadFromURI("http://petstore.swagger.io/v2/swagger.json")

    if err != nil {
        log.Fatal(err)
    }

    assert := assert.New(doc)

    http.HandleFunc("/v2/pet", func(w http.ResponseWriter, r *http.Request) {
        err := assert.Request(r)

        fmt.Fprintf(w, err)
    })

    log.Fatal(
        http.ListenAndServer("127.0.0.1:9000", nil),
    )
}

Asserting http response object using the swagger schema file: 

package main

import (
    "log"
    "net/http"

    assert "github.com/faabiosr/openapi-assert"
)

func main() {
    doc, err := assert.LoadFromURI("http://petstore.swagger.io/v2/swagger.json")

    if err != nil {
        log.Fatal(err)
    }

    assert := assert.New(doc

    res, err := http.Get("https://petstore.swagger.io/v2/pet/111111422")

    if err != nil {
        log.Fatal(err)
    }

    log.Println(assert.Response(res))
}

Index

Constants

View Source 
const (
	// ErrSwaggerLoad returns an error when load swagger document.
	ErrSwaggerLoad = err("unable to load the document by uri")

	// ErrBodyNotFound returns an error when body does not exists.
	ErrBodyNotFound = err("body does not exists")
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Assertions 

type Assertions struct {
	// contains filtered or unexported fields
}

Assertions packs all assert methods into one structure.

func New 

func New(doc Document) *Assertions

New returns the Assertions instance.

func (*Assertions) Request added in v0.8.0 

func (a *Assertions) Request(req *http.Request) error

Request asserts http request against a schema.

func (*Assertions) RequestBody added in v0.6.0 

func (a *Assertions) RequestBody(body io.Reader, path, method string) error

RequestBody asserts request body against a schema.

func (*Assertions) RequestHeaders 

func (a *Assertions) RequestHeaders(header http.Header, path, method string) error

RequestHeaders asserts rquest headers againt a schema header list.

func (*Assertions) RequestMediaType 

func (a *Assertions) RequestMediaType(mediaType, path, method string) error

RequestMediaType asserts request media type against a list.

func (*Assertions) RequestQuery 

func (a *Assertions) RequestQuery(query url.Values, path, method string) error

RequestQuery asserts request query againt a schema query list.

func (*Assertions) Response added in v0.9.0 

func (a *Assertions) Response(res *http.Response) error

Response asserts http response against a schema.

func (*Assertions) ResponseBody added in v0.7.0 

func (a *Assertions) ResponseBody(body io.Reader, path, method string, statusCode int) error

ResponseBody asserts response body against a schema.

func (*Assertions) ResponseHeaders 

func (a *Assertions) ResponseHeaders(header http.Header, path, method string, statusCode int) error

ResponseHeaders asserts response headers againt a schema header list.

func (*Assertions) ResponseMediaType 

func (a *Assertions) ResponseMediaType(mediaType, path, method string) error

ResponseMediaType asserts response media type against a list.

type Body added in v0.7.0 

type Body interface{}

Body is a document schema in json format.

type Document 

type Document interface {
	// RequestMediaTypes retrives a list of request media types allowed.
	RequestMediaTypes(path, method string) ([]string, error)

	// ResponseMediaTypes retrives a list of response media types allowed.
	ResponseMediaTypes(path, method string) ([]string, error)

	// RequestHeaders retrieves a list of request headers.
	RequestHeaders(path, method string) (Headers, error)

	// ResponseHeaders retrieves a list of response headers.
	ResponseHeaders(path, method string, statusCode int) (Headers, error)

	// RequestQuery retrieves a list of request query.
	RequestQuery(path, method string) (Query, error)

	// RequestBody retrieves the request body.
	RequestBody(path, method string) (Body, error)

	// ResponseBody retrieves the response body.
	ResponseBody(path, method string, statusCode int) (Body, error)
}

Document that defines the contract for reading OpenAPI documents.

func LoadFromReader added in v0.11.0 

func LoadFromReader(r io.Reader) (Document, error)

LoadFromReader loads and expand swagger document from io.Reader.

func LoadFromURI 

func LoadFromURI(uri string) (Document, error)

LoadFromURI loads and expands swagger document by uri.

type Headers 

type Headers map[string]interface{}

Headers is a list of headers in json schema format.

type Param 

type Param struct {
	Type        string
	Description string
	In          string
}

Param is a document parameter in json schema format.

type Query 

type Query map[string]interface{}

Query is a list of query parameters in json schema format.

type Required 

type Required []string

Required is a list of required parameters.

Source Files

View all Source files

Directories

Path Synopsis
_examples
echo
middleware
echo

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.