Nested comparison

[Nvos]

What would be best way to asert more complex structure, for example:

type Cursor struct {
	ID    int   `msgpack:"i"`
	Value Value `msgpack:"v,omitempty"`
}

type User struct {
	ID int `json:"id,omitempty"`
        Active bool `json:"active,omitempty"`
        Username string `json:"username,omitempty"`
}

type UserEdge struct {
	Node   *User  `json:"node"`
	Cursor Cursor `json:"cursor"`
}

type UserConnection struct {
	Edges      []*UserEdge `json:"edges"`
	PageInfo   PageInfo    `json:"pageInfo"`
	TotalCount int         `json:"totalCount"`
}

type PageInfo struct {
	HasNextPage     bool    `json:"hasNextPage"`
	HasPreviousPage bool    `json:"hasPreviousPage"`
	StartCursor     *Cursor `json:"startCursor"`
	EndCursor       *Cursor `json:"endCursor"`
}

In given example I would like to:

• Asert edges at specific index
• Do lax comparison, while ignoring specific fields

[maxatome]

Hello,

You can use JSONPointer to surgically test deeply nested field. Note you can combine several JSONPointer with a All to test several fields.

You can also use JSON directly, including SubJSONOf and SuperJSONOf, even if some of your struct don't have json tags, but the tested fields have to be public.

You can use Struct, but for deeply nested fields, it is sometimes a bit heavy to read.

You can use Smuggle and its special case field-path case (similar to JSONPointer but handles only structs and not slices/maps, but private fields are OK).

Perhaps could you give us a literal of what you get with comments telling which fields you want to test, and which ones you want to ignore? I would be happy to demonstrate each case.

Something like:

PageInfo{
  StartCursor: &Cursor{
    ID: 123, // ← I want to test this field and ignore others
  },
}

Max.

[Nvos]

&ent.UserConnection{
	Edges: []*ent.UserEdge{ // <- I want to test structs at specific indexes in this slice
		{
			Node: &ent.User{ // <- I want to test fields from this struct
				ID:       21474836481,
				Username: "user 1",
				Active:   true,
			},
		},
		{
			Node: &ent.User{// <- I want to test fields from this struct
				ID:       21474836482,
				Username: "user2",
				Active:   false,
			},
		},
	},
}

Currently I'm handling this using go-cmp diff while ignoring concrete fields. Is it possible to achieve same effect but maybe more granular/custom?

[maxatome]

See https://gist.github.com/maxatome/d31a99550cb7493295c50491c8b114eb

Perhaps should we have a new operator based on Slice to test only some entries in an array or slice, whatever its length is.

Or a GetKey (or more Index to mimic reflect naming) similar to ContainsKey, extended to handle arrays/slices and so we could do:

td.Cmp(t, got,
	td.Smuggle("Edges",
		td.Index(index,
			&User{
				ID:       21474836482,
				Username: "user2",
				Active:   false,
			})),
	"Using new possible new Index operator")

Max.

[maxatome]

Or a new SuperSliceOf operator:

func SuperSliceOf(model interface{}, expectedEntries ArrayEntries) TestDeep

• model has to be a slice or an array
• ArrayEntries type already exists.

In our case we could have:

td.Cmp(t, got,
	td.Smuggle("Edges",
		td.SuperSliceOf(
			[]*UserEdge{
				1: &User{
					ID:       21474836482,
					Username: "user2",
					Active:   false,
				},
			}, nil),
	),
	"Using new possible new SuperSliceOf operator")

td.Cmp(t, got,
	td.Smuggle("Edges",
		td.SuperSliceOf(
			[]*UserEdge{},
			td.ArrayEntries{
				1: td.Struct(&User{Username: "user2"}, nil),
			})),
	"Using new possible new SuperSliceOf operator + Struct")

What do you think?

Max.

[maxatome]

I am currently enhancing Smuggle field-path feature to make the following possible:

td.Cmp(t, got,
	td.Smuggle("Edges[1]",
		&User{
			ID:       21474836482,
			Username: "user2",
			Active:   false,
		}),
	"Using enhanced Smuggle operator")

td.Cmp(t, got,
	td.Smuggle("Edges[1]", td.Struct(&User{Username: "user2"}, nil)),
	"Using enhanced Smuggle operator + Struct")

[maxatome]

You can test my last example using the smuggle branch.

[maxatome]

Smuggle can now handle maps/slices in its fields-path form, so for this specific case we can use either JSONPointer or Smuggle operators:

package main_test

import (
	"testing"

	"github.com/maxatome/go-testdeep/td"
)

var got = &UserConnection{
	Edges: []*UserEdge{ // <- I want to test structs at specific indexes in this slice
		{
			Node: &User{ // <- I want to test fields from this struct
				ID:       21474836481,
				Username: "user 1",
				Active:   true,
			},
		},
		{
			Node: &User{ // <- I want to test fields from this struct
				ID:       21474836482,
				Username: "user2",
				Active:   false,
			},
		},
	},
}

func Test(t *testing.T) {
	//
	// With JSONPointer + JSON
	td.Cmp(t, got,
		//the index in slice --v
		td.JSONPointer("/edges/1/node",
			td.JSON(`
{
  "id":       21474836482,
  "username": "user2",
  // "active" is omitted as false
}`)),
		"With JSONPointer + JSON")

	//
	// JSONPointer to test Username field, so with SuperJSONOf
	td.Cmp(t, got,
		//the index in slice --v
		td.JSONPointer("/edges/1/node",
			td.SuperJSONOf(`{"username": "user2"}`)),
		"With JSONPointer + SuperJSONOf")

	//
	// Smuggle now handles slice/array/map indexing as JSONPointer already does
	// (available in master branch or future 1.10 release).
	td.Cmp(t, got,
		td.Smuggle("Edges[1].Node",
			// The final expected User
			&User{
				ID:       21474836482,
				Username: "user2",
				Active:   false,
			}),
		"With Smuggle")

	//
	// Smuggle to test Username field
	td.Cmp(t, got,
		td.Smuggle("Edges[1].Node",
			// Only the Username field of User
			td.Struct(&User{Username: "user2"}, nil)),
		"With Smuggle + Struct")
}

Note that SuperSliceOf operator has been added too. Both Smuggle map/slice support and SuperSliceOf operator are available in master branch and will be in the next 1.10 release.

Max.