mirror of
https://github.com/kubernetes/kubernetes.git
synced 2026-02-14 08:14:28 -05:00
551cf6f171
The original implementation was inspired by how context.Context is handled via wrapping a parent context. That approach had several issues: - It is useful to let users call methods (e.g. tCtx.ExpectNoError) instead of ktesting functions with a tCtx parameters, but that only worked if all implementations of the interface implemented that set of methods. This made extending those methods cumbersome (see the commit which added Require+Assert) and could potentially break implementations of the interface elsewhere, defeating part of the motivation for having the interface in the first place. - It was hard to see how the different TContext wrappers cooperated with each other. - Layering injection of "ERROR" and "FATAL ERROR" on top of prefixing with the klog header caused post-processing of a failed unit test to remove that line because it looked like log output. Other log output lines where kept because they were not indented. - In Go <=1.25, the `go vet sprintf` check only works for functions and methods if they get called directly and themselves directly pass their parameters on to fmt.Sprint. The check does not work when calling methods through an interface. Support for that is coming in Go 1.26, but will depend on bumping the Go version also in go.mod and thus may not be immediately possible in Kubernetes. - Interface documentation in https://pkg.go.dev/k8s.io/kubernetes@v1.34.2/test/utils/ktesting#TContext is a monolithic text block. Documentation for methods is more readable and allows referencing those methods with [] (e.g. [TC.Errorf] works, [TContext.Errorf] didn't). The revised implementation is a single struct with (almost) no exported fields. The two exceptions (embedded context.Context and TB) are useful because it avoids having to write wrappers for several functions resp. necessary because Helper cannot be wrapped. Like a logr.LogSink, With* methods can make a shallow copy and then change some fields in the cloned instance. The former `ktesting.TContext` interface is now a type alias for `*ktesting.TC`. This ensures that existing code using ktesting doesn't need to be updated and because that code is a bit more compact (`tCtx ktesting.TContext` instead of `tCtx *ktesting.TContext` when not using such an alias). Hiding that it is a pointer might discourage accessing the exported fields because it looks like an interface. Output gets fixed and improved such that: - "FATAL ERROR" and "ERROR" are at the start of the line, followed by the klog header. - The failure message follows in the next line. - Continuation lines are always indented. The set of methods exposed via TB is now a bit more complete (Attr, Chdir). All former stand-alone With* functions are now also available as methods and should be used instead of the functions. Those will be removed. Linting of log calls now works and found some issues.
99 lines
2.8 KiB
Go
99 lines
2.8 KiB
Go
/*
|
|
Copyright 2023 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 ktesting
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
)
|
|
|
|
// cleanupErr creates a cause when canceling a context because the test has completed.
|
|
// It is a context.Canceled error.
|
|
func cleanupErr(testName string) error {
|
|
return canceledError(fmt.Sprintf("test %s is cleaning up", testName))
|
|
}
|
|
|
|
type canceledError string
|
|
|
|
func (c canceledError) Error() string { return string(c) }
|
|
|
|
func (c canceledError) Is(target error) bool {
|
|
return target == context.Canceled
|
|
}
|
|
|
|
// withTimeout corresponds to [context.WithTimeout]. In contrast to
|
|
// [context.WithTimeout], it automatically cancels during test cleanup, provides
|
|
// the given cause when the deadline is reached, and its cancel function
|
|
// requires a cause.
|
|
func withTimeout(ctx context.Context, tb TB, timeout time.Duration, timeoutCause string) (context.Context, func(cause string)) {
|
|
tb.Helper()
|
|
|
|
now := time.Now()
|
|
|
|
cancelCtx, cancel := context.WithCancelCause(ctx)
|
|
after := time.NewTimer(timeout)
|
|
stopCtx, stop := context.WithCancel(ctx) // Only used internally, doesn't need a cause.
|
|
tb.Cleanup(func() {
|
|
cancel(cleanupErr(tb.Name()))
|
|
stop()
|
|
})
|
|
go func() {
|
|
select {
|
|
case <-stopCtx.Done():
|
|
after.Stop()
|
|
// No need to set a cause here. The cause or error of
|
|
// the parent context will be used.
|
|
case <-after.C:
|
|
// Code using this tCtx may or may not log the
|
|
// information above when it runs into the
|
|
// cancellation. It's better if we do it, just to be on
|
|
// the safe side.
|
|
//
|
|
// Would be nice to log this with the source code location
|
|
// of our caller, but testing.Logf does not support that.
|
|
tb.Log(fmt.Sprintf("\nINFO: canceling context: %s\n", timeoutCause))
|
|
cancel(canceledError(timeoutCause))
|
|
}
|
|
}()
|
|
|
|
// Determine which deadline is sooner: ours or that of our parent.
|
|
deadline := now.Add(timeout)
|
|
if parentDeadline, ok := ctx.Deadline(); ok {
|
|
if deadline.After(parentDeadline) {
|
|
deadline = parentDeadline
|
|
}
|
|
}
|
|
|
|
// We always have a deadline.
|
|
return deadlineContext{Context: cancelCtx, deadline: deadline}, func(cause string) {
|
|
var cancelCause error
|
|
if cause != "" {
|
|
cancelCause = canceledError(cause)
|
|
}
|
|
cancel(cancelCause)
|
|
}
|
|
}
|
|
|
|
type deadlineContext struct {
|
|
context.Context
|
|
deadline time.Time
|
|
}
|
|
|
|
func (d deadlineContext) Deadline() (time.Time, bool) {
|
|
return d.deadline, true
|
|
}
|