mirror of
https://github.com/kubernetes/kubernetes.git
synced 2026-04-23 07:10:53 -04: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.
93 lines
2.6 KiB
Go
93 lines
2.6 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"
|
|
"time"
|
|
|
|
"k8s.io/klog/v2"
|
|
)
|
|
|
|
// Deprecated: use tCtx.WithCancel instead
|
|
func WithCancel(tCtx TContext) TContext { return tCtx.WithCancel() }
|
|
|
|
// WithCancel sets up cancellation in a [TContext.Cleanup] callback and
|
|
// constructs a new TContext where [TContext.Cancel] cancels only the new
|
|
// context.
|
|
func (tc *TC) WithCancel() TContext {
|
|
ctx, cancel := context.WithCancelCause(tc)
|
|
|
|
tc = tc.clone()
|
|
tc.Context = ctx
|
|
tc.cancel = func(cause string) {
|
|
var cancelCause error
|
|
if cause != "" {
|
|
cancelCause = canceledError(cause)
|
|
}
|
|
cancel(cancelCause)
|
|
}
|
|
return tc
|
|
}
|
|
|
|
// Deprecated: use tCtx.WithoutCancel instead
|
|
func WithoutCancel(tCtx TContext) TContext { return tCtx.WithoutCancel() }
|
|
|
|
// WithoutCancel causes the returned context to ignore cancellation of its parent.
|
|
// Calling Cancel will not cancel the parent either.
|
|
// This matches [context.WithoutCancel].
|
|
func (tc *TC) WithoutCancel() TContext {
|
|
ctx := context.WithoutCancel(tc)
|
|
|
|
tc = tc.clone()
|
|
tc.Context = ctx
|
|
tc.cancel = nil
|
|
return tc
|
|
}
|
|
|
|
// Deprecated: use tCtx.WithTimeout instead
|
|
func WithTimeout(tCtx TContext, timeout time.Duration, timeoutCause string) TContext {
|
|
return tCtx.WithTimeout(timeout, timeoutCause)
|
|
}
|
|
|
|
// WithTimeout sets up new context with a timeout. Canceling the timeout gets
|
|
// registered in a cleanup callback. [TContext.Cancel] cancels only
|
|
// the new context. The cause is used as reason why the context is canceled
|
|
// once the timeout is reached. It may be empty, in which case the usual
|
|
// "context canceled" error is used.
|
|
func (tc *TC) WithTimeout(timeout time.Duration, timeoutCause string) TContext {
|
|
ctx, cancel := withTimeout(tc, tc.TB(), timeout, timeoutCause)
|
|
|
|
tc = tc.clone()
|
|
tc.Context = ctx
|
|
tc.cancel = cancel
|
|
return tc
|
|
}
|
|
|
|
// Deprecated: used tCtx.WithLogger instead
|
|
func WithLogger(tCtx TContext, logger klog.Logger) TContext {
|
|
return tCtx.WithLogger(logger)
|
|
}
|
|
|
|
// WithLogger constructs a new context with a different logger.
|
|
func (tc *TC) WithLogger(logger klog.Logger) TContext {
|
|
ctx := klog.NewContext(tc, logger)
|
|
|
|
tc = tc.clone()
|
|
tc.Context = ctx
|
|
return tc
|
|
}
|