efritz/derision

Function makeHandler has 6 return statements (exceeds 4 allowed).

Open

func makeHandler(input []byte) (handler.Handler, error) {
    payload := &jsonHandler{}
    if err := json.Unmarshal(input, &payload); err != nil {
        return nil, fmt.Errorf("failed to unmarshal payload (%s)", err.Error())
    }

Function Unmarshal has 6 return statements (exceeds 4 allowed).

Open

func Unmarshal(payload []byte) (Expectation, error) {
    e := &jsonExpectation{}
    if err := json.Unmarshal(payload, &e); err != nil {
        return nil, fmt.Errorf("failed to unmarshal payload (%s)", err.Error())
    }

Function makeHandlersFromPath has 5 return statements (exceeds 4 allowed).

Open

func makeHandlersFromPath(schema *gojsonschema.Schema, segments ...string) ([]handler.Handler, error) {
    data, err := loadYAML(segments...)
    if err != nil {
        return nil, err
    }

Function Unmarshal has 5 return statements (exceeds 4 allowed).

Open

func Unmarshal(payload []byte) (Template, error) {
    t := &jsonTemplate{}
    if err := json.Unmarshal(payload, &t); err != nil {
        return nil, fmt.Errorf("failed to unmarshal payload (%s)", err.Error())
    }

Function setupDataStructures has 5 return statements (exceeds 4 allowed).

Open

func setupDataStructures(config nacelle.Config, services nacelle.ServiceContainer) error {
    serverConfig := &Config{}
    if err := config.Load(serverConfig); err != nil {
        return err
    }

Method template.Respond has 5 return statements (exceeds 4 allowed).

Open

func (t *template) Respond(r *request.Request, m *expectation.Match) (response.Response, error) {
    args := map[string]interface{}{
        "Method":       r.Method,
        "Path":         r.Path,
        "Headers":      r.Headers,

exported func NewLog returns unexported type *request.log, which can be annoying to use

Open

func NewLog(capacity int) *log {

• Exclude checks
  • Disable engine
  • Disable check

exported type Request should have comment or be unexported

Open

type Request struct {

• Exclude checks
  • Disable engine
  • Disable check

exported var ErrIllegalStatusCode should have comment or be unexported

Open

var ErrIllegalStatusCode = fmt.Errorf("illegal status code")

• Exclude checks
  • Disable engine
  • Disable check

exported type Expectation should have comment or be unexported

Open

    Expectation interface {

• Exclude checks
  • Disable engine
  • Disable check

exported type Handler should have comment or be unexported

Open

type Handler func(r *request.Request) (response.Response, error)

• Exclude checks
  • Disable engine
  • Disable check

exported type Config should have comment or be unexported

Open

type Config struct {

• Exclude checks
  • Disable engine
  • Disable check

exported method ControlMiddleware.Convert should have comment or be unexported

Open

func (m *ControlMiddleware) Convert(f chevron.Handler) (chevron.Handler, error) {

• Exclude checks
  • Disable engine
  • Disable check

exported method SSEResource.Get should have comment or be unexported

Open

func (r *SSEResource) Get(ctx context.Context, req *http.Request, logger nacelle.Logger) response.Response {

• Exclude checks
  • Disable engine
  • Disable check

exported method Server.Stop should have comment or be unexported

Open

func (s *Server) Stop() error {

• Exclude checks
  • Disable engine
  • Disable check

exported function NewHandlerSet should have comment or be unexported

Open

func NewHandlerSet() *handlerSet {

• Exclude checks
  • Disable engine
  • Disable check

exported type RequestsResource should have comment or be unexported

Open

    RequestsResource struct{ *BaseResource }

• Exclude checks
  • Disable engine
  • Disable check

exported function NewServer should have comment or be unexported

Open

func NewServer() *Server {

• Exclude checks
  • Disable engine
  • Disable check

exported type Match should have comment or be unexported

Open

    Match struct {

• Exclude checks
  • Disable engine
  • Disable check

exported function Unmarshal should have comment or be unexported

Open

func Unmarshal(payload []byte) (Expectation, error) {

• Exclude checks
  • Disable engine
  • Disable check