goext/mongo/internal/testutil/assert/assert.go

138 lines
3.4 KiB
Go

// Copyright (C) MongoDB, Inc. 2017-present.
//
// 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
package assert
import (
"context"
"reflect"
"sync"
"testing"
"time"
"github.com/google/go-cmp/cmp"
)
var cmpOpts sync.Map
var errorCompareFn = func(e1, e2 error) bool {
if e1 == nil || e2 == nil {
return e1 == nil && e2 == nil
}
return e1.Error() == e2.Error()
}
var errorCompareOpts = cmp.Options{cmp.Comparer(errorCompareFn)}
// RegisterOpts registers go-cmp options for a type. These options will be used when comparing two objects for equality.
func RegisterOpts(t reflect.Type, opts ...cmp.Option) {
cmpOpts.Store(t, cmp.Options(opts))
}
// Equal compares first and second for equality. The objects must be of the same type.
// If the objects are not equal, the test will be failed with an error message containing msg and args.
func Equal(t testing.TB, first, second interface{}, msg string, args ...interface{}) {
t.Helper()
if !cmp.Equal(first, second, getCmpOpts(first)...) {
t.Fatalf(msg, args...)
}
}
// NotEqual compares first and second for inequality. The objects must be of the same type.
func NotEqual(t testing.TB, first, second interface{}, msg string, args ...interface{}) {
t.Helper()
if cmp.Equal(first, second, getCmpOpts(first)...) {
t.Fatalf(msg, args...)
}
}
// True asserts that the obj parameter is a boolean with value true.
func True(t testing.TB, obj interface{}, msg string, args ...interface{}) {
t.Helper()
b, ok := obj.(bool)
if !ok || !b {
t.Fatalf(msg, args...)
}
}
// False asserts that the obj parameter is a boolean with value false.
func False(t testing.TB, obj interface{}, msg string, args ...interface{}) {
t.Helper()
b, ok := obj.(bool)
if !ok || b {
t.Fatalf(msg, args...)
}
}
// Nil asserts that the obj parameter is nil.
func Nil(t testing.TB, obj interface{}, msg string, args ...interface{}) {
t.Helper()
if !isNil(obj) {
t.Fatalf(msg, args...)
}
}
// NotNil asserts that the obj parameter is not nil.
func NotNil(t testing.TB, obj interface{}, msg string, args ...interface{}) {
t.Helper()
if isNil(obj) {
t.Fatalf(msg, args...)
}
}
// Soon runs the provided callback for a maximum of timeoutMS milliseconds. The provided callback
// should respect the passed-in context and cease execution when it has expired.
func Soon(t testing.TB, callback func(ctx context.Context), timeout time.Duration) {
t.Helper()
// Create context to manually cancel callback after Soon assertion.
callbackCtx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
fullCallback := func() {
callback(callbackCtx)
done <- struct{}{}
}
timer := time.NewTimer(timeout)
defer timer.Stop()
go fullCallback()
select {
case <-done:
return
case <-timer.C:
t.Fatalf("timed out in %s waiting for callback", timeout)
}
}
func getCmpOpts(obj interface{}) cmp.Options {
opts, ok := cmpOpts.Load(reflect.TypeOf(obj))
if ok {
return opts.(cmp.Options)
}
if _, ok := obj.(error); ok {
return errorCompareOpts
}
return nil
}
func isNil(object interface{}) bool {
if object == nil {
return true
}
val := reflect.ValueOf(object)
switch val.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
return val.IsNil()
default:
return false
}
}