assert

package module
Version: 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.

Directories

Path Synopsis
_examples
middleware

Jump to

Keyboard shortcuts

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