package expect import ( "bytes" "encoding/json" "reflect" "strings" "time" ) type JSON string var NotNil = struct{}{} type Expectation struct { actual interface{} others []interface{} Greater *ThanAssertion GreaterOrEqual *ToAssertion Less *ThanAssertion LessOrEqual *ToAssertion To *ToExpectation Not *InvertedExpectation } func (e *Expectation) ToEqual(expected interface{}, others ...interface{}) PostHandler { return e.To.Equal(expected, others...) } func (e *Expectation) ToEql(expected interface{}, others ...interface{}) PostHandler { return e.To.Eql(expected, others...) } func (e *Expectation) GreaterThan(expected interface{}) PostHandler { return e.Greater.Than(expected) } func (e *Expectation) GreaterOrEqualTo(expected interface{}) PostHandler { return e.GreaterOrEqual.To(expected) } func (e *Expectation) LessThan(expected interface{}) PostHandler { return e.Less.Than(expected) } func (e *Expectation) LessOrEqualTo(expected interface{}) PostHandler { return e.LessOrEqual.To(expected) } type InvertedExpectation struct { *Expectation } var Errorf = func(format string, args ...interface{}) { runner.Errorf(format, args...) } func Expect(actual interface{}, others ...interface{}) *Expectation { return expect(actual, others, true) } func Fail(format string, args ...interface{}) { Errorf(format, args...) panic(endTestErr) } func Skip(format string, args ...interface{}) { runner.Skip(format, args...) panic(endTestErr) } func expect(actual interface{}, others []interface{}, includeNot bool) *Expectation { e := &Expectation{actual: actual, others: others} e.Greater = newThanAssertion(actual, GreaterThanComparitor, "to be greater than", "greater than") e.GreaterOrEqual = newToAssertion(actual, GreaterOrEqualToComparitor, "to be greater or equal to") e.Less = newThanAssertion(actual, LessThanComparitor, "to be less than", "less than") e.LessOrEqual = newToAssertion(actual, LessThanOrEqualToComparitor, "to be less or equal to") e.To = &ToExpectation{ actual: actual, others: others, } if includeNot { e.Not = NotExpect(actual, others...) } return e } func NotExpect(actual interface{}, others ...interface{}) *InvertedExpectation { e := &InvertedExpectation{expect(actual, others, false)} e.Greater.invert = true e.GreaterOrEqual.invert = true e.Less.invert = true e.LessOrEqual.invert = true e.To.invert = true return e } type ToExpectation struct { invert bool actual interface{} others []interface{} } func (e *ToExpectation) Equal(expected interface{}, others ...interface{}) PostHandler { display := "to be equal to" if e.invert { display = "to equal" } assertion := newToAssertion(e.actual, EqualsComparitor, display) assertion.invert = e.invert failed := !equal(assertion, e.actual, expected) if len(others) != len(e.others) { Errorf("mismatch number of values and expectations %d != %d", len(e.others)+1, len(others)+1) failed = true } else { for i := 0; i < len(others); i++ { if equal(assertion, e.others[i], others[i]) == false { failed = true } } } if failed { return NewFailureHandler(expected, e.actual) } return SuccessHandler } func (e *ToExpectation) Eql(expected interface{}, others ...interface{}) PostHandler { if len(others) == len(e.others) { expected = coerce(e.actual, expected) for i := 0; i < len(others); i++ { others[i] = coerce(e.others[i], others[i]) } } return e.Equal(expected, others...) } func equal(assertion *ToAssertion, a, b interface{}) bool { aIsNil := IsNil(a) if b == NotNil { if aIsNil { showError(a, "", false, "to be nil", false) return false } else { return true } } bIsNil := IsNil(b) if aIsNil || bIsNil { if (aIsNil == bIsNil) == assertion.invert { showError(a, b, assertion.invert, assertion.display, false) return false } return true } assertion.actual = a return assertion.To(b) == SuccessHandler } func (e *ToExpectation) Contain(expected interface{}) PostHandler { c := contains(e.actual, expected) if e.invert == false && c == false { Errorf("%v does not contain %v", e.actual, expected) return NewFailureHandler(expected, e.actual) } if e.invert == true && c == true { Errorf("%v contains %v", e.actual, expected) return NewFailureHandler(expected, e.actual) } return SuccessHandler } type ToAssertion struct { actual interface{} comparitor comparitor display string invert bool } func newToAssertion(a interface{}, c comparitor, display string) *ToAssertion { return &ToAssertion{ actual: a, comparitor: c, display: display, } } func (a *ToAssertion) To(expected interface{}) PostHandler { original, actual := a.actual, a.actual isJson := false if j, ok := expected.(JSON); ok { var a []byte switch t := actual.(type) { case []byte: a = t case string: a = []byte(t) default: Errorf("JSON() helper can only be used with a string or []byte actual") return NewFailureHandler(expected, original) } if actual, ok = convertToJson(a); ok == false { Errorf("invalid json %v", string(a)) return NewFailureHandler(expected, original) } if expected, ok = convertToJson([]byte(j)); ok == false { Errorf("invalid json %v", string(j)) return NewFailureHandler(expected, original) } isJson = true } kind, ok := SameKind(actual, expected) if ok == false { Errorf("expected %v %s %v - type mismatch %s != %s", actual, a.display, expected, reflect.ValueOf(actual).Kind(), reflect.ValueOf(expected).Kind()) return NewFailureHandler(expected, a.actual) } if IsInt(actual) { actual, expected = ToInt64(actual, expected) kind = reflect.Int64 } else if IsUint(actual) { actual, expected = ToUint64(actual, expected) kind = reflect.Uint64 } else if kind == reflect.Slice && IsString(expected) { actual = ToString(actual) } else if kind == reflect.String && IsSlice(expected) { expected = ToString(expected) } if a.comparitor(kind, actual, expected) == a.invert { if isJson { actual, expected = convertFromJson(actual), convertFromJson(expected) } showError(actual, expected, a.invert, a.display, !isJson) return NewFailureHandler(expected, original) } return SuccessHandler } func showError(actual, expected interface{}, invert bool, display string, escape bool) { var inversion string if invert { inversion = "not " } if _, ok := actual.(string); ok { if escape == true { Errorf("expected %q %s%s %q", actual, inversion, display, expected) } else { Errorf("expected %s %s%s %s", actual, inversion, display, expected) } } else { Errorf("expected %v %s%s %v", actual, inversion, display, expected) } } type ThanAssertion struct { to *ToAssertion display string invert bool } func newThanAssertion(actual interface{}, c comparitor, toDisplay, thanDisplay string) *ThanAssertion { return &ThanAssertion{ to: newToAssertion(actual, c, toDisplay), display: thanDisplay, } } func (a *ThanAssertion) Than(expected interface{}) PostHandler { actual := a.to.actual a.to.invert = a.invert if _, ok := actual.(time.Time); ok { return a.to.To(expected) } if IsNumeric(actual) == false { Errorf("cannot use %s for type %s", a.display, reflect.ValueOf(actual).Kind()) return NewFailureHandler(expected, actual) } if IsNumeric(expected) == false { Errorf("cannot use %s for type %s", a.display, reflect.ValueOf(expected).Kind()) NewFailureHandler(expected, actual) } return a.to.To(expected) } func contains(actual, expected interface{}) bool { actualValue, expectedValue := reflect.ValueOf(actual), reflect.ValueOf(expected) actualKind, expectedKind := actualValue.Kind(), expectedValue.Kind() if actualKind == reflect.String { if expectedKind == reflect.String && strings.Contains(actual.(string), expected.(string)) { return true } return false } if actualKind == reflect.Slice || actualKind == reflect.Array { for i, l := 0, actualValue.Len(); i < l; i++ { if reflect.DeepEqual(actualValue.Index(i).Interface(), expected) { return true } } } if actualKind == reflect.Map { return actualValue.MapIndex(expectedValue).Kind() != reflect.Invalid } if actualBytes, ok := actual.([]byte); ok { if expectedBytes, ok := expected.([]byte); ok { return bytes.Contains(actualBytes, expectedBytes) } } return false } func convertToJson(bytes []byte) (interface{}, bool) { var m interface{} if err := json.Unmarshal(bytes, &m); err != nil { return bytes, false } return m, true } func convertFromJson(value interface{}) string { bytes, _ := json.MarshalIndent(value, "", " ") return string(bytes) } func coerce(actual interface{}, expected interface{}) interface{} { at := reflect.TypeOf(actual) et := reflect.TypeOf(expected) if et.ConvertibleTo(at) { return reflect.ValueOf(expected).Convert(at).Interface() } return expected }