gomega | Ginkgo 's Preferred Matcher Library

You can't abort a running function. The function has to support abortion, idiomatically through a context.Context or a channel. If you want to support timeout or abortion, you have to change / refactor your function. And the function itself has to support this, e.g. it has to monitor the context.Context and return early if cancellation was requested. For details and example, see Terminating function execution if a context is cancelled

See related:

cancel a blocking operation in Go

Cancelling user specific goroutines

If you are only interested in testing the log message, you can use a hook.

In particular zap.Hooks function constructs a zap.Option from a variable number of hooks. A hook is just a func(entry zapcore.Entry) error which you can use to intercept the entry and write its message to the buffer.

To set this zap.Option into your sigs.k8s.io logger, you set it to the ZapOpts field:

What I discovered here is that sqlmock has a function called ValueConverterOption, which, when provided with a custom driver.ValueConverter interface. This will be called in place of the standard function for every invocation of ConvertValue. If you want to test around the ExecContext function when it receives a non-standard argument, a TVP in this case, then you can use this function to inject custom conversion logic into sqlmock.

Here's a basic proof-of-concept using Testify:

Do you plan to run tests in parallel? If so, then results will be unpredictable. In that case it's recommended to have a separate instance of external resources for each process.

I would recommend to look at how controller tests are implemented in controller-runtime. I believe, they create new Control Plane with envtest each time BeforeSuit function is called. And as ginkgo docs states:

when running in parallel, each parallel process will run BeforeSuite and AfterSuite functions

After @Volker's comment on my Q I knew I had to take the challenge and went straight for the source code of Go's testing package. While @marco.m's suggestion is helpful in many cases, it cannot handle my admittedly slightly bizare usecase. testing's mechanics relevant to my original question are as follows, heavily simplified:

• cover.go: implements coverReport() which writes a coverage data file (in ASCII text format); if the file already exists (stale version from a previous run), then it will be truncated first. Please note that coverReport() has the annoying habit of printing some “statistics” information to os.Stdout.
• testing.go:
  • gets the CLI arguments -test.coverprofile= and -test.outputdir= from os.Args (via the flags package). If also implements toOutputDir(path) which places cover profile files inside -test.outputdir if specified.
  • But when does coverReport() get called? Simply spoken, at the end of testing.M.Run().

Now with this knowledge under the belt, a crazy solutions starts to emerge, kind of "Go-ing Bad" ;)

• Wrap testing.M in a special re-execution enabled version reexec.testing.M: it detects whether it is running with coverage enabled:
  • if it is the "parent" process P, then it runs the tests as normal, and then it collects coverage profile data files from re-executed child processes C and merges them into P's coverage profile data file.
  • while in P and when just about to re-execute a new child C, a new dedicated coverage profile data filename is allocated for the child C. C then gets the filename via its "personal" -test.coverprofile= CLI arg.
  • when in C, we run the desired action function. Next, we need to run an empty test set in order to trigger writing the coverage profile data for C. For this, the re-execution function in P adds a test.run= with a very special "Bielefeld test pattern" that will most likely result in an empty result. Remember, P will -- after it has run all its tests -- pick up the individual C coverage profile data files and merge them into P's.
• when coverage profiling isn't enabled, then no special actions need to be taken.

The downside of this solution is that it depends on some un-guaranteed behavior of Go's testing with respect to how and when it writes code coverage reports. But since a Linux-kernel namespace discovery package already pushes Go probably even harder than Docker's libnetwork, that's just a quantum further over the edge.

To a test developer, the whole enchilada is hidden inside an "enhanced" rxtst.M wrapper.