Use assert for tests

cli/internal/util_test.go

@@ -14,21 +14,20 @@
 
 package internal
 
-import "testing"
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
 
 func TestParseKeyPair(t *testing.T) {
 	s := []string{"FOO=bar", "BAR=", "BAZ=qux=quux", "INVALID"}
 	p := ParseKeyPair(s)
-	if p["FOO"] != "bar" {
-		t.Errorf("Wanted %q, got %q.", "bar", p["FOO"])
-	}
-	if p["BAZ"] != "qux=quux" {
-		t.Errorf("Wanted %q, got %q.", "qux=quux", p["BAZ"])
-	}
-	if _, exists := p["BAR"]; !exists {
-		t.Error("Missing a key with no value. Keys with empty values are also valid.")
-	}
-	if _, exists := p["INVALID"]; exists {
-		t.Error("Keys without an equal sign suffix are invalid.")
-	}
+	assert.Equal(t, "bar", p["FOO"])
+	assert.Equal(t, "qux=quux", p["BAZ"])
+	val, exists := p["BAR"]
+	assert.Empty(t, val)
+	assert.True(t, exists, "missing a key with no value, keys with empty values are also valid")
+	_, exists = p["INVALID"]
+	assert.False(t, exists, "keys without an equal sign suffix are invalid")
 }

cmd/agent/config_test.go

@@ -28,14 +28,14 @@ func TestReadAgentIDFileNotExists(t *testing.T) {
 func TestReadAgentIDFileExists(t *testing.T) {
 	tmpF, errTmpF := os.CreateTemp("", "tmp_")
 	if !assert.NoError(t, errTmpF) {
-		t.FailNow()
+		return
 	}
 	defer os.Remove(tmpF.Name())
 
 	// there is an existing config
 	errWrite := os.WriteFile(tmpF.Name(), []byte(`{"agent_id":3}`), 0o644)
 	if !assert.NoError(t, errWrite) {
-		t.FailNow()
+		return
 	}
 
 	// read existing config
@@ -50,7 +50,7 @@ func TestReadAgentIDFileExists(t *testing.T) {
 
 	tmpF2, errTmpF := os.CreateTemp("", "tmp_")
 	if !assert.NoError(t, errTmpF) {
-		t.FailNow()
+		return
 	}
 	defer os.Remove(tmpF2.Name())
 

cmd/agent/health_test.go

@@ -18,6 +18,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+
 	"go.woodpecker-ci.org/woodpecker/v2/agent"
 )
 
@@ -27,35 +29,23 @@ func TestHealthy(t *testing.T) {
 
 	s.Add("1", time.Hour, "octocat/hello-world", "42")
 
-	if got, want := s.Metadata["1"].ID, "1"; got != want {
-		t.Errorf("got ID %s, want %s", got, want)
-	}
-	if got, want := s.Metadata["1"].Timeout, time.Hour; got != want {
-		t.Errorf("got duration %v, want %v", got, want)
-	}
-	if got, want := s.Metadata["1"].Repo, "octocat/hello-world"; got != want {
-		t.Errorf("got repository name %s, want %s", got, want)
-	}
+	assert.Equal(t, "1", s.Metadata["1"].ID)
+	assert.Equal(t, time.Hour, s.Metadata["1"].Timeout)
+	assert.Equal(t, "octocat/hello-world", s.Metadata["1"].Repo)
 
 	s.Metadata["1"] = agent.Info{
 		Timeout: time.Hour,
 		Started: time.Now().UTC(),
 	}
-	if s.Healthy() == false {
-		t.Error("want healthy status when timeout not exceeded, got false")
-	}
+	assert.True(t, s.Healthy(), "want healthy status when timeout not exceeded, got false")
 
 	s.Metadata["1"] = agent.Info{
 		Started: time.Now().UTC().Add(-(time.Minute * 30)),
 	}
-	if s.Healthy() == false {
-		t.Error("want healthy status when timeout+buffer not exceeded, got false")
-	}
+	assert.True(t, s.Healthy(), "want healthy status when timeout+buffer not exceeded, got false")
 
 	s.Metadata["1"] = agent.Info{
 		Started: time.Now().UTC().Add(-(time.Hour + time.Minute)),
 	}
-	if s.Healthy() == true {
-		t.Error("want unhealthy status when timeout+buffer not exceeded, got true")
-	}
+	assert.False(t, s.Healthy(), "want unhealthy status when timeout+buffer not exceeded, got true")
 }

pipeline/backend/docker/convert_test.go

@@ -86,9 +86,7 @@ func TestSplitVolumeParts(t *testing.T) {
 	for _, test := range testdata {
 		results, err := splitVolumeParts(test.from)
 		if test.success != (err == nil) {
-			if reflect.DeepEqual(results, test.to) != test.success {
-				t.Errorf("Expect %q matches %q is %v", test.from, results, test.to)
-			}
+			assert.Equal(t, test.success, reflect.DeepEqual(results, test.to))
 		}
 	}
 }

pipeline/error_test.go

@@ -16,25 +16,21 @@ package pipeline
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestExitError(t *testing.T) {
 	err := ExitError{
 		UUID: "14534321",
 		Code: 255,
 	}
-	got, want := err.Error(), "uuid=14534321: exit code 255"
-	if got != want {
-		t.Errorf("Want error message %q, got %q", want, got)
-	}
+	assert.Equal(t, "uuid=14534321: exit code 255", err.Error())
 }
 
 func TestOomError(t *testing.T) {
 	err := OomError{
 		UUID: "14534321",
 	}
-	got, want := err.Error(), "uuid=14534321: received oom kill"
-	if got != want {
-		t.Errorf("Want error message %q, got %q", want, got)
-	}
+	assert.Equal(t, "uuid=14534321: received oom kill", err.Error())
 }

pipeline/errors/error_test.go

@@ -151,8 +151,6 @@ func TestHasBlockingErrors(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		if pipeline_errors.HasBlockingErrors(test.err) != test.expected {
-			t.Error("Should only return true if there are blocking errors")
-		}
+		assert.Equal(t, test.expected, pipeline_errors.HasBlockingErrors(test.err))
 	}
 }

pipeline/frontend/yaml/compiler/option_test.go

@@ -15,9 +15,10 @@
 package compiler
 
 import (
-	"reflect"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+
 	"go.woodpecker-ci.org/woodpecker/v2/pipeline/frontend/metadata"
 )
 
@@ -28,12 +29,8 @@ func TestWithWorkspace(t *testing.T) {
 			"src/github.com/octocat/hello-world",
 		),
 	)
-	if compiler.base != "/pipeline" {
-		t.Errorf("WithWorkspace must set the base directory")
-	}
-	if compiler.path != "src/github.com/octocat/hello-world" {
-		t.Errorf("WithWorkspace must set the path directory")
-	}
+	assert.Equal(t, "/pipeline", compiler.base)
+	assert.Equal(t, "src/github.com/octocat/hello-world", compiler.path)
 }
 
 func TestWithEscalated(t *testing.T) {
@@ -43,9 +40,8 @@ func TestWithEscalated(t *testing.T) {
 			"docker-dev",
 		),
 	)
-	if compiler.escalated[0] != "docker" || compiler.escalated[1] != "docker-dev" {
-		t.Errorf("WithEscalated must whitelist privileged images")
-	}
+	assert.Equal(t, "docker", compiler.escalated[0])
+	assert.Equal(t, "docker-dev", compiler.escalated[1])
 }
 
 func TestWithVolumes(t *testing.T) {
@@ -55,9 +51,8 @@ func TestWithVolumes(t *testing.T) {
 			"/foo:/foo",
 		),
 	)
-	if compiler.volumes[0] != "/tmp:/tmp" || compiler.volumes[1] != "/foo:/foo" {
-		t.Errorf("TestWithVolumes must set default volumes")
-	}
+	assert.Equal(t, "/tmp:/tmp", compiler.volumes[0])
+	assert.Equal(t, "/foo:/foo", compiler.volumes[1])
 }
 
 func TestWithNetworks(t *testing.T) {
@@ -67,9 +62,8 @@ func TestWithNetworks(t *testing.T) {
 			"overlay_bar",
 		),
 	)
-	if compiler.networks[0] != "overlay_1" || compiler.networks[1] != "overlay_bar" {
-		t.Errorf("TestWithNetworks must set networks from parameters")
-	}
+	assert.Equal(t, "overlay_1", compiler.networks[0])
+	assert.Equal(t, "overlay_bar", compiler.networks[1])
 }
 
 func TestWithResourceLimit(t *testing.T) {
@@ -83,30 +77,16 @@ func TestWithResourceLimit(t *testing.T) {
 			"0,2-5",
 		),
 	)
-	if compiler.reslimit.MemSwapLimit != 1 {
-		t.Errorf("TestWithResourceLimit must set MemSwapLimit from parameters")
-	}
-	if compiler.reslimit.MemLimit != 2 {
-		t.Errorf("TestWithResourceLimit must set MemLimit from parameters")
-	}
-	if compiler.reslimit.ShmSize != 3 {
-		t.Errorf("TestWithResourceLimit must set ShmSize from parameters")
-	}
-	if compiler.reslimit.CPUQuota != 4 {
-		t.Errorf("TestWithResourceLimit must set CPUQuota from parameters")
-	}
-	if compiler.reslimit.CPUShares != 5 {
-		t.Errorf("TestWithResourceLimit must set CPUShares from parameters")
-	}
-	if compiler.reslimit.CPUSet != "0,2-5" {
-		t.Errorf("TestWithResourceLimit must set CPUSet from parameters")
-	}
+	assert.EqualValues(t, 1, compiler.reslimit.MemSwapLimit)
+	assert.EqualValues(t, 2, compiler.reslimit.MemLimit)
+	assert.EqualValues(t, 3, compiler.reslimit.ShmSize)
+	assert.EqualValues(t, 4, compiler.reslimit.CPUQuota)
+	assert.EqualValues(t, 5, compiler.reslimit.CPUShares)
+	assert.Equal(t, "0,2-5", compiler.reslimit.CPUSet)
 }
 
 func TestWithPrefix(t *testing.T) {
-	if New(WithPrefix("someprefix_")).prefix != "someprefix_" {
-		t.Errorf("WithPrefix must set the prefix")
-	}
+	assert.Equal(t, "someprefix_", New(WithPrefix("someprefix_")).prefix)
 }
 
 func TestWithMetadata(t *testing.T) {
@@ -122,28 +102,16 @@ func TestWithMetadata(t *testing.T) {
 	compiler := New(
 		WithMetadata(metadata),
 	)
-	if !reflect.DeepEqual(compiler.metadata, metadata) {
-		t.Errorf("WithMetadata must set compiler the metadata")
-	}
 
-	if compiler.env["CI_REPO_NAME"] != metadata.Repo.Name {
-		t.Errorf("WithMetadata must set CI_REPO_NAME")
-	}
-	if compiler.env["CI_REPO_URL"] != metadata.Repo.ForgeURL {
-		t.Errorf("WithMetadata must set CI_REPO_URL")
-	}
-	if compiler.env["CI_REPO_CLONE_URL"] != metadata.Repo.CloneURL {
-		t.Errorf("WithMetadata must set CI_REPO_CLONE_URL")
-	}
+	assert.Equal(t, metadata, compiler.metadata)
+	assert.Equal(t, metadata.Repo.Name, compiler.env["CI_REPO_NAME"])
+	assert.Equal(t, metadata.Repo.ForgeURL, compiler.env["CI_REPO_URL"])
+	assert.Equal(t, metadata.Repo.CloneURL, compiler.env["CI_REPO_CLONE_URL"])
 }
 
 func TestWithLocal(t *testing.T) {
-	if New(WithLocal(true)).local == false {
-		t.Errorf("WithLocal true must enable the local flag")
-	}
-	if New(WithLocal(false)).local == true {
-		t.Errorf("WithLocal false must disable the local flag")
-	}
+	assert.True(t, New(WithLocal(true)).local)
+	assert.False(t, New(WithLocal(false)).local)
 }
 
 func TestWithNetrc(t *testing.T) {
@@ -154,15 +122,9 @@ func TestWithNetrc(t *testing.T) {
 			"github.com",
 		),
 	)
-	if compiler.cloneEnv["CI_NETRC_USERNAME"] != "octocat" {
-		t.Errorf("WithNetrc should set CI_NETRC_USERNAME")
-	}
-	if compiler.cloneEnv["CI_NETRC_PASSWORD"] != "password" {
-		t.Errorf("WithNetrc should set CI_NETRC_PASSWORD")
-	}
-	if compiler.cloneEnv["CI_NETRC_MACHINE"] != "github.com" {
-		t.Errorf("WithNetrc should set CI_NETRC_MACHINE")
-	}
+	assert.Equal(t, "octocat", compiler.cloneEnv["CI_NETRC_USERNAME"])
+	assert.Equal(t, "password", compiler.cloneEnv["CI_NETRC_PASSWORD"])
+	assert.Equal(t, "github.com", compiler.cloneEnv["CI_NETRC_MACHINE"])
 }
 
 func TestWithProxy(t *testing.T) {
@@ -187,9 +149,7 @@ func TestWithProxy(t *testing.T) {
 		}),
 	)
 	for key, value := range testdata {
-		if compiler.env[key] != value {
-			t.Errorf("WithProxy should set %s=%s", key, value)
-		}
+		assert.Equal(t, value, compiler.env[key])
 	}
 }
 
@@ -202,54 +162,34 @@ func TestWithEnviron(t *testing.T) {
 			},
 		),
 	)
-	if compiler.env["RACK_ENV"] != "development" {
-		t.Errorf("WithEnviron should set RACK_ENV")
-	}
-	if compiler.env["SHOW"] != "true" {
-		t.Errorf("WithEnviron should set SHOW")
-	}
+	assert.Equal(t, "development", compiler.env["RACK_ENV"])
+	assert.Equal(t, "true", compiler.env["SHOW"])
 }
 
 func TestWithVolumeCacher(t *testing.T) {
 	compiler := New(
 		WithVolumeCacher("/cache"),
 	)
 	cacher, ok := compiler.cacher.(*volumeCacher)
-	if !ok {
-		t.Errorf("Expected volume cacher configured")
-	}
-	if got, want := cacher.base, "/cache"; got != want {
-		t.Errorf("Expected volume cacher with base %s, got %s", want, got)
-	}
+	assert.True(t, ok)
+	assert.Equal(t, "/cache", cacher.base)
 }
 
 func TestWithDefaultCloneImage(t *testing.T) {
 	compiler := New(
 		WithDefaultCloneImage("not-an-image"),
 	)
-	if compiler.defaultCloneImage != "not-an-image" {
-		t.Errorf("Expected default clone image 'not-an-image' not found")
-	}
+	assert.Equal(t, "not-an-image", compiler.defaultCloneImage)
 }
 
 func TestWithS3Cacher(t *testing.T) {
 	compiler := New(
 		WithS3Cacher("some-access-key", "some-secret-key", "some-region", "some-bucket"),
 	)
 	cacher, ok := compiler.cacher.(*s3Cacher)
-	if !ok {
-		t.Errorf("Expected s3 cacher configured")
-	}
-	if got, want := cacher.bucket, "some-bucket"; got != want {
-		t.Errorf("Expected s3 cacher with bucket %s, got %s", want, got)
-	}
-	if got, want := cacher.access, "some-access-key"; got != want {
-		t.Errorf("Expected s3 cacher with access key %s, got %s", want, got)
-	}
-	if got, want := cacher.region, "some-region"; got != want {
-		t.Errorf("Expected s3 cacher with region %s, got %s", want, got)
-	}
-	if got, want := cacher.secret, "some-secret-key"; got != want {
-		t.Errorf("Expected s3 cacher with secret key %s, got %s", want, got)
-	}
+	assert.True(t, ok)
+	assert.Equal(t, "some-bucket", cacher.bucket)
+	assert.Equal(t, "some-access-key", cacher.access)
+	assert.Equal(t, "some-region", cacher.region)
+	assert.Equal(t, "some-secret-key", cacher.secret)
 }