feat(parameter): add dependson for the parameter group

Author: shipengqi

internal/helpers/contains.go

@@ -0,0 +1,79 @@
+package helpers
+
+import (
+	"reflect"
+	"strings"
+)
+
+// Contains asserts that the specified string, list(array, slice...) or map contains the
+// specified substring or element.
+//
+//	helpers.Contains("Hello World", "World")
+//	helpers.Contains(["Hello", "World"], "World")
+//	helpers.Contains({"Hello": "World"}, "Hello")
+func Contains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+	ok, found := containsElement(s, contains)
+	if !ok {
+		return false
+	}
+
+	return found
+}
+
+// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the
+// specified substring or element.
+//
+//	helpers.NotContains("Hello World", "Earth")
+//	helpers.NotContains(["Hello", "World"], "Earth")
+//	helpers.NotContains({"Hello": "World"}, "Earth")
+func NotContains(s, contains interface{}, msgAndArgs ...interface{}) bool {
+	ok, found := containsElement(s, contains)
+	if !ok {
+		return false
+	}
+
+	return !found
+}
+
+// containsElement try loop over the list check if the list includes the element.
+// return (false, false) if impossible.
+// return (true, false) if element was not found.
+// return (true, true) if element was found.
+func containsElement(list interface{}, element interface{}) (ok, found bool) {
+
+	listValue := reflect.ValueOf(list)
+	listType := reflect.TypeOf(list)
+	if listType == nil {
+		return false, false
+	}
+	listKind := listType.Kind()
+	defer func() {
+		if e := recover(); e != nil {
+			ok = false
+			found = false
+		}
+	}()
+
+	if listKind == reflect.String {
+		elementValue := reflect.ValueOf(element)
+		return true, strings.Contains(listValue.String(), elementValue.String())
+	}
+
+	if listKind == reflect.Map {
+		mapKeys := listValue.MapKeys()
+		for i := 0; i < len(mapKeys); i++ {
+			if ObjectsAreEqual(mapKeys[i].Interface(), element) {
+				return true, true
+			}
+		}
+		return true, false
+	}
+
+	for i := 0; i < listValue.Len(); i++ {
+		if ObjectsAreEqual(listValue.Index(i).Interface(), element) {
+			return true, true
+		}
+	}
+	return true, false
+
+}

internal/helpers/contains_test.go

@@ -0,0 +1,68 @@
+package helpers
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestContainsNotContains(t *testing.T) {
+
+	type A struct {
+		Name, Value string
+	}
+	list := []string{"Foo", "Bar"}
+
+	complexList := []*A{
+		{"b", "c"},
+		{"d", "e"},
+		{"g", "h"},
+		{"j", "k"},
+	}
+	simpleMap := map[interface{}]interface{}{"Foo": "Bar"}
+	var zeroMap map[interface{}]interface{}
+
+	cases := []struct {
+		expected interface{}
+		actual   interface{}
+		result   bool
+	}{
+		{"Hello World", "Hello", true},
+		{"Hello World", "Salut", false},
+		{list, "Bar", true},
+		{list, "Salut", false},
+		{complexList, &A{"g", "h"}, true},
+		{complexList, &A{"g", "e"}, false},
+		{simpleMap, "Foo", true},
+		{simpleMap, "Bar", false},
+		{zeroMap, "Bar", false},
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("Contains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := Contains(c.expected, c.actual)
+
+			if res != c.result {
+				if res {
+					t.Errorf("Contains(%#v, %#v) should return true:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
+				} else {
+					t.Errorf("Contains(%#v, %#v) should return false:\n\t%#v does not contain %#v", c.expected, c.actual, c.expected, c.actual)
+				}
+			}
+		})
+	}
+
+	for _, c := range cases {
+		t.Run(fmt.Sprintf("NotContains(%#v, %#v)", c.expected, c.actual), func(t *testing.T) {
+			res := NotContains(c.expected, c.actual)
+
+			// NotContains should be inverse of Contains. If it's not, something is wrong
+			if res == Contains(c.expected, c.actual) {
+				if res {
+					t.Errorf("NotContains(%#v, %#v) should return true:\n\t%#v does not contains %#v", c.expected, c.actual, c.expected, c.actual)
+				} else {
+					t.Errorf("NotContains(%#v, %#v) should return false:\n\t%#v contains %#v", c.expected, c.actual, c.expected, c.actual)
+				}
+			}
+		})
+	}
+}

internal/helpers/empty.go

@@ -0,0 +1,50 @@
+package helpers
+
+import "reflect"
+
+// Empty asserts that the specified object is empty.  I.e. nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	helpers.Empty(obj)
+func Empty(object interface{}) bool {
+	return isEmpty(object)
+}
+
+// NotEmpty asserts that the specified object is NOT empty.  I.e. not nil, "", false, 0 or either
+// a slice or a channel with len == 0.
+//
+//	if helpers.NotEmpty(obj) {
+//	  helpers.Equal("two", obj[1])
+//	}
+func NotEmpty(object interface{}) bool {
+	return !isEmpty(object)
+}
+
+// isEmpty gets whether the specified object is considered empty or not.
+func isEmpty(object interface{}) bool {
+
+	// get nil case out of the way
+	if object == nil {
+		return true
+	}
+
+	objValue := reflect.ValueOf(object)
+
+	switch objValue.Kind() {
+	// collection types are empty when they have no element
+	case reflect.Chan, reflect.Map, reflect.Slice:
+		return objValue.Len() == 0
+	// pointers are empty if nil or if the value they point to is empty
+	case reflect.Ptr:
+		if objValue.IsNil() {
+			return true
+		}
+		deref := objValue.Elem().Interface()
+		return isEmpty(deref)
+	// for all other types, compare against the zero value
+	// array types are empty when they match their zero-initialized state
+	default:
+		zero := reflect.Zero(objValue.Type())
+		return reflect.DeepEqual(object, zero.Interface())
+	}
+}

internal/helpers/empty_test.go

@@ -0,0 +1,75 @@
+package helpers
+
+import (
+	"errors"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestEmpty(t *testing.T) {
+
+	chWithValue := make(chan struct{}, 1)
+	chWithValue <- struct{}{}
+	var tiP *time.Time
+	var tiNP time.Time
+	var s *string
+	var f *os.File
+	sP := &s
+	x := 1
+	xP := &x
+
+	type TString string
+	type TStruct struct {
+		x int
+	}
+
+	assert.True(t, Empty(""), "Empty string is empty")
+	assert.True(t, Empty(nil), "Nil is empty")
+	assert.True(t, Empty([]string{}), "Empty string array is empty")
+	assert.True(t, Empty(0), "Zero int value is empty")
+	assert.True(t, Empty(false), "False value is empty")
+	assert.True(t, Empty(make(chan struct{})), "Channel without values is empty")
+	assert.True(t, Empty(s), "Nil string pointer is empty")
+	assert.True(t, Empty(f), "Nil os.File pointer is empty")
+	assert.True(t, Empty(tiP), "Nil time.Time pointer is empty")
+	assert.True(t, Empty(tiNP), "time.Time is empty")
+	assert.True(t, Empty(TStruct{}), "struct with zero values is empty")
+	assert.True(t, Empty(TString("")), "empty aliased string is empty")
+	assert.True(t, Empty(sP), "ptr to nil value is empty")
+	assert.True(t, Empty([1]int{}), "array is state")
+
+	assert.False(t, Empty("something"), "Non Empty string is not empty")
+	assert.False(t, Empty(errors.New("something")), "Non nil object is not empty")
+	assert.False(t, Empty([]string{"something"}), "Non empty string array is not empty")
+	assert.False(t, Empty(1), "Non-zero int value is not empty")
+	assert.False(t, Empty(true), "True value is not empty")
+	assert.False(t, Empty(chWithValue), "Channel with values is not empty")
+	assert.False(t, Empty(TStruct{x: 1}), "struct with initialized values is empty")
+	assert.False(t, Empty(TString("abc")), "non-empty aliased string is empty")
+	assert.False(t, Empty(xP), "ptr to non-nil value is not empty")
+	assert.False(t, Empty([1]int{42}), "array is not state")
+}
+
+func TestNotEmpty(t *testing.T) {
+	chWithValue := make(chan struct{}, 1)
+	chWithValue <- struct{}{}
+
+	assert.False(t, NotEmpty(""), "Empty string is empty")
+	assert.False(t, NotEmpty(nil), "Nil is empty")
+	assert.False(t, NotEmpty([]string{}), "Empty string array is empty")
+	assert.False(t, NotEmpty(0), "Zero int value is empty")
+	assert.False(t, NotEmpty(false), "False value is empty")
+	assert.False(t, NotEmpty(make(chan struct{})), "Channel without values is empty")
+	assert.False(t, NotEmpty([1]int{}), "array is state")
+
+	assert.True(t, NotEmpty("something"), "Non Empty string is not empty")
+	assert.True(t, NotEmpty(errors.New("something")), "Non nil object is not empty")
+	assert.True(t, NotEmpty([]string{"something"}), "Non empty string array is not empty")
+	assert.True(t, NotEmpty(1), "Non-zero int value is not empty")
+	assert.True(t, NotEmpty(true), "True value is not empty")
+	assert.True(t, NotEmpty(chWithValue), "Channel with values is not empty")
+	assert.True(t, NotEmpty([1]int{42}), "array is not state")
+}

internal/helpers/equal.go

@@ -0,0 +1,80 @@
+package helpers
+
+import (
+	"bytes"
+	"errors"
+	"reflect"
+)
+
+// Equal asserts that two objects are equal.
+//
+//	helpers.Equal(123, 123)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses). Function equality
+// cannot be determined and will always fail.
+func Equal(expected, actual interface{}) bool {
+	if err := validateEqualArgs(expected, actual); err != nil {
+		// invalid operation
+		return false
+	}
+	return ObjectsAreEqual(expected, actual)
+}
+
+// NotEqual asserts that the specified values are NOT equal.
+//
+//	helpers.NotEqual(obj1, obj2)
+//
+// Pointer variable equality is determined based on the equality of the
+// referenced values (as opposed to the memory addresses).
+func NotEqual(expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	if err := validateEqualArgs(expected, actual); err != nil {
+		// invalid operation
+		return false
+	}
+
+	return !ObjectsAreEqual(expected, actual)
+}
+
+// ObjectsAreEqual determines if two objects are considered equal.
+//
+// This function does no assertion of any kind.
+func ObjectsAreEqual(expected, actual interface{}) bool {
+	if expected == nil || actual == nil {
+		return expected == actual
+	}
+
+	exp, ok := expected.([]byte)
+	if !ok {
+		return reflect.DeepEqual(expected, actual)
+	}
+
+	act, ok := actual.([]byte)
+	if !ok {
+		return false
+	}
+	if exp == nil || act == nil {
+		return exp == nil && act == nil
+	}
+	return bytes.Equal(exp, act)
+}
+
+// validateEqualArgs checks whether provided arguments can be safely used in the
+// Equal/NotEqual functions.
+func validateEqualArgs(expected, actual interface{}) error {
+	if expected == nil && actual == nil {
+		return nil
+	}
+
+	if isFunction(expected) || isFunction(actual) {
+		return errors.New("cannot take func type as argument")
+	}
+	return nil
+}
+
+func isFunction(arg interface{}) bool {
+	if arg == nil {
+		return false
+	}
+	return reflect.TypeOf(arg).Kind() == reflect.Func
+}