add interface request verification method.

internal/builtin/assertion.go

@@ -2,6 +2,7 @@ package builtin
 
 import (
 	"fmt"
+	"reflect"
 	"strings"
 
 	"github.com/stretchr/testify/assert"
@@ -18,10 +19,14 @@ var Assertions = map[string]func(t assert.TestingT, expected interface{}, actual
 	"contains":          assert.Contains,
 	"regex_match":       assert.Regexp,
 	// custom assertions
-	"startswith":    StartsWith, // check if string starts with substring
-	"endswith":      EndsWith,   // check if string ends with substring
-	"length_equals": EqualLength,
-	"length_equal":  EqualLength, // alias for length_equals
+	"startswith":               StartsWith, // check if string starts with substring
+	"endswith":                 EndsWith,   // check if string ends with substring
+	"length_equals":            EqualLength,
+	"length_equal":             EqualLength, // alias for length_equals
+	"length_less_than":         LessThanLength,
+	"length_less_or_equals":    LessOrEqualsLength,
+	"length_greater_than":      GreaterThanLength,
+	"length_greater_or_equals": GreaterOrEqualsLength,
 }
 
 func StartsWith(t assert.TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
@@ -57,6 +62,66 @@ func EqualLength(t assert.TestingT, expected, actual interface{}, msgAndArgs ...
 	return assert.Len(t, actual, length, msgAndArgs...)
 }
 
+func GreaterThanLength(t assert.TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	length, err := convertInt(expected)
+	if err != nil {
+		return assert.Fail(t, fmt.Sprintf("expected type is not int, got %#v", expected), msgAndArgs...)
+	}
+	ok, l := getLen(actual)
+	if !ok {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...)
+	}
+	if l > length {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" should be more than %d item(s), but has %d", actual, length, l), msgAndArgs...)
+	}
+	return true
+}
+
+func GreaterOrEqualsLength(t assert.TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	length, err := convertInt(expected)
+	if err != nil {
+		return assert.Fail(t, fmt.Sprintf("expected type is not int, got %#v", expected), msgAndArgs...)
+	}
+	ok, l := getLen(actual)
+	if !ok {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...)
+	}
+	if l >= length {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" should be no less than %d item(s), but has %d", actual, length, l), msgAndArgs...)
+	}
+	return true
+}
+
+func LessThanLength(t assert.TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	length, err := convertInt(expected)
+	if err != nil {
+		return assert.Fail(t, fmt.Sprintf("expected type is not int, got %#v", expected), msgAndArgs...)
+	}
+	ok, l := getLen(actual)
+	if !ok {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...)
+	}
+	if l < length {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" should be less than %d item(s), but has %d", actual, length, l), msgAndArgs...)
+	}
+	return true
+}
+
+func LessOrEqualsLength(t assert.TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool {
+	length, err := convertInt(expected)
+	if err != nil {
+		return assert.Fail(t, fmt.Sprintf("expected type is not int, got %#v", expected), msgAndArgs...)
+	}
+	ok, l := getLen(actual)
+	if !ok {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", actual), msgAndArgs...)
+	}
+	if l <= length {
+		return assert.Fail(t, fmt.Sprintf("\"%s\" should be no more than %d item(s), but has %d", actual, length, l), msgAndArgs...)
+	}
+	return true
+}
+
 func convertInt(value interface{}) (int, error) {
 	switch v := value.(type) {
 	case int:
@@ -83,3 +148,15 @@ func convertInt(value interface{}) (int, error) {
 		return 0, fmt.Errorf("unsupported int convertion for %v(%T)", v, v)
 	}
 }
+
+// getLen try to get length of object.
+// return (false, 0) if impossible.
+func getLen(x interface{}) (ok bool, length int) {
+	v := reflect.ValueOf(x)
+	defer func() {
+		if e := recover(); e != nil {
+			ok = false
+		}
+	}()
+	return true, v.Len()
+}