8e79f4ce27
The failure message from Gomega was hard to read because explanation and error text were separated by the error dump. In many cases, that error dump doesn't add any relevant information. Now the error is dumped first as info message (just in case that it is relevant) and then a shorter failure message is created from explanation and error text.
93 lines
3.5 KiB
Go
93 lines
3.5 KiB
Go
/*
|
|
Copyright 2014 The Kubernetes 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 framework
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/onsi/gomega"
|
|
"github.com/onsi/gomega/format"
|
|
)
|
|
|
|
// ExpectEqual expects the specified two are the same, otherwise an exception raises
|
|
func ExpectEqual(actual interface{}, extra interface{}, explain ...interface{}) {
|
|
gomega.ExpectWithOffset(1, actual).To(gomega.Equal(extra), explain...)
|
|
}
|
|
|
|
// ExpectNotEqual expects the specified two are not the same, otherwise an exception raises
|
|
func ExpectNotEqual(actual interface{}, extra interface{}, explain ...interface{}) {
|
|
gomega.ExpectWithOffset(1, actual).NotTo(gomega.Equal(extra), explain...)
|
|
}
|
|
|
|
// ExpectError expects an error happens, otherwise an exception raises
|
|
func ExpectError(err error, explain ...interface{}) {
|
|
gomega.ExpectWithOffset(1, err).To(gomega.HaveOccurred(), explain...)
|
|
}
|
|
|
|
// ExpectNoError checks if "err" is set, and if so, fails assertion while logging the error.
|
|
func ExpectNoError(err error, explain ...interface{}) {
|
|
ExpectNoErrorWithOffset(1, err, explain...)
|
|
}
|
|
|
|
// ExpectNoErrorWithOffset checks if "err" is set, and if so, fails assertion while logging the error at "offset" levels above its caller
|
|
// (for example, for call chain f -> g -> ExpectNoErrorWithOffset(1, ...) error would be logged for "f").
|
|
func ExpectNoErrorWithOffset(offset int, err error, explain ...interface{}) {
|
|
if err == nil {
|
|
return
|
|
}
|
|
|
|
// Errors usually contain unexported fields. We have to use
|
|
// a formatter here which can print those.
|
|
prefix := ""
|
|
if len(explain) > 0 {
|
|
if str, ok := explain[0].(string); ok {
|
|
prefix = fmt.Sprintf(str, explain[1:]...) + ": "
|
|
} else {
|
|
prefix = fmt.Sprintf("unexpected explain arguments, need format string: %v", explain)
|
|
}
|
|
}
|
|
|
|
// This intentionally doesn't use gomega.Expect. Instead we take
|
|
// full control over what information is presented where:
|
|
// - The complete error object is logged because it may contain
|
|
// additional information that isn't included in its error
|
|
// string.
|
|
// - It is not included in the failure message because
|
|
// it might make the failure message very large and/or
|
|
// cause error aggregation to work less well: two
|
|
// failures at the same code line might not be matched in
|
|
// https://go.k8s.io/triage because the error details are too
|
|
// different.
|
|
Logf("Unexpected error: %s\n%s", prefix, format.Object(err, 1))
|
|
Fail(prefix+err.Error(), 1+offset)
|
|
}
|
|
|
|
// ExpectConsistOf expects actual contains precisely the extra elements. The ordering of the elements does not matter.
|
|
func ExpectConsistOf(actual interface{}, extra interface{}, explain ...interface{}) {
|
|
gomega.ExpectWithOffset(1, actual).To(gomega.ConsistOf(extra), explain...)
|
|
}
|
|
|
|
// ExpectHaveKey expects the actual map has the key in the keyset
|
|
func ExpectHaveKey(actual interface{}, key interface{}, explain ...interface{}) {
|
|
gomega.ExpectWithOffset(1, actual).To(gomega.HaveKey(key), explain...)
|
|
}
|
|
|
|
// ExpectEmpty expects actual is empty
|
|
func ExpectEmpty(actual interface{}, explain ...interface{}) {
|
|
gomega.ExpectWithOffset(1, actual).To(gomega.BeEmpty(), explain...)
|
|
}
|