Wrote and applied helper function for tests

replaced with new function

removed log/slog

readded log/slog when needed

fixed last testwriter problems

bootstrapper/internal/initserver/initserver_test.go

@@ -11,12 +11,12 @@ import (
 	"context"
 	"errors"
 	"io"
-	"log/slog"
 	"net"
 	"strings"
 	"sync"
 	"testing"
 	"time"
+  "log/slog"
 
 	"github.com/edgelesssys/constellation/v2/bootstrapper/initproto"
 	"github.com/edgelesssys/constellation/v2/internal/atls"
@@ -67,7 +67,7 @@ func TestNew(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)
 
-			server, err := New(context.TODO(), newFakeLock(), &stubClusterInitializer{}, atls.NewFakeIssuer(variant.Dummy{}), fh, &tc.metadata, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			server, err := New(context.TODO(), newFakeLock(), &stubClusterInitializer{}, atls.NewFakeIssuer(variant.Dummy{}), fh, &tc.metadata, logger.NewTest(t))
 			if tc.wantErr {
 				assert.Error(err)
 				return
@@ -215,7 +215,7 @@ func TestInit(t *testing.T) {
 				initializer:       tc.initializer,
 				disk:              tc.disk,
 				fileHandler:       tc.fileHandler,
-				log:               slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:               logger.NewTest(t),
 				grpcServer:        serveStopper,
 				cleaner:           &fakeCleaner{serveStopper: serveStopper},
 				initSecretHash:    tc.initSecretHash,

bootstrapper/internal/joinclient/joinclient_test.go

@@ -9,12 +9,12 @@ package joinclient
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"net"
 	"strconv"
 	"sync"
 	"testing"
 	"time"
+  "log/slog"
 
 	"github.com/edgelesssys/constellation/v2/internal/cloud/metadata"
 	"github.com/edgelesssys/constellation/v2/internal/constants"
@@ -221,7 +221,7 @@ func TestClient(t *testing.T) {
 				fileHandler: fileHandler,
 				metadataAPI: metadataAPI,
 				clock:       clock,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 			}
 
 			serverCreds := atlscredentials.New(nil, nil)
@@ -276,7 +276,7 @@ func TestClientConcurrentStartStop(t *testing.T) {
 		fileHandler: file.NewHandler(afero.NewMemMapFs()),
 		metadataAPI: &stubRepeaterMetadataAPI{},
 		clock:       testclock.NewFakeClock(time.Now()),
-		log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:         logger.NewTest(t),
 	}
 
 	wg := sync.WaitGroup{}

bootstrapper/internal/kubernetes/kubernetes_test.go

@@ -9,10 +9,10 @@ package kubernetes
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"net"
 	"strconv"
 	"testing"
+  "log/slog"
 
 	"github.com/edgelesssys/constellation/v2/bootstrapper/internal/kubernetes/k8sapi"
 	"github.com/edgelesssys/constellation/v2/bootstrapper/internal/kubernetes/kubewaiter"
@@ -188,7 +188,7 @@ func TestInitCluster(t *testing.T) {
 
 			_, err := kube.InitCluster(
 				context.Background(), string(tc.k8sVersion), "kubernetes",
-				false, nil, nil, "", slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				false, nil, nil, "", logger.NewTest(t),
 			)
 
 			if tc.wantErr {
@@ -360,7 +360,7 @@ func TestJoinCluster(t *testing.T) {
 				getIPAddr:        func() (string, error) { return privateIP, nil },
 			}
 
-			err := kube.JoinCluster(context.Background(), joinCommand, tc.role, tc.k8sComponents, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			err := kube.JoinCluster(context.Background(), joinCommand, tc.role, tc.k8sComponents, logger.NewTest(t))
 			if tc.wantErr {
 				assert.Error(err)
 				return

cli/internal/cmd/apply_test.go

@@ -12,7 +12,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log/slog"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -197,7 +196,7 @@ func TestBackupHelmCharts(t *testing.T) {
 				applier: &stubConstellApplier{
 					stubKubernetesUpgrader: tc.backupClient,
 				},
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 			}
 
 			err := a.backupHelmCharts(context.Background(), tc.helmApplier, tc.includesUpgrades, "")
@@ -443,7 +442,7 @@ func TestValidateInputs(t *testing.T) {
 			cmd.SetIn(bytes.NewBufferString(tc.stdin))
 
 			a := applyCmd{
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				fileHandler: fileHandler,
 				flags:       tc.flags,
 			}

cli/internal/cmd/configfetchmeasurements_test.go

@@ -8,7 +8,6 @@ package cmd
 
 import (
 	"context"
-	"log/slog"
 	"net/http"
 	"net/url"
 	"testing"
@@ -181,7 +180,7 @@ func TestConfigFetchMeasurements(t *testing.T) {
 			err := fileHandler.WriteYAML(constants.ConfigFilename, gcpConfig, file.OptMkdirAll)
 			require.NoError(err)
 			fetcher := stubVerifyFetcher{err: tc.err}
-			cfm := &configFetchMeasurementsCmd{canFetchMeasurements: true, log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), verifyFetcher: fetcher}
+			cfm := &configFetchMeasurementsCmd{canFetchMeasurements: true, log: logger.NewTest(t), verifyFetcher: fetcher}
 			cfm.flags.insecure = tc.insecureFlag
 			cfm.flags.force = true
 

cli/internal/cmd/configgenerate_test.go

@@ -8,7 +8,6 @@ package cmd
 
 import (
 	"fmt"
-	"log/slog"
 	"strings"
 	"testing"
 
@@ -93,7 +92,7 @@ func TestConfigGenerateDefault(t *testing.T) {
 	cmd := newConfigGenerateCmd()
 
 	cg := &configGenerateCmd{
-		log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log: logger.NewTest(t),
 		flags: generateFlags{
 			attestationVariant: variant.Dummy{},
 			k8sVersion:         versions.Default,
@@ -145,7 +144,7 @@ func TestConfigGenerateDefaultProviderSpecific(t *testing.T) {
 			wantConf.RemoveProviderAndAttestationExcept(tc.provider)
 
 			cg := &configGenerateCmd{
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 				flags: generateFlags{
 					attestationVariant: variant.Dummy{},
 					k8sVersion:         versions.Default,
@@ -178,7 +177,7 @@ func TestConfigGenerateDefaultExists(t *testing.T) {
 	cmd := newConfigGenerateCmd()
 
 	cg := &configGenerateCmd{
-		log:   slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:   logger.NewTest(t),
 		flags: generateFlags{attestationVariant: variant.Dummy{}},
 	}
 	require.Error(cg.configGenerate(cmd, fileHandler, cloudprovider.Unknown, ""))

cli/internal/cmd/create_test.go

@@ -9,7 +9,6 @@ package cmd
 import (
 	"bytes"
 	"context"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/cloud/cloudprovider"
@@ -228,7 +227,7 @@ func TestCreate(t *testing.T) {
 					skipPhases: newPhases(skipInitPhase, skipAttestationConfigPhase, skipCertSANsPhase, skipHelmPhase, skipImagePhase, skipK8sPhase),
 				},
 
-				log:     slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:     logger.NewTest(t),
 				spinner: &nopSpinner{},
 
 				newInfraApplier: func(_ context.Context) (cloudApplier, func(), error) {
@@ -296,7 +295,7 @@ func TestCheckDirClean(t *testing.T) {
 			for _, f := range tc.existingFiles {
 				require.NoError(fh.Write(f, []byte{1, 2, 3}, file.OptNone))
 			}
-			a := &applyCmd{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), fileHandler: fh}
+			a := &applyCmd{log: logger.NewTest(t), fileHandler: fh}
 			err := a.checkInitFilesClean()
 
 			if tc.wantErr {

cli/internal/cmd/iamcreate_test.go

@@ -8,7 +8,6 @@ package cmd
 import (
 	"bytes"
 	"encoding/base64"
-	"log/slog"
 	"strings"
 	"testing"
 
@@ -210,7 +209,7 @@ func TestIAMCreateAWS(t *testing.T) {
 
 			iamCreator := &iamCreator{
 				cmd:         cmd,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				spinner:     &nopSpinner{},
 				creator:     tc.creator,
 				fileHandler: fileHandler,
@@ -386,7 +385,7 @@ func TestIAMCreateAzure(t *testing.T) {
 
 			iamCreator := &iamCreator{
 				cmd:         cmd,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				spinner:     &nopSpinner{},
 				creator:     tc.creator,
 				fileHandler: fileHandler,
@@ -577,7 +576,7 @@ func TestIAMCreateGCP(t *testing.T) {
 
 			iamCreator := &iamCreator{
 				cmd:         cmd,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				spinner:     &nopSpinner{},
 				creator:     tc.creator,
 				fileHandler: fileHandler,

cli/internal/cmd/iamdestroy_test.go

@@ -7,7 +7,6 @@ package cmd
 import (
 	"bytes"
 	"errors"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/cloud/gcpshared"
@@ -107,7 +106,7 @@ func TestIAMDestroy(t *testing.T) {
 			cmd.SetErr(&bytes.Buffer{})
 			cmd.SetIn(bytes.NewBufferString(tc.stdin))
 
-			c := &destroyCmd{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), flags: iamDestroyFlags{
+			c := &destroyCmd{log: logger.NewTest(t), flags: iamDestroyFlags{
 				yes: tc.yesFlag,
 			}}
 
@@ -197,7 +196,7 @@ func TestDeleteGCPServiceAccountKeyFile(t *testing.T) {
 			cmd.SetErr(&bytes.Buffer{})
 			cmd.SetIn(bytes.NewBufferString(tc.stdin))
 
-			c := &destroyCmd{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))}
+			c := &destroyCmd{log: logger.NewTest(t)}
 
 			proceed, err := c.deleteGCPServiceAccountKeyFile(cmd, tc.destroyer, tc.fsHandler)
 			if tc.wantErr {

cli/internal/cmd/iamupgradeapply_test.go

@@ -8,7 +8,6 @@ package cmd
 import (
 	"context"
 	"io"
-	"log/slog"
 	"path/filepath"
 	"strings"
 	"testing"
@@ -132,7 +131,7 @@ func TestIamUpgradeApply(t *testing.T) {
 
 			iamUpgradeApplyCmd := &iamUpgradeApplyCmd{
 				fileHandler:   tc.fh,
-				log:           slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:           logger.NewTest(t),
 				configFetcher: tc.configFetcher,
 				flags: iamUpgradeApplyFlags{
 					yes: tc.yesFlag,

cli/internal/cmd/init_test.go

@@ -10,7 +10,6 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"log/slog"
 	"strings"
 	"testing"
 	"time"
@@ -229,7 +228,7 @@ func TestInitialize(t *testing.T) {
 					rootFlags:  rootFlags{force: true},
 					skipPhases: newPhases(skipInfrastructurePhase),
 				},
-				log:     slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:     logger.NewTest(t),
 				spinner: &nopSpinner{},
 				merger:  &stubMerger{},
 				applier: &stubConstellApplier{
@@ -369,8 +368,8 @@ func TestWriteOutput(t *testing.T) {
 		fileHandler: fileHandler,
 		spinner:     &nopSpinner{},
 		merger:      &stubMerger{},
-		log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
-		applier:     constellation.NewApplier(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), &nopSpinner{}, constellation.ApplyContextCLI, nil),
+		log:         logger.NewTest(t),
+		applier:     constellation.NewApplier(logger.NewTest(t), &nopSpinner{}, constellation.ApplyContextCLI, nil),
 	}
 	err = i.writeInitOutput(stateFile, initOutput, false, &out, measurementSalt)
 	require.NoError(err)
@@ -461,8 +460,8 @@ func TestGenerateMasterSecret(t *testing.T) {
 			var out bytes.Buffer
 			i := &applyCmd{
 				fileHandler: fileHandler,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
-				applier:     constellation.NewApplier(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), &nopSpinner{}, constellation.ApplyContextCLI, nil),
+				log:         logger.NewTest(t),
+				applier:     constellation.NewApplier(logger.NewTest(t), &nopSpinner{}, constellation.ApplyContextCLI, nil),
 			}
 			secret, err := i.generateAndPersistMasterSecret(&out)
 

cli/internal/cmd/maapatch_test.go

@@ -8,7 +8,6 @@ package cmd
 
 import (
 	"context"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/logger"
@@ -39,7 +38,7 @@ func TestMAAPatch(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			require := require.New(t)
 
-			c := &maaPatchCmd{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), patcher: tc.patcher}
+			c := &maaPatchCmd{log: logger.NewTest(t), patcher: tc.patcher}
 			err := c.patchMAA(&cobra.Command{}, tc.attestationURL)
 			if tc.wantErr {
 				require.Error(err)

cli/internal/cmd/recover_test.go

@@ -10,7 +10,6 @@ import (
 	"bytes"
 	"context"
 	"errors"
-	"log/slog"
 	"net"
 	"strconv"
 	"testing"
@@ -165,7 +164,7 @@ func TestRecover(t *testing.T) {
 
 			newDialer := func(atls.Validator) *dialer.Dialer { return nil }
 			r := &recoverCmd{
-				log:           slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:           logger.NewTest(t),
 				configFetcher: stubAttestationFetcher{},
 				flags: recoverFlags{
 					rootFlags: rootFlags{force: true},
@@ -219,7 +218,7 @@ func TestDoRecovery(t *testing.T) {
 			go recoverServer.Serve(listener)
 			defer recoverServer.GracefulStop()
 
-			r := &recoverCmd{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))}
+			r := &recoverCmd{log: logger.NewTest(t)}
 			recoverDoer := &recoverDoer{
 				dialer:   dialer.New(nil, nil, netDialer),
 				endpoint: addr,

cli/internal/cmd/terminate_test.go

@@ -9,7 +9,6 @@ package cmd
 import (
 	"bytes"
 	"errors"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/constants"
@@ -140,7 +139,7 @@ func TestTerminate(t *testing.T) {
 			fileHandler := file.NewHandler(tc.setupFs(require, tc.stateFile))
 
 			tCmd := &terminateCmd{
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				fileHandler: fileHandler,
 				flags: terminateFlags{
 					yes: tc.yesFlag,

cli/internal/cmd/upgradeapply_test.go

@@ -9,7 +9,6 @@ package cmd
 import (
 	"bytes"
 	"context"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/cli/internal/cloudcmd"
@@ -252,7 +251,7 @@ func TestUpgradeApply(t *testing.T) {
 			upgrader := &applyCmd{
 				fileHandler: fh,
 				flags:       tc.flags,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				spinner:     &nopSpinner{},
 				merger:      &stubMerger{},
 				newInfraApplier: func(ctx context.Context) (cloudApplier, func(), error) {

cli/internal/cmd/upgradecheck_test.go

@@ -11,7 +11,6 @@ import (
 	"context"
 	"errors"
 	"io"
-	"log/slog"
 	"net/http"
 	"strings"
 	"testing"
@@ -140,7 +139,7 @@ func TestGetCompatibleImageMeasurements(t *testing.T) {
 		}
 	})
 
-	upgrades, err := getCompatibleImageMeasurements(context.Background(), &bytes.Buffer{}, client, &stubCosignVerifier{}, singleUUIDVerifier(), csp, attestationVariant, versionZero, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+	upgrades, err := getCompatibleImageMeasurements(context.Background(), &bytes.Buffer{}, client, &stubCosignVerifier{}, singleUUIDVerifier(), csp, attestationVariant, versionZero, logger.NewTest(t))
 	assert.NoError(err)
 
 	for _, measurement := range upgrades {
@@ -216,7 +215,7 @@ func TestUpgradeCheck(t *testing.T) {
 				collect:          &tc.collector,
 				terraformChecker: tc.checker,
 				fileHandler:      fileHandler,
-				log:              slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:              logger.NewTest(t),
 			}
 
 			cmd := newUpgradeCheckCmd()

cli/internal/cmd/verify_test.go

@@ -14,7 +14,6 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"errors"
-	"log/slog"
 	"net"
 	"strconv"
 	"strings"
@@ -211,7 +210,7 @@ func TestVerify(t *testing.T) {
 
 			v := &verifyCmd{
 				fileHandler: fileHandler,
-				log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:         logger.NewTest(t),
 				flags: verifyFlags{
 					clusterID: tc.clusterIDFlag,
 					endpoint:  tc.nodeEndpointFlag,
@@ -243,7 +242,7 @@ func (f *stubAttDocFormatter) format(_ context.Context, _ string, _ bool, _ conf
 func TestFormat(t *testing.T) {
 	formatter := func() *defaultAttestationDocFormatter {
 		return &defaultAttestationDocFormatter{
-			log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+			log: logger.NewTest(t),
 		}
 	}
 
@@ -334,7 +333,7 @@ func TestVerifyClient(t *testing.T) {
 			go verifyServer.Serve(listener)
 			defer verifyServer.GracefulStop()
 
-			verifier := &constellationVerifier{dialer: dialer, log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))}
+			verifier := &constellationVerifier{dialer: dialer, log: logger.NewTest(t)}
 			request := &verifyproto.GetAttestationRequest{
 				Nonce: tc.nonce,
 			}

debugd/internal/debugd/deploy/download_test.go

@@ -9,7 +9,6 @@ package deploy
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"net"
 	"strconv"
 	"testing"
@@ -118,7 +117,7 @@ func TestDownloadDeployment(t *testing.T) {
 			defer grpcServ.GracefulStop()
 
 			download := &Download{
-				log:            slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:            logger.NewTest(t),
 				dialer:         dialer,
 				transfer:       transfer,
 				serviceManager: serviceMgr,
@@ -190,7 +189,7 @@ func TestDownloadInfo(t *testing.T) {
 			defer grpcServer.GracefulStop()
 
 			download := &Download{
-				log:    slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:    logger.NewTest(t),
 				dialer: dialer,
 				info:   &tc.infoSetter,
 			}

debugd/internal/debugd/deploy/service_test.go

@@ -10,7 +10,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"log/slog"
 	"sync"
 	"testing"
 
@@ -103,7 +102,7 @@ func TestSystemdAction(t *testing.T) {
 
 			fs := afero.NewMemMapFs()
 			manager := ServiceManager{
-				log:                      slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:                      logger.NewTest(t),
 				dbus:                     &tc.dbus,
 				fs:                       fs,
 				systemdUnitFilewriteLock: sync.Mutex{},
@@ -182,7 +181,7 @@ func TestWriteSystemdUnitFile(t *testing.T) {
 				fs = afero.NewReadOnlyFs(fs)
 			}
 			manager := ServiceManager{
-				log:                      slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:                      logger.NewTest(t),
 				dbus:                     &tc.dbus,
 				fs:                       fs,
 				systemdUnitFilewriteLock: sync.Mutex{},
@@ -295,7 +294,7 @@ func TestOverrideServiceUnitExecStart(t *testing.T) {
 				fs = afero.NewReadOnlyFs(fs)
 			}
 			manager := ServiceManager{
-				log:                      slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:                      logger.NewTest(t),
 				dbus:                     &tc.dbus,
 				fs:                       fs,
 				systemdUnitFilewriteLock: sync.Mutex{},

debugd/internal/debugd/metadata/scheduler_test.go

@@ -9,7 +9,6 @@ package metadata
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"sync"
 	"testing"
 	"time"
@@ -85,7 +84,7 @@ func TestSchedulerStart(t *testing.T) {
 			assert := assert.New(t)
 
 			scheduler := Scheduler{
-				log:        slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:        logger.NewTest(t),
 				fetcher:    &tc.fetcher,
 				downloader: &tc.downloader,
 				interval:   20 * time.Millisecond,

debugd/internal/debugd/server/server_test.go

@@ -10,7 +10,6 @@ import (
 	"context"
 	"errors"
 	"io"
-	"log/slog"
 	"net"
 	"strconv"
 	"testing"
@@ -66,7 +65,7 @@ func TestSetInfo(t *testing.T) {
 			require := require.New(t)
 
 			serv := debugdServer{
-				log:  slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:  logger.NewTest(t),
 				info: tc.info,
 			}
 
@@ -129,7 +128,7 @@ func TestGetInfo(t *testing.T) {
 			}
 
 			serv := debugdServer{
-				log:  slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:  logger.NewTest(t),
 				info: tc.info,
 			}
 
@@ -193,7 +192,7 @@ func TestUploadFiles(t *testing.T) {
 			transfer := &stubTransfer{files: tc.files, recvFilesErr: tc.recvFilesErr}
 
 			serv := debugdServer{
-				log:            slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:            logger.NewTest(t),
 				serviceManager: serviceMgr,
 				transfer:       transfer,
 			}
@@ -238,7 +237,7 @@ func TestDownloadFiles(t *testing.T) {
 
 			transfer := &stubTransfer{canSend: tc.canSend}
 			serv := debugdServer{
-				log:      slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:      logger.NewTest(t),
 				transfer: transfer,
 			}
 
@@ -318,7 +317,7 @@ func TestUploadSystemServiceUnits(t *testing.T) {
 			require := require.New(t)
 
 			serv := debugdServer{
-				log:            slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:            logger.NewTest(t),
 				serviceManager: &tc.serviceManager,
 			}
 			grpcServ, conn, err := setupServerWithConn(endpoint, &serv)

debugd/internal/filetransfer/filetransfer_test.go

@@ -9,7 +9,6 @@ package filetransfer
 import (
 	"errors"
 	"io"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/debugd/internal/filetransfer/streamer"
@@ -118,7 +117,7 @@ func TestSendFiles(t *testing.T) {
 			streamer := &stubStreamReadWriter{readStreamErr: tc.readStreamErr}
 			stream := &stubSendFilesStream{sendErr: tc.sendErr}
 			transfer := &FileTransferer{
-				log:          slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:          logger.NewTest(t),
 				streamer:     streamer,
 				showProgress: false,
 			}
@@ -255,7 +254,7 @@ func TestRecvFiles(t *testing.T) {
 
 			streamer := &stubStreamReadWriter{writeStreamErr: tc.writeStreamErr}
 			stream := &fakeRecvFilesStream{msgs: tc.msgs, recvErr: tc.recvErr}
-			transfer := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), streamer, false)
+			transfer := New(logger.NewTest(t), streamer, false)
 			if tc.recvAlreadyStarted {
 				transfer.receiveStarted = true
 			}
@@ -308,7 +307,7 @@ func TestGetSetFiles(t *testing.T) {
 			assert := assert.New(t)
 
 			streamer := &dummyStreamReadWriter{}
-			transfer := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), streamer, false)
+			transfer := New(logger.NewTest(t), streamer, false)
 			if tc.setFiles != nil {
 				transfer.SetFiles(*tc.setFiles)
 			}
@@ -320,7 +319,7 @@ func TestGetSetFiles(t *testing.T) {
 }
 
 func TestConcurrency(t *testing.T) {
-	ft := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), &stubStreamReadWriter{}, false)
+	ft := New(logger.NewTest(t), &stubStreamReadWriter{}, false)
 
 	sendFiles := func() {
 		_ = ft.SendFiles(&stubSendFilesStream{})

disk-mapper/internal/recoveryserver/recoveryserver_test.go

@@ -9,7 +9,6 @@ package recoveryserver
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"sync"
 	"testing"
 	"time"
@@ -36,7 +35,7 @@ func TestMain(m *testing.M) {
 
 func TestServe(t *testing.T) {
 	assert := assert.New(t)
-	log := slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))
+	log := logger.NewTest(t)
 	uuid := "uuid"
 	server := New(atls.NewFakeIssuer(variant.Dummy{}), newStubKMS(nil, nil), log)
 	dialer := testdialer.NewBufconnDialer()
@@ -107,7 +106,7 @@ func TestRecover(t *testing.T) {
 
 			ctx := context.Background()
 			serverUUID := "uuid"
-			server := New(atls.NewFakeIssuer(variant.Dummy{}), tc.factory, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			server := New(atls.NewFakeIssuer(variant.Dummy{}), tc.factory, logger.NewTest(t))
 			netDialer := testdialer.NewBufconnDialer()
 			listener := netDialer.GetListener("192.0.2.1:1234")
 

disk-mapper/internal/rejoinclient/rejoinclient_test.go

@@ -9,7 +9,6 @@ package rejoinclient
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"net"
 	"strconv"
 	"sync"
@@ -57,7 +56,7 @@ func TestStartCancel(t *testing.T) {
 		dialer:      dialer,
 		nodeInfo:    metadata.InstanceMetadata{Role: role.Worker},
 		metadataAPI: metaAPI,
-		log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:         logger.NewTest(t),
 		timeout:     time.Second * 30,
 		interval:    time.Second,
 		clock:       clock,
@@ -217,7 +216,7 @@ func TestGetJoinEndpoints(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)
 
-			client := New(nil, tc.nodeInfo, tc.meta, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			client := New(nil, tc.nodeInfo, tc.meta, logger.NewTest(t))
 
 			endpoints, err := client.getJoinEndpoints()
 			if tc.wantErr {
@@ -293,7 +292,7 @@ func TestStart(t *testing.T) {
 				},
 			}
 
-			client := New(dialer, tc.nodeInfo, meta, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			client := New(dialer, tc.nodeInfo, meta, logger.NewTest(t))
 
 			passphrase, secret := client.Start(context.Background(), "uuid")
 			assert.Equal(diskKey, passphrase)

disk-mapper/internal/setup/setup_test.go

@@ -11,7 +11,6 @@ import (
 	"errors"
 	"io"
 	"io/fs"
-	"log/slog"
 	"net"
 	"path/filepath"
 	"sync"
@@ -137,7 +136,7 @@ func TestPrepareExistingDisk(t *testing.T) {
 			}
 
 			setupManager := &Manager{
-				log:        slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:        logger.NewTest(t),
 				csp:        "test",
 				diskPath:   "disk-path",
 				fs:         fs,
@@ -215,7 +214,7 @@ func TestPrepareNewDisk(t *testing.T) {
 			assert := assert.New(t)
 
 			setupManager := &Manager{
-				log:      slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:      logger.NewTest(t),
 				csp:      "test",
 				diskPath: "disk-path",
 				fs:       tc.fs,
@@ -271,7 +270,7 @@ func TestReadMeasurementSalt(t *testing.T) {
 				require.NoError(handler.WriteJSON("test-state.json", state, file.OptMkdirAll))
 			}
 
-			setupManager := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "disk-path", fs, nil, nil, nil)
+			setupManager := New(logger.NewTest(t), "test", "disk-path", fs, nil, nil, nil)
 
 			measurementSalt, err := setupManager.readMeasurementSalt("test-state.json")
 			if tc.wantErr {

disk-mapper/internal/test/benchmark_test.go

@@ -10,7 +10,6 @@ package integration
 
 import (
 	"fmt"
-	"log/slog"
 	"math"
 	"testing"
 

disk-mapper/internal/test/integration_test.go

@@ -12,7 +12,6 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
-	"log/slog"
 	"os"
 	"os/exec"
 	"path/filepath"

e2e/internal/upgrade/helm.go

@@ -21,11 +21,11 @@ import (
 
 func servicesVersion(t *testing.T) (semver.Semver, error) {
 	t.Helper()
-	log := slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))
+	log := logger.NewTest(t)
 	settings := cli.New()
 	settings.KubeConfig = "constellation-admin.conf"
 	actionConfig := &action.Configuration{}
-	if err := actionConfig.Init(settings.RESTClientGetter(), constants.HelmNamespace, "secret", log.Infof); err != nil {
+	if err := actionConfig.Init(settings.RESTClientGetter(), constants.HelmNamespace, "secret", log.Info); err != nil {
 		return semver.Semver{}, fmt.Errorf("initializing config: %w", err)
 	}
 

hack/bazel-deps-mirror/internal/mirror/mirror_test.go

@@ -11,7 +11,6 @@ import (
 	"context"
 	"io"
 	"log"
-	"log/slog"
 	"net/http"
 	"testing"
 
@@ -136,7 +135,7 @@ func TestMirror(t *testing.T) {
 					}(),
 				},
 				unauthenticated: tc.unauthenticated,
-				log:             slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:             logger.NewTest(t),
 			}
 			err := m.Mirror(context.Background(), tc.hash, []string{tc.upstreamURL})
 			if tc.wantErr {
@@ -179,7 +178,7 @@ func TestLearn(t *testing.T) {
 						body:       tc.upstreamResponse,
 					},
 				},
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 			}
 			gotHash, err := m.Learn(context.Background(), []string{"https://example.com/foo"})
 			if tc.wantErr {
@@ -273,7 +272,7 @@ func TestCheck(t *testing.T) {
 					response: tc.authenticatedResponse,
 					err:      tc.authenticatedErr,
 				},
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 			}
 			err := m.Check(context.Background(), tc.hash)
 			if tc.wantErr {

hack/qemu-metadata-api/server/server_test.go

@@ -11,7 +11,6 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"testing"
@@ -68,7 +67,7 @@ func TestListAll(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)
 
-			server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "initSecretHash", tc.connect)
+			server := New(logger.NewTest(t), "test", "initSecretHash", tc.connect)
 
 			res, err := server.listAll()
 
@@ -139,7 +138,7 @@ func TestListSelf(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)
 
-			server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "initSecretHash", tc.connect)
+			server := New(logger.NewTest(t), "test", "initSecretHash", tc.connect)
 
 			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://192.0.0.1/self", nil)
 			require.NoError(err)
@@ -199,7 +198,7 @@ func TestListPeers(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)
 
-			server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", "initSecretHash", tc.connect)
+			server := New(logger.NewTest(t), "test", "initSecretHash", tc.connect)
 
 			req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, "http://192.0.0.1/peers", nil)
 			require.NoError(err)
@@ -254,7 +253,7 @@ func TestInitSecretHash(t *testing.T) {
 			assert := assert.New(t)
 			require := require.New(t)
 
-			server := New(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), "test", tc.wantHash, defaultConnect)
+			server := New(logger.NewTest(t), "test", tc.wantHash, defaultConnect)
 
 			req, err := http.NewRequestWithContext(context.Background(), tc.method, "http://192.0.0.1/initsecrethash", nil)
 			require.NoError(err)

internal/attestation/aws/snp/validator_test.go

@@ -17,7 +17,6 @@ import (
 	"encoding/pem"
 	"errors"
 	"fmt"
-	"log/slog"
 	"regexp"
 	"testing"
 
@@ -162,7 +161,7 @@ func TestValidateSNPReport(t *testing.T) {
 			require.NoError(err)
 
 			v := awsValidator{httpsGetter: newStubHTTPSGetter(&urlResponseMatcher{}, nil), verifier: tc.verifier, validator: tc.validator}
-			err = v.validate(vtpm.AttestationDocument{InstanceInfo: infoMarshalled}, ask, ark, [64]byte(hash), config.DefaultForAWSSEVSNP(), slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			err = v.validate(vtpm.AttestationDocument{InstanceInfo: infoMarshalled}, ask, ark, [64]byte(hash), config.DefaultForAWSSEVSNP(), logger.NewTest(t))
 			if tc.wantErr {
 				assert.Error(err)
 			} else {

internal/attestation/azure/snp/validator_test.go

@@ -14,7 +14,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log/slog"
 	"os"
 	"regexp"
 	"testing"
@@ -49,7 +48,7 @@ func TestNewValidator(t *testing.T) {
 	}{
 		"success": {
 			cfg:    config.DefaultForAzureSEVSNP(),
-			logger: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+			logger: logger.NewTest(t),
 		},
 		"nil logger": {
 			cfg:    config.DefaultForAzureSEVSNP(),
@@ -128,7 +127,7 @@ func TestCheckIDKeyDigest(t *testing.T) {
 		return report
 	}
 	newTestValidator := func(cfg *config.AzureSEVSNP, validateTokenErr error) *Validator {
-		validator := NewValidator(cfg, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+		validator := NewValidator(cfg, logger.NewTest(t))
 		validator.maa = &stubMaaValidator{
 			validateTokenErr: validateTokenErr,
 		}
@@ -645,7 +644,7 @@ func TestTrustedKeyFromSNP(t *testing.T) {
 			validator := &Validator{
 				hclValidator:         &stubAttestationKey{},
 				config:               defaultCfg,
-				log:                  slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:                  logger.NewTest(t),
 				getter:               tc.getter,
 				attestationVerifier:  tc.verifier,
 				attestationValidator: tc.validator,

internal/attestation/azure/trustedlaunch/trustedlaunch_test.go

@@ -14,7 +14,6 @@ import (
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"io"
-	"log/slog"
 	"net/http"
 	"os"
 	"testing"
@@ -190,7 +189,7 @@ func TestGetAttestationCert(t *testing.T) {
 			))
 			require.NoError(tpm2.NVWrite(tpm, tpm2.HandleOwner, tpmAkCertIdx, "", akCert, 0))
 
-			issuer := NewIssuer(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			issuer := NewIssuer(logger.NewTest(t))
 			issuer.hClient = newTestClient(tc.crlServer)
 
 			certs, err := issuer.getAttestationCert(context.Background(), tpm, nil)

internal/attestation/snp/snp_test.go

@@ -10,7 +10,6 @@ import (
 	"crypto/x509"
 	"encoding/hex"
 	"fmt"
-	"log/slog"
 	"regexp"
 	"strings"
 	"testing"
@@ -267,7 +266,7 @@ func TestAttestationWithCerts(t *testing.T) {
 			}
 
 			defer trust.ClearProductCertCache()
-			att, err := instanceInfo.AttestationWithCerts(tc.getter, tc.fallbackCerts, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			att, err := instanceInfo.AttestationWithCerts(tc.getter, tc.fallbackCerts, logger.NewTest(t))
 			if tc.wantErr {
 				assert.Error(err)
 			} else {

internal/attestation/vtpm/attestation_test.go

@@ -13,7 +13,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log/slog"
 	"os"
 	"testing"
 
@@ -85,8 +84,8 @@ func TestValidate(t *testing.T) {
 	tpmOpen, tpmCloser := tpmsim.NewSimulatedTPMOpenFunc()
 	defer tpmCloser.Close()
 
-	issuer := NewIssuer(tpmOpen, tpmclient.AttestationKeyRSA, fakeGetInstanceInfo, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
-	validator := NewValidator(testExpectedPCRs, fakeGetTrustedKey, fakeValidateCVM, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+	issuer := NewIssuer(tpmOpen, tpmclient.AttestationKeyRSA, fakeGetInstanceInfo, logger.NewTest(t))
+	validator := NewValidator(testExpectedPCRs, fakeGetTrustedKey, fakeValidateCVM, logger.NewTest(t))
 
 	nonce := []byte{1, 2, 3, 4}
 	challenge := []byte("Constellation")
@@ -238,7 +237,7 @@ func TestValidate(t *testing.T) {
 				},
 				fakeGetTrustedKey,
 				fakeValidateCVM,
-				slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))),
+				logger.NewTest(t)),
 			attDoc:  mustMarshalAttestation(attDoc, require),
 			nonce:   nonce,
 			wantErr: false,
@@ -346,7 +345,7 @@ func TestFailIssuer(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)
 
-			tc.issuer.log = slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))
+			tc.issuer.log = logger.NewTest(t)
 
 			_, err := tc.issuer.Issue(context.Background(), tc.userData, tc.nonce)
 			assert.Error(err)

internal/constellation/apply_test.go

@@ -8,7 +8,6 @@ package constellation
 
 import (
 	"context"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/cloud/cloudprovider"
@@ -38,7 +37,7 @@ func TestCheckLicense(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			require := require.New(t)
 
-			a := &Applier{licenseChecker: tc.licenseChecker, log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))}
+			a := &Applier{licenseChecker: tc.licenseChecker, log: logger.NewTest(t)}
 			_, err := a.CheckLicense(context.Background(), cloudprovider.Unknown, true, license.CommunityLicense)
 			if tc.wantErr {
 				require.Error(err)
@@ -59,7 +58,7 @@ func (c *stubLicenseChecker) CheckLicense(context.Context, cloudprovider.Provide
 
 func TestGenerateMasterSecret(t *testing.T) {
 	assert := assert.New(t)
-	a := &Applier{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))}
+	a := &Applier{log: logger.NewTest(t)}
 	sec, err := a.GenerateMasterSecret()
 	assert.NoError(err)
 	assert.Len(sec.Key, crypto.MasterSecretLengthDefault)
@@ -68,7 +67,7 @@ func TestGenerateMasterSecret(t *testing.T) {
 
 func TestGenerateMeasurementSalt(t *testing.T) {
 	assert := assert.New(t)
-	a := &Applier{log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))}
+	a := &Applier{log: logger.NewTest(t)}
 	salt, err := a.GenerateMeasurementSalt()
 	assert.NoError(err)
 	assert.Len(salt, crypto.RNGLengthDefault)

internal/constellation/applyinit_test.go

@@ -12,7 +12,6 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
-	"log/slog"
 	"net"
 	"strconv"
 	"testing"
@@ -207,7 +206,7 @@ func TestInit(t *testing.T) {
 			defer stop()
 
 			a := &Applier{
-				log:     slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:     logger.NewTest(t),
 				spinner: &nopSpinner{},
 				newDialer: func(atls.Validator) *dialer.Dialer {
 					return dialer.New(nil, nil, netDialer)
@@ -286,7 +285,7 @@ func TestAttestation(t *testing.T) {
 	defer cancel()
 
 	initer := &Applier{
-		log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log: logger.NewTest(t),
 		newDialer: func(v atls.Validator) *dialer.Dialer {
 			return dialer.New(nil, v, netDialer)
 		},

internal/constellation/helm/actionfactory_test.go

@@ -8,7 +8,6 @@ package helm
 
 import (
 	"errors"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -241,7 +240,7 @@ func TestAppendNewAction(t *testing.T) {
 			assert := assert.New(t)
 
 			actions := []applyAction{}
-			actionFactory := newActionFactory(nil, tc.lister, &action.Configuration{}, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			actionFactory := newActionFactory(nil, tc.lister, &action.Configuration{}, logger.NewTest(t))
 
 			err := actionFactory.appendNewAction(tc.release, tc.configTargetVersion, tc.force, tc.allowDestructive, time.Second, &actions)
 			if tc.wantErr {

internal/constellation/helm/helm_test.go

@@ -8,7 +8,6 @@ package helm
 
 import (
 	"errors"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/attestation/variant"
@@ -174,7 +173,7 @@ func TestHelmApply(t *testing.T) {
 		},
 	}
 
-	log := slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))
+	log := logger.NewTest(t)
 	options := Options{
 		DeployCSIDriver:  true,
 		Conformance:      false,

internal/constellation/helm/retryaction_test.go

@@ -8,7 +8,6 @@ package helm
 
 import (
 	"context"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -65,7 +64,7 @@ func TestRetryApply(t *testing.T) {
 		t.Run(name, func(t *testing.T) {
 			assert := assert.New(t)
 
-			err := retryApply(context.Background(), tc.applier, time.Millisecond, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			err := retryApply(context.Background(), tc.applier, time.Millisecond, logger.NewTest(t))
 			if tc.wantErr {
 				assert.Error(err)
 			} else {

internal/constellation/kubecmd/kubecmd_test.go

@@ -11,7 +11,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log/slog"
 	"strings"
 	"testing"
 	"time"
@@ -177,7 +176,7 @@ func TestUpgradeNodeImage(t *testing.T) {
 
 			upgrader := KubeCmd{
 				kubectl: kubectl,
-				log:     slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:     logger.NewTest(t),
 			}
 
 			err = upgrader.UpgradeNodeImage(context.Background(), tc.newImageVersion, fmt.Sprintf("/path/to/image:%s", tc.newImageVersion.String()), tc.force)
@@ -288,7 +287,7 @@ func TestUpgradeKubernetesVersion(t *testing.T) {
 
 			upgrader := KubeCmd{
 				kubectl: kubectl,
-				log:     slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:     logger.NewTest(t),
 			}
 
 			err = upgrader.UpgradeKubernetesVersion(context.Background(), tc.newKubernetesVersion, tc.force)
@@ -343,7 +342,7 @@ func TestIsValidImageUpgrade(t *testing.T) {
 			assert := assert.New(t)
 
 			upgrader := &KubeCmd{
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 			}
 
 			nodeVersion := updatev1alpha1.NodeVersion{
@@ -394,7 +393,7 @@ func TestUpdateK8s(t *testing.T) {
 			assert := assert.New(t)
 
 			upgrader := &KubeCmd{
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 			}
 
 			nodeVersion := updatev1alpha1.NodeVersion{
@@ -589,7 +588,7 @@ func TestApplyJoinConfig(t *testing.T) {
 
 			cmd := &KubeCmd{
 				kubectl:       tc.kubectl,
-				log:           slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:           logger.NewTest(t),
 				retryInterval: time.Millisecond,
 			}
 

internal/logger/log.go

@@ -10,8 +10,8 @@ working with slog easier.
 
 1. Logging in unit tests
 
-To log in unit tests you can create a new slog logger that uses logger.TestWriter as its writer. This can be constructed
-by creating a logger like this: `slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))`.
+To log in unit tests you can create a new slog logger that uses logger.testWriter as its writer. This can be constructed
+by creating a logger like this: `logger.NewTest(t)`.
 
 2. Creating a new logger with an increased log level based on another logger
 
@@ -152,13 +152,17 @@ func (h *LevelHandler) Handler() slog.Handler {
 	return h.handler
 }
 
-// TestWriter is a writer to a testing.T used in tests for logging with slog.
-type TestWriter struct {
-	T *testing.T
+func NewTest(t * testing.T) *slog.Logger {
+  return slog.New(slog.NewTextHandler(testWriter{t: t}, nil))
 }
 
-func (t TestWriter) Write(p []byte) (int, error) {
-	t.T.Helper()
-	t.T.Log(string(p))
+// TestWriter is a writer to a testing.T used in tests for logging with slog.
+type testWriter struct {
+	t *testing.T
+}
+
+func (t testWriter) Write(p []byte) (int, error) {
+	t.t.Helper()
+	t.t.Log(string(p))
 	return len(p), nil
 }

internal/staticupload/staticupload_test.go

@@ -12,7 +12,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log/slog"
 	"sync"
 	"testing"
 	"time"
@@ -107,7 +106,7 @@ func TestUpload(t *testing.T) {
 				distributionID:               "test-distribution-id",
 				cacheInvalidationStrategy:    tc.cacheInvalidationStrategy,
 				cacheInvalidationWaitTimeout: tc.cacheInvalidationWaitTimeout,
-				logger:                       slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger:                       logger.NewTest(t),
 			}
 			_, err := client.Upload(context.Background(), tc.in)
 
@@ -219,7 +218,7 @@ func TestDeleteObject(t *testing.T) {
 				distributionID:               "test-distribution-id",
 				cacheInvalidationStrategy:    tc.cacheInvalidationStrategy,
 				cacheInvalidationWaitTimeout: tc.cacheInvalidationWaitTimeout,
-				logger:                       slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger:                       logger.NewTest(t),
 			}
 			_, err := client.DeleteObject(context.Background(), newObjectInput(tc.nilInput, tc.nilKey))
 
@@ -258,7 +257,7 @@ func TestDeleteObject(t *testing.T) {
 				distributionID:               "test-distribution-id",
 				cacheInvalidationStrategy:    tc.cacheInvalidationStrategy,
 				cacheInvalidationWaitTimeout: tc.cacheInvalidationWaitTimeout,
-				logger:                       slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger:                       logger.NewTest(t),
 			}
 			_, err := client.DeleteObjects(context.Background(), newObjectsInput(tc.nilInput, tc.nilKey))
 
@@ -400,7 +399,7 @@ func TestFlush(t *testing.T) {
 				cacheInvalidationWaitTimeout: tc.cacheInvalidationWaitTimeout,
 				dirtyKeys:                    tc.dirtyKeys,
 				invalidationIDs:              tc.invalidationIDs,
-				logger:                       slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger:                       logger.NewTest(t),
 			}
 			err := client.Flush(context.Background())
 
@@ -438,7 +437,7 @@ func TestConcurrency(t *testing.T) {
 		uploadClient:                 uploadClient,
 		distributionID:               "test-distribution-id",
 		cacheInvalidationWaitTimeout: 50 * time.Millisecond,
-		logger:                       slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		logger:                       logger.NewTest(t),
 	}
 
 	var wg sync.WaitGroup

internal/verify/verify_test.go

@@ -6,7 +6,6 @@ SPDX-License-Identifier: AGPL-3.0-only
 package verify
 
 import (
-	"log/slog"
 	"strings"
 	"testing"
 
@@ -46,7 +45,7 @@ func TestParseCerts(t *testing.T) {
 
 			b := &strings.Builder{}
 
-			certs, err := newCertificates("Some Cert", tc.cert, slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)))
+			certs, err := newCertificates("Some Cert", tc.cert, logger.NewTest(t))
 			if err != nil {
 				assert.True(tc.wantErr)
 				return

joinservice/internal/certcache/amdkds/amdkds_test.go

@@ -8,8 +8,8 @@ package amdkds
 
 import (
 	"fmt"
-	"log/slog"
 	"testing"
+  "log/slog"
 
 	"github.com/edgelesssys/constellation/v2/internal/logger"
 	"github.com/edgelesssys/constellation/v2/joinservice/internal/certcache/amdkds/testdata"
@@ -25,20 +25,20 @@ func TestCertChain(t *testing.T) {
 	}{
 		"success": {
 			getter: &stubGetter{
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 				ret: testdata.CertChain,
 			},
 		},
 		"getter error": {
 			getter: &stubGetter{
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 				err: assert.AnError,
 			},
 			wantErr: true,
 		},
 		"empty cert chain": {
 			getter: &stubGetter{
-				log: slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log: logger.NewTest(t),
 				ret: nil,
 			},
 			wantErr: true,

joinservice/internal/certcache/certcache_test.go

@@ -9,7 +9,6 @@ package certcache
 import (
 	"context"
 	"crypto/x509"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/attestation/variant"
@@ -121,7 +120,7 @@ func TestCreateCertChainCache(t *testing.T) {
 
 			c := &Client{
 				attVariant: variant.Dummy{},
-				log:        slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:        logger.NewTest(t),
 				kubeClient: tc.kubeClient,
 				kdsClient:  tc.kdsClient,
 			}
@@ -207,7 +206,7 @@ func TestGetCertChainCache(t *testing.T) {
 
 			ctx := context.Background()
 
-			c := NewClient(slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)), tc.kubeClient, variant.Dummy{})
+			c := NewClient(logger.NewTest(t), tc.kubeClient, variant.Dummy{})
 
 			ask, ark, err := c.getCertChainCache(ctx)
 			if tc.wantErr {

joinservice/internal/kms/kms_test.go

@@ -9,7 +9,6 @@ package kms
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/logger"
@@ -55,7 +54,7 @@ func TestGetDataKey(t *testing.T) {
 			defer listener.Close()
 
 			client := New(
-				slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger.NewTest(t),
 				listener.Addr().String(),
 			)
 

joinservice/internal/kubeadm/kubeadm_test.go

@@ -7,7 +7,6 @@ SPDX-License-Identifier: AGPL-3.0-only
 package kubeadm
 
 import (
-	"log/slog"
 	"path/filepath"
 	"testing"
 	"time"
@@ -86,7 +85,7 @@ kind: Config`,
 			require := require.New(t)
 
 			client := &Kubeadm{
-				log:    slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:    logger.NewTest(t),
 				file:   file.NewHandler(afero.NewMemMapFs()),
 				client: fake.NewSimpleClientset(),
 			}
@@ -150,7 +149,7 @@ func TestGetControlPlaneCertificatesAndKeys(t *testing.T) {
 			require := require.New(t)
 
 			client := &Kubeadm{
-				log:    slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:    logger.NewTest(t),
 				file:   file.NewHandler(afero.NewMemMapFs()),
 				client: fake.NewSimpleClientset(),
 			}

joinservice/internal/kubernetesca/kubernetesca_test.go

@@ -15,7 +15,6 @@ import (
 	"crypto/x509"
 	"crypto/x509/pkix"
 	"encoding/pem"
-	"log/slog"
 	"math/big"
 	"strings"
 	"testing"
@@ -186,7 +185,7 @@ Q29uc3RlbGxhdGlvbg==
 			}
 
 			ca := New(
-				slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger.NewTest(t),
 				fileHandler,
 			)
 

joinservice/internal/server/server_test.go

@@ -9,7 +9,6 @@ package server
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"testing"
 	"time"
 
@@ -163,7 +162,7 @@ func TestIssueJoinTicket(t *testing.T) {
 				joinTokenGetter: tc.kubeadm,
 				dataKeyGetter:   tc.kms,
 				kubeClient:      &tc.kubeClient,
-				log:             slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:             logger.NewTest(t),
 			}
 
 			req := &joinproto.IssueJoinTicketRequest{
@@ -228,7 +227,7 @@ func TestIssueRejoinTicker(t *testing.T) {
 				ca:              stubCA{},
 				joinTokenGetter: stubTokenGetter{},
 				dataKeyGetter:   tc.keyGetter,
-				log:             slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:             logger.NewTest(t),
 			}
 
 			req := &joinproto.IssueRejoinTicketRequest{

joinservice/internal/watcher/validator_test.go

@@ -12,7 +12,6 @@ import (
 	"encoding/asn1"
 	"encoding/json"
 	"io"
-	"log/slog"
 	"net/http"
 	"net/http/httptest"
 	"path/filepath"
@@ -88,7 +87,7 @@ func TestNewUpdateableValidator(t *testing.T) {
 			}
 
 			_, err := NewValidator(
-				slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger.NewTest(t),
 				tc.variant,
 				handler,
 				tc.snpCerts,
@@ -119,7 +118,7 @@ func TestUpdate(t *testing.T) {
 
 	// create server
 	validator := &Updatable{
-		log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:         logger.NewTest(t),
 		variant:     variant.Dummy{},
 		fileHandler: handler,
 	}
@@ -179,7 +178,7 @@ func TestOIDConcurrency(t *testing.T) {
 
 	// create server
 	validator := &Updatable{
-		log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:         logger.NewTest(t),
 		variant:     variant.Dummy{},
 		fileHandler: handler,
 	}
@@ -208,7 +207,7 @@ func TestUpdateConcurrency(t *testing.T) {
 
 	handler := file.NewHandler(afero.NewMemMapFs())
 	validator := &Updatable{
-		log:         slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:         logger.NewTest(t),
 		fileHandler: handler,
 		variant:     variant.Dummy{},
 	}

joinservice/internal/watcher/watcher_test.go

@@ -8,7 +8,6 @@ package watcher
 
 import (
 	"errors"
-	"log/slog"
 	"sync"
 	"testing"
 	"time"
@@ -107,7 +106,7 @@ func TestWatcher(t *testing.T) {
 			assert := assert.New(t)
 
 			watcher := &FileWatcher{
-				log:     slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:     logger.NewTest(t),
 				updater: tc.updater,
 				watcher: tc.watcher,
 				done:    make(chan struct{}, 1),

keyservice/internal/server/server_test.go

@@ -9,7 +9,6 @@ package server
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/kms/kms"
@@ -28,7 +27,7 @@ func TestGetDataKey(t *testing.T) {
 	assert := assert.New(t)
 	require := require.New(t)
 
-	log := slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil))
+	log := logger.NewTest(t)
 
 	kms := &stubKMS{derivedKey: []byte{0x0, 0x1, 0x2, 0x3, 0x4, 0x5}}
 	api := New(log, kms)

s3proxy/internal/kms/kms_test.go

@@ -9,7 +9,6 @@ package kms
 import (
 	"context"
 	"errors"
-	"log/slog"
 	"testing"
 
 	"github.com/edgelesssys/constellation/v2/internal/logger"
@@ -55,7 +54,7 @@ func TestGetDataKey(t *testing.T) {
 			defer listener.Close()
 
 			client := New(
-				slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				logger.NewTest(t),
 				listener.Addr().String(),
 			)
 

verify/server/server_test.go

@@ -12,7 +12,6 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
-	"log/slog"
 	"net"
 	"net/http"
 	"net/http/httptest"
@@ -38,7 +37,7 @@ func TestRun(t *testing.T) {
 	var err error
 	var wg sync.WaitGroup
 	s := &Server{
-		log:    slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+		log:    logger.NewTest(t),
 		issuer: stubIssuer{attestation: []byte("quote")},
 	}
 
@@ -105,7 +104,7 @@ func TestGetAttestationGRPC(t *testing.T) {
 			assert := assert.New(t)
 
 			server := &Server{
-				log:    slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:    logger.NewTest(t),
 				issuer: tc.issuer,
 			}
 
@@ -158,7 +157,7 @@ func TestGetAttestationHTTP(t *testing.T) {
 			require := require.New(t)
 
 			server := &Server{
-				log:    slog.New(slog.NewTextHandler(logger.TestWriter{T: t}, nil)),
+				log:    logger.NewTest(t),
 				issuer: tc.issuer,
 			}