pkg/test/util/structpath/instance.go - dubbo-go-pixiu - Git at Google

 // Copyright Istio Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package structpath

 import (
 	"bytes"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"reflect"
 	"regexp"
 	"strings"
 )

 import (
 	"github.com/google/go-cmp/cmp"
 	"google.golang.org/protobuf/proto"
 	"k8s.io/client-go/util/jsonpath"
 )

 import (
 	"github.com/apache/dubbo-go-pixiu/pkg/test"
 	"github.com/apache/dubbo-go-pixiu/pkg/util/protomarshal"
 )

 var (
 	fixupNumericJSONComparison = regexp.MustCompile(`([=<>]+)\s*([0-9]+)\s*\)`)
 	fixupAttributeReference    = regexp.MustCompile(`\[\s*'[^']+\s*'\s*]`)
 )

 type Instance struct {
 	structure     interface{}
 	isJSON        bool
 	constraints   []constraint
 	creationError error
 }

 type constraint func() error

 // ForProto creates a structpath Instance by marshaling the proto to JSON and then evaluating over that
 // structure. This is the most generally useful form as serialization to JSON also automatically
 // converts proto.Any and proto.Struct to the serialized JSON forms which can then be evaluated
 // over. The downside is the loss of type fidelity for numeric types as JSON can only represent
 // floats.
 func ForProto(proto proto.Message) *Instance {
 	if proto == nil {
 		return newErrorInstance(errors.New("expected non-nil proto"))
 	}

 	parsed, err := protoToParsedJSON(proto)
 	if err != nil {
 		return newErrorInstance(err)
 	}

 	i := &Instance{
 		isJSON:    true,
 		structure: parsed,
 	}
 	i.structure = parsed
 	return i
 }

 func newErrorInstance(err error) *Instance {
 	return &Instance{
 		isJSON:        true,
 		creationError: err,
 	}
 }

 func protoToParsedJSON(message proto.Message) (interface{}, error) {
 	// Convert proto to json and then parse into struct
 	jsonText, err := protomarshal.MarshalIndent(message, "  ")
 	if err != nil {
 		return nil, fmt.Errorf("failed to convert proto to JSON: %v", err)
 	}
 	var parsed interface{}
 	err = json.Unmarshal(jsonText, &parsed)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse into JSON struct: %v", err)
 	}
 	return parsed, nil
 }

 func (i *Instance) Select(path string, args ...interface{}) *Instance {
 	if i.creationError != nil {
 		// There was an error during the creation of this Instance. Just return the
 		// same instance since it will error on Check anyway.
 		return i
 	}

 	path = fmt.Sprintf(path, args...)
 	value, err := i.findValue(path)
 	if err != nil {
 		return newErrorInstance(err)
 	}
 	if value == nil {
 		return newErrorInstance(fmt.Errorf("cannot select non-existent path: %v", path))
 	}

 	// Success.
 	return &Instance{
 		isJSON:    i.isJSON,
 		structure: value,
 	}
 }

 func (i *Instance) appendConstraint(fn func() error) *Instance {
 	i.constraints = append(i.constraints, fn)
 	return i
 }

 func (i *Instance) Equals(expected interface{}, path string, args ...interface{}) *Instance {
 	path = fmt.Sprintf(path, args...)
 	return i.appendConstraint(func() error {
 		typeOf := reflect.TypeOf(expected)
 		protoMessageType := reflect.TypeOf((*proto.Message)(nil)).Elem()
 		if typeOf.Implements(protoMessageType) {
 			return i.equalsStruct(expected.(proto.Message), path)
 		}
 		switch kind := typeOf.Kind(); kind {
 		case reflect.String:
 			return i.equalsString(reflect.ValueOf(expected).String(), path)
 		case reflect.Bool:
 			return i.equalsBool(reflect.ValueOf(expected).Bool(), path)
 		case reflect.Float32, reflect.Float64:
 			return i.equalsNumber(reflect.ValueOf(expected).Float(), path)
 		case reflect.Int, reflect.Int8, reflect.Int32, reflect.Int64:
 			return i.equalsNumber(float64(reflect.ValueOf(expected).Int()), path)
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 			return i.equalsNumber(float64(reflect.ValueOf(expected).Uint()), path)
 		case protoMessageType.Kind():
 		}
 		// TODO: Add struct support
 		return fmt.Errorf("attempt to call Equals for unsupported type: %v", expected)
 	})
 }

 func (i *Instance) ContainSubstring(substr, path string) *Instance {
 	return i.appendConstraint(func() error {
 		value, err := i.execute(path)
 		if err != nil {
 			return err
 		}
 		if found := strings.Contains(value, substr); !found {
 			return fmt.Errorf("substring %v did not match: %v", substr, value)
 		}
 		return nil
 	})
 }

 func (i *Instance) equalsString(expected string, path string) error {
 	value, err := i.execute(path)
 	if err != nil {
 		return err
 	}
 	if value != expected {
 		return fmt.Errorf("expected %v but got %v for path %v", expected, value, path)
 	}
 	return nil
 }

 func (i *Instance) equalsNumber(expected float64, path string) error {
 	v, err := i.findValue(path)
 	if err != nil {
 		return err
 	}
 	result := reflect.ValueOf(v).Float()
 	if result != expected {
 		return fmt.Errorf("expected %v but got %v for path %v", expected, result, path)
 	}
 	return nil
 }

 func (i *Instance) equalsBool(expected bool, path string) error {
 	v, err := i.findValue(path)
 	if err != nil {
 		return err
 	}
 	result := reflect.ValueOf(v).Bool()
 	if result != expected {
 		return fmt.Errorf("expected %v but got %v for path %v", expected, result, path)
 	}
 	return nil
 }

 func (i *Instance) equalsStruct(proto proto.Message, path string) error {
 	jsonStruct, err := protoToParsedJSON(proto)
 	if err != nil {
 		return err
 	}
 	v, err := i.findValue(path)
 	if err != nil {
 		return err
 	}
 	diff := cmp.Diff(reflect.ValueOf(v).Interface(), jsonStruct)
 	if diff != "" {
 		return fmt.Errorf("structs did not match: %v", diff)
 	}
 	return nil
 }

 func (i *Instance) Exists(path string, args ...interface{}) *Instance {
 	path = fmt.Sprintf(path, args...)
 	return i.appendConstraint(func() error {
 		v, err := i.findValue(path)
 		if err != nil {
 			return err
 		}
 		if v == nil {
 			return fmt.Errorf("no entry exists at path: %v", path)
 		}
 		return nil
 	})
 }

 func (i *Instance) NotExists(path string, args ...interface{}) *Instance {
 	path = fmt.Sprintf(path, args...)
 	return i.appendConstraint(func() error {
 		parser := jsonpath.New("path")
 		err := parser.Parse(i.fixPath(path))
 		if err != nil {
 			return fmt.Errorf("invalid path: %v - %v", path, err)
 		}
 		values, err := parser.AllowMissingKeys(true).FindResults(i.structure)
 		if err != nil {
 			return fmt.Errorf("err finding results for path: %v - %v", path, err)
 		}
 		if len(values) == 0 {
 			return nil
 		}
 		if len(values[0]) > 0 {
 			return fmt.Errorf("expected no result but got: %v for path: %v", values[0], path)
 		}
 		return nil
 	})
 }

 // Check executes the set of constraints for this selection
 // and returns the first error encountered, or nil if all constraints
 // have been successfully met. All constraints are removed after them
 // check is performed.
 func (i *Instance) Check() error {
 	// After the check completes, clear out the constraints.
 	defer func() {
 		i.constraints = i.constraints[:0]
 	}()

 	// If there was a creation error, just return that immediately.
 	if i.creationError != nil {
 		return i.creationError
 	}

 	for _, c := range i.constraints {
 		if err := c(); err != nil {
 			return err
 		}
 	}
 	return nil
 }

 // CheckOrFail calls Check on this selection and fails the given test if an
 // error is encountered.
 func (i *Instance) CheckOrFail(t test.Failer) *Instance {
 	t.Helper()
 	if err := i.Check(); err != nil {
 		t.Fatal(err)
 	}
 	return i
 }

 func (i *Instance) execute(path string) (string, error) {
 	parser := jsonpath.New("path")
 	err := parser.Parse(i.fixPath(path))
 	if err != nil {
 		return "", fmt.Errorf("invalid path: %v - %v", path, err)
 	}
 	buf := new(bytes.Buffer)
 	err = parser.Execute(buf, i.structure)
 	if err != nil {
 		return "", fmt.Errorf("err finding results for path: %v - %v", path, err)
 	}
 	return buf.String(), nil
 }

 func (i *Instance) findValue(path string) (interface{}, error) {
 	parser := jsonpath.New("path")
 	err := parser.Parse(i.fixPath(path))
 	if err != nil {
 		return nil, fmt.Errorf("invalid path: %v - %v", path, err)
 	}
 	values, err := parser.FindResults(i.structure)
 	if err != nil {
 		return nil, fmt.Errorf("err finding results for path: %v: %v. Structure: %v", path, err, i.structure)
 	}
 	if len(values) == 0 || len(values[0]) == 0 {
 		return nil, fmt.Errorf("no value for path: %v", path)
 	}
 	return values[0][0].Interface(), nil
 }

 // Fixes up some quirks in jsonpath handling.
 // See https://github.com/kubernetes/client-go/issues/553
 func (i *Instance) fixPath(path string) string {
 	// jsonpath doesn't handle numeric comparisons in a tolerant way. All json numbers are floats
 	// and filter expressions on the form {.x[?(@.some.value==123]} won't work but
 	// {.x[?(@.some.value==123.0]} will.
 	result := path
 	if i.isJSON {
 		template := "$1$2.0)"
 		result = fixupNumericJSONComparison.ReplaceAllString(path, template)
 	}
 	// jsonpath doesn't like map literal references that contain periods. I.e
 	// you can't do x['user.map'] but x.user\.map works so we just translate to that
 	result = string(fixupAttributeReference.ReplaceAllFunc([]byte(result), func(i []byte) []byte {
 		input := string(i)
 		input = strings.Replace(input, "[", "", 1)
 		input = strings.Replace(input, "]", "", 1)
 		input = strings.Replace(input, "'", "", 2)
 		parts := strings.Split(input, ".")
 		output := "."
 		for i := 0; i < len(parts)-1; i++ {
 			output += parts[i]
 			output += "\\."
 		}
 		output += parts[len(parts)-1]
 		return []byte(output)
 	}))

 	return result
 }
	// Copyright Istio Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package structpath

	import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"reflect"
	"regexp"
	"strings"
	)

	import (
	"github.com/google/go-cmp/cmp"
	"google.golang.org/protobuf/proto"
	"k8s.io/client-go/util/jsonpath"
	)

	import (
	"github.com/apache/dubbo-go-pixiu/pkg/test"
	"github.com/apache/dubbo-go-pixiu/pkg/util/protomarshal"
	)

	var (
	fixupNumericJSONComparison = regexp.MustCompile(`([=<>]+)\s([0-9]+)\s\)`)
	fixupAttributeReference = regexp.MustCompile(`\[\s'[^']+\s'\s*]`)
	)

	type Instance struct {
	structure interface{}
	isJSON bool
	constraints []constraint
	creationError error
	}

	type constraint func() error

	// ForProto creates a structpath Instance by marshaling the proto to JSON and then evaluating over that
	// structure. This is the most generally useful form as serialization to JSON also automatically
	// converts proto.Any and proto.Struct to the serialized JSON forms which can then be evaluated
	// over. The downside is the loss of type fidelity for numeric types as JSON can only represent
	// floats.
	func ForProto(proto proto.Message) *Instance {
	if proto == nil {
	return newErrorInstance(errors.New("expected non-nil proto"))
	}

	parsed, err := protoToParsedJSON(proto)
	if err != nil {
	return newErrorInstance(err)
	}

	i := &Instance{
	isJSON: true,
	structure: parsed,
	}
	i.structure = parsed
	return i
	}

	func newErrorInstance(err error) *Instance {
	return &Instance{
	isJSON: true,
	creationError: err,
	}
	}

	func protoToParsedJSON(message proto.Message) (interface{}, error) {
	// Convert proto to json and then parse into struct
	jsonText, err := protomarshal.MarshalIndent(message, " ")
	if err != nil {
	return nil, fmt.Errorf("failed to convert proto to JSON: %v", err)
	}
	var parsed interface{}
	err = json.Unmarshal(jsonText, &parsed)
	if err != nil {
	return nil, fmt.Errorf("failed to parse into JSON struct: %v", err)
	}
	return parsed, nil
	}

	func (i Instance) Select(path string, args ...interface{}) Instance {
	if i.creationError != nil {
	// There was an error during the creation of this Instance. Just return the
	// same instance since it will error on Check anyway.
	return i
	}

	path = fmt.Sprintf(path, args...)
	value, err := i.findValue(path)
	if err != nil {
	return newErrorInstance(err)
	}
	if value == nil {
	return newErrorInstance(fmt.Errorf("cannot select non-existent path: %v", path))
	}

	// Success.
	return &Instance{
	isJSON: i.isJSON,
	structure: value,
	}
	}

	func (i Instance) appendConstraint(fn func() error) Instance {
	i.constraints = append(i.constraints, fn)
	return i
	}

	func (i Instance) Equals(expected interface{}, path string, args ...interface{}) Instance {
	path = fmt.Sprintf(path, args...)
	return i.appendConstraint(func() error {
	typeOf := reflect.TypeOf(expected)
	protoMessageType := reflect.TypeOf((*proto.Message)(nil)).Elem()
	if typeOf.Implements(protoMessageType) {
	return i.equalsStruct(expected.(proto.Message), path)
	}
	switch kind := typeOf.Kind(); kind {
	case reflect.String:
	return i.equalsString(reflect.ValueOf(expected).String(), path)
	case reflect.Bool:
	return i.equalsBool(reflect.ValueOf(expected).Bool(), path)
	case reflect.Float32, reflect.Float64:
	return i.equalsNumber(reflect.ValueOf(expected).Float(), path)
	case reflect.Int, reflect.Int8, reflect.Int32, reflect.Int64:
	return i.equalsNumber(float64(reflect.ValueOf(expected).Int()), path)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
	return i.equalsNumber(float64(reflect.ValueOf(expected).Uint()), path)
	case protoMessageType.Kind():
	}
	// TODO: Add struct support
	return fmt.Errorf("attempt to call Equals for unsupported type: %v", expected)
	})
	}

	func (i Instance) ContainSubstring(substr, path string) Instance {
	return i.appendConstraint(func() error {
	value, err := i.execute(path)
	if err != nil {
	return err
	}
	if found := strings.Contains(value, substr); !found {
	return fmt.Errorf("substring %v did not match: %v", substr, value)
	}
	return nil
	})
	}

	func (i *Instance) equalsString(expected string, path string) error {
	value, err := i.execute(path)
	if err != nil {
	return err
	}
	if value != expected {
	return fmt.Errorf("expected %v but got %v for path %v", expected, value, path)
	}
	return nil
	}

	func (i *Instance) equalsNumber(expected float64, path string) error {
	v, err := i.findValue(path)
	if err != nil {
	return err
	}
	result := reflect.ValueOf(v).Float()
	if result != expected {
	return fmt.Errorf("expected %v but got %v for path %v", expected, result, path)
	}
	return nil
	}

	func (i *Instance) equalsBool(expected bool, path string) error {
	v, err := i.findValue(path)
	if err != nil {
	return err
	}
	result := reflect.ValueOf(v).Bool()
	if result != expected {
	return fmt.Errorf("expected %v but got %v for path %v", expected, result, path)
	}
	return nil
	}

	func (i *Instance) equalsStruct(proto proto.Message, path string) error {
	jsonStruct, err := protoToParsedJSON(proto)
	if err != nil {
	return err
	}
	v, err := i.findValue(path)
	if err != nil {
	return err
	}
	diff := cmp.Diff(reflect.ValueOf(v).Interface(), jsonStruct)
	if diff != "" {
	return fmt.Errorf("structs did not match: %v", diff)
	}
	return nil
	}

	func (i Instance) Exists(path string, args ...interface{}) Instance {
	path = fmt.Sprintf(path, args...)
	return i.appendConstraint(func() error {
	v, err := i.findValue(path)
	if err != nil {
	return err
	}
	if v == nil {
	return fmt.Errorf("no entry exists at path: %v", path)
	}
	return nil
	})
	}

	func (i Instance) NotExists(path string, args ...interface{}) Instance {
	path = fmt.Sprintf(path, args...)
	return i.appendConstraint(func() error {
	parser := jsonpath.New("path")
	err := parser.Parse(i.fixPath(path))
	if err != nil {
	return fmt.Errorf("invalid path: %v - %v", path, err)
	}
	values, err := parser.AllowMissingKeys(true).FindResults(i.structure)
	if err != nil {
	return fmt.Errorf("err finding results for path: %v - %v", path, err)
	}
	if len(values) == 0 {
	return nil
	}
	if len(values[0]) > 0 {
	return fmt.Errorf("expected no result but got: %v for path: %v", values[0], path)
	}
	return nil
	})
	}

	// Check executes the set of constraints for this selection
	// and returns the first error encountered, or nil if all constraints
	// have been successfully met. All constraints are removed after them
	// check is performed.
	func (i *Instance) Check() error {
	// After the check completes, clear out the constraints.
	defer func() {
	i.constraints = i.constraints[:0]
	}()

	// If there was a creation error, just return that immediately.
	if i.creationError != nil {
	return i.creationError
	}

	for _, c := range i.constraints {
	if err := c(); err != nil {
	return err
	}
	}
	return nil
	}

	// CheckOrFail calls Check on this selection and fails the given test if an
	// error is encountered.
	func (i Instance) CheckOrFail(t test.Failer) Instance {
	t.Helper()
	if err := i.Check(); err != nil {
	t.Fatal(err)
	}
	return i
	}

	func (i *Instance) execute(path string) (string, error) {
	parser := jsonpath.New("path")
	err := parser.Parse(i.fixPath(path))
	if err != nil {
	return "", fmt.Errorf("invalid path: %v - %v", path, err)
	}
	buf := new(bytes.Buffer)
	err = parser.Execute(buf, i.structure)
	if err != nil {
	return "", fmt.Errorf("err finding results for path: %v - %v", path, err)
	}
	return buf.String(), nil
	}

	func (i *Instance) findValue(path string) (interface{}, error) {
	parser := jsonpath.New("path")
	err := parser.Parse(i.fixPath(path))
	if err != nil {
	return nil, fmt.Errorf("invalid path: %v - %v", path, err)
	}
	values, err := parser.FindResults(i.structure)
	if err != nil {
	return nil, fmt.Errorf("err finding results for path: %v: %v. Structure: %v", path, err, i.structure)
	}
	if len(values) == 0 \|\| len(values[0]) == 0 {
	return nil, fmt.Errorf("no value for path: %v", path)
	}
	return values[0][0].Interface(), nil
	}

	// Fixes up some quirks in jsonpath handling.
	// See https://github.com/kubernetes/client-go/issues/553
	func (i *Instance) fixPath(path string) string {
	// jsonpath doesn't handle numeric comparisons in a tolerant way. All json numbers are floats
	// and filter expressions on the form {.x[?(@.some.value==123]} won't work but
	// {.x[?(@.some.value==123.0]} will.
	result := path
	if i.isJSON {
	template := "$1$2.0)"
	result = fixupNumericJSONComparison.ReplaceAllString(path, template)
	}
	// jsonpath doesn't like map literal references that contain periods. I.e
	// you can't do x['user.map'] but x.user\.map works so we just translate to that
	result = string(fixupAttributeReference.ReplaceAllFunc([]byte(result), func(i []byte) []byte {
	input := string(i)
	input = strings.Replace(input, "[", "", 1)
	input = strings.Replace(input, "]", "", 1)
	input = strings.Replace(input, "'", "", 2)
	parts := strings.Split(input, ".")
	output := "."
	for i := 0; i < len(parts)-1; i++ {
	output += parts[i]
	output += "\\."
	}
	output += parts[len(parts)-1]
	return []byte(output)
	}))

	return result
	}