assertjson

README

JSON assertions

This library extends awesome github.com/stretchr/testify/assert with nice JSON equality assertions built with github.com/yudai/gojsondiff.

Also it provides JSON marshaler with compact indentation.

Usage

Default comparer is set up to ignore difference against "<ignore-diff>" values. It is accessible with package functions Equal and EqualMarshal.

package my_test

import (
	"testing"

	"github.com/swaggest/assertjson"
)

func Test(t *testing.T) {
	assertjson.Equal(t,
		[]byte(`{"a": [1, {"val": "<ignore-diff>"}, 3], "b": 2, "c": 3}`),
		[]byte(`{"a": [1, {"val": 123}, 3], "c": 2, "b": 3}`),
	)

	// Output:
	// Error Trace:	....
	//	Error:      	Not equal:
	//	            	 {
	//	            	   "a": [
	//	            	     1,
	//	            	     {
	//	            	       "val": "<ignore-diff>"
	//	            	     },
	//	            	     3
	//	            	   ],
	//	            	-  "b": 2,
	//	            	+  "b": 3,
	//	            	-  "c": 3
	//	            	+  "c": 2
	//	            	 }
}

Custom Comparer can be created and used to control ignore behavior and formatter options.

Compact Indentation

Often json.MarshalIndent produces result, that is not easy to comprehend due to high count of lines that requires massive scrolling effort to read.

This library provides an alternative assertjson.MarshalIndentCompact which keeps indentation and line breaks only for major part of JSON document, while compacting smaller pieces.

j, err := assertjson.MarshalIndentCompact(v, "", "  ", 100) // 100 is line width limit.

{
  "openapi":"3.0.2","info":{"title":"","version":""},
  "paths":{
    "/test/{in-path}":{
      "post":{
        "summary":"Title","description":"","operationId":"name",
        "x-some-array":[
          "abc","def",123456,7890123456,[],{"foo":"bar"},
          "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!"
        ],
        "parameters":[
          {"name":"in_query","in":"query","schema":{"type":"integer"}},
          {"name":"in-path","in":"path","required":true,"schema":{"type":"boolean"}},
          {"name":"in_cookie","in":"cookie","schema":{"type":"number"}},
          {"name":"X-In-Header","in":"header","schema":{"type":"string"}}
        ],
        "requestBody":{
          "content":{
            "application/x-www-form-urlencoded":{"schema":{"$ref":"#/components/schemas/FormDataOpenapiTestInput"}}
          }
        },
        "responses":{"200":{"description":"OK","content":{"application/json":{"schema":{}}}}},
        "deprecated":true
      }
    }
  },
  "components":{
    "schemas":{"FormDataOpenapiTestInput":{"type":"object","properties":{"in_form_data":{"type":"string"}}}}
  }
}

Available as jsoncompact CLI tool.

go get github.com/swaggest/assertjson/cmd/jsoncompact

Documentation

Overview

Package assertjson implements JSON equality assertion for tests.

Example

package main

import (
	"fmt"

	"github.com/swaggest/assertjson"
)

var t = testingT(func(format string, args ...interface{}) {
	fmt.Printf(format, args...)
})

func main() {
	assertjson.Equal(t,
		[]byte(`{"a": [1, {"val": "<ignore-diff>"}, 3], "b": 2, "c": 3}`),
		[]byte(`{"a": [1, {"val": 123}, 3], "c": 2, "b": 3}`),
	)

}

Output:

Error Trace:	equal.go:69
	            				equal.go:44
	            				example_test.go:14
	Error:      	Not equal:
	            	 {
	            	   "a": [
	            	     1,
	            	     {
	            	       "val": "<ignore-diff>"
	            	     },
	            	     3
	            	   ],
	            	-  "b": 2,
	            	+  "b": 3,
	            	-  "c": 3
	            	+  "c": 2
	            	 }

Index

• func Equal(t TestingT, expected, actual []byte, msgAndArgs ...interface{}) bool
• func EqualMarshal(t TestingT, expected []byte, actualValue interface{}, ...) bool
• func FailNotEqual(expected, actual []byte) error
• func MarshalIndentCompact(v interface{}, prefix, indent string, lineLen int) ([]byte, error)
• type Comparer
  • func (c Comparer) Equal(t TestingT, expected, actual []byte, msgAndArgs ...interface{}) bool
  • func (c Comparer) EqualMarshal(t TestingT, expected []byte, actualValue interface{}, ...) bool
  • func (c Comparer) FailNotEqual(expected, actual []byte) error
• type TestingT

Examples

• Package

Functions

func Equal

func Equal(t TestingT, expected, actual []byte, msgAndArgs ...interface{}) bool

Equal compares two JSON documents ignoring string values "<ignore-diff>".

func EqualMarshal

func EqualMarshal(t TestingT, expected []byte, actualValue interface{}, msgAndArgs ...interface{}) bool

EqualMarshal marshals actual value and compares two JSON documents ignoring string values "<ignore-diff>".

func FailNotEqual

func FailNotEqual(expected, actual []byte) error

FailNotEqual returns error if JSON payloads are different, nil otherwise.

func MarshalIndentCompact

func MarshalIndentCompact(v interface{}, prefix, indent string, lineLen int) ([]byte, error)

MarshalIndentCompact applies indentation for large chunks of JSON and uses compact format for smaller ones.

Line length limits indented width of JSON structure, does not apply to long distinct scalars. This function is not optimized for performance, so it might be not a good fit for high load scenarios.

Types

type Comparer

type Comparer struct {
	// IgnoreDiff is a value in expected document to ignore difference with actual document.
	IgnoreDiff string

	// FormatterConfig controls diff formatter configuration.
	FormatterConfig formatter.AsciiFormatterConfig
}

Comparer compares JSON documents.

func (Comparer) Equal

func (c Comparer) Equal(t TestingT, expected, actual []byte, msgAndArgs ...interface{}) bool

Equal compares two JSON payloads.

func (Comparer) EqualMarshal

func (c Comparer) EqualMarshal(t TestingT, expected []byte, actualValue interface{}, msgAndArgs ...interface{}) bool

EqualMarshal marshals actual JSON payload and compares it with expected payload.

func (Comparer) FailNotEqual

func (c Comparer) FailNotEqual(expected, actual []byte) error

FailNotEqual returns error if JSON payloads are different, nil otherwise.

type TestingT

type TestingT interface {
	Errorf(format string, args ...interface{})
}

TestingT is an interface wrapper around *testing.T.