Wrote graph filter types and serializers.
This commit is contained in:
280
filters/filters.go
Normal file
280
filters/filters.go
Normal file
@@ -0,0 +1,280 @@
|
||||
package filters
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
roots "git.wisehodl.dev/jay/go-roots/filters"
|
||||
"strings"
|
||||
)
|
||||
|
||||
type HeartwoodFilter struct {
|
||||
Legacy roots.Filter
|
||||
Graph []GraphFilter
|
||||
}
|
||||
|
||||
type GraphFilter struct {
|
||||
IDs []string
|
||||
Authors []string
|
||||
Kinds []json.RawMessage
|
||||
Since json.RawMessage
|
||||
Until json.RawMessage
|
||||
Limit *int
|
||||
Tags roots.TagFilters
|
||||
Distance *Distance
|
||||
Graph []GraphFilter
|
||||
Extensions roots.FilterExtensions
|
||||
}
|
||||
|
||||
type Distance struct {
|
||||
Min int
|
||||
Max int
|
||||
}
|
||||
|
||||
func MarshalJSON(f HeartwoodFilter) ([]byte, error) {
|
||||
legacyFilter := f.Legacy
|
||||
|
||||
if f.Graph != nil {
|
||||
graphArray, err := marshalGraphArray(f.Graph)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error marshalling graph field: %w", err)
|
||||
}
|
||||
|
||||
graphField, err := json.Marshal(graphArray)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error marshalling graph field: %w", err)
|
||||
}
|
||||
|
||||
if legacyFilter.Extensions == nil {
|
||||
legacyFilter.Extensions = make(roots.FilterExtensions)
|
||||
}
|
||||
|
||||
legacyFilter.Extensions["graph"] = graphField
|
||||
}
|
||||
|
||||
return roots.MarshalJSON(legacyFilter)
|
||||
}
|
||||
|
||||
func UnmarshalJSON(data []byte, f *HeartwoodFilter) error {
|
||||
var rootsFilter roots.Filter
|
||||
if err := roots.UnmarshalJSON(data, &rootsFilter); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if rootsFilter.Extensions["graph"] != nil {
|
||||
graphArray, err := unmarshalGraphArray(rootsFilter.Extensions["graph"])
|
||||
if err != nil {
|
||||
return fmt.Errorf("error unmarshalling graph extension field: %w", err)
|
||||
}
|
||||
f.Graph = graphArray
|
||||
delete(rootsFilter.Extensions, "graph")
|
||||
}
|
||||
|
||||
f.Legacy = rootsFilter
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func MarshalGraphJSON(f GraphFilter) ([]byte, error) {
|
||||
outputMap := make(map[string]interface{})
|
||||
|
||||
// Add standard fields
|
||||
if f.IDs != nil {
|
||||
outputMap["ids"] = f.IDs
|
||||
}
|
||||
if f.Authors != nil {
|
||||
outputMap["authors"] = f.Authors
|
||||
}
|
||||
if f.Kinds != nil {
|
||||
outputMap["kinds"] = f.Kinds
|
||||
}
|
||||
if f.Since != nil {
|
||||
outputMap["since"] = f.Since
|
||||
}
|
||||
if f.Until != nil {
|
||||
outputMap["until"] = f.Until
|
||||
}
|
||||
if f.Limit != nil {
|
||||
outputMap["limit"] = *f.Limit
|
||||
}
|
||||
|
||||
// Add distance field
|
||||
if f.Distance != nil {
|
||||
distanceMap := make(map[string]interface{})
|
||||
distanceMap["max"] = f.Distance.Max
|
||||
distanceMap["min"] = f.Distance.Min
|
||||
outputMap["distance"] = distanceMap
|
||||
}
|
||||
|
||||
// Add nested graph field
|
||||
if f.Graph != nil {
|
||||
graphArray, err := marshalGraphArray(f.Graph)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("error in nested graph: %w", err)
|
||||
}
|
||||
outputMap["graph"] = graphArray
|
||||
}
|
||||
|
||||
// Add tags
|
||||
for key, values := range f.Tags {
|
||||
outputMap["#"+key] = values
|
||||
}
|
||||
|
||||
// Merge extensions
|
||||
for key, raw := range f.Extensions {
|
||||
// Disallow standard keys in extensions
|
||||
if key == "ids" ||
|
||||
key == "authors" ||
|
||||
key == "kinds" ||
|
||||
key == "since" ||
|
||||
key == "until" ||
|
||||
key == "limit" ||
|
||||
key == "distance" ||
|
||||
key == "graph" {
|
||||
continue
|
||||
}
|
||||
|
||||
// Disallow tag keys in extensions
|
||||
if strings.HasPrefix(key, "#") {
|
||||
continue
|
||||
}
|
||||
|
||||
var extValue interface{}
|
||||
if err := json.Unmarshal(raw, &extValue); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
outputMap[key] = extValue
|
||||
}
|
||||
|
||||
return json.Marshal(outputMap)
|
||||
}
|
||||
|
||||
func UnmarshalGraphJSON(data []byte, f *GraphFilter) error {
|
||||
// Decode into raw map
|
||||
raw := make(map[string]json.RawMessage)
|
||||
if err := json.Unmarshal(data, &raw); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// Extract standard fields
|
||||
if v, ok := raw["ids"]; ok {
|
||||
if err := json.Unmarshal(v, &f.IDs); err != nil {
|
||||
return err
|
||||
}
|
||||
delete(raw, "ids")
|
||||
}
|
||||
|
||||
if v, ok := raw["authors"]; ok {
|
||||
if err := json.Unmarshal(v, &f.Authors); err != nil {
|
||||
return err
|
||||
}
|
||||
delete(raw, "authors")
|
||||
}
|
||||
|
||||
if v, ok := raw["kinds"]; ok {
|
||||
if err := json.Unmarshal(v, &f.Kinds); err != nil {
|
||||
return err
|
||||
}
|
||||
delete(raw, "kinds")
|
||||
}
|
||||
|
||||
if v, ok := raw["since"]; ok {
|
||||
var val json.RawMessage
|
||||
if err := json.Unmarshal(v, &val); err != nil {
|
||||
return err
|
||||
}
|
||||
f.Since = val
|
||||
delete(raw, "since")
|
||||
}
|
||||
|
||||
if v, ok := raw["until"]; ok {
|
||||
var val json.RawMessage
|
||||
if err := json.Unmarshal(v, &val); err != nil {
|
||||
return err
|
||||
}
|
||||
f.Until = val
|
||||
delete(raw, "until")
|
||||
}
|
||||
|
||||
if v, ok := raw["limit"]; ok {
|
||||
if len(v) == 4 && string(v) == "null" {
|
||||
f.Limit = nil
|
||||
} else {
|
||||
var val int
|
||||
if err := json.Unmarshal(v, &val); err != nil {
|
||||
return err
|
||||
}
|
||||
f.Limit = &val
|
||||
}
|
||||
delete(raw, "limit")
|
||||
}
|
||||
|
||||
// Extract distance field
|
||||
if v, ok := raw["distance"]; ok {
|
||||
if err := json.Unmarshal(v, &f.Distance); err != nil {
|
||||
return err
|
||||
}
|
||||
delete(raw, "distance")
|
||||
}
|
||||
|
||||
// Extract nested graph field
|
||||
if v, ok := raw["graph"]; ok {
|
||||
graphArray, err := unmarshalGraphArray(v)
|
||||
if err != nil {
|
||||
return fmt.Errorf("error unmarshalling nested graph filter: %w", err)
|
||||
}
|
||||
f.Graph = graphArray
|
||||
delete(raw, "graph")
|
||||
}
|
||||
|
||||
// Extract tag fields
|
||||
for key := range raw {
|
||||
if strings.HasPrefix(key, "#") {
|
||||
// Leave Tags as `nil` unless tag fields exist
|
||||
if f.Tags == nil {
|
||||
f.Tags = make(roots.TagFilters)
|
||||
}
|
||||
tagKey := key[1:]
|
||||
var tagValues []string
|
||||
if err := json.Unmarshal(raw[key], &tagValues); err != nil {
|
||||
return err
|
||||
}
|
||||
f.Tags[tagKey] = tagValues
|
||||
delete(raw, key)
|
||||
}
|
||||
}
|
||||
|
||||
// Place remaining fields in extensions
|
||||
if len(raw) > 0 {
|
||||
f.Extensions = raw
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func marshalGraphArray(filters []GraphFilter) ([]json.RawMessage, error) {
|
||||
result := []json.RawMessage{}
|
||||
for _, f := range filters {
|
||||
b, err := MarshalGraphJSON(f)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result = append(result, b)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func unmarshalGraphArray(raws json.RawMessage) ([]GraphFilter, error) {
|
||||
var rawArray []json.RawMessage
|
||||
if err := json.Unmarshal(raws, &rawArray); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
var result []GraphFilter
|
||||
for _, raw := range rawArray {
|
||||
var f GraphFilter
|
||||
if err := UnmarshalGraphJSON(raw, &f); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result = append(result, f)
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
376
filters/filters_test.go
Normal file
376
filters/filters_test.go
Normal file
@@ -0,0 +1,376 @@
|
||||
package filters
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
roots "git.wisehodl.dev/jay/go-roots/filters"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// Helpers
|
||||
|
||||
func intPtr(i int) *int {
|
||||
return &i
|
||||
}
|
||||
|
||||
func expectEqualHeartwoodFilters(t *testing.T, got, want HeartwoodFilter) {
|
||||
t.Helper()
|
||||
assert.Equal(t, want.Legacy.IDs, got.Legacy.IDs)
|
||||
assert.Equal(t, want.Legacy.Authors, got.Legacy.Authors)
|
||||
assert.Equal(t, want.Legacy.Kinds, got.Legacy.Kinds)
|
||||
assert.Equal(t, want.Legacy.Since, got.Legacy.Since)
|
||||
assert.Equal(t, want.Legacy.Until, got.Legacy.Until)
|
||||
assert.Equal(t, want.Legacy.Limit, got.Legacy.Limit)
|
||||
assert.Equal(t, want.Legacy.Tags, got.Legacy.Tags)
|
||||
assert.Equal(t, len(want.Graph), len(got.Graph))
|
||||
for i := range want.Graph {
|
||||
expectEqualGraphFilters(t, got.Graph[i], want.Graph[i])
|
||||
}
|
||||
}
|
||||
|
||||
func expectEqualGraphFilters(t *testing.T, got, want GraphFilter) {
|
||||
t.Helper()
|
||||
assert.Equal(t, want.IDs, got.IDs)
|
||||
assert.Equal(t, want.Authors, got.Authors)
|
||||
assert.Equal(t, want.Kinds, got.Kinds)
|
||||
assert.Equal(t, want.Since, got.Since)
|
||||
assert.Equal(t, want.Until, got.Until)
|
||||
assert.Equal(t, want.Limit, got.Limit)
|
||||
assert.Equal(t, want.Tags, got.Tags)
|
||||
assert.Equal(t, want.Distance, got.Distance)
|
||||
assert.Equal(t, len(want.Graph), len(got.Graph))
|
||||
for i := range want.Graph {
|
||||
expectEqualGraphFilters(t, got.Graph[i], want.Graph[i])
|
||||
}
|
||||
// assert.Equal(t, want.Extensions, got.Extensions)
|
||||
}
|
||||
|
||||
// Tests
|
||||
|
||||
func TestMarshalJSON(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
filter HeartwoodFilter
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
name: "empty filter",
|
||||
filter: HeartwoodFilter{},
|
||||
expected: `{}`,
|
||||
},
|
||||
{
|
||||
name: "legacy fields only",
|
||||
filter: HeartwoodFilter{
|
||||
Legacy: roots.Filter{
|
||||
IDs: []string{"abc"},
|
||||
Kinds: []int{1},
|
||||
Since: intPtr(1000),
|
||||
},
|
||||
},
|
||||
expected: `{"ids":["abc"],"kinds":[1],"since":1000}`,
|
||||
},
|
||||
{
|
||||
name: "empty graph field",
|
||||
filter: HeartwoodFilter{
|
||||
Graph: []GraphFilter{},
|
||||
},
|
||||
expected: `{"graph":[]}`,
|
||||
},
|
||||
{
|
||||
name: "graph field only",
|
||||
filter: HeartwoodFilter{
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`"$event.kind"`)}},
|
||||
},
|
||||
},
|
||||
expected: `{"graph":[{"kinds":["$event.kind"]}]}`,
|
||||
},
|
||||
{
|
||||
name: "legacy and graph present",
|
||||
filter: HeartwoodFilter{
|
||||
Legacy: roots.Filter{
|
||||
IDs: []string{"abc"},
|
||||
},
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`1`)}},
|
||||
},
|
||||
},
|
||||
expected: `{"ids":["abc"],"graph":[{"kinds":[1]}]}`,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
result, err := MarshalJSON(tc.filter)
|
||||
assert.NoError(t, err)
|
||||
|
||||
var expectedMap, actualMap map[string]interface{}
|
||||
assert.NoError(t, json.Unmarshal([]byte(tc.expected), &expectedMap))
|
||||
assert.NoError(t, json.Unmarshal(result, &actualMap))
|
||||
assert.Equal(t, expectedMap, actualMap)
|
||||
})
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func TestUnmarshalJSON(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
input string
|
||||
expected HeartwoodFilter
|
||||
}{
|
||||
{
|
||||
name: "empty object",
|
||||
input: `{}`,
|
||||
expected: HeartwoodFilter{},
|
||||
},
|
||||
{
|
||||
name: "legacy fields only",
|
||||
input: `{"ids":["abc"],"kinds":[1],"since":1000}`,
|
||||
expected: HeartwoodFilter{
|
||||
Legacy: roots.Filter{
|
||||
IDs: []string{"abc"},
|
||||
Kinds: []int{1},
|
||||
Since: intPtr(1000),
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "empty graph field",
|
||||
input: `{"graph":[]}`,
|
||||
expected: HeartwoodFilter{
|
||||
Graph: []GraphFilter{},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "graph field only",
|
||||
input: `{"graph":[{"kinds":[1]}]}`,
|
||||
expected: HeartwoodFilter{
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`1`)}},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "legacy and graph present",
|
||||
input: `{"ids":["abc"],"graph":[{"kinds":[1]}]}`,
|
||||
expected: HeartwoodFilter{
|
||||
Legacy: roots.Filter{
|
||||
IDs: []string{"abc"},
|
||||
},
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`1`)}},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "graph is removed from legacy extensions",
|
||||
input: `{"ids":["abc"],"graph":[{"kinds":[1]}],"search":"bitcoin"}`,
|
||||
expected: HeartwoodFilter{
|
||||
Legacy: roots.Filter{
|
||||
IDs: []string{"abc"},
|
||||
Extensions: map[string]json.RawMessage{
|
||||
"search": json.RawMessage(`"bitcoin"`),
|
||||
},
|
||||
},
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`1`)}},
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
var result HeartwoodFilter
|
||||
err := UnmarshalJSON([]byte(tc.input), &result)
|
||||
assert.NoError(t, err)
|
||||
expectEqualHeartwoodFilters(t, result, tc.expected)
|
||||
|
||||
// Ensure graph extension was popped from legacy filter
|
||||
assert.Nil(t, result.Legacy.Extensions["graph"])
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestMarshalGraphJSON(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
filter GraphFilter
|
||||
expected string
|
||||
}{
|
||||
{
|
||||
name: "empty filter",
|
||||
filter: GraphFilter{},
|
||||
expected: `{}`,
|
||||
},
|
||||
{
|
||||
name: "standard fields",
|
||||
filter: GraphFilter{
|
||||
IDs: []string{"abc"},
|
||||
Authors: []string{"def"},
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Since: json.RawMessage(`1000`),
|
||||
Until: []byte("2000"),
|
||||
Limit: intPtr(10),
|
||||
},
|
||||
expected: `{"ids":["abc"],"authors":["def"],"kinds":[1],"since":1000,"until":2000,"limit":10}`,
|
||||
},
|
||||
{
|
||||
name: "tag field",
|
||||
filter: GraphFilter{
|
||||
Tags: roots.TagFilters{"e": {"event1"}},
|
||||
},
|
||||
expected: `{"#e":["event1"]}`,
|
||||
},
|
||||
{
|
||||
name: "distance present",
|
||||
filter: GraphFilter{
|
||||
Distance: &Distance{Min: 1, Max: 10},
|
||||
},
|
||||
expected: `{"distance":{"min":1,"max":10}}`,
|
||||
},
|
||||
{
|
||||
name: "distance absent",
|
||||
filter: GraphFilter{Distance: nil},
|
||||
expected: `{}`,
|
||||
},
|
||||
{
|
||||
name: "empty graph",
|
||||
filter: GraphFilter{
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Graph: []GraphFilter{},
|
||||
},
|
||||
expected: `{"kinds":[1],"graph":[]}`,
|
||||
},
|
||||
{
|
||||
name: "nested graph",
|
||||
filter: GraphFilter{
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`7`)}},
|
||||
},
|
||||
},
|
||||
expected: `{"kinds":[1],"graph":[{"kinds":[7]}]}`,
|
||||
},
|
||||
{
|
||||
name: "extensions",
|
||||
filter: GraphFilter{
|
||||
Extensions: roots.FilterExtensions{
|
||||
"search": json.RawMessage(`"abc"`),
|
||||
},
|
||||
},
|
||||
expected: `{"search":"abc"}`,
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
result, err := MarshalGraphJSON(tc.filter)
|
||||
assert.NoError(t, err)
|
||||
|
||||
var expectedMap, actualMap map[string]interface{}
|
||||
assert.NoError(t, json.Unmarshal([]byte(tc.expected), &expectedMap))
|
||||
assert.NoError(t, json.Unmarshal(result, &actualMap))
|
||||
assert.Equal(t, expectedMap, actualMap)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnmarshalGraphJSON(t *testing.T) {
|
||||
cases := []struct {
|
||||
name string
|
||||
input string
|
||||
expected GraphFilter
|
||||
}{
|
||||
{
|
||||
name: "empty object",
|
||||
input: `{}`,
|
||||
expected: GraphFilter{},
|
||||
},
|
||||
{
|
||||
name: "standard fields",
|
||||
input: `{"ids":["abc"],"authors":["def"],"kinds":[1],"since":1000,"until":2000,"limit":10}`,
|
||||
expected: GraphFilter{
|
||||
IDs: []string{"abc"},
|
||||
Authors: []string{"def"},
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Since: json.RawMessage(`1000`),
|
||||
Until: json.RawMessage(`2000`),
|
||||
Limit: intPtr(10),
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "tag field",
|
||||
input: `{"#e":["event1"]}`,
|
||||
expected: GraphFilter{
|
||||
Tags: roots.TagFilters{"e": {"event1"}},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "distance present",
|
||||
input: `{"distance":{"min":1,"max":10}}`,
|
||||
expected: GraphFilter{
|
||||
Distance: &Distance{Min: 1, Max: 10},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "distance absent",
|
||||
input: `{}`,
|
||||
expected: GraphFilter{Distance: nil},
|
||||
},
|
||||
{
|
||||
name: "empty graph",
|
||||
input: `{"kinds":[1],"graph":[]}`,
|
||||
expected: GraphFilter{
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Graph: []GraphFilter{},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "nested graph",
|
||||
input: `{"kinds":[1],"graph":[{"kinds":[7]}]}`,
|
||||
expected: GraphFilter{
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`7`)}},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "fully populated",
|
||||
input: `{"ids":["abc"],"authors":["def"],"kinds":[1],"since":1000,"until":2000,"limit":10,"#e":["event1"],"distance":{"min":1,"max":5},"graph":[{"kinds":[7]}]}`,
|
||||
expected: GraphFilter{
|
||||
IDs: []string{"abc"},
|
||||
Authors: []string{"def"},
|
||||
Kinds: []json.RawMessage{json.RawMessage(`1`)},
|
||||
Since: json.RawMessage(`1000`),
|
||||
Until: json.RawMessage(`2000`),
|
||||
Limit: intPtr(10),
|
||||
Tags: roots.TagFilters{"e": {"event1"}},
|
||||
Distance: &Distance{Min: 1, Max: 5},
|
||||
Graph: []GraphFilter{
|
||||
{Kinds: []json.RawMessage{json.RawMessage(`7`)}},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "unknown fields routed to extensions",
|
||||
input: `{"search":"abc"}`,
|
||||
expected: GraphFilter{
|
||||
Extensions: roots.FilterExtensions{
|
||||
"search": json.RawMessage(`"abc"`),
|
||||
},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tc := range cases {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
var result GraphFilter
|
||||
err := UnmarshalGraphJSON([]byte(tc.input), &result)
|
||||
assert.NoError(t, err)
|
||||
expectEqualGraphFilters(t, result, tc.expected)
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user