mockingjay

package
Version: v0.0.0-...-7b93ee8 Latest Latest
Warning

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

Go to latest
Published: Jan 15, 2021 License: MIT Imports: 24 Imported by: 1

README

mockingjay

GoDoc

Create a server from configuration. Can be useful for:

  • Integration tests
  • Consumer driven contracts
  • Performance tests when combined with monkey

Example

package main

import (
	"github.com/quii/mockingjay-server/mockingjay"
	"log"
	"net/http"
)

func main() {
	testYAML := `
---
 - name: Test endpoint
   request:
     uri: /hello
     method: GET
   response:
     code: 200
     body: hello, world
     headers:
       content-type: text/plain

 - name: Test endpoint 2
   request:
     uri: /world
     method: DELETE
   response:
     code: 200
     body: hello, world

 - name: Failing endpoint
   request:
     uri: /card
     method: POST
     body: Greetings
   response:
     code: 500
     body: Oh bugger
 `
	endpoints, err := mockingjay.NewFakeEndpoints([]byte(testYAML))

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

	server := mockingjay.NewServer(endpoints)

	// Mount it just like any other server
	http.Handle("/", server)
	http.ListenAndServe(":9090", nil)
}

Building

  • Requires Go 1.3+
  • godeps

## Todo

  • Although it supports request/response headers, it only supports one value per header (http allows you to set multiple values)
  • Tests for stuff inside request.go

Documentation

Overview

Package mockingjay allows you to create a HTTP server to return canned responses for certain requests. These operations are configured via YAML. The aim of this is to let you easily create fake servers for testing purposes.

Index

Examples

Constants

View Source
const DefaultHTTPTimeoutSeconds = 5

DefaultHTTPTimeoutSeconds is the default http timeout for compatability checks

Variables

This section is empty.

Functions

This section is empty.

Types

type CompatibilityChecker

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

CompatibilityChecker is responsible for checking endpoints are compatible

func NewCompatabilityChecker

func NewCompatabilityChecker(logger *log.Logger, httpTimeout time.Duration) *CompatibilityChecker

NewCompatabilityChecker creates a new CompatabilityChecker. The httpTimeout refers to the http timeout when making requests to the real server

func (*CompatibilityChecker) CheckCompatibility

func (c *CompatibilityChecker) CheckCompatibility(endpoints []FakeEndpoint, realURL string) bool

CheckCompatibility checks the endpoints against a "real" URL

type FakeEndpoint

type FakeEndpoint struct {
	Name        string //A description of what this endpoint is.
	CDCDisabled bool   // When set to true it will not be included in the consumer driven contract tests against real server
	Request     Request
	Response    response
}

FakeEndpoint represents the information required to listen to a particular request and respond to it

func NewFakeEndpoints

func NewFakeEndpoints(data io.ReadCloser) (endpoints []FakeEndpoint, err error)

NewFakeEndpoints returns an array of Endpoints from a YAML byte array. Returns an error if YAML cannot be parsed or there are validation concerns

func NewFakeEndpointsFromJSON

func NewFakeEndpointsFromJSON(data io.ReadCloser) (endpoints []FakeEndpoint, err error)

NewFakeEndpointsFromJSON returns an array of Endpoints from a JSON byte array. Returns an error if JSON cannot be parsed or there are validation concerns

func (FakeEndpoint) Generate

func (f FakeEndpoint) Generate(rand *rand.Rand, size int) reflect.Value

Generate creates a random endpoint typically used for testing

func (*FakeEndpoint) String

func (f *FakeEndpoint) String() string

type MJDecoder

type MJDecoder interface {
	Decode(interface{}) error
}

type MJDecoderFunc

type MJDecoderFunc func(interface{}) error

func (MJDecoderFunc) Decode

func (m MJDecoderFunc) Decode(target interface{}) error

type RegexField

type RegexField struct {
	*regexp.Regexp
}

RegexField allows you to work with regex fields in YAML

func (*RegexField) MarshalJSON

func (r *RegexField) MarshalJSON() ([]byte, error)

MarshalJSON returns a string for the regex

func (*RegexField) MarshalYAML

func (r *RegexField) MarshalYAML() (interface{}, error)

MarshalYAML returns the string of the regex

func (*RegexField) UnmarshalJSON

func (r *RegexField) UnmarshalJSON(data []byte) error

UnmarshalJSON will unhmarshal a JSON field into regexp

func (*RegexField) UnmarshalYAML

func (r *RegexField) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML will unhmarshal a YAML field into regexp

type Request

type Request struct {
	URI      string            `yaml:"uri"`
	RegexURI *RegexField       `yaml:"regexuri,omitempty" json:"RegexURI,omitempty"`
	Method   string            `yaml:"method"`
	Headers  map[string]string `yaml:"headers,omitempty"`
	Body     string            `yaml:"body,omitempty"`
	Form     map[string]string `yaml:"form,omitempty"`
}

Request is a simplified version of a http.Request

func NewRequest

func NewRequest(httpRequest *http.Request) (req Request)

NewRequest creates a mockingjay request from a http request

func (Request) AsCURL

func (r Request) AsCURL(baseURL string) (string, error)

AsCURL returns a string which is the curl command to match the reqquest

func (Request) AsHTTPRequest

func (r Request) AsHTTPRequest(baseURL string) (req *http.Request, err error)

AsHTTPRequest tries to create a http.Request from a given baseURL

func (Request) Hash

func (r Request) Hash() string

func (Request) String

func (r Request) String() string

type Server

type Server struct {
	Endpoints []FakeEndpoint
	// contains filtered or unexported fields
}

Server allows you to configure a HTTP server for a slice of fake endpoints

func NewServer

func NewServer(endpoints []FakeEndpoint, debugMode bool, newConfigStateWriter io.Writer) *Server

NewServer creates a new Server instance. debugMode will log additional info at runtime and newConfigStateWriter will write out the new state of the config if it gets changed at runtime

Example

ExampleNewServer is an example as to how to make a fake server. The mockingjay server implements what is needed to mount it as a standard web server.

// Create a fake server from YAML
testYAML := `
---
 - name: Test endpoint
   request:
     uri: /hello
     method: GET
     headers:
       content-type: application/json
     body: foobar
   response:
     code: 200
     body: hello, world
     headers:
       content-type: text/plain

 - name: Test endpoint 2
   request:
     uri: /world
     method: DELETE
   response:
     code: 200
     body: hello, world

 - name: Failing endpoint
   request:
     uri: /card
     method: POST
     body: Greetings
   response:
     code: 500
     body: Oh bugger

 - name: Endpoint not used for CDC
   cdcdisabled: true
   request:
     uri: /burp
     method: POST
     body: Belch
   response:
     code: 500
     body: Oh no
 `

endpoints, _ := NewFakeEndpoints(yamlToReadCloser(testYAML))
server := NewServer(endpoints, false, ioutil.Discard)

// Mount it just like any other server
http.Handle("/", server)
http.ListenAndServe(":9090", nil)
Output:

func (*Server) ServeHTTP

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request)

Jump to

Keyboard shortcuts

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