assert => require

cmd/root_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestReadSecrets(t *testing.T) {
@@ -34,7 +35,7 @@ func TestListOptions(t *testing.T) {
 	err := newRunCommand(context.Background(), &Input{
 		listOptions: true,
 	})(rootCmd, []string{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestRun(t *testing.T) {
@@ -44,7 +45,7 @@ func TestRun(t *testing.T) {
 		workdir:       "../pkg/runner/testdata/",
 		workflowsPath: "./basic/push.yml",
 	})(rootCmd, []string{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestRunPush(t *testing.T) {
@@ -54,7 +55,7 @@ func TestRunPush(t *testing.T) {
 		workdir:       "../pkg/runner/testdata/",
 		workflowsPath: "./basic/push.yml",
 	})(rootCmd, []string{"push"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestRunPushJsonLogger(t *testing.T) {
@@ -65,7 +66,7 @@ func TestRunPushJsonLogger(t *testing.T) {
 		workflowsPath: "./basic/push.yml",
 		jsonLogger:    true,
 	})(rootCmd, []string{"push"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestFlags(t *testing.T) {
@@ -73,13 +74,13 @@ func TestFlags(t *testing.T) {
 		t.Run("TestFlag-"+f, func(t *testing.T) {
 			rootCmd := createRootCommand(context.Background(), &Input{}, "")
 			err := rootCmd.Flags().Set(f, "true")
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			err = newRunCommand(context.Background(), &Input{
 				platforms:     []string{"ubuntu-latest=node:16-buster-slim"},
 				workdir:       "../pkg/runner/testdata/",
 				workflowsPath: "./basic/push.yml",
 			})(rootCmd, []string{})
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		})
 	}
 }
@@ -92,7 +93,7 @@ func TestWorkflowCall(t *testing.T) {
 		workflowsPath: "./workflow_call_inputs/workflow_call_inputs.yml",
 		inputs:        []string{"required=required input", "boolean=true"},
 	})(rootCmd, []string{"workflow_call"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestLocalRepositories(t *testing.T) {
@@ -105,5 +106,5 @@ func TestLocalRepositories(t *testing.T) {
 		workflowsPath:   "./remote-action-composite-action-ref-partial-override/push.yml",
 		localRepository: []string{"needs/override@main=" + wd + "/actions-environment-and-context-tests"},
 	})(rootCmd, []string{"push"})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

internal/eval/functions/format_test.go

@@ -4,11 +4,11 @@ import (
 	"fmt"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestFormat(t *testing.T) {
 	s, err := Format("Hello {0}, you have {1} new messages", "Alice", 5)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	fmt.Println(s) // Hello Alice, you have 5 new messages
 }

internal/model/workflow_state_test.go

@@ -95,7 +95,7 @@ jobs:
 
 	var raw any
 	err = node.Content[0].Decode(&raw)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	ee.RestrictEval = true
 	ee.EvaluationContext.Variables = v2.CaseInsensitiveObject[any]{
@@ -136,6 +136,6 @@ jobs:
 		}
 	}
 	out, err := yaml.Marshal(&myw)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, out)
 }

internal/templateeval/rewrite_subexpression_test.go

@@ -4,12 +4,13 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRewriteSubExpression_NoExpression(t *testing.T) {
 	in := "Hello world"
 	out, ok, err := rewriteSubExpression(in, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if ok {
 		t.Fatalf("expected ok=false for no expression, got true with output %q", out)
 	}
@@ -21,7 +22,7 @@ func TestRewriteSubExpression_NoExpression(t *testing.T) {
 func TestRewriteSubExpression_SingleExpression(t *testing.T) {
 	in := "Hello ${{ 'world' }}"
 	out, ok, err := rewriteSubExpression(in, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if !ok {
 		t.Fatalf("expected ok=true for single expression, got false")
 	}
@@ -34,7 +35,7 @@ func TestRewriteSubExpression_SingleExpression(t *testing.T) {
 func TestRewriteSubExpression_MultipleExpressions(t *testing.T) {
 	in := "Hello ${{ 'world' }}, you are ${{ 'awesome' }}"
 	out, ok, err := rewriteSubExpression(in, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if !ok {
 		t.Fatalf("expected ok=true for multiple expressions, got false")
 	}
@@ -47,7 +48,7 @@ func TestRewriteSubExpression_MultipleExpressions(t *testing.T) {
 func TestRewriteSubExpression_ForceFormatSingle(t *testing.T) {
 	in := "Hello ${{ 'world' }}"
 	out, ok, err := rewriteSubExpression(in, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if !ok {
 		t.Fatalf("expected ok=true when forceFormat, got false")
 	}
@@ -60,7 +61,7 @@ func TestRewriteSubExpression_ForceFormatSingle(t *testing.T) {
 func TestRewriteSubExpression_ForceFormatMultiple(t *testing.T) {
 	in := "Hello ${{ 'world' }}, you are ${{ 'awesome' }}"
 	out, ok, err := rewriteSubExpression(in, true)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	if !ok {
 		t.Fatalf("expected ok=true when forceFormat, got false")
 	}
@@ -88,7 +89,7 @@ func TestRewriteSubExpression_EscapedStringLiteral(t *testing.T) {
 	// Two single quotes represent an escaped quote inside a string
 	in := "Hello ${{ 'It''s a test' }}"
 	out, ok, err := rewriteSubExpression(in, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, ok)
 	expected := "format('Hello {0}', 'It''s a test')"
 	assert.Equal(t, expected, out)
@@ -98,7 +99,7 @@ func TestRewriteSubExpression_ExpressionAtEnd(t *testing.T) {
 	// Expression ends exactly at the string end – should be valid
 	in := "Hello ${{ 'world' }}"
 	out, ok, err := rewriteSubExpression(in, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, ok)
 	expected := "format('Hello {0}', 'world')"
 	assert.Equal(t, expected, out)
@@ -108,7 +109,7 @@ func TestRewriteSubExpression_ExpressionNotAtEnd(t *testing.T) {
 	// Expression followed by additional text – should still be valid
 	in := "Hello ${{ 'world' }}, how are you?"
 	out, ok, err := rewriteSubExpression(in, false)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, ok)
 	expected := "format('Hello {0}, how are you?', 'world')"
 	assert.Equal(t, expected, out)

pkg/artifactcache/handler_test.go

@@ -687,7 +687,7 @@ func TestHandler_gcCache(t *testing.T) {
 			cache := &Cache{}
 			err = db.Get(v.Cache.ID, cache)
 			if v.Kept {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
 				assert.ErrorIs(t, err, bolthold.ErrNotFound)
 			}

pkg/artifacts/server_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/julienschmidt/httprouter"
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"gitea.com/gitea/act_runner/pkg/model"
 	"gitea.com/gitea/act_runner/pkg/runner"
@@ -283,7 +284,7 @@ func runTestJobFile(ctx context.Context, t *testing.T, tjfi TestJobFileInfo) {
 		}
 
 		workdir, err := filepath.Abs(tjfi.workdir)
-		assert.NoError(t, err, workdir)
+		require.NoError(t, err, workdir)
 		fullWorkflowPath := filepath.Join(workdir, tjfi.workflowPath)
 		runnerConfig := &runner.Config{
 			Workdir:               workdir,
@@ -299,16 +300,16 @@ func runTestJobFile(ctx context.Context, t *testing.T, tjfi TestJobFileInfo) {
 		}
 
 		runner, err := runner.New(runnerConfig)
-		assert.NoError(t, err, tjfi.workflowPath)
+		require.NoError(t, err, tjfi.workflowPath)
 
 		planner, err := model.NewWorkflowPlanner(fullWorkflowPath, model.PlannerConfig{})
-		assert.NoError(t, err, fullWorkflowPath)
+		require.NoError(t, err, fullWorkflowPath)
 
 		plan, err := planner.PlanEvent(tjfi.eventName)
 		if err == nil {
 			err = runner.NewPlanExecutor(plan)(ctx)
 			if tjfi.errorMessage == "" {
-				assert.NoError(t, err, fullWorkflowPath)
+				require.NoError(t, err, fullWorkflowPath)
 			} else {
 				assert.Error(t, err, tjfi.errorMessage)
 			}

pkg/common/auth_test.go

@@ -10,18 +10,19 @@ import (
 
 	"github.com/golang-jwt/jwt/v5"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestCreateAuthorizationToken(t *testing.T) {
 	var taskID int64 = 23
 	token, err := CreateAuthorizationToken(taskID, 1, 2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, token)
 	claims := jwt.MapClaims{}
 	_, err = jwt.ParseWithClaims(token, claims, func(_ *jwt.Token) (any, error) {
 		return []byte{}, nil
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	scp, ok := claims["scp"]
 	assert.True(t, ok, "Has scp claim in jwt token")
 	assert.Contains(t, scp, "Actions.Results:1:2")
@@ -34,21 +35,21 @@ func TestCreateAuthorizationToken(t *testing.T) {
 	assert.True(t, ok, "ac claim is a string for buildx gha cache")
 	scopes := []actionsCacheScope{}
 	err = json.Unmarshal([]byte(ac), &scopes)
-	assert.NoError(t, err, "ac claim is a json list for buildx gha cache")
+	require.NoError(t, err, "ac claim is a json list for buildx gha cache")
 	assert.GreaterOrEqual(t, len(scopes), 1, "Expected at least one action cache scope for buildx gha cache")
 }
 
 func TestParseAuthorizationToken(t *testing.T) {
 	var taskID int64 = 23
 	token, err := CreateAuthorizationToken(taskID, 1, 2)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotEmpty(t, token)
 	headers := http.Header{}
 	headers.Set("Authorization", "Bearer "+token)
 	rTaskID, err := ParseAuthorizationToken(&http.Request{
 		Header: headers,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, taskID, rTaskID)
 }
 
@@ -57,6 +58,6 @@ func TestParseAuthorizationTokenNoAuthHeader(t *testing.T) {
 	rTaskID, err := ParseAuthorizationToken(&http.Request{
 		Header: headers,
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, int64(0), rTaskID)
 }

pkg/common/context_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGracefulJobCancellationViaSigint(t *testing.T) {
@@ -18,8 +19,8 @@ func TestGracefulJobCancellationViaSigint(t *testing.T) {
 	assert.NotNil(t, channel)
 	cancelCtx := JobCancelContext(ctx)
 	assert.NotNil(t, cancelCtx)
-	assert.NoError(t, ctx.Err())
+	require.NoError(t, ctx.Err())
-	assert.NoError(t, cancelCtx.Err())
+	require.NoError(t, cancelCtx.Err())
 	channel <- os.Interrupt
 	select {
 	case <-time.After(1 * time.Second):
@@ -30,7 +31,7 @@ func TestGracefulJobCancellationViaSigint(t *testing.T) {
 	if assert.Error(t, cancelCtx.Err(), "context canceled") {
 		assert.Equal(t, context.Canceled, cancelCtx.Err())
 	}
-	assert.NoError(t, ctx.Err())
+	require.NoError(t, ctx.Err())
 	channel <- os.Interrupt
 	select {
 	case <-time.After(1 * time.Second):
@@ -50,8 +51,8 @@ func TestForceCancellationViaSigterm(t *testing.T) {
 	assert.NotNil(t, channel)
 	cancelCtx := JobCancelContext(ctx)
 	assert.NotNil(t, cancelCtx)
-	assert.NoError(t, ctx.Err())
+	require.NoError(t, ctx.Err())
-	assert.NoError(t, cancelCtx.Err())
+	require.NoError(t, cancelCtx.Err())
 	channel <- syscall.SIGTERM
 	select {
 	case <-time.After(1 * time.Second):
@@ -78,7 +79,7 @@ func TestCreateGracefulJobCancellationContext(t *testing.T) {
 	assert.NotNil(t, cancel)
 	cancelCtx := JobCancelContext(ctx)
 	assert.NotNil(t, cancelCtx)
-	assert.NoError(t, cancelCtx.Err())
+	require.NoError(t, cancelCtx.Err())
 }
 
 func TestCreateGracefulJobCancellationContextCancelFunc(t *testing.T) {
@@ -87,7 +88,7 @@ func TestCreateGracefulJobCancellationContextCancelFunc(t *testing.T) {
 	assert.NotNil(t, cancel)
 	cancelCtx := JobCancelContext(ctx)
 	assert.NotNil(t, cancelCtx)
-	assert.NoError(t, cancelCtx.Err())
+	require.NoError(t, cancelCtx.Err())
 	cancel()
 	if assert.Error(t, ctx.Err(), "context canceled") {
 		assert.Equal(t, context.Canceled, ctx.Err())

pkg/common/executor_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewWorkflow(t *testing.T) {
@@ -16,7 +17,7 @@ func TestNewWorkflow(t *testing.T) {
 
 	// empty
 	emptyWorkflow := NewPipelineExecutor()
-	assert.NoError(emptyWorkflow(ctx))
+	require.NoError(emptyWorkflow(ctx))
 
 	// error case
 	errorWorkflow := NewErrorExecutor(errors.New("test error"))
@@ -33,7 +34,7 @@ func TestNewWorkflow(t *testing.T) {
 			runcount++
 			return nil
 		})
-	assert.NoError(successWorkflow(ctx))
+	require.NoError(successWorkflow(ctx))
 	assert.Equal(2, runcount)
 }
 
@@ -55,7 +56,7 @@ func TestNewConditionalExecutor(t *testing.T) {
 		return nil
 	})(ctx)
 
-	assert.NoError(err)
+	require.NoError(err)
 	assert.Equal(0, trueCount)
 	assert.Equal(1, falseCount)
 
@@ -69,7 +70,7 @@ func TestNewConditionalExecutor(t *testing.T) {
 		return nil
 	})(ctx)
 
-	assert.NoError(err)
+	require.NoError(err)
 	assert.Equal(1, trueCount)
 	assert.Equal(1, falseCount)
 }
@@ -99,7 +100,7 @@ func TestNewParallelExecutor(t *testing.T) {
 
 	assert.Equal(3, count, "should run all 3 executors")
 	assert.Equal(2, maxCount, "should run at most 2 executors in parallel")
-	assert.NoError(err)
+	require.NoError(err)
 
 	// Reset to test running the executor with 0 parallelism
 	count = 0
@@ -110,7 +111,7 @@ func TestNewParallelExecutor(t *testing.T) {
 
 	assert.Equal(3, count, "should run all 3 executors")
 	assert.Equal(1, maxCount, "should run at most 1 executors in parallel")
-	assert.NoError(errSingle)
+	require.NoError(errSingle)
 }
 
 func TestNewParallelExecutorFailed(t *testing.T) {

pkg/common/git/git_test.go

@@ -40,7 +40,7 @@ func TestFindGitSlug(t *testing.T) {
 	for _, tt := range slugTests {
 		provider, slug, err := findGitSlug(tt.url, "github.com")
 
-		assert.NoError(err)
+		require.NoError(err)
 		assert.Equal(tt.provider, provider)
 		assert.Equal(tt.slug, slug)
 	}
@@ -80,23 +80,23 @@ func TestFindGitRemoteURL(t *testing.T) {
 	basedir := testDir(t)
 	gitConfig()
 	err := gitCmd("init", basedir)
-	assert.NoError(err)
+	require.NoError(err)
 	err = cleanGitHooks(basedir)
-	assert.NoError(err)
+	require.NoError(err)
 
 	remoteURL := "https://git-codecommit.us-east-1.amazonaws.com/v1/repos/my-repo-name"
 	err = gitCmd("-C", basedir, "remote", "add", "origin", remoteURL)
-	assert.NoError(err)
+	require.NoError(err)
 
 	u, err := findGitRemoteURL(context.Background(), basedir, "origin")
-	assert.NoError(err)
+	require.NoError(err)
 	assert.Equal(remoteURL, u)
 
 	remoteURL = "git@github.com/AwesomeOwner/MyAwesomeRepo.git"
 	err = gitCmd("-C", basedir, "remote", "add", "upstream", remoteURL)
-	assert.NoError(err)
+	require.NoError(err)
 	u, err = findGitRemoteURL(context.Background(), basedir, "upstream")
-	assert.NoError(err)
+	require.NoError(err)
 	assert.Equal(remoteURL, u)
 }
 
@@ -216,7 +216,7 @@ func TestGitCloneExecutor(t *testing.T) {
 				assert.Error(t, err)
 				assert.Equal(t, tt.Err, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 		})
 	}
@@ -258,7 +258,7 @@ func TestCloneIfRequired(t *testing.T) {
 			URL: "https://github.com/actions/checkout",
 			Dir: tempDir,
 		}, common.Logger(ctx))
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		assert.NotNil(t, repo)
 	})
 

pkg/common/line_writer_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestLineWriter(t *testing.T) {
@@ -18,7 +19,7 @@ func TestLineWriter(t *testing.T) {
 	assert := assert.New(t)
 	write := func(s string) {
 		n, err := lineWriter.Write([]byte(s))
-		assert.NoError(err)
+		require.NoError(err)
 		assert.Equal(len(s), n, s)
 	}
 

pkg/container/docker_images_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/docker/docker/client"
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func init() {
@@ -26,17 +27,17 @@ func TestImageExistsLocally(t *testing.T) {
 
 	// Test if image exists with specific tag
 	invalidImageTag, err := ImageExistsLocally(ctx, "library/alpine:this-random-tag-will-never-exist", "linux/amd64")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, invalidImageTag)
 
 	// Test if image exists with specific architecture (image platform)
 	invalidImagePlatform, err := ImageExistsLocally(ctx, "alpine:latest", "windows/amd64")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.False(t, invalidImagePlatform)
 
 	// pull an image
 	cli, err := client.NewClientWithOpts(client.FromEnv)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cli.NegotiateAPIVersion(context.Background())
 
 	// Chose alpine latest because it's so small
@@ -44,13 +45,13 @@ func TestImageExistsLocally(t *testing.T) {
 	readerDefault, err := cli.ImagePull(ctx, "node:16-buster-slim", image.PullOptions{
 		Platform: "linux/amd64",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer readerDefault.Close()
 	_, err = io.ReadAll(readerDefault)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	imageDefaultArchExists, err := ImageExistsLocally(ctx, "node:16-buster-slim", "linux/amd64")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, imageDefaultArchExists)
 }
 
@@ -66,19 +67,19 @@ func TestImageExistsLocallyQemu(t *testing.T) {
 
 	// pull an image
 	cli, err := client.NewClientWithOpts(client.FromEnv)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	cli.NegotiateAPIVersion(context.Background())
 
 	// Validate if another architecture platform can be pulled
 	readerArm64, err := cli.ImagePull(ctx, "node:16-buster-slim", image.PullOptions{
 		Platform: "linux/arm64",
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer readerArm64.Close()
 	_, err = io.ReadAll(readerArm64)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	imageArm64Exists, err := ImageExistsLocally(ctx, "node:16-buster-slim", "linux/arm64")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.True(t, imageArm64Exists)
 }

pkg/container/docker_pull_test.go

@@ -8,6 +8,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	assert "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func init() {
@@ -40,7 +41,7 @@ func TestGetImagePullOptions(t *testing.T) {
 	config.SetDir("/non-existent/docker")
 
 	options, err := getImagePullOptions(ctx, NewDockerPullExecutorInput{})
-	assert.NoError(t, err, "Failed to create ImagePullOptions")
+	require.NoError(t, err, "Failed to create ImagePullOptions")
 	assert.Empty(t, options.RegistryAuth, "RegistryAuth should be empty if no username or password is set")
 
 	options, err = getImagePullOptions(ctx, NewDockerPullExecutorInput{
@@ -48,7 +49,7 @@ func TestGetImagePullOptions(t *testing.T) {
 		Username: "username",
 		Password: "password",
 	})
-	assert.NoError(t, err, "Failed to create ImagePullOptions")
+	require.NoError(t, err, "Failed to create ImagePullOptions")
 	assert.Equal(t, "eyJ1c2VybmFtZSI6InVzZXJuYW1lIiwicGFzc3dvcmQiOiJwYXNzd29yZCJ9", options.RegistryAuth, "Username and Password should be provided")
 
 	config.SetDir("testdata/docker-pull-options")
@@ -56,6 +57,6 @@ func TestGetImagePullOptions(t *testing.T) {
 	options, err = getImagePullOptions(ctx, NewDockerPullExecutorInput{
 		Image: "nektos/act",
 	})
-	assert.NoError(t, err, "Failed to create ImagePullOptions")
+	require.NoError(t, err, "Failed to create ImagePullOptions")
 	assert.Equal(t, "eyJ1c2VybmFtZSI6InVzZXJuYW1lIiwicGFzc3dvcmQiOiJwYXNzd29yZFxuIiwic2VydmVyYWRkcmVzcyI6Imh0dHBzOi8vaW5kZXguZG9ja2VyLmlvL3YxLyJ9", options.RegistryAuth, "RegistryAuth should be taken from local docker config")
 }

pkg/container/docker_run_test.go

@@ -16,12 +16,13 @@ import (
 	"github.com/docker/docker/client"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestDocker(t *testing.T) {
 	ctx := context.Background()
 	client, err := GetDockerClient(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer client.Close()
 
 	dockerBuild := NewDockerBuildExecutor(NewDockerBuildExecutorInput{
@@ -30,7 +31,7 @@ func TestDocker(t *testing.T) {
 	})
 
 	err = dockerBuild(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cr := &containerReference{
 		cli: client,
@@ -47,7 +48,7 @@ func TestDocker(t *testing.T) {
 
 	envExecutor := cr.extractFromImageEnv(&env)
 	err = envExecutor(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, map[string]string{
 		"PATH":            "/usr/local/bin:/usr/bin:/usr/sbin:/bin:/sbin:/this/path/does/not/exists/anywhere:/this/either",
 		"RANDOM_VAR":      "WITH_VALUE",

pkg/container/docker_socket_test.go

@@ -6,6 +6,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	assert "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func init() {
@@ -25,7 +26,7 @@ func TestGetSocketAndHostWithSocket(t *testing.T) {
 	ret, err := GetSocketAndHost(socketURI)
 
 	// Assert
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, SocketAndHost{socketURI, dockerHost}, ret)
 }
 
@@ -38,7 +39,7 @@ func TestGetSocketAndHostNoSocket(t *testing.T) {
 	ret, err := GetSocketAndHost("")
 
 	// Assert
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, SocketAndHost{dockerHost, dockerHost}, ret)
 }
 
@@ -53,7 +54,7 @@ func TestGetSocketAndHostOnlySocket(t *testing.T) {
 	ret, err := GetSocketAndHost(socketURI)
 
 	// Assert
-	assert.NoError(t, err, "Expected no error from GetSocketAndHost")
+	require.NoError(t, err, "Expected no error from GetSocketAndHost")
 	assert.True(t, defaultSocketFound, "Expected to find default socket")
 	assert.Equal(t, socketURI, ret.Socket, "Expected socket to match common location")
 	assert.Equal(t, defaultSocket, ret.Host, "Expected ret.Host to match default socket location")
@@ -69,7 +70,7 @@ func TestGetSocketAndHostDontMount(t *testing.T) {
 	ret, err := GetSocketAndHost("-")
 
 	// Assert
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, SocketAndHost{"-", dockerHost}, ret)
 }
 
@@ -84,7 +85,7 @@ func TestGetSocketAndHostNoHostNoSocket(t *testing.T) {
 
 	// Assert
 	assert.True(t, found, "Expected a default socket to be found")
-	assert.NoError(t, err, "Expected no error from GetSocketAndHost")
+	require.NoError(t, err, "Expected no error from GetSocketAndHost")
 	assert.Equal(t, SocketAndHost{defaultSocket, defaultSocket}, ret, "Expected to match default socket location")
 }
 
@@ -97,7 +98,7 @@ func TestGetSocketAndHostNoHostNoSocketDefaultLocation(t *testing.T) {
 	mySocket := mySocketFile.Name()
 	unixSocket := "unix://" + mySocket
 	defer os.RemoveAll(mySocket)
-	assert.NoError(t, tmpErr)
+	require.NoError(t, tmpErr)
 	os.Unsetenv("DOCKER_HOST")
 
 	CommonSocketLocations = []string{mySocket}
@@ -109,7 +110,7 @@ func TestGetSocketAndHostNoHostNoSocketDefaultLocation(t *testing.T) {
 	// Assert
 	assert.Equal(t, unixSocket, defaultSocket, "Expected default socket to match common socket location")
 	assert.True(t, found, "Expected default socket to be found")
-	assert.NoError(t, err, "Expected no error from GetSocketAndHost")
+	require.NoError(t, err, "Expected no error from GetSocketAndHost")
 	assert.Equal(t, SocketAndHost{unixSocket, unixSocket}, ret, "Expected to match default socket location")
 }
 
@@ -145,6 +146,6 @@ func TestGetSocketAndHostOnlySocketValidButUnusualLocation(t *testing.T) {
 	assert.Empty(t, defaultSocket, "Expect default socket location to be empty")
 	assert.False(t, found, "Expected no default socket to be found")
 	// Sane default
-	assert.NoError(t, err, "Expect no error from GetSocketAndHost")
+	require.NoError(t, err, "Expect no error from GetSocketAndHost")
 	assert.Equal(t, socketURI, ret.Host, "Expect host to default to unusual socket")
 }

pkg/container/host_environment_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 // Type assert HostEnvironment implements ExecutionsEnvironment
@@ -17,7 +18,7 @@ var _ ExecutionsEnvironment = &HostEnvironment{}
 
 func TestCopyDir(t *testing.T) {
 	dir, err := os.MkdirTemp("", "test-host-env-*")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(dir)
 	ctx := context.Background()
 	e := &HostEnvironment{
@@ -33,12 +34,12 @@ func TestCopyDir(t *testing.T) {
 	_ = os.MkdirAll(e.ToolCache, 0700)
 	_ = os.MkdirAll(e.ActPath, 0700)
 	err = e.CopyDir(e.Workdir, e.Path, true)(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestGetContainerArchive(t *testing.T) {
 	dir, err := os.MkdirTemp("", "test-host-env-*")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer os.RemoveAll(dir)
 	ctx := context.Background()
 	e := &HostEnvironment{
@@ -55,16 +56,16 @@ func TestGetContainerArchive(t *testing.T) {
 	_ = os.MkdirAll(e.ActPath, 0700)
 	expectedContent := []byte("sdde/7sh")
 	err = os.WriteFile(filepath.Join(e.Path, "action.yml"), expectedContent, 0600)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	archive, err := e.GetContainerArchive(ctx, e.Path)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	defer archive.Close()
 	reader := tar.NewReader(archive)
 	h, err := reader.Next()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, "action.yml", h.Name)
 	content, err := io.ReadAll(reader)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, expectedContent, content)
 	_, err = reader.Next()
 	assert.ErrorIs(t, err, io.EOF)

pkg/exprparser/interpreter_test.go

@@ -6,6 +6,7 @@ import (
 
 	"gitea.com/gitea/act_runner/pkg/model"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestLiterals(t *testing.T) {
@@ -30,7 +31,7 @@ func TestLiterals(t *testing.T) {
 	for _, tt := range table {
 		t.Run(tt.name, func(t *testing.T) {
 			output, err := NewInterpeter(env, Config{}).Evaluate(tt.input, DefaultStatusCheckNone)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, tt.expected, output)
 		})
@@ -105,7 +106,7 @@ func TestOperators(t *testing.T) {
 				assert.Error(t, err)
 				assert.Equal(t, tt.error, err.Error())
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 
 			assert.Equal(t, tt.expected, output)
@@ -154,7 +155,7 @@ func TestOperatorsCompare(t *testing.T) {
 	for _, tt := range table {
 		t.Run(tt.name, func(t *testing.T) {
 			output, err := NewInterpeter(env, Config{}).Evaluate(tt.input, DefaultStatusCheckNone)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, tt.expected, output)
 		})
@@ -517,7 +518,7 @@ func TestOperatorsBooleanEvaluation(t *testing.T) {
 	for _, tt := range table {
 		t.Run(tt.name, func(t *testing.T) {
 			output, err := NewInterpeter(env, Config{}).Evaluate(tt.input, DefaultStatusCheckNone)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			// Normalize int => float64
 			if i, ok := tt.expected.(int); ok {
@@ -648,7 +649,7 @@ func TestContexts(t *testing.T) {
 			tenv.EnvCS = tt.caseSensitiveEnv
 			tenv.CtxData = tt.ctxdata
 			output, err := NewInterpeter(&tenv, Config{}).Evaluate(tt.input, DefaultStatusCheckNone)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, tt.expected, output)
 		})

pkg/filecollector/file_collector_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/go-git/go-git/v5/plumbing/format/index"
 	"github.com/go-git/go-git/v5/storage/filesystem"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type memoryFs struct {
@@ -105,12 +106,12 @@ func TestIgnoredTrackedfile(t *testing.T) {
 		},
 	}
 	err := fc.Fs.Walk("mygitrepo", fc.CollectFiles(context.Background(), []string{}))
-	assert.NoError(t, err, "successfully collect files")
+	require.NoError(t, err, "successfully collect files")
 	tw.Close()
 	_, _ = tmpTar.Seek(0, io.SeekStart)
 	tr := tar.NewReader(tmpTar)
 	h, err := tr.Next()
-	assert.NoError(t, err, "tar must not be empty")
+	require.NoError(t, err, "tar must not be empty")
 	assert.Equal(t, ".gitignore", h.Name)
 	_, err = tr.Next()
 	assert.ErrorIs(t, err, io.EOF, "tar must only contain one element")
@@ -124,21 +125,21 @@ func TestSymlinks(t *testing.T) {
 	repo, _ := git.Init(filesystem.NewStorage(dotgit, cache.NewObjectLRUDefault()), worktree)
 	// This file shouldn't be in the tar
 	f, err := worktree.Create(".env")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = f.Write([]byte("test=val1\n"))
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	f.Close()
 	err = worktree.Symlink(".env", "test.env")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	w, err := repo.Worktree()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// .gitignore is in the tar after adding it to the index
 	_, err = w.Add(".env")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	_, err = w.Add("test.env")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	tmpTar, _ := fs.Create("temp.tar")
 	tw := tar.NewWriter(tmpTar)
@@ -154,7 +155,7 @@ func TestSymlinks(t *testing.T) {
 		},
 	}
 	err = fc.Fs.Walk("mygitrepo", fc.CollectFiles(context.Background(), []string{}))
-	assert.NoError(t, err, "successfully collect files")
+	require.NoError(t, err, "successfully collect files")
 	tw.Close()
 	_, _ = tmpTar.Seek(0, io.SeekStart)
 	tr := tar.NewReader(tmpTar)

pkg/model/anchors_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 )
 
@@ -17,7 +18,7 @@ test:
 	*node.Content[0].Content[1].Content[1] = yaml.Node{
 		Kind: yaml.AliasNode,
 	}
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = resolveAliases(&node)
 	assert.Error(t, err)
 }
@@ -102,12 +103,12 @@ c: *a
 				assert.Error(t, err)
 				return
 			}
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			err = resolveAliases(&node)
 			if tt.anchorErr {
 				assert.Error(t, err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 		})
 	}

pkg/model/planner_test.go

@@ -6,6 +6,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 type WorkflowPlanTest struct {
@@ -28,14 +29,14 @@ func TestPlanner(t *testing.T) {
 	}
 
 	workdir, err := filepath.Abs("testdata")
-	assert.NoError(t, err, workdir)
+	require.NoError(t, err, workdir)
 	for _, table := range tables {
 		fullWorkflowPath := filepath.Join(workdir, table.workflowPath)
 		_, err = NewWorkflowPlanner(fullWorkflowPath, PlannerConfig{
 			Recursive: !table.noWorkflowRecurse,
 		})
 		if table.errorMessage == "" {
-			assert.NoError(t, err, "WorkflowPlanner should exit without any error")
+			require.NoError(t, err, "WorkflowPlanner should exit without any error")
 		} else {
 			assert.EqualError(t, err, table.errorMessage)
 		}
@@ -55,6 +56,6 @@ func TestWorkflow(t *testing.T) {
 
 	// Check that a valid job id returns non-error
 	result, err := createStages(&workflow, "valid_job")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, result)
 }

pkg/model/workflow_test.go

@@ -22,7 +22,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 
 	assert.Len(t, workflow.On(), 1)
 	assert.Contains(t, workflow.On(), "push")
@@ -41,7 +41,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 
 	assert.Len(t, workflow.On(), 2)
 	assert.Contains(t, workflow.On(), "push")
@@ -67,7 +67,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Len(t, workflow.On(), 2)
 	assert.Contains(t, workflow.On(), "push")
 	assert.Contains(t, workflow.On(), "pull_request")
@@ -86,7 +86,7 @@ jobs:
     - uses: ./actions/docker-url`
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Equal(t, []string{"ubuntu-latest"}, workflow.Jobs["test"].RunsOn())
 }
 
@@ -104,7 +104,7 @@ jobs:
     - uses: ./actions/docker-url`
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Equal(t, []string{"ubuntu-latest", "linux"}, workflow.Jobs["test"].RunsOn())
 }
 
@@ -129,7 +129,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Len(t, workflow.Jobs, 2)
 	assert.Contains(t, workflow.Jobs["test"].Container().Image, "nginx:latest")
 	assert.Contains(t, workflow.Jobs["test2"].Container().Image, "nginx:latest")
@@ -159,7 +159,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Len(t, workflow.Jobs, 1)
 
 	container := workflow.GetJob("test").Container()
@@ -197,31 +197,31 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Len(t, workflow.Jobs, 6)
 
 	jobType, err := workflow.Jobs["default-job"].Type()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JobTypeDefault, jobType)
 
 	jobType, err = workflow.Jobs["remote-reusable-workflow-yml"].Type()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JobTypeReusableWorkflowRemote, jobType)
 
 	jobType, err = workflow.Jobs["remote-reusable-workflow-yaml"].Type()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JobTypeReusableWorkflowRemote, jobType)
 
 	jobType, err = workflow.Jobs["remote-reusable-workflow-custom-path"].Type()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JobTypeReusableWorkflowRemote, jobType)
 
 	jobType, err = workflow.Jobs["local-reusable-workflow-yml"].Type()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JobTypeReusableWorkflowLocal, jobType)
 
 	jobType, err = workflow.Jobs["local-reusable-workflow-yaml"].Type()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, JobTypeReusableWorkflowLocal, jobType)
 }
 
@@ -241,7 +241,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Len(t, workflow.Jobs, 4)
 
 	jobType, err := workflow.Jobs["remote-reusable-workflow-missing-version"].Type()
@@ -315,7 +315,7 @@ jobs:
 `
 
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	assert.Len(t, workflow.Jobs, 2)
 
 	assert.Len(t, workflow.Jobs["test1"].Steps, 1)
@@ -330,10 +330,10 @@ jobs:
 
 func TestReadWorkflow_Strategy(t *testing.T) {
 	w, err := NewWorkflowPlanner("testdata/strategy/push.yml", PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	p, err := w.PlanJob("strategy-only-max-parallel")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Len(t, p.Stages, 1)
 	assert.Len(t, p.Stages[0].Runs, 1)
@@ -342,7 +342,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 
 	job := wf.Jobs["strategy-only-max-parallel"]
 	matrixes, err := job.GetMatrixes()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []map[string]any{{}}, matrixes)
 	assert.Equal(t, job.Matrix(), map[string][]any(nil))
 	assert.Equal(t, 2, job.Strategy.MaxParallel)
@@ -350,7 +350,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 
 	job = wf.Jobs["strategy-only-fail-fast"]
 	matrixes, err = job.GetMatrixes()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []map[string]any{{}}, matrixes)
 	assert.Equal(t, job.Matrix(), map[string][]any(nil))
 	assert.Equal(t, 4, job.Strategy.MaxParallel)
@@ -358,7 +358,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 
 	job = wf.Jobs["strategy-no-matrix"]
 	matrixes, err = job.GetMatrixes()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []map[string]any{{}}, matrixes)
 	assert.Equal(t, job.Matrix(), map[string][]any(nil))
 	assert.Equal(t, 2, job.Strategy.MaxParallel)
@@ -366,7 +366,7 @@ func TestReadWorkflow_Strategy(t *testing.T) {
 
 	job = wf.Jobs["strategy-all"]
 	matrixes, err = job.GetMatrixes()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, []map[string]any{
 		{"datacenter": "site-c", "node-version": "14.x", "site": "staging", "php-version": 5.4},
 		{"datacenter": "site-c", "node-version": "16.x", "site": "staging", "php-version": 5.4},
@@ -449,7 +449,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch := workflow.WorkflowDispatchConfig()
 	assert.Nil(t, workflowDispatch)
 
@@ -463,7 +463,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err = ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch = workflow.WorkflowDispatchConfig()
 	assert.NotNil(t, workflowDispatch)
 	assert.Nil(t, workflowDispatch.Inputs)
@@ -478,7 +478,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err = ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch = workflow.WorkflowDispatchConfig()
 	assert.Nil(t, workflowDispatch)
 
@@ -492,7 +492,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err = ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch = workflow.WorkflowDispatchConfig()
 	assert.NotNil(t, workflowDispatch)
 	assert.Nil(t, workflowDispatch.Inputs)
@@ -509,7 +509,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err = ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch = workflow.WorkflowDispatchConfig()
 	assert.NotNil(t, workflowDispatch)
 	assert.Nil(t, workflowDispatch.Inputs)
@@ -526,7 +526,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err = ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch = workflow.WorkflowDispatchConfig()
 	assert.Nil(t, workflowDispatch)
 
@@ -553,7 +553,7 @@ func TestReadWorkflow_WorkflowDispatchConfig(t *testing.T) {
         - run: echo Test
     `
 	workflow, err = ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 	workflowDispatch = workflow.WorkflowDispatchConfig()
 	assert.NotNil(t, workflowDispatch)
 	assert.Equal(t, WorkflowDispatchInput{
@@ -601,7 +601,7 @@ jobs:
 `
 
 	w, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{Strict: true})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 
 	for _, job := range w.Jobs {
 		assert.Equal(t, []string{"ubuntu-latest"}, job.RunsOn())
@@ -629,7 +629,7 @@ on: push #*trigger
 `
 
 	w, err := ReadWorkflow(strings.NewReader(yaml), WorkflowConfig{})
-	assert.NoError(t, err, "read workflow should succeed")
+	require.NoError(t, err, "read workflow should succeed")
 
 	for _, job := range w.Jobs {
 		assert.Equal(t, []string{"ubuntu-latest"}, job.RunsOn())

pkg/runner/action_test.go

@@ -10,6 +10,7 @@ import (
 	"gitea.com/gitea/act_runner/pkg/model"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 type closerMock struct {
@@ -99,7 +100,7 @@ runs:
 
 			action, err := readActionImpl(context.Background(), tt.step, readFile, model.ActionConfig{})
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.expected, action)
 
 			closerMock.AssertExpectations(t)
@@ -218,7 +219,7 @@ func TestActionRunner(t *testing.T) {
 
 			err := runActionImpl(tt.step)(ctx)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			cm.AssertExpectations(t)
 		})
 	}

pkg/runner/expression_test.go

@@ -12,6 +12,7 @@ import (
 	"gitea.com/gitea/act_runner/pkg/exprparser"
 	"gitea.com/gitea/act_runner/pkg/model"
 	assert "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	yaml "gopkg.in/yaml.v3"
 )
 
@@ -21,7 +22,7 @@ func createRunContext(t *testing.T) *RunContext {
 		"os":  {"Linux", "Windows"},
 		"foo": {"bar", "baz"},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	return &RunContext{
 		Config: &Config{

pkg/runner/job_executor_test.go

@@ -13,6 +13,7 @@ import (
 	"gitea.com/gitea/act_runner/pkg/model"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestJobExecutor(t *testing.T) {
@@ -324,7 +325,7 @@ func TestNewJobExecutor(t *testing.T) {
 
 			executor := newJobExecutor(jim, sfm, rc)
 			err := executor(ctx)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			assert.Equal(t, tt.executedSteps, executorOrder)
 
 			jim.AssertExpectations(t)

pkg/runner/run_context_test.go

@@ -16,6 +16,7 @@ import (
 
 	log "github.com/sirupsen/logrus"
 	assert "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	yaml "gopkg.in/yaml.v3"
 )
 
@@ -25,7 +26,7 @@ func TestRunContext_EvalBool(t *testing.T) {
 		"os":  {"Linux", "Windows"},
 		"foo": {"bar", "baz"},
 	})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	rc := &RunContext{
 		Config: &Config{
@@ -310,7 +311,7 @@ func TestRunContext_GetBindsAndMounts(t *testing.T) {
 				err := job.RawContainer.Encode(map[string][]string{
 					"volumes": testcase.volumes,
 				})
-				assert.NoError(t, err)
+				require.NoError(t, err)
 
 				rc := &RunContext{
 					Name: "TestRCName",
@@ -345,7 +346,7 @@ func TestGetGitHubContext(t *testing.T) {
 	log.SetLevel(log.DebugLevel)
 
 	cwd, err := os.Getwd()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	rc := &RunContext{
 		Config: &Config{
@@ -401,7 +402,7 @@ func TestGetGitHubContextOverlay(t *testing.T) {
 	log.SetLevel(log.DebugLevel)
 
 	cwd, err := os.Getwd()
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	rc := &RunContext{
 		Config: &Config{
@@ -511,7 +512,7 @@ func createIfTestRunContext(jobs map[string]*model.Job) *RunContext {
 func createJob(t *testing.T, input string, result string) *model.Job {
 	var job *model.Job
 	err := yaml.Unmarshal([]byte(input), &job)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	job.Result = result
 
 	return job
@@ -748,7 +749,7 @@ func TestSetRuntimeVariables(t *testing.T) {
 
 	tkn, _, err := jwt.NewParser().ParseUnverified(runtimeToken, jwt.MapClaims{})
 	assert.NotNil(t, tkn)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestSetRuntimeVariablesWithRunID(t *testing.T) {
@@ -773,7 +774,7 @@ func TestSetRuntimeVariablesWithRunID(t *testing.T) {
 	claims := jwt.MapClaims{}
 	tkn, _, err := jwt.NewParser().ParseUnverified(runtimeToken, &claims)
 	assert.NotNil(t, tkn)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	scp, ok := claims["scp"]
 	assert.True(t, ok, "scp claim exists")
 	assert.Equal(t, "Actions.Results:45:45", scp, "contains expected scp claim")

pkg/runner/runner_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/joho/godotenv"
 	log "github.com/sirupsen/logrus"
 	assert "github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 
 	"gitea.com/gitea/act_runner/pkg/common"
@@ -58,7 +59,7 @@ func init() {
 
 func TestNoWorkflowsFoundByPlanner(t *testing.T) {
 	planner, err := model.NewWorkflowPlanner("hashfiles", model.PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	out := log.StandardLogger().Out
 	var buf bytes.Buffer
@@ -66,19 +67,19 @@ func TestNoWorkflowsFoundByPlanner(t *testing.T) {
 	log.SetLevel(log.DebugLevel)
 	plan, err := planner.PlanEvent("pull_request")
 	assert.NotNil(t, plan)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Contains(t, buf.String(), "no workflows found by planner")
 	buf.Reset()
 	plan, err = planner.PlanAll()
 	assert.NotNil(t, plan)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Contains(t, buf.String(), "no workflows found by planner")
 	log.SetOutput(out)
 }
 
 func TestGraphMissingEvent(t *testing.T) {
 	planner, err := model.NewWorkflowPlanner("testdata/issue-1595/no-event.yml", model.PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	out := log.StandardLogger().Out
 	var buf bytes.Buffer
@@ -86,7 +87,7 @@ func TestGraphMissingEvent(t *testing.T) {
 	log.SetLevel(log.DebugLevel)
 
 	plan, err := planner.PlanEvent("push")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, plan)
 	assert.Empty(t, plan.Stages)
 
@@ -96,7 +97,7 @@ func TestGraphMissingEvent(t *testing.T) {
 
 func TestGraphMissingFirst(t *testing.T) {
 	planner, err := model.NewWorkflowPlanner("testdata/issue-1595/no-first.yml", model.PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	plan, err := planner.PlanEvent("push")
 	assert.EqualError(t, err, "unable to build dependency graph for no first (no-first.yml)")
@@ -106,7 +107,7 @@ func TestGraphMissingFirst(t *testing.T) {
 
 func TestGraphWithMissing(t *testing.T) {
 	planner, err := model.NewWorkflowPlanner("testdata/issue-1595/missing.yml", model.PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	out := log.StandardLogger().Out
 	var buf bytes.Buffer
@@ -125,7 +126,7 @@ func TestGraphWithSomeMissing(t *testing.T) {
 	log.SetLevel(log.DebugLevel)
 
 	planner, err := model.NewWorkflowPlanner("testdata/issue-1595/", model.PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	out := log.StandardLogger().Out
 	var buf bytes.Buffer
@@ -143,10 +144,10 @@ func TestGraphWithSomeMissing(t *testing.T) {
 
 func TestGraphEvent(t *testing.T) {
 	planner, err := model.NewWorkflowPlanner("testdata/basic", model.PlannerConfig{})
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	plan, err := planner.PlanEvent("push")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, plan)
 	assert.NotNil(t, plan.Stages)
 	assert.Len(t, plan.Stages, 3, "stages")
@@ -158,7 +159,7 @@ func TestGraphEvent(t *testing.T) {
 	assert.Equal(t, "test", plan.Stages[2].Runs[0].JobID, "jobid")
 
 	plan, err = planner.PlanEvent("release")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.NotNil(t, plan)
 	assert.Empty(t, plan.Stages)
 }
@@ -178,7 +179,7 @@ func (j *TestJobFileInfo) runTest(ctx context.Context, t *testing.T, cfg *Config
 	log.SetLevel(logLevel)
 
 	workdir, err := filepath.Abs(j.workdir)
-	assert.NoError(t, err, workdir)
+	require.NoError(t, err, workdir)
 
 	fullWorkflowPath := filepath.Join(workdir, j.workflowPath)
 	runnerConfig := &Config{
@@ -199,18 +200,18 @@ func (j *TestJobFileInfo) runTest(ctx context.Context, t *testing.T, cfg *Config
 	}
 
 	runner, err := New(runnerConfig)
-	assert.NoError(t, err, j.workflowPath)
+	require.NoError(t, err, j.workflowPath)
 
 	planner, err := model.NewWorkflowPlanner(fullWorkflowPath, model.PlannerConfig{})
 	if j.errorMessage != "" && err != nil {
 		assert.Error(t, err, j.errorMessage)
-	} else if assert.NoError(t, err, fullWorkflowPath) {
+	} else if require.NoError(t, err, fullWorkflowPath) {
 		plan, err := planner.PlanEvent(j.eventName)
 		assert.NotEqual(t, (err == nil), (plan == nil), "PlanEvent should return either a plan or an error")
 		if err == nil && plan != nil {
 			err = runner.NewPlanExecutor(plan)(ctx)
 			if j.errorMessage == "" {
-				assert.NoError(t, err, fullWorkflowPath)
+				require.NoError(t, err, fullWorkflowPath)
 			} else {
 				assert.Error(t, err, j.errorMessage)
 			}
@@ -780,9 +781,9 @@ func TestRunEventSecrets(t *testing.T) {
 	}
 
 	env, err := godotenv.Read(filepath.Join(workdir, workflowPath, ".env"))
-	assert.NoError(t, err, "Failed to read .env")
+	require.NoError(t, err, "Failed to read .env")
 	secrets, _ := godotenv.Read(filepath.Join(workdir, workflowPath, ".secrets"))
-	assert.NoError(t, err, "Failed to read .secrets")
+	require.NoError(t, err, "Failed to read .secrets")
 
 	tjfi.runTest(context.Background(), t, &Config{Secrets: secrets, Env: env})
 }

pkg/runner/step_action_local_test.go

@@ -11,6 +11,7 @@ import (
 	"gitea.com/gitea/act_runner/pkg/model"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 )
 
@@ -92,10 +93,10 @@ func TestStepActionLocalTest(t *testing.T) {
 	})
 
 	err := sal.pre()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = sal.main()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cm.AssertExpectations(t)
 	salm.AssertExpectations(t)

pkg/runner/step_action_remote_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 
 	"gitea.com/gitea/act_runner/pkg/common"
@@ -290,7 +291,7 @@ func TestStepActionRemotePre(t *testing.T) {
 
 			err := sar.pre()(ctx)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			sarm.AssertExpectations(t)
 			cacheMock.AssertExpectations(t)
@@ -343,7 +344,7 @@ func TestStepActionRemotePreThroughAction(t *testing.T) {
 
 			err := sar.pre()(ctx)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			sarm.AssertExpectations(t)
 			cacheMock.AssertExpectations(t)
@@ -397,7 +398,7 @@ func TestStepActionRemotePreThroughActionToken(t *testing.T) {
 
 			err := sar.pre()(ctx)
 
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			sarm.AssertExpectations(t)
 			cacheMock.AssertExpectations(t)

pkg/runner/step_docker_test.go

@@ -10,6 +10,7 @@ import (
 	"gitea.com/gitea/act_runner/pkg/model"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStepDockerMain(t *testing.T) {
@@ -97,7 +98,7 @@ func TestStepDockerMain(t *testing.T) {
 	cm.On("GetContainerArchive", ctx, "/var/run/act/workflow/pathcmd.txt").Return(io.NopCloser(&bytes.Buffer{}), nil)
 
 	err := sd.main()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	assert.Equal(t, "node:14", input.Image)
 
@@ -109,8 +110,8 @@ func TestStepDockerPrePost(t *testing.T) {
 	sd := &stepDocker{}
 
 	err := sd.pre()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = sd.post()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

pkg/runner/step_factory_test.go

@@ -5,6 +5,7 @@ import (
 
 	"gitea.com/gitea/act_runner/pkg/model"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStepFactoryNewStep(t *testing.T) {
@@ -62,7 +63,7 @@ func TestStepFactoryNewStep(t *testing.T) {
 			step, err := sf.newStep(tt.model, &RunContext{})
 
 			assert.True(t, tt.check((step)))
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		})
 	}
 }

pkg/runner/step_run_test.go

@@ -6,8 +6,8 @@ import (
 	"io"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 
 	"gitea.com/gitea/act_runner/pkg/container"
 	"gitea.com/gitea/act_runner/pkg/model"
@@ -78,7 +78,7 @@ func TestStepRun(t *testing.T) {
 	cm.On("GetContainerArchive", ctx, "/var/run/act/workflow/pathcmd.txt").Return(io.NopCloser(&bytes.Buffer{}), nil)
 
 	err := sr.main()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	cm.AssertExpectations(t)
 }
@@ -88,8 +88,8 @@ func TestStepRunPrePost(t *testing.T) {
 	sr := &stepRun{}
 
 	err := sr.pre()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	err = sr.post()(ctx)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

pkg/runner/step_test.go

@@ -9,6 +9,7 @@ import (
 	log "github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 	yaml "gopkg.in/yaml.v3"
 )
 
@@ -152,7 +153,7 @@ func TestSetupEnv(t *testing.T) {
 	sm.On("getEnv").Return(&env)
 
 	err := setupEnv(context.Background(), sm)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	// These are commit or system specific
 	delete((env), "GITHUB_REF")
@@ -198,7 +199,7 @@ func TestIsStepEnabled(t *testing.T) {
 	createTestStep := func(t *testing.T, input string) step {
 		var step *model.Step
 		err := yaml.Unmarshal([]byte(input), &step)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		return &stepRun{
 			RunContext: &RunContext{
@@ -280,7 +281,7 @@ func TestIsContinueOnError(t *testing.T) {
 	createTestStep := func(t *testing.T, input string) step {
 		var step *model.Step
 		err := yaml.Unmarshal([]byte(input), &step)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 
 		return &stepRun{
 			RunContext: &RunContext{
@@ -365,7 +366,7 @@ func TestSymlinkJoin(t *testing.T) {
 	for _, entry := range table {
 		result, err := symlinkJoin(entry.from, entry.target, entry.root...)
 		if entry.err == "" {
-			assert.NoError(t, err)
+			require.NoError(t, err)
 		} else {
 			assert.Error(t, err, entry.err)
 		}

pkg/schema/gitea_schema_test.go

@@ -5,7 +5,7 @@ import (
 	"os"
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGiteaSchemaFactory(t *testing.T) {
@@ -13,7 +13,7 @@ func TestGiteaSchemaFactory(t *testing.T) {
 	_ = schema
 
 	data, err := json.MarshalIndent(schema, "", "  ")
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	err = os.WriteFile("gitea_workflow_schema.json", append(data, "\n"...), 0o600)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }

pkg/schema/schema_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"gopkg.in/yaml.v3"
 )
 
@@ -18,14 +19,14 @@ jobs:
     steps:
     - run: exit 0
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
 		Definition: "workflow-root-strict",
 		Schema:     GetWorkflowSchema(),
 	}).UnmarshalYAML(&node)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestAdditionalFunctionsFailure(t *testing.T) {
@@ -39,7 +40,7 @@ jobs:
     steps:
     - run: exit 0
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
@@ -60,14 +61,14 @@ jobs:
     - run: exit 0
       if: success() || failure() || always()
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
 		Definition: "workflow-root-strict",
 		Schema:     GetWorkflowSchema(),
 	}).UnmarshalYAML(&node)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestAdditionalFunctionsStepsExprSyntax(t *testing.T) {
@@ -81,14 +82,14 @@ jobs:
     - run: exit 0
       if: ${{ success() || failure() || always() }}
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
 		Definition: "workflow-root-strict",
 		Schema:     GetWorkflowSchema(),
 	}).UnmarshalYAML(&node)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestFailure(t *testing.T) {
@@ -100,7 +101,7 @@ jobs:
     runs-on: self-hosted
     x: failure
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
@@ -119,7 +120,7 @@ jobs:
     runs-on: self-hosted
     Runs-on: failure
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
@@ -139,14 +140,14 @@ jobs:
     steps:
     - run: exit 0
 `), &node)
-	if !assert.NoError(t, err) {
+	if !require.NoError(t, err) {
 		return
 	}
 	err = (&Node{
 		Definition: "workflow-root-strict",
 		Schema:     GetWorkflowSchema(),
 	}).UnmarshalYAML(&node)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 }
 
 func TestSchemaErrors(t *testing.T) {
@@ -208,7 +209,7 @@ jobs:
 		t.Run(test.name, func(t *testing.T) {
 			var node yaml.Node
 			err := yaml.Unmarshal([]byte(test.input), &node)
-			if !assert.NoError(t, err) {
+			if !require.NoError(t, err) {
 				return
 			}
 			err = (&Node{
@@ -218,7 +219,7 @@ jobs:
 			if test.err != "" {
 				assert.ErrorContains(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 		})
 	}
@@ -246,7 +247,7 @@ runs:
 		t.Run(test.name, func(t *testing.T) {
 			var node yaml.Node
 			err := yaml.Unmarshal([]byte(test.input), &node)
-			if !assert.NoError(t, err) {
+			if !require.NoError(t, err) {
 				return
 			}
 			err = (&Node{
@@ -256,7 +257,7 @@ runs:
 			if test.err != "" {
 				assert.ErrorContains(t, err, test.err)
 			} else {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			}
 		})
 	}

pkg/workflowpattern/workflow_pattern_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMatchPattern(t *testing.T) {
@@ -405,7 +406,7 @@ func TestMatchPattern(t *testing.T) {
 	for _, kase := range kases {
 		t.Run(strings.Join(kase.patterns, ","), func(t *testing.T) {
 			patterns, err := CompilePatterns(kase.patterns...)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 
 			assert.Equal(t, kase.skipResult, Skip(patterns, kase.inputs, &StdOutTraceWriter{}), "skipResult")
 			assert.Equal(t, kase.filterResult, Filter(patterns, kase.inputs, &StdOutTraceWriter{}), "filterResult")