package object

import (
	"context"
	"fmt"
	"testing"

	"github.com/nspcc-dev/neofs-api-go/object"
	"github.com/nspcc-dev/neofs-api-go/query"
	"github.com/nspcc-dev/neofs-api-go/refs"
	"github.com/nspcc-dev/neofs-api-go/storagegroup"
	"github.com/nspcc-dev/neofs-node/internal"
	"github.com/nspcc-dev/neofs-node/lib/localstore"
	"github.com/nspcc-dev/neofs-node/lib/transport"
	"github.com/stretchr/testify/require"
	"go.uber.org/zap"
)

type (
	// Entity for mocking interfaces.
	// Implementation of any interface intercepts arguments via f (if not nil).
	// If err is not nil, it returns as it is. Otherwise, casted to needed type res returns w/o error.
	testQueryEntity struct {
		// Set of interfaces which testQueryEntity must implement, but some methods from those does not call.
		Filter

		// Argument interceptor. Used for ascertain of correct parameter passage between components.
		f func(...interface{})
		// Mocked result of any interface.
		res interface{}
		// Mocked error of any interface.
		err error
	}
)

var (
	_ filterCreator     = (*testQueryEntity)(nil)
	_ localQueryImposer = (*testQueryEntity)(nil)
)

func (s *testQueryEntity) imposeQuery(_ context.Context, c CID, q []byte, v int) ([]Address, error) {
	if s.f != nil {
		s.f(c, q, v)
	}
	if s.err != nil {
		return nil, s.err
	}
	return s.res.([]Address), nil
}

func (s *testQueryEntity) createFilter(p query.Query) Filter {
	if s.f != nil {
		s.f(p)
	}
	return s
}

func (s *testQueryEntity) Iterate(p Filter, h localstore.MetaHandler) error {
	if s.f != nil {
		s.f(p)
	}
	if s.err != nil {
		return s.err
	}
	for _, item := range s.res.([]localstore.ListItem) {
		h(&item.ObjectMeta)
	}
	return nil
}

func Test_queryVersionController_imposeQuery(t *testing.T) {
	ctx := context.TODO()
	cid := testObjectAddress(t).CID

	t.Run("unsupported version", func(t *testing.T) {
		qImp := &queryVersionController{
			m: make(map[int]localQueryImposer),
		}

		res, err := qImp.imposeQuery(ctx, cid, nil, 1)
		require.EqualError(t, err, errUnsupportedQueryVersion.Error())
		require.Empty(t, res)
	})

	t.Run("correct imposer choose", func(t *testing.T) {
		m := make(map[int]localQueryImposer)
		qData := testData(t, 10)

		qImp := &queryVersionController{m: m}

		m[0] = &testQueryEntity{
			f: func(items ...interface{}) {
				t.Run("correct imposer params", func(t *testing.T) {
					require.Equal(t, cid, items[0].(CID))
					require.Equal(t, qData, items[1].([]byte))
					require.Equal(t, 0, items[2].(int))
				})
			},
			err: internal.Error(""), // just to prevent panic
		}

		_, _ = qImp.imposeQuery(ctx, cid, qData, 0)
	})

	t.Run("correct imposer result", func(t *testing.T) {
		t.Run("error", func(t *testing.T) {
			m := make(map[int]localQueryImposer)
			qImp := &queryVersionController{m: m}

			impErr := internal.Error("test error for query imposer")

			m[0] = &testQueryEntity{
				err: impErr, // force localQueryImposer to return impErr
			}

			res, err := qImp.imposeQuery(ctx, cid, nil, 0)

			// ascertain that error returns as expected
			require.EqualError(t, err, impErr.Error())
			// ascertain that result is empty
			require.Empty(t, res)

			// create test address list
			addrList := testAddrList(t, 5)

			m[1] = &testQueryEntity{
				res: addrList, // force localQueryImposer to return addrList
			}

			res, err = qImp.imposeQuery(ctx, cid, nil, 1)
			require.NoError(t, err)

			// ascertain that result returns as expected
			require.Equal(t, addrList, res)
		})
	})
}

func Test_coreQueryImposer_imposeQuery(t *testing.T) {
	v := 1
	ctx := context.TODO()
	cid := testObjectAddress(t).CID
	log := zap.L()

	t.Run("query unmarshal failure", func(t *testing.T) {
		var (
			qErr error
			data []byte
		)

		// create invalid query binary representation
		for {
			data = testData(t, 1024)
			if qErr = new(query.Query).Unmarshal(data); qErr != nil {
				break
			}
		}

		s := &coreQueryImposer{
			log: zap.L(),
		}

		// trying to impose invalid query data
		res, err := s.imposeQuery(ctx, cid, data, v)

		// ascertain that reached error exactly like in unmarshal
		require.EqualError(t, err, errSearchQueryUnmarshal.Error())

		// ascertain that empty result returned
		require.Nil(t, res)
	})

	t.Run("mould query failure", func(t *testing.T) {
		// create testQuery with CID filter with value other than cid
		testQuery := &query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: KeyCID, Value: cid.String() + "1"}}}

		// try to mould this testQuery
		mErr := mouldQuery(cid, testQuery)

		// ascertain that testQuery mould failed
		require.Error(t, mErr)

		// ascertain that testQuery marshals normally
		d, err := testQuery.Marshal()
		require.NoError(t, err)

		s := &coreQueryImposer{
			log: log,
		}

		// try to impose testQuery
		res, err := s.imposeQuery(ctx, cid, d, v)

		// ascertain that impose fails with same error as mould
		require.EqualError(t, err, errLocalQueryImpose.Error())

		// ascertain that result is empty
		require.Nil(t, res)
	})

	t.Run("local store listing", func(t *testing.T) {
		// create testQuery and object which matches to it
		testQuery, obj := testFullObjectWithQuery(t)

		// ascertain testQuery marshals normally
		qBytes, err := testQuery.Marshal()
		require.NoError(t, err)

		t.Run("listing error", func(t *testing.T) {
			// create new error for test
			lsErr := internal.Error("test error of local store listing")

			// create test query imposer with mocked always failing lister
			qImposer := &coreQueryImposer{
				fCreator: new(coreFilterCreator),
				lsLister: &testQueryEntity{err: lsErr},
				log:      log,
			}

			// try to impose testQuery
			list, err := qImposer.imposeQuery(ctx, obj.SystemHeader.CID, qBytes, v)

			// ascertain that impose fails same error as lister
			require.EqualError(t, err, errLocalQueryImpose.Error())

			// ascertain that result is empty
			require.Empty(t, list)
		})

		t.Run("correct parameter", func(t *testing.T) {
			// create new mocked filter creator
			fc := new(testQueryEntity)
			fc.res = fc

			// create testQuery imposer
			qImposer := &coreQueryImposer{
				fCreator: fc,
				lsLister: &testQueryEntity{
					f: func(p ...interface{}) {
						// intercept lister arguments
						// ascertain that argument is as expected
						require.Equal(t, fc, p[0].(Filter))
					},
					err: internal.Error(""),
				},
				log: log,
			}

			_, _ = qImposer.imposeQuery(ctx, obj.SystemHeader.CID, qBytes, v)
		})

		t.Run("correct result", func(t *testing.T) {
			// create list of random address items
			addrList := testAddrList(t, 10)
			items := make([]localstore.ListItem, 0, len(addrList))
			for i := range addrList {
				items = append(items, localstore.ListItem{
					ObjectMeta: Meta{
						Object: &Object{
							SystemHeader: SystemHeader{
								ID:  addrList[i].ObjectID,
								CID: addrList[i].CID,
							},
						},
					},
				})
			}

			// create imposer with mocked lister
			qImposer := &coreQueryImposer{
				fCreator: new(coreFilterCreator),
				lsLister: &testQueryEntity{res: items},
			}

			// try to impose testQuery
			list, err := qImposer.imposeQuery(ctx, obj.SystemHeader.CID, qBytes, v)

			// ascertain that imposing finished normally
			require.NoError(t, err)

			// ascertain that resulting list size as expected
			require.Len(t, list, len(addrList))

			// ascertain that all source items are presented in result
			for i := range addrList {
				require.Contains(t, list, addrList[i])
			}
		})
	})
}

func Test_coreFilterCreator_createFilter(t *testing.T) {
	ctx := context.TODO()
	fCreator := new(coreFilterCreator)

	t.Run("composing correct filter", func(t *testing.T) {
		var f Filter

		// ascertain filter creation does not panic
		require.NotPanics(t, func() { f = fCreator.createFilter(query.Query{}) })

		// ascertain that created filter is not empty
		require.NotNil(t, f)

		// ascertain that created filter has expected name
		require.Equal(t, queryFilterName, f.GetName())
	})

	t.Run("passage on matching query", func(t *testing.T) {
		// create testQuery and object which matches to it
		testQuery, obj := testFullObjectWithQuery(t)

		// create filter for testQuery and pass object to it
		res := fCreator.createFilter(testQuery).Pass(ctx, &Meta{Object: obj})

		// ascertain that filter is passed
		require.Equal(t, localstore.CodePass, res.Code())
	})

	t.Run("failure on mismatching query", func(t *testing.T) {
		testQuery, obj := testFullObjectWithQuery(t)
		obj.SystemHeader.ID[0]++
		require.False(t, imposeQuery(testQuery, obj))

		res := fCreator.createFilter(testQuery).Pass(ctx, &Meta{Object: obj})

		require.Equal(t, localstore.CodeFail, res.Code())
	})
}

func Test_mouldQuery(t *testing.T) {
	cid := testObjectAddress(t).CID

	t.Run("invalid CID filter", func(t *testing.T) {
		// create query with CID filter with other than cid value
		query := &query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: KeyCID, Value: cid.String() + "1"}}}

		// try to mould this query for cid
		err := mouldQuery(cid, query)

		// ascertain wrong CID value is not allowed
		require.EqualError(t, err, errInvalidCIDFilter.Error())
	})

	t.Run("correct CID filter", func(t *testing.T) {
		// create testQuery with CID filter with cid value
		cidF := QueryFilter{Type: query.Filter_Exact, Name: KeyCID, Value: cid.String()}
		testQuery := &query.Query{Filters: []QueryFilter{cidF}}

		// ascertain mould is processed
		require.NoError(t, mouldQuery(cid, testQuery))

		// ascertain filter is still in testQuery
		require.Contains(t, testQuery.Filters, cidF)
	})

	t.Run("missing CID filter", func(t *testing.T) {
		// create CID filter with cid value
		expF := QueryFilter{Type: query.Filter_Exact, Name: KeyCID, Value: cid.String()}

		// create empty testQuery
		testQuery := new(query.Query)

		// ascertain mould is processed
		require.NoError(t, mouldQuery(cid, testQuery))

		// ascertain exact CID filter added to testQuery
		require.Contains(t, testQuery.Filters, expF)
	})
}

func Test_applyFilter(t *testing.T) {
	k, v := "key", "value"

	t.Run("empty map", func(t *testing.T) {
		// ascertain than applyFilter always return true on empty filter map
		require.True(t, applyFilter(nil, k, v))
	})

	t.Run("passage on missing key", func(t *testing.T) {
		t.Run("exact", func(t *testing.T) {
			require.True(t, applyFilter(map[string]*QueryFilter{k: {Type: query.Filter_Exact, Value: v + "1"}}, k+"1", v))
		})

		t.Run("regex", func(t *testing.T) {
			require.True(t, applyFilter(map[string]*QueryFilter{k: {Type: query.Filter_Regex, Value: v + "1"}}, k+"1", v))
		})
	})

	t.Run("passage on key presence and matching value", func(t *testing.T) {
		t.Run("exact", func(t *testing.T) {
			require.True(t, applyFilter(map[string]*QueryFilter{k: {Type: query.Filter_Exact, Value: v}}, k, v))
		})

		t.Run("regex", func(t *testing.T) {
			require.True(t, applyFilter(map[string]*QueryFilter{k: {Type: query.Filter_Regex, Value: v + "|" + v + "1"}}, k, v))
		})
	})

	t.Run("failure on key presence and mismatching value", func(t *testing.T) {
		t.Run("exact", func(t *testing.T) {
			require.False(t, applyFilter(map[string]*QueryFilter{k: {Type: query.Filter_Exact, Value: v + "1"}}, k, v))
		})

		t.Run("regex", func(t *testing.T) {
			require.False(t, applyFilter(map[string]*QueryFilter{k: {Type: query.Filter_Regex, Value: v + "&" + v + "1"}}, k, v))
		})
	})

	t.Run("key removes from filter map", func(t *testing.T) {
		// create filter map with several elements
		m := map[string]*QueryFilter{
			k:       {Type: query.Filter_Exact, Value: v},
			k + "1": {Type: query.Filter_Exact, Value: v},
		}

		// save initial len
		initLen := len(m)

		// apply filter with key from filter map
		applyFilter(m, k, v)

		// ascertain exactly key was removed from filter map
		require.Len(t, m, initLen-1)

		// ascertain this is exactly applyFilter argument
		_, ok := m[k]
		require.False(t, ok)
	})

	t.Run("panic on unknown filter type", func(t *testing.T) {
		// create filter type other than FilterExact and FilterRegex
		fType := query.Filter_Exact + query.Filter_Regex + 1
		require.NotEqual(t, query.Filter_Exact, fType)
		require.NotEqual(t, query.Filter_Regex, fType)

		// ascertain applyFilter does not process this type but panic
		require.PanicsWithValue(t,
			fmt.Sprintf(pmUndefinedFilterType, fType),
			func() { applyFilter(map[string]*QueryFilter{k: {Type: fType}}, k, v) },
		)
	})
}

func Test_imposeQuery(t *testing.T) {
	t.Run("tombstone filter", func(t *testing.T) {
		// create testQuery with only tombstone filter
		testQuery := query.Query{Filters: []QueryFilter{{Name: transport.KeyTombstone}}}

		// create object which is not a tombstone
		obj := new(Object)

		testQueryMatch(t, testQuery, obj, func(t *testing.T, obj *Object) {
			// adding tombstone header makes object to satisfy tombstone testQuery
			obj.Headers = append(obj.Headers, Header{Value: new(object.Header_Tombstone)})
		})
	})

	t.Run("system header", func(t *testing.T) {
		addr := testObjectAddress(t)
		cid, oid, ownerID := addr.CID, addr.ObjectID, OwnerID{3}

		// create testQuery with system header filters
		testQuery := query.Query{Filters: []QueryFilter{
			{Type: query.Filter_Exact, Name: KeyCID, Value: cid.String()},
			{Type: query.Filter_Exact, Name: KeyID, Value: oid.String()},
			{Type: query.Filter_Exact, Name: KeyOwnerID, Value: ownerID.String()},
		}}

		// fn sets system header fields values to ones from filters
		fn := func(t *testing.T, obj *Object) { obj.SystemHeader = SystemHeader{CID: cid, ID: oid, OwnerID: ownerID} }

		// create object with empty system header fields
		obj := new(Object)
		testQueryMatch(t, testQuery, obj, fn)

		// create object with CID from filters
		sysHdr := SystemHeader{CID: cid}
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)

		// create object with OID from filters
		sysHdr.CID = CID{}
		sysHdr.ID = oid
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)

		// create object with OwnerID from filters
		sysHdr.ID = ID{}
		sysHdr.OwnerID = ownerID
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)

		// create object with CID and OwnerID from filters
		sysHdr.CID = cid
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)

		// create object with OID and OwnerID from filters
		sysHdr.CID = CID{}
		sysHdr.ID = oid
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)

		// create object with OID and OwnerID from filters
		sysHdr.ID = oid
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)

		// create object with CID and OID from filters
		sysHdr.CID = cid
		sysHdr.OwnerID = OwnerID{}
		obj = &Object{SystemHeader: sysHdr}
		testQueryMatch(t, testQuery, obj, fn)
	})

	t.Run("no children filter", func(t *testing.T) {
		// create testQuery with only orphan filter
		testQuery := query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: transport.KeyNoChildren}}}

		// create object with child relation
		obj := &Object{Headers: []Header{{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Child}}}}}

		testQueryMatch(t, testQuery, obj, func(t *testing.T, obj *Object) {
			// child relation removal makes object to satisfy orphan testQuery
			obj.Headers = nil
		})
	})

	t.Run("has parent filter", func(t *testing.T) {
		// create testQuery with parent relation filter
		testQuery := query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: transport.KeyHasParent}}}

		// create object w/o parent
		obj := new(Object)

		testQueryMatch(t, testQuery, obj, func(t *testing.T, obj *Object) {
			// adding parent relation makes object to satisfy parent testQuery
			obj.Headers = append(obj.Headers, Header{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Parent}}})
		})
	})

	t.Run("root object filter", func(t *testing.T) {
		// create testQuery with only root filter
		testQuery := query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: KeyRootObject}}}

		// create object with parent relation
		obj := &Object{Headers: []Header{{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Parent}}}}}

		testQueryMatch(t, testQuery, obj, func(t *testing.T, obj *Object) {
			// parent removal makes object to satisfy root testQuery
			obj.Headers = nil
		})
	})

	t.Run("link value filters", func(t *testing.T) {
		t.Run("parent", func(t *testing.T) {
			testLinkQuery(t, transport.KeyParent, object.Link_Parent)
		})

		t.Run("child", func(t *testing.T) {
			testLinkQuery(t, KeyChild, object.Link_Child)
		})

		t.Run("previous", func(t *testing.T) {
			testLinkQuery(t, KeyPrev, object.Link_Previous)
		})

		t.Run("next", func(t *testing.T) {
			testLinkQuery(t, KeyNext, object.Link_Next)
		})

		t.Run("other", func(t *testing.T) {
			// create not usable link type
			linkKey := object.Link_Parent + object.Link_Child + object.Link_Next + object.Link_Previous

			// add some usable link to testQuery
			par := ID{1, 2, 3}
			testQuery := query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: transport.KeyParent, Value: par.String()}}}

			// ascertain that undefined link type has no affect on testQuery imposing
			require.True(t, imposeQuery(testQuery, &Object{
				Headers: []Header{
					{Value: &object.Header_Link{Link: &object.Link{Type: linkKey}}},
					{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Parent, ID: par}}},
				},
			}))
		})
	})

	t.Run("user header filter", func(t *testing.T) {
		// user header key-value pair
		k, v := "header", "value"

		// query with user header filter
		query := query.Query{Filters: []QueryFilter{{
			Type:  query.Filter_Exact,
			Name:  k,
			Value: v,
		}}}

		// create user header with same key and different value
		hdr := &UserHeader{Key: k, Value: v + "1"}

		// create object with this user header
		obj := &Object{Headers: []Header{{Value: &object.Header_UserHeader{UserHeader: hdr}}}}

		testQueryMatch(t, query, obj, func(t *testing.T, obj *Object) {
			// correcting value to one from filter makes object to satisfy query
			hdr.Value = v
		})
	})

	t.Run("storage group filter", func(t *testing.T) {
		// create testQuery with only storage group filter
		testQuery := query.Query{Filters: []QueryFilter{{Type: query.Filter_Exact, Name: transport.KeyStorageGroup}}}

		// create object w/o storage group header
		obj := new(Object)

		testQueryMatch(t, testQuery, obj, func(t *testing.T, obj *Object) {
			// adding storage group headers make object to satisfy testQuery
			obj.Headers = append(obj.Headers, Header{Value: &object.Header_StorageGroup{StorageGroup: new(storagegroup.StorageGroup)}})
		})
	})
}

func Test_filterSystemHeader(t *testing.T) {
	var (
		ownerID1, ownerID2 = OwnerID{1}, OwnerID{2}
		addr1, addr2       = testObjectAddress(t), testObjectAddress(t)
		cid1, cid2         = addr1.CID, addr2.CID
		oid1, oid2         = addr1.ObjectID, addr2.ObjectID
		sysHdr             = SystemHeader{ID: oid1, OwnerID: ownerID1, CID: cid1}
	)
	require.NotEqual(t, ownerID1, ownerID2)
	require.NotEqual(t, cid1, cid2)
	require.NotEqual(t, oid1, oid2)

	t.Run("empty filter map", func(t *testing.T) {
		// ascertain that any system header satisfies to empty (nil) filter map
		require.True(t, filterSystemHeader(nil, &sysHdr))
	})

	t.Run("missing of some of the fields", func(t *testing.T) {
		// create filter map for system header
		m := sysHeaderFilterMap(sysHdr)

		// copy system header for initial values saving
		h := sysHdr

		// change CID
		h.CID = cid2

		// ascertain filter failure
		require.False(t, filterSystemHeader(m, &h))

		// remove CID from filter map
		delete(m, KeyCID)

		// ascertain filter passage
		require.True(t, filterSystemHeader(m, &h))

		m = sysHeaderFilterMap(sysHdr)
		h = sysHdr

		// change OwnerID
		h.OwnerID = ownerID2

		// ascertain filter failure
		require.False(t, filterSystemHeader(m, &h))

		// remove OwnerID from filter map
		delete(m, KeyOwnerID)

		// ascertain filter passage
		require.True(t, filterSystemHeader(m, &h))

		m = sysHeaderFilterMap(sysHdr)
		h = sysHdr

		// change ObjectID
		h.ID = oid2

		// ascertain filter failure
		require.False(t, filterSystemHeader(m, &h))

		// remove ObjectID from filter map
		delete(m, KeyID)

		// ascertain filter passage
		require.True(t, filterSystemHeader(m, &h))
	})

	t.Run("valid fields passage", func(t *testing.T) {
		require.True(t, filterSystemHeader(sysHeaderFilterMap(sysHdr), &sysHdr))
	})

	t.Run("mismatching values failure", func(t *testing.T) {
		h := sysHdr

		// make CID value not matching
		h.CID = cid2

		require.False(t, filterSystemHeader(sysHeaderFilterMap(sysHdr), &h))

		h = sysHdr

		// make ObjectID value not matching
		h.ID = oid2

		require.False(t, filterSystemHeader(sysHeaderFilterMap(sysHdr), &h))

		h = sysHdr

		// make OwnerID value not matching
		h.OwnerID = ownerID2

		require.False(t, filterSystemHeader(sysHeaderFilterMap(sysHdr), &h))
	})
}

// testQueryMatch imposes passed query to passed object for tests.
// Passed object should not match to passed query.
// Passed function must mutate object so that becomes query matching.
func testQueryMatch(t *testing.T, q query.Query, obj *Object, fn func(*testing.T, *Object)) {
	require.False(t, imposeQuery(q, obj))
	fn(t, obj)
	require.True(t, imposeQuery(q, obj))
}

// testLinkQuery tests correctness of imposing query with link filters.
// Inits object with value different from one from filter. Then uses testQueryMatch with correcting value func.
func testLinkQuery(t *testing.T, key string, lt object.Link_Type) {
	// create new relation link
	relative, err := refs.NewObjectID()
	require.NoError(t, err)

	// create another relation link
	wrongRelative := relative
	for wrongRelative.Equal(relative) {
		wrongRelative, err = refs.NewObjectID()
		require.NoError(t, err)
	}

	// create query with relation filter
	query := query.Query{Filters: []QueryFilter{{
		Type:  query.Filter_Exact,
		Name:  key,
		Value: relative.String(),
	}}}

	// create link with relation different from one from filter
	link := &object.Link{Type: lt, ID: wrongRelative}
	// create object with this link
	obj := &Object{Headers: []Header{{Value: &object.Header_Link{Link: link}}}}
	testQueryMatch(t, query, obj, func(t *testing.T, object *Object) {
		// changing link value to one from filter make object to satisfy relation query
		link.ID = relative
	})
}

// sysHeaderFilterMap creates filter map for passed system header.
func sysHeaderFilterMap(hdr SystemHeader) map[string]*QueryFilter {
	return map[string]*QueryFilter{
		KeyCID: {
			Type:  query.Filter_Exact,
			Name:  KeyCID,
			Value: hdr.CID.String(),
		},
		KeyOwnerID: {
			Type:  query.Filter_Exact,
			Name:  KeyOwnerID,
			Value: hdr.OwnerID.String(),
		},
		KeyID: {
			Type:  query.Filter_Exact,
			Name:  KeyID,
			Value: hdr.ID.String(),
		},
	}
}

// testFullObjectWithQuery creates query with set of permissible filters and object matching to this query.
func testFullObjectWithQuery(t *testing.T) (query.Query, *Object) {
	addr := testObjectAddress(t)
	selfID, cid := addr.ObjectID, addr.CID

	ownerID := OwnerID{}
	copy(ownerID[:], testData(t, refs.OwnerIDSize))

	addrList := testAddrList(t, 4)

	parID, childID, nextID, prevID := addrList[0].ObjectID, addrList[1].ObjectID, addrList[2].ObjectID, addrList[3].ObjectID

	query := query.Query{Filters: []QueryFilter{
		{Type: query.Filter_Exact, Name: transport.KeyParent, Value: parID.String()},
		{Type: query.Filter_Exact, Name: KeyPrev, Value: prevID.String()},
		{Type: query.Filter_Exact, Name: KeyNext, Value: nextID.String()},
		{Type: query.Filter_Exact, Name: KeyChild, Value: childID.String()},
		{Type: query.Filter_Exact, Name: KeyOwnerID, Value: ownerID.String()},
		{Type: query.Filter_Exact, Name: KeyID, Value: selfID.String()},
		{Type: query.Filter_Exact, Name: KeyCID, Value: cid.String()},
		{Type: query.Filter_Exact, Name: transport.KeyStorageGroup},
		{Type: query.Filter_Exact, Name: transport.KeyTombstone},
		{Type: query.Filter_Exact, Name: transport.KeyHasParent},
	}}

	obj := &Object{
		SystemHeader: SystemHeader{
			ID:      selfID,
			OwnerID: ownerID,
			CID:     cid,
		},
		Headers: []Header{
			{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Parent, ID: parID}}},
			{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Previous, ID: prevID}}},
			{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Next, ID: nextID}}},
			{Value: &object.Header_Link{Link: &object.Link{Type: object.Link_Child, ID: childID}}},
			{Value: &object.Header_StorageGroup{StorageGroup: new(storagegroup.StorageGroup)}},
			{Value: &object.Header_Tombstone{Tombstone: new(object.Tombstone)}},
		},
	}

	require.True(t, imposeQuery(query, obj))

	return query, obj
}