diff --git a/api/server/middleware/debug_test.go b/api/server/middleware/debug_test.go
index a467c4a442..cc227b3248 100644
--- a/api/server/middleware/debug_test.go
+++ b/api/server/middleware/debug_test.go
@@ -3,7 +3,8 @@ package middleware // import "github.com/docker/docker/api/server/middleware"
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestMaskSecretKeys(t *testing.T) {
@@ -53,6 +54,6 @@ func TestMaskSecretKeys(t *testing.T) {
for _, testcase := range tests {
maskSecretKeys(testcase.input, testcase.path)
- assert.Equal(t, testcase.expected, testcase.input)
+ assert.Check(t, is.DeepEqual(testcase.expected, testcase.input))
}
}
diff --git a/api/server/middleware/version_test.go b/api/server/middleware/version_test.go
index 37d22b5c46..f426acf0a3 100644
--- a/api/server/middleware/version_test.go
+++ b/api/server/middleware/version_test.go
@@ -7,7 +7,8 @@ import (
"testing"
"github.com/docker/docker/api/server/httputils"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -17,7 +18,7 @@ func TestVersionMiddlewareVersion(t *testing.T) {
expectedVersion := defaultVersion
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
v := httputils.VersionFromContext(ctx)
- assert.Equal(t, expectedVersion, v)
+ assert.Check(t, is.Equal(expectedVersion, v))
return nil
}
@@ -56,9 +57,9 @@ func TestVersionMiddlewareVersion(t *testing.T) {
err := h(ctx, resp, req, map[string]string{"version": test.reqVersion})
if test.errString != "" {
- assert.EqualError(t, err, test.errString)
+ assert.Check(t, is.Error(err, test.errString))
} else {
- assert.NoError(t, err)
+ assert.Check(t, err)
}
}
}
@@ -66,7 +67,7 @@ func TestVersionMiddlewareVersion(t *testing.T) {
func TestVersionMiddlewareWithErrorsReturnsHeaders(t *testing.T) {
handler := func(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
v := httputils.VersionFromContext(ctx)
- assert.NotEmpty(t, v)
+ assert.Check(t, len(v) != 0)
return nil
}
@@ -81,11 +82,11 @@ func TestVersionMiddlewareWithErrorsReturnsHeaders(t *testing.T) {
vars := map[string]string{"version": "0.1"}
err := h(ctx, resp, req, vars)
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
hdr := resp.Result().Header
- assert.Contains(t, hdr.Get("Server"), "Docker/"+defaultVersion)
- assert.Contains(t, hdr.Get("Server"), runtime.GOOS)
- assert.Equal(t, hdr.Get("API-Version"), defaultVersion)
- assert.Equal(t, hdr.Get("OSType"), runtime.GOOS)
+ assert.Check(t, is.Contains(hdr.Get("Server"), "Docker/"+defaultVersion))
+ assert.Check(t, is.Contains(hdr.Get("Server"), runtime.GOOS))
+ assert.Check(t, is.Equal(hdr.Get("API-Version"), defaultVersion))
+ assert.Check(t, is.Equal(hdr.Get("OSType"), runtime.GOOS))
}
diff --git a/api/types/filters/parse_test.go b/api/types/filters/parse_test.go
index b54ffa66ec..fbd9ae4fb1 100644
--- a/api/types/filters/parse_test.go
+++ b/api/types/filters/parse_test.go
@@ -4,8 +4,8 @@ import (
"errors"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestParseArgs(t *testing.T) {
@@ -22,10 +22,10 @@ func TestParseArgs(t *testing.T) {
for i := range flagArgs {
args, err = ParseFlag(flagArgs[i], args)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
- assert.Len(t, args.Get("created"), 1)
- assert.Len(t, args.Get("image.name"), 2)
+ assert.Check(t, is.Len(args.Get("created"), 1))
+ assert.Check(t, is.Len(args.Get("image.name"), 2))
}
func TestParseArgsEdgeCase(t *testing.T) {
@@ -231,7 +231,7 @@ func TestArgsMatch(t *testing.T) {
}
for args, field := range matches {
- assert.True(t, args.Match(field, source),
+ assert.Check(t, args.Match(field, source),
"Expected field %s to match %s", field, source)
}
@@ -255,8 +255,7 @@ func TestArgsMatch(t *testing.T) {
}
for args, field := range differs {
- assert.False(t, args.Match(field, source),
- "Expected field %s to not match %s", field, source)
+ assert.Check(t, !args.Match(field, source), "Expected field %s to not match %s", field, source)
}
}
diff --git a/builder/dockerfile/buildargs_test.go b/builder/dockerfile/buildargs_test.go
index c46dd7d49e..1ce841b404 100644
--- a/builder/dockerfile/buildargs_test.go
+++ b/builder/dockerfile/buildargs_test.go
@@ -4,7 +4,8 @@ import (
"bytes"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func strPtr(source string) *string {
@@ -39,7 +40,7 @@ func TestGetAllAllowed(t *testing.T) {
"ArgFromMeta": "frommeta1",
"ArgFromMetaOverridden": "fromdockerfile3",
}
- assert.Equal(t, expected, all)
+ assert.Check(t, is.DeepEqual(expected, all))
}
func TestGetAllMeta(t *testing.T) {
@@ -61,7 +62,7 @@ func TestGetAllMeta(t *testing.T) {
"ArgOverriddenByOptions": "fromopt2",
"ArgNoDefaultInMetaFromOptions": "fromopt3",
}
- assert.Equal(t, expected, all)
+ assert.Check(t, is.DeepEqual(expected, all))
}
func TestWarnOnUnusedBuildArgs(t *testing.T) {
@@ -80,7 +81,7 @@ func TestWarnOnUnusedBuildArgs(t *testing.T) {
assert.NotContains(t, out, "ThisArgIsUsed")
assert.NotContains(t, out, "HTTPS_PROXY")
assert.NotContains(t, out, "HTTP_PROXY")
- assert.Contains(t, out, "ThisArgIsNotUsed")
+ assert.Check(t, is.Contains(out, "ThisArgIsNotUsed"))
}
func TestIsUnreferencedBuiltin(t *testing.T) {
@@ -93,8 +94,8 @@ func TestIsUnreferencedBuiltin(t *testing.T) {
buildArgs.AddArg("ThisArgIsUsed", nil)
buildArgs.AddArg("HTTPS_PROXY", nil)
- assert.True(t, buildArgs.IsReferencedOrNotBuiltin("ThisArgIsUsed"))
- assert.True(t, buildArgs.IsReferencedOrNotBuiltin("ThisArgIsNotUsed"))
- assert.True(t, buildArgs.IsReferencedOrNotBuiltin("HTTPS_PROXY"))
- assert.False(t, buildArgs.IsReferencedOrNotBuiltin("HTTP_PROXY"))
+ assert.Check(t, buildArgs.IsReferencedOrNotBuiltin("ThisArgIsUsed"))
+ assert.Check(t, buildArgs.IsReferencedOrNotBuiltin("ThisArgIsNotUsed"))
+ assert.Check(t, buildArgs.IsReferencedOrNotBuiltin("HTTPS_PROXY"))
+ assert.Check(t, !buildArgs.IsReferencedOrNotBuiltin("HTTP_PROXY"))
}
diff --git a/builder/dockerfile/builder_test.go b/builder/dockerfile/builder_test.go
index a3a1f122f9..6c73b6cced 100644
--- a/builder/dockerfile/builder_test.go
+++ b/builder/dockerfile/builder_test.go
@@ -5,13 +5,14 @@ import (
"testing"
"github.com/docker/docker/builder/dockerfile/parser"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestAddNodesForLabelOption(t *testing.T) {
dockerfile := "FROM scratch"
result, err := parser.Parse(strings.NewReader(dockerfile))
- assert.NoError(t, err)
+ assert.Check(t, err)
labels := map[string]string{
"org.e": "cli-e",
@@ -27,8 +28,8 @@ func TestAddNodesForLabelOption(t *testing.T) {
"FROM scratch",
`LABEL "org.a"='cli-a' "org.b"='cli-b' "org.c"='cli-c' "org.d"='cli-d' "org.e"='cli-e'`,
}
- assert.Len(t, nodes.Children, 2)
+ assert.Check(t, is.Len(nodes.Children, 2))
for i, v := range nodes.Children {
- assert.Equal(t, expected[i], v.Original)
+ assert.Check(t, is.Equal(expected[i], v.Original))
}
}
diff --git a/builder/dockerfile/copy_test.go b/builder/dockerfile/copy_test.go
index da8e0711ac..f2f895387c 100644
--- a/builder/dockerfile/copy_test.go
+++ b/builder/dockerfile/copy_test.go
@@ -5,8 +5,9 @@ import (
"testing"
"github.com/docker/docker/pkg/containerfs"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/assert"
)
func TestIsExistingDirectory(t *testing.T) {
@@ -39,10 +40,10 @@ func TestIsExistingDirectory(t *testing.T) {
for _, testcase := range testcases {
result, err := isExistingDirectory(©Endpoint{driver: containerfs.NewLocalDriver(), path: testcase.path})
- if !assert.NoError(t, err) {
+ if !assert.Check(t, err) {
continue
}
- assert.Equal(t, testcase.expected, result, testcase.doc)
+ assert.Check(t, is.Equal(testcase.expected, result), testcase.doc)
}
}
@@ -142,6 +143,6 @@ func TestGetFilenameForDownload(t *testing.T) {
resp.Header.Add("Content-Disposition", testcase.disposition)
}
filename := getFilenameForDownload(testcase.path, &resp)
- assert.Equal(t, testcase.expected, filename)
+ assert.Check(t, is.Equal(testcase.expected, filename))
}
}
diff --git a/builder/dockerfile/dispatchers_test.go b/builder/dockerfile/dispatchers_test.go
index 6d52e7e619..988580cb15 100644
--- a/builder/dockerfile/dispatchers_test.go
+++ b/builder/dockerfile/dispatchers_test.go
@@ -16,8 +16,8 @@ import (
"github.com/docker/docker/image"
"github.com/docker/docker/pkg/system"
"github.com/docker/go-connections/nat"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func newBuilderWithMockBackend() *Builder {
@@ -49,13 +49,13 @@ func TestEnv2Variables(t *testing.T) {
},
}
err := dispatch(sb, envCommand)
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := []string{
"var1=val1",
"var2=val2",
}
- assert.Equal(t, expected, sb.state.runConfig.Env)
+ assert.Check(t, is.DeepEqual(expected, sb.state.runConfig.Env))
}
func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {
@@ -68,12 +68,12 @@ func TestEnvValueWithExistingRunConfigEnv(t *testing.T) {
},
}
err := dispatch(sb, envCommand)
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := []string{
"var1=val1",
"var2=fromenv",
}
- assert.Equal(t, expected, sb.state.runConfig.Env)
+ assert.Check(t, is.DeepEqual(expected, sb.state.runConfig.Env))
}
func TestMaintainer(t *testing.T) {
@@ -82,8 +82,8 @@ func TestMaintainer(t *testing.T) {
sb := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), newStagesBuildResults())
cmd := &instructions.MaintainerCommand{Maintainer: maintainerEntry}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- assert.Equal(t, maintainerEntry, sb.state.maintainer)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(maintainerEntry, sb.state.maintainer))
}
func TestLabel(t *testing.T) {
@@ -98,10 +98,10 @@ func TestLabel(t *testing.T) {
},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
- require.Contains(t, sb.state.runConfig.Labels, labelName)
- assert.Equal(t, sb.state.runConfig.Labels[labelName], labelValue)
+ assert.Assert(t, is.Contains(sb.state.runConfig.Labels, labelName))
+ assert.Check(t, is.Equal(sb.state.runConfig.Labels[labelName], labelValue))
}
func TestFromScratch(t *testing.T) {
@@ -113,22 +113,22 @@ func TestFromScratch(t *testing.T) {
err := initializeStage(sb, cmd)
if runtime.GOOS == "windows" && !system.LCOWSupported() {
- assert.EqualError(t, err, "Windows does not support FROM scratch")
+ assert.Check(t, is.Error(err, "Windows does not support FROM scratch"))
return
}
- require.NoError(t, err)
- assert.True(t, sb.state.hasFromImage())
- assert.Equal(t, "", sb.state.imageID)
+ assert.NilError(t, err)
+ assert.Check(t, sb.state.hasFromImage())
+ assert.Check(t, is.Equal("", sb.state.imageID))
expected := "PATH=" + system.DefaultPathEnv(runtime.GOOS)
- assert.Equal(t, []string{expected}, sb.state.runConfig.Env)
+ assert.Check(t, is.DeepEqual([]string{expected}, sb.state.runConfig.Env))
}
func TestFromWithArg(t *testing.T) {
tag, expected := ":sometag", "expectedthisid"
getImage := func(name string) (builder.Image, builder.ROLayer, error) {
- assert.Equal(t, "alpine"+tag, name)
+ assert.Check(t, is.Equal("alpine"+tag, name))
return &mockImage{id: "expectedthisid"}, nil, nil
}
b := newBuilderWithMockBackend()
@@ -146,21 +146,21 @@ func TestFromWithArg(t *testing.T) {
err := processMetaArg(metaArg, shell.NewLex('\\'), args)
sb := newDispatchRequest(b, '\\', nil, args, newStagesBuildResults())
- require.NoError(t, err)
+ assert.NilError(t, err)
err = initializeStage(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, expected, sb.state.imageID)
- assert.Equal(t, expected, sb.state.baseImage.ImageID())
- assert.Len(t, sb.state.buildArgs.GetAllAllowed(), 0)
- assert.Len(t, sb.state.buildArgs.GetAllMeta(), 1)
+ assert.Check(t, is.Equal(expected, sb.state.imageID))
+ assert.Check(t, is.Equal(expected, sb.state.baseImage.ImageID()))
+ assert.Check(t, is.Len(sb.state.buildArgs.GetAllAllowed(), 0))
+ assert.Check(t, is.Len(sb.state.buildArgs.GetAllMeta(), 1))
}
func TestFromWithUndefinedArg(t *testing.T) {
tag, expected := "sometag", "expectedthisid"
getImage := func(name string) (builder.Image, builder.ROLayer, error) {
- assert.Equal(t, "alpine", name)
+ assert.Check(t, is.Equal("alpine", name))
return &mockImage{id: "expectedthisid"}, nil, nil
}
b := newBuilderWithMockBackend()
@@ -173,8 +173,8 @@ func TestFromWithUndefinedArg(t *testing.T) {
BaseName: "alpine${THETAG}",
}
err := initializeStage(sb, cmd)
- require.NoError(t, err)
- assert.Equal(t, expected, sb.state.imageID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(expected, sb.state.imageID))
}
func TestFromMultiStageWithNamedStage(t *testing.T) {
@@ -185,13 +185,13 @@ func TestFromMultiStageWithNamedStage(t *testing.T) {
firstSB := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), previousResults)
secondSB := newDispatchRequest(b, '\\', nil, newBuildArgs(make(map[string]*string)), previousResults)
err := initializeStage(firstSB, firstFrom)
- require.NoError(t, err)
- assert.True(t, firstSB.state.hasFromImage())
+ assert.NilError(t, err)
+ assert.Check(t, firstSB.state.hasFromImage())
previousResults.indexed["base"] = firstSB.state.runConfig
previousResults.flat = append(previousResults.flat, firstSB.state.runConfig)
err = initializeStage(secondSB, secondFrom)
- require.NoError(t, err)
- assert.True(t, secondSB.state.hasFromImage())
+ assert.NilError(t, err)
+ assert.Check(t, secondSB.state.hasFromImage())
}
func TestOnbuild(t *testing.T) {
@@ -201,8 +201,8 @@ func TestOnbuild(t *testing.T) {
Expression: "ADD . /app/src",
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- assert.Equal(t, "ADD . /app/src", sb.state.runConfig.OnBuild[0])
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("ADD . /app/src", sb.state.runConfig.OnBuild[0]))
}
func TestWorkdir(t *testing.T) {
@@ -217,8 +217,8 @@ func TestWorkdir(t *testing.T) {
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- assert.Equal(t, workingDir, sb.state.runConfig.WorkingDir)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(workingDir, sb.state.runConfig.WorkingDir))
}
func TestCmd(t *testing.T) {
@@ -233,7 +233,7 @@ func TestCmd(t *testing.T) {
},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
var expectedCommand strslice.StrSlice
if runtime.GOOS == "windows" {
@@ -242,8 +242,8 @@ func TestCmd(t *testing.T) {
expectedCommand = strslice.StrSlice(append([]string{"/bin/sh"}, "-c", command))
}
- assert.Equal(t, expectedCommand, sb.state.runConfig.Cmd)
- assert.True(t, sb.state.cmdSet)
+ assert.Check(t, is.DeepEqual(expectedCommand, sb.state.runConfig.Cmd))
+ assert.Check(t, sb.state.cmdSet)
}
func TestHealthcheckNone(t *testing.T) {
@@ -255,10 +255,10 @@ func TestHealthcheckNone(t *testing.T) {
},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
- require.NotNil(t, sb.state.runConfig.Healthcheck)
- assert.Equal(t, []string{"NONE"}, sb.state.runConfig.Healthcheck.Test)
+ assert.Assert(t, sb.state.runConfig.Healthcheck != nil)
+ assert.Check(t, is.DeepEqual([]string{"NONE"}, sb.state.runConfig.Healthcheck.Test))
}
func TestHealthcheckCmd(t *testing.T) {
@@ -272,10 +272,10 @@ func TestHealthcheckCmd(t *testing.T) {
},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
- require.NotNil(t, sb.state.runConfig.Healthcheck)
- assert.Equal(t, expectedTest, sb.state.runConfig.Healthcheck.Test)
+ assert.Assert(t, sb.state.runConfig.Healthcheck != nil)
+ assert.Check(t, is.DeepEqual(expectedTest, sb.state.runConfig.Healthcheck.Test))
}
func TestEntrypoint(t *testing.T) {
@@ -290,8 +290,8 @@ func TestEntrypoint(t *testing.T) {
},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- require.NotNil(t, sb.state.runConfig.Entrypoint)
+ assert.NilError(t, err)
+ assert.Assert(t, sb.state.runConfig.Entrypoint != nil)
var expectedEntrypoint strslice.StrSlice
if runtime.GOOS == "windows" {
@@ -299,7 +299,7 @@ func TestEntrypoint(t *testing.T) {
} else {
expectedEntrypoint = strslice.StrSlice(append([]string{"/bin/sh"}, "-c", entrypointCmd))
}
- assert.Equal(t, expectedEntrypoint, sb.state.runConfig.Entrypoint)
+ assert.Check(t, is.DeepEqual(expectedEntrypoint, sb.state.runConfig.Entrypoint))
}
func TestExpose(t *testing.T) {
@@ -311,14 +311,14 @@ func TestExpose(t *testing.T) {
Ports: []string{exposedPort},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
- require.NotNil(t, sb.state.runConfig.ExposedPorts)
- require.Len(t, sb.state.runConfig.ExposedPorts, 1)
+ assert.Assert(t, sb.state.runConfig.ExposedPorts != nil)
+ assert.Assert(t, is.Len(sb.state.runConfig.ExposedPorts, 1))
portsMapping, err := nat.ParsePortSpec(exposedPort)
- require.NoError(t, err)
- assert.Contains(t, sb.state.runConfig.ExposedPorts, portsMapping[0].Port)
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(sb.state.runConfig.ExposedPorts, portsMapping[0].Port))
}
func TestUser(t *testing.T) {
@@ -329,8 +329,8 @@ func TestUser(t *testing.T) {
User: "test",
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- assert.Equal(t, "test", sb.state.runConfig.User)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("test", sb.state.runConfig.User))
}
func TestVolume(t *testing.T) {
@@ -343,10 +343,10 @@ func TestVolume(t *testing.T) {
Volumes: []string{exposedVolume},
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- require.NotNil(t, sb.state.runConfig.Volumes)
- assert.Len(t, sb.state.runConfig.Volumes, 1)
- assert.Contains(t, sb.state.runConfig.Volumes, exposedVolume)
+ assert.NilError(t, err)
+ assert.Assert(t, sb.state.runConfig.Volumes != nil)
+ assert.Check(t, is.Len(sb.state.runConfig.Volumes, 1))
+ assert.Check(t, is.Contains(sb.state.runConfig.Volumes, exposedVolume))
}
func TestStopSignal(t *testing.T) {
@@ -362,8 +362,8 @@ func TestStopSignal(t *testing.T) {
Signal: signal,
}
err := dispatch(sb, cmd)
- require.NoError(t, err)
- assert.Equal(t, signal, sb.state.runConfig.StopSignal)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(signal, sb.state.runConfig.StopSignal))
}
func TestArg(t *testing.T) {
@@ -374,10 +374,10 @@ func TestArg(t *testing.T) {
argVal := "bar"
cmd := &instructions.ArgCommand{Key: argName, Value: &argVal}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := map[string]string{argName: argVal}
- assert.Equal(t, expected, sb.state.buildArgs.GetAllAllowed())
+ assert.Check(t, is.DeepEqual(expected, sb.state.buildArgs.GetAllAllowed()))
}
func TestShell(t *testing.T) {
@@ -388,10 +388,10 @@ func TestShell(t *testing.T) {
cmd := &instructions.ShellCommand{Shell: strslice.StrSlice{shellCmd}}
err := dispatch(sb, cmd)
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedShell := strslice.StrSlice([]string{shellCmd})
- assert.Equal(t, expectedShell, sb.state.runConfig.Shell)
+ assert.Check(t, is.DeepEqual(expectedShell, sb.state.runConfig.Shell))
}
func TestPrependEnvOnCmd(t *testing.T) {
@@ -403,7 +403,7 @@ func TestPrependEnvOnCmd(t *testing.T) {
cmdWithEnv := prependEnvOnCmd(buildArgs, args, cmd)
expected := strslice.StrSlice([]string{
"|3", "NO_PROXY=YA", "args=not", "sorted=nope", "foo", "bar"})
- assert.Equal(t, expected, cmdWithEnv)
+ assert.Check(t, is.DeepEqual(expected, cmdWithEnv))
}
func TestRunWithBuildArgs(t *testing.T) {
@@ -422,8 +422,8 @@ func TestRunWithBuildArgs(t *testing.T) {
imageCache := &mockImageCache{
getCacheFunc: func(parentID string, cfg *container.Config) (string, error) {
// Check the runConfig.Cmd sent to probeCache()
- assert.Equal(t, cachedCmd, cfg.Cmd)
- assert.Equal(t, strslice.StrSlice(nil), cfg.Entrypoint)
+ assert.Check(t, is.DeepEqual(cachedCmd, cfg.Cmd))
+ assert.Check(t, is.DeepEqual(strslice.StrSlice(nil), cfg.Entrypoint))
return "", nil
},
}
@@ -441,21 +441,21 @@ func TestRunWithBuildArgs(t *testing.T) {
}
mockBackend.containerCreateFunc = func(config types.ContainerCreateConfig) (container.ContainerCreateCreatedBody, error) {
// Check the runConfig.Cmd sent to create()
- assert.Equal(t, cmdWithShell, config.Config.Cmd)
- assert.Contains(t, config.Config.Env, "one=two")
- assert.Equal(t, strslice.StrSlice{""}, config.Config.Entrypoint)
+ assert.Check(t, is.DeepEqual(cmdWithShell, config.Config.Cmd))
+ assert.Check(t, is.Contains(config.Config.Env, "one=two"))
+ assert.Check(t, is.DeepEqual(strslice.StrSlice{""}, config.Config.Entrypoint))
return container.ContainerCreateCreatedBody{ID: "12345"}, nil
}
mockBackend.commitFunc = func(cfg backend.CommitConfig) (image.ID, error) {
// Check the runConfig.Cmd sent to commit()
- assert.Equal(t, origCmd, cfg.Config.Cmd)
- assert.Equal(t, cachedCmd, cfg.ContainerConfig.Cmd)
- assert.Equal(t, strslice.StrSlice(nil), cfg.Config.Entrypoint)
+ assert.Check(t, is.DeepEqual(origCmd, cfg.Config.Cmd))
+ assert.Check(t, is.DeepEqual(cachedCmd, cfg.ContainerConfig.Cmd))
+ assert.Check(t, is.DeepEqual(strslice.StrSlice(nil), cfg.Config.Entrypoint))
return "", nil
}
from := &instructions.Stage{BaseName: "abcdef"}
err := initializeStage(sb, from)
- require.NoError(t, err)
+ assert.NilError(t, err)
sb.state.buildArgs.AddArg("one", strPtr("two"))
run := &instructions.RunCommand{
ShellDependantCmdLine: instructions.ShellDependantCmdLine{
@@ -463,8 +463,8 @@ func TestRunWithBuildArgs(t *testing.T) {
PrependShell: true,
},
}
- require.NoError(t, dispatch(sb, run))
+ assert.NilError(t, dispatch(sb, run))
// Check that runConfig.Cmd has not been modified by run
- assert.Equal(t, origCmd, sb.state.runConfig.Cmd)
+ assert.Check(t, is.DeepEqual(origCmd, sb.state.runConfig.Cmd))
}
diff --git a/builder/dockerfile/instructions/parse_test.go b/builder/dockerfile/instructions/parse_test.go
index ffd6d4f45c..b084ad11c7 100644
--- a/builder/dockerfile/instructions/parse_test.go
+++ b/builder/dockerfile/instructions/parse_test.go
@@ -7,8 +7,8 @@ import (
"github.com/docker/docker/builder/dockerfile/command"
"github.com/docker/docker/builder/dockerfile/parser"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestCommandsExactlyOneArgument(t *testing.T) {
@@ -21,9 +21,9 @@ func TestCommandsExactlyOneArgument(t *testing.T) {
for _, command := range commands {
ast, err := parser.Parse(strings.NewReader(command))
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = ParseInstruction(ast.AST.Children[0])
- assert.EqualError(t, err, errExactlyOneArgument(command).Error())
+ assert.Check(t, is.Error(err, errExactlyOneArgument(command).Error()))
}
}
@@ -39,9 +39,9 @@ func TestCommandsAtLeastOneArgument(t *testing.T) {
for _, command := range commands {
ast, err := parser.Parse(strings.NewReader(command))
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = ParseInstruction(ast.AST.Children[0])
- assert.EqualError(t, err, errAtLeastOneArgument(command).Error())
+ assert.Check(t, is.Error(err, errAtLeastOneArgument(command).Error()))
}
}
@@ -53,9 +53,9 @@ func TestCommandsNoDestinationArgument(t *testing.T) {
for _, command := range commands {
ast, err := parser.Parse(strings.NewReader(command + " arg1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = ParseInstruction(ast.AST.Children[0])
- assert.EqualError(t, err, errNoDestinationArgument(command).Error())
+ assert.Check(t, is.Error(err, errNoDestinationArgument(command).Error()))
}
}
@@ -80,7 +80,7 @@ func TestCommandsTooManyArguments(t *testing.T) {
},
}
_, err := ParseInstruction(node)
- assert.EqualError(t, err, errTooManyArguments(command).Error())
+ assert.Check(t, is.Error(err, errTooManyArguments(command).Error()))
}
}
@@ -102,7 +102,7 @@ func TestCommandsBlankNames(t *testing.T) {
},
}
_, err := ParseInstruction(node)
- assert.EqualError(t, err, errBlankCommandNames(command).Error())
+ assert.Check(t, is.Error(err, errBlankCommandNames(command).Error()))
}
}
@@ -120,11 +120,11 @@ func TestHealthCheckCmd(t *testing.T) {
},
}
cmd, err := ParseInstruction(node)
- assert.NoError(t, err)
+ assert.Check(t, err)
hc, ok := cmd.(*HealthCheckCommand)
- assert.True(t, ok)
+ assert.Check(t, ok)
expected := []string{"CMD-SHELL", "hello world"}
- assert.Equal(t, expected, hc.Health.Test)
+ assert.Check(t, is.DeepEqual(expected, hc.Health.Test))
}
func TestParseOptInterval(t *testing.T) {
@@ -138,7 +138,7 @@ func TestParseOptInterval(t *testing.T) {
flInterval.Value = "1ms"
_, err = parseOptInterval(flInterval)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestErrorCases(t *testing.T) {
diff --git a/builder/dockerfile/internals_linux_test.go b/builder/dockerfile/internals_linux_test.go
index 08067f8573..c244ddfe3f 100644
--- a/builder/dockerfile/internals_linux_test.go
+++ b/builder/dockerfile/internals_linux_test.go
@@ -6,8 +6,8 @@ import (
"testing"
"github.com/docker/docker/pkg/idtools"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestChownFlagParsing(t *testing.T) {
@@ -99,8 +99,8 @@ othergrp:x:6666:
} {
t.Run(testcase.name, func(t *testing.T) {
idPair, err := parseChownFlag(testcase.chownStr, contextDir, testcase.idMapping)
- require.NoError(t, err, "Failed to parse chown flag: %q", testcase.chownStr)
- assert.Equal(t, testcase.expected, idPair, "chown flag mapping failure")
+ assert.NilError(t, err, "Failed to parse chown flag: %q", testcase.chownStr)
+ assert.Check(t, is.DeepEqual(testcase.expected, idPair), "chown flag mapping failure")
})
}
@@ -132,7 +132,7 @@ othergrp:x:6666:
} {
t.Run(testcase.name, func(t *testing.T) {
_, err := parseChownFlag(testcase.chownStr, contextDir, testcase.idMapping)
- assert.EqualError(t, err, testcase.descr, "Expected error string doesn't match")
+ assert.Check(t, is.Error(err, testcase.descr), "Expected error string doesn't match")
})
}
}
diff --git a/builder/dockerfile/internals_test.go b/builder/dockerfile/internals_test.go
index 24103ecd8e..ae20026833 100644
--- a/builder/dockerfile/internals_test.go
+++ b/builder/dockerfile/internals_test.go
@@ -12,8 +12,8 @@ import (
"github.com/docker/docker/builder/remotecontext"
"github.com/docker/docker/pkg/archive"
"github.com/docker/go-connections/nat"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestEmptyDockerfile(t *testing.T) {
@@ -60,7 +60,7 @@ func TestNonExistingDockerfile(t *testing.T) {
func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath, expectedError string) {
tarStream, err := archive.Tar(contextDir, archive.Uncompressed)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer func() {
if err = tarStream.Close(); err != nil {
@@ -77,7 +77,7 @@ func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath,
Source: tarStream,
}
_, _, err = remotecontext.Detect(config)
- assert.EqualError(t, err, expectedError)
+ assert.Check(t, is.Error(err, expectedError))
}
func TestCopyRunConfig(t *testing.T) {
@@ -124,9 +124,9 @@ func TestCopyRunConfig(t *testing.T) {
Env: defaultEnv,
}
runConfigCopy := copyRunConfig(runConfig, testcase.modifiers...)
- assert.Equal(t, testcase.expected, runConfigCopy, testcase.doc)
+ assert.Check(t, is.DeepEqual(testcase.expected, runConfigCopy), testcase.doc)
// Assert the original was not modified
- assert.NotEqual(t, runConfig, runConfigCopy, testcase.doc)
+ assert.Check(t, runConfig != runConfigCopy, testcase.doc)
}
}
@@ -156,7 +156,7 @@ func fullMutableRunConfig() *container.Config {
func TestDeepCopyRunConfig(t *testing.T) {
runConfig := fullMutableRunConfig()
copy := copyRunConfig(runConfig)
- assert.Equal(t, fullMutableRunConfig(), copy)
+ assert.Check(t, is.DeepEqual(fullMutableRunConfig(), copy))
copy.Cmd[1] = "arg2"
copy.Env[1] = "env2=new"
@@ -166,5 +166,5 @@ func TestDeepCopyRunConfig(t *testing.T) {
copy.OnBuild[0] = "start"
copy.Labels["label3"] = "value3"
copy.Shell[0] = "sh"
- assert.Equal(t, fullMutableRunConfig(), runConfig)
+ assert.Check(t, is.DeepEqual(fullMutableRunConfig(), runConfig))
}
diff --git a/builder/dockerfile/internals_windows_test.go b/builder/dockerfile/internals_windows_test.go
index 08f394ac60..1fc55c0752 100644
--- a/builder/dockerfile/internals_windows_test.go
+++ b/builder/dockerfile/internals_windows_test.go
@@ -7,7 +7,8 @@ import (
"testing"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestNormalizeDest(t *testing.T) {
@@ -42,10 +43,10 @@ func TestNormalizeDest(t *testing.T) {
msg := fmt.Sprintf("Input: %s, %s", testcase.current, testcase.requested)
actual, err := normalizeDest(testcase.current, testcase.requested, "windows")
if testcase.etext == "" {
- if !assert.NoError(t, err, msg) {
+ if !assert.Check(t, err, msg) {
continue
}
- assert.Equal(t, testcase.expected, actual, msg)
+ assert.Check(t, is.Equal(testcase.expected, actual), msg)
} else {
testutil.ErrorContains(t, err, testcase.etext)
}
diff --git a/builder/dockerfile/parser/line_parsers_test.go b/builder/dockerfile/parser/line_parsers_test.go
index 8ce6a7ad6f..20369cad0b 100644
--- a/builder/dockerfile/parser/line_parsers_test.go
+++ b/builder/dockerfile/parser/line_parsers_test.go
@@ -3,25 +3,26 @@ package parser // import "github.com/docker/docker/builder/dockerfile/parser"
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestParseNameValOldFormat(t *testing.T) {
directive := Directive{}
node, err := parseNameVal("foo bar", "LABEL", &directive)
- assert.NoError(t, err)
+ assert.Check(t, err)
expected := &Node{
Value: "foo",
Next: &Node{Value: "bar"},
}
- assert.Equal(t, expected, node)
+ assert.Check(t, is.DeepEqual(expected, node))
}
func TestParseNameValNewFormat(t *testing.T) {
directive := Directive{}
node, err := parseNameVal("foo=bar thing=star", "LABEL", &directive)
- assert.NoError(t, err)
+ assert.Check(t, err)
expected := &Node{
Value: "foo",
@@ -35,7 +36,7 @@ func TestParseNameValNewFormat(t *testing.T) {
},
},
}
- assert.Equal(t, expected, node)
+ assert.Check(t, is.DeepEqual(expected, node))
}
func TestNodeFromLabels(t *testing.T) {
@@ -61,7 +62,7 @@ func TestNodeFromLabels(t *testing.T) {
}
node := NodeFromLabels(labels)
- assert.Equal(t, expected, node)
+ assert.Check(t, is.DeepEqual(expected, node))
}
@@ -70,5 +71,5 @@ func TestParseNameValWithoutVal(t *testing.T) {
// In Config.Env, a variable without `=` is removed from the environment. (#31634)
// However, in Dockerfile, we don't allow "unsetting" an environment variable. (#11922)
_, err := parseNameVal("foo", "ENV", &directive)
- assert.Error(t, err, "ENV must have two arguments")
+ assert.Check(t, is.ErrorContains(err, ""), "ENV must have two arguments")
}
diff --git a/builder/dockerfile/parser/parser_test.go b/builder/dockerfile/parser/parser_test.go
index 807ac1b097..10bed1f756 100644
--- a/builder/dockerfile/parser/parser_test.go
+++ b/builder/dockerfile/parser/parser_test.go
@@ -11,8 +11,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
const testDir = "testfiles"
@@ -21,11 +21,11 @@ const testFileLineInfo = "testfile-line/Dockerfile"
func getDirs(t *testing.T, dir string) []string {
f, err := os.Open(dir)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer f.Close()
dirs, err := f.Readdirnames(0)
- require.NoError(t, err)
+ assert.NilError(t, err)
return dirs
}
@@ -34,11 +34,11 @@ func TestParseErrorCases(t *testing.T) {
dockerfile := filepath.Join(negativeTestDir, dir, "Dockerfile")
df, err := os.Open(dockerfile)
- require.NoError(t, err, dockerfile)
+ assert.NilError(t, err, dockerfile)
defer df.Close()
_, err = Parse(df)
- assert.Error(t, err, dockerfile)
+ assert.Check(t, is.ErrorContains(err, ""), dockerfile)
}
}
@@ -48,20 +48,20 @@ func TestParseCases(t *testing.T) {
resultfile := filepath.Join(testDir, dir, "result")
df, err := os.Open(dockerfile)
- require.NoError(t, err, dockerfile)
+ assert.NilError(t, err, dockerfile)
defer df.Close()
result, err := Parse(df)
- require.NoError(t, err, dockerfile)
+ assert.NilError(t, err, dockerfile)
content, err := ioutil.ReadFile(resultfile)
- require.NoError(t, err, resultfile)
+ assert.NilError(t, err, resultfile)
if runtime.GOOS == "windows" {
// CRLF --> CR to match Unix behavior
content = bytes.Replace(content, []byte{'\x0d', '\x0a'}, []byte{'\x0a'}, -1)
}
- assert.Equal(t, result.AST.Dump()+"\n", string(content), "In "+dockerfile)
+ assert.Check(t, is.Equal(result.AST.Dump()+"\n", string(content)), "In "+dockerfile)
}
}
@@ -103,22 +103,22 @@ func TestParseWords(t *testing.T) {
for _, test := range tests {
words := parseWords(test["input"][0], NewDefaultDirective())
- assert.Equal(t, test["expect"], words)
+ assert.Check(t, is.DeepEqual(test["expect"], words))
}
}
func TestParseIncludesLineNumbers(t *testing.T) {
df, err := os.Open(testFileLineInfo)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer df.Close()
result, err := Parse(df)
- require.NoError(t, err)
+ assert.NilError(t, err)
ast := result.AST
- assert.Equal(t, 5, ast.StartLine)
- assert.Equal(t, 31, ast.endLine)
- assert.Len(t, ast.Children, 3)
+ assert.Check(t, is.Equal(5, ast.StartLine))
+ assert.Check(t, is.Equal(31, ast.endLine))
+ assert.Check(t, is.Len(ast.Children, 3))
expected := [][]int{
{5, 5},
{11, 12},
@@ -126,7 +126,7 @@ func TestParseIncludesLineNumbers(t *testing.T) {
}
for i, child := range ast.Children {
msg := fmt.Sprintf("Child %d", i)
- assert.Equal(t, expected[i], []int{child.StartLine, child.endLine}, msg)
+ assert.Check(t, is.DeepEqual(expected[i], []int{child.StartLine, child.endLine}), msg)
}
}
@@ -153,13 +153,13 @@ RUN indented \
`)
result, err := Parse(dockerfile)
- require.NoError(t, err)
+ assert.NilError(t, err)
warnings := result.Warnings
- assert.Len(t, warnings, 3)
- assert.Contains(t, warnings[0], "Empty continuation line found in")
- assert.Contains(t, warnings[0], "RUN something following more")
- assert.Contains(t, warnings[1], "RUN another thing")
- assert.Contains(t, warnings[2], "will become errors in a future release")
+ assert.Check(t, is.Len(warnings, 3))
+ assert.Check(t, is.Contains(warnings[0], "Empty continuation line found in"))
+ assert.Check(t, is.Contains(warnings[0], "RUN something following more"))
+ assert.Check(t, is.Contains(warnings[1], "RUN another thing"))
+ assert.Check(t, is.Contains(warnings[2], "will become errors in a future release"))
}
func TestParseReturnsScannerErrors(t *testing.T) {
@@ -170,5 +170,5 @@ func TestParseReturnsScannerErrors(t *testing.T) {
LABEL test=%s
`, label))
_, err := Parse(dockerfile)
- assert.EqualError(t, err, "dockerfile line greater than max allowed size of 65535")
+ assert.Check(t, is.Error(err, "dockerfile line greater than max allowed size of 65535"))
}
diff --git a/builder/dockerfile/shell/lex_test.go b/builder/dockerfile/shell/lex_test.go
index 6932a44e3d..7a726ad79b 100644
--- a/builder/dockerfile/shell/lex_test.go
+++ b/builder/dockerfile/shell/lex_test.go
@@ -7,7 +7,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestShellParser4EnvVars(t *testing.T) {
@@ -15,7 +16,7 @@ func TestShellParser4EnvVars(t *testing.T) {
lineCount := 0
file, err := os.Open(fn)
- assert.NoError(t, err)
+ assert.Check(t, err)
defer file.Close()
shlex := NewLex('\\')
@@ -37,7 +38,7 @@ func TestShellParser4EnvVars(t *testing.T) {
}
words := strings.Split(line, "|")
- assert.Len(t, words, 3)
+ assert.Check(t, is.Len(words, 3))
platform := strings.TrimSpace(words[0])
source := strings.TrimSpace(words[1])
@@ -52,10 +53,10 @@ func TestShellParser4EnvVars(t *testing.T) {
((platform == "U" || platform == "A") && runtime.GOOS != "windows") {
newWord, err := shlex.ProcessWord(source, envs)
if expected == "error" {
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
} else {
- assert.NoError(t, err)
- assert.Equal(t, newWord, expected)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(newWord, expected))
}
}
}
diff --git a/builder/fscache/fscache_test.go b/builder/fscache/fscache_test.go
index 7afee49ed5..613070f7b6 100644
--- a/builder/fscache/fscache_test.go
+++ b/builder/fscache/fscache_test.go
@@ -7,14 +7,15 @@ import (
"testing"
"time"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/moby/buildkit/session/filesync"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
func TestFSCache(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "fscache")
- assert.Nil(t, err)
+ assert.Check(t, err)
defer os.RemoveAll(tmpDir)
backend := NewNaiveCacheBackend(filepath.Join(tmpDir, "backend"))
@@ -26,84 +27,84 @@ func TestFSCache(t *testing.T) {
}
fscache, err := NewFSCache(opt)
- assert.Nil(t, err)
+ assert.Check(t, err)
defer fscache.Close()
err = fscache.RegisterTransport("test", &testTransport{})
- assert.Nil(t, err)
+ assert.Check(t, err)
src1, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo", "data", "bar"})
- assert.Nil(t, err)
+ assert.Check(t, err)
dt, err := ioutil.ReadFile(filepath.Join(src1.Root().Path(), "foo"))
- assert.Nil(t, err)
- assert.Equal(t, string(dt), "data")
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(string(dt), "data"))
// same id doesn't recalculate anything
src2, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo", "data2", "bar"})
- assert.Nil(t, err)
- assert.Equal(t, src1.Root().Path(), src2.Root().Path())
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(src1.Root().Path(), src2.Root().Path()))
dt, err = ioutil.ReadFile(filepath.Join(src1.Root().Path(), "foo"))
- assert.Nil(t, err)
- assert.Equal(t, string(dt), "data")
- assert.Nil(t, src2.Close())
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(string(dt), "data"))
+ assert.Check(t, src2.Close())
src3, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo2", "data2", "bar"})
- assert.Nil(t, err)
- assert.NotEqual(t, src1.Root().Path(), src3.Root().Path())
+ assert.Check(t, err)
+ assert.Check(t, src1.Root().Path() != src3.Root().Path())
dt, err = ioutil.ReadFile(filepath.Join(src3.Root().Path(), "foo2"))
- assert.Nil(t, err)
- assert.Equal(t, string(dt), "data2")
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(string(dt), "data2"))
s, err := fscache.DiskUsage()
- assert.Nil(t, err)
- assert.Equal(t, s, int64(0))
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(s, int64(0)))
- assert.Nil(t, src3.Close())
+ assert.Check(t, src3.Close())
s, err = fscache.DiskUsage()
- assert.Nil(t, err)
- assert.Equal(t, s, int64(5))
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(s, int64(5)))
// new upload with the same shared key shoutl overwrite
src4, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo3", "data3", "bar"})
- assert.Nil(t, err)
- assert.NotEqual(t, src1.Root().Path(), src3.Root().Path())
+ assert.Check(t, err)
+ assert.Check(t, src1.Root().Path() != src3.Root().Path())
dt, err = ioutil.ReadFile(filepath.Join(src3.Root().Path(), "foo3"))
- assert.Nil(t, err)
- assert.Equal(t, string(dt), "data3")
- assert.Equal(t, src4.Root().Path(), src3.Root().Path())
- assert.Nil(t, src4.Close())
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(string(dt), "data3"))
+ assert.Check(t, is.Equal(src4.Root().Path(), src3.Root().Path()))
+ assert.Check(t, src4.Close())
s, err = fscache.DiskUsage()
- assert.Nil(t, err)
- assert.Equal(t, s, int64(10))
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(s, int64(10)))
// this one goes over the GC limit
src5, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo4", "datadata", "baz"})
- assert.Nil(t, err)
- assert.Nil(t, src5.Close())
+ assert.Check(t, err)
+ assert.Check(t, src5.Close())
// GC happens async
time.Sleep(100 * time.Millisecond)
// only last insertion after GC
s, err = fscache.DiskUsage()
- assert.Nil(t, err)
- assert.Equal(t, s, int64(8))
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(s, int64(8)))
// prune deletes everything
released, err := fscache.Prune(context.TODO())
- assert.Nil(t, err)
- assert.Equal(t, released, uint64(8))
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(released, uint64(8)))
s, err = fscache.DiskUsage()
- assert.Nil(t, err)
- assert.Equal(t, s, int64(0))
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(s, int64(0)))
}
type testTransport struct {
diff --git a/builder/remotecontext/git/gitutils_test.go b/builder/remotecontext/git/gitutils_test.go
index 4f4d833508..cb2adb8c29 100644
--- a/builder/remotecontext/git/gitutils_test.go
+++ b/builder/remotecontext/git/gitutils_test.go
@@ -13,40 +13,40 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestParseRemoteURL(t *testing.T) {
dir, err := parseRemoteURL("git://github.com/user/repo.git")
- require.NoError(t, err)
- assert.NotEmpty(t, dir)
- assert.Equal(t, gitRepo{"git://github.com/user/repo.git", "master", ""}, dir)
+ assert.NilError(t, err)
+ assert.Check(t, len(dir) != 0)
+ assert.Check(t, is.DeepEqual(gitRepo{"git://github.com/user/repo.git", "master", ""}, dir))
dir, err = parseRemoteURL("git://github.com/user/repo.git#mybranch:mydir/mysubdir/")
- require.NoError(t, err)
- assert.NotEmpty(t, dir)
- assert.Equal(t, gitRepo{"git://github.com/user/repo.git", "mybranch", "mydir/mysubdir/"}, dir)
+ assert.NilError(t, err)
+ assert.Check(t, len(dir) != 0)
+ assert.Check(t, is.DeepEqual(gitRepo{"git://github.com/user/repo.git", "mybranch", "mydir/mysubdir/"}, dir))
dir, err = parseRemoteURL("https://github.com/user/repo.git")
- require.NoError(t, err)
- assert.NotEmpty(t, dir)
- assert.Equal(t, gitRepo{"https://github.com/user/repo.git", "master", ""}, dir)
+ assert.NilError(t, err)
+ assert.Check(t, len(dir) != 0)
+ assert.Check(t, is.DeepEqual(gitRepo{"https://github.com/user/repo.git", "master", ""}, dir))
dir, err = parseRemoteURL("https://github.com/user/repo.git#mybranch:mydir/mysubdir/")
- require.NoError(t, err)
- assert.NotEmpty(t, dir)
- assert.Equal(t, gitRepo{"https://github.com/user/repo.git", "mybranch", "mydir/mysubdir/"}, dir)
+ assert.NilError(t, err)
+ assert.Check(t, len(dir) != 0)
+ assert.Check(t, is.DeepEqual(gitRepo{"https://github.com/user/repo.git", "mybranch", "mydir/mysubdir/"}, dir))
dir, err = parseRemoteURL("git@github.com:user/repo.git")
- require.NoError(t, err)
- assert.NotEmpty(t, dir)
- assert.Equal(t, gitRepo{"git@github.com:user/repo.git", "master", ""}, dir)
+ assert.NilError(t, err)
+ assert.Check(t, len(dir) != 0)
+ assert.Check(t, is.DeepEqual(gitRepo{"git@github.com:user/repo.git", "master", ""}, dir))
dir, err = parseRemoteURL("git@github.com:user/repo.git#mybranch:mydir/mysubdir/")
- require.NoError(t, err)
- assert.NotEmpty(t, dir)
- assert.Equal(t, gitRepo{"git@github.com:user/repo.git", "mybranch", "mydir/mysubdir/"}, dir)
+ assert.NilError(t, err)
+ assert.Check(t, len(dir) != 0)
+ assert.Check(t, is.DeepEqual(gitRepo{"git@github.com:user/repo.git", "mybranch", "mydir/mysubdir/"}, dir))
}
func TestCloneArgsSmartHttp(t *testing.T) {
@@ -63,7 +63,7 @@ func TestCloneArgsSmartHttp(t *testing.T) {
args := fetchArgs(serverURL.String(), "master")
exp := []string{"fetch", "--depth", "1", "origin", "master"}
- assert.Equal(t, exp, args)
+ assert.Check(t, is.DeepEqual(exp, args))
}
func TestCloneArgsDumbHttp(t *testing.T) {
@@ -79,13 +79,13 @@ func TestCloneArgsDumbHttp(t *testing.T) {
args := fetchArgs(serverURL.String(), "master")
exp := []string{"fetch", "origin", "master"}
- assert.Equal(t, exp, args)
+ assert.Check(t, is.DeepEqual(exp, args))
}
func TestCloneArgsGit(t *testing.T) {
args := fetchArgs("git://github.com/docker/docker", "master")
exp := []string{"fetch", "--depth", "1", "origin", "master"}
- assert.Equal(t, exp, args)
+ assert.Check(t, is.DeepEqual(exp, args))
}
func gitGetConfig(name string) string {
@@ -100,7 +100,7 @@ func gitGetConfig(name string) string {
func TestCheckoutGit(t *testing.T) {
root, err := ioutil.TempDir("", "docker-build-git-checkout")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(root)
autocrlf := gitGetConfig("core.autocrlf")
@@ -115,22 +115,22 @@ func TestCheckoutGit(t *testing.T) {
gitDir := filepath.Join(root, "repo")
_, err = git("init", gitDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "config", "user.email", "test@docker.com")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "config", "user.name", "Docker test")
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(gitDir, "Dockerfile"), []byte("FROM scratch"), 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
subDir := filepath.Join(gitDir, "subdir")
- require.NoError(t, os.Mkdir(subDir, 0755))
+ assert.NilError(t, os.Mkdir(subDir, 0755))
err = ioutil.WriteFile(filepath.Join(subDir, "Dockerfile"), []byte("FROM scratch\nEXPOSE 5000"), 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
if runtime.GOOS != "windows" {
if err = os.Symlink("../subdir", filepath.Join(gitDir, "parentlink")); err != nil {
@@ -143,58 +143,58 @@ func TestCheckoutGit(t *testing.T) {
}
_, err = gitWithinDir(gitDir, "add", "-A")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "commit", "-am", "First commit")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "checkout", "-b", "test")
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(gitDir, "Dockerfile"), []byte("FROM scratch\nEXPOSE 3000"), 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(subDir, "Dockerfile"), []byte("FROM busybox\nEXPOSE 5000"), 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "add", "-A")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "commit", "-am", "Branch commit")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "checkout", "master")
- require.NoError(t, err)
+ assert.NilError(t, err)
// set up submodule
subrepoDir := filepath.Join(root, "subrepo")
_, err = git("init", subrepoDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(subrepoDir, "config", "user.email", "test@docker.com")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(subrepoDir, "config", "user.name", "Docker test")
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(subrepoDir, "subfile"), []byte("subcontents"), 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(subrepoDir, "add", "-A")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(subrepoDir, "commit", "-am", "Subrepo initial")
- require.NoError(t, err)
+ assert.NilError(t, err)
cmd := exec.Command("git", "submodule", "add", subrepoDir, "sub") // this command doesn't work with --work-tree
cmd.Dir = gitDir
- require.NoError(t, cmd.Run())
+ assert.NilError(t, cmd.Run())
_, err = gitWithinDir(gitDir, "add", "-A")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = gitWithinDir(gitDir, "commit", "-am", "With submodule")
- require.NoError(t, err)
+ assert.NilError(t, err)
type singleCase struct {
frag string
@@ -232,24 +232,24 @@ func TestCheckoutGit(t *testing.T) {
r, err := cloneGitRepo(gitRepo{remote: gitDir, ref: ref, subdir: subdir})
if c.fail {
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
continue
}
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(r)
if c.submodule {
b, err := ioutil.ReadFile(filepath.Join(r, "sub/subfile"))
- require.NoError(t, err)
- assert.Equal(t, "subcontents", string(b))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("subcontents", string(b)))
} else {
_, err := os.Stat(filepath.Join(r, "sub/subfile"))
- require.Error(t, err)
- require.True(t, os.IsNotExist(err))
+ assert.Assert(t, is.ErrorContains(err, ""))
+ assert.Assert(t, os.IsNotExist(err))
}
b, err := ioutil.ReadFile(filepath.Join(r, "Dockerfile"))
- require.NoError(t, err)
- assert.Equal(t, c.exp, string(b))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(c.exp, string(b)))
}
}
diff --git a/builder/remotecontext/mimetype_test.go b/builder/remotecontext/mimetype_test.go
index ff097c2e7b..b13429cfa8 100644
--- a/builder/remotecontext/mimetype_test.go
+++ b/builder/remotecontext/mimetype_test.go
@@ -3,14 +3,14 @@ package remotecontext // import "github.com/docker/docker/builder/remotecontext"
import (
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestDetectContentType(t *testing.T) {
input := []byte("That is just a plain text")
contentType, _, err := detectContentType(input)
- require.NoError(t, err)
- assert.Equal(t, "text/plain", contentType)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("text/plain", contentType))
}
diff --git a/builder/remotecontext/remote_test.go b/builder/remotecontext/remote_test.go
index 3983bd1b6c..5267d23969 100644
--- a/builder/remotecontext/remote_test.go
+++ b/builder/remotecontext/remote_test.go
@@ -11,9 +11,9 @@ import (
"github.com/docker/docker/builder"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
var binaryContext = []byte{0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00} //xz magic
@@ -189,12 +189,12 @@ func TestDownloadRemote(t *testing.T) {
mux.Handle("/", http.FileServer(http.Dir(contextDir.Path())))
contentType, content, err := downloadRemote(remoteURL)
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, mimeTypes.TextPlain, contentType)
+ assert.Check(t, is.Equal(mimeTypes.TextPlain, contentType))
raw, err := ioutil.ReadAll(content)
- require.NoError(t, err)
- assert.Equal(t, dockerfileContents, string(raw))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(dockerfileContents, string(raw)))
}
func TestGetWithStatusError(t *testing.T) {
@@ -226,11 +226,11 @@ func TestGetWithStatusError(t *testing.T) {
response, err := GetWithStatusError(ts.URL)
if testcase.expectedErr == "" {
- require.NoError(t, err)
+ assert.NilError(t, err)
body, err := readBody(response.Body)
- require.NoError(t, err)
- assert.Contains(t, string(body), testcase.expectedBody)
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(string(body), testcase.expectedBody))
} else {
testutil.ErrorContains(t, err, testcase.expectedErr)
}
diff --git a/client/client_test.go b/client/client_test.go
index d6b8f67352..335dd99bcf 100644
--- a/client/client_test.go
+++ b/client/client_test.go
@@ -11,10 +11,10 @@ import (
"github.com/docker/docker/api"
"github.com/docker/docker/api/types"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/env"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestNewEnvClient(t *testing.T) {
@@ -89,19 +89,19 @@ func TestNewEnvClient(t *testing.T) {
env.PatchAll(t, c.envs)
apiclient, err := NewEnvClient()
if c.expectedError != "" {
- assert.Error(t, err, c.doc)
- assert.Equal(t, c.expectedError, err.Error(), c.doc)
+ assert.Check(t, is.ErrorContains(err, ""), c.doc)
+ assert.Check(t, is.Equal(c.expectedError, err.Error()), c.doc)
} else {
- assert.NoError(t, err, c.doc)
+ assert.Check(t, err, c.doc)
version := apiclient.ClientVersion()
- assert.Equal(t, c.expectedVersion, version, c.doc)
+ assert.Check(t, is.Equal(c.expectedVersion, version), c.doc)
}
if c.envs["DOCKER_TLS_VERIFY"] != "" {
// pedantic checking that this is handled correctly
tr := apiclient.client.Transport.(*http.Transport)
- assert.NotNil(t, tr.TLSClientConfig, c.doc)
- assert.Equal(t, tr.TLSClientConfig.InsecureSkipVerify, false, c.doc)
+ assert.Check(t, tr.TLSClientConfig != nil, c.doc)
+ assert.Check(t, is.Equal(tr.TLSClientConfig.InsecureSkipVerify, false), c.doc)
}
}
}
@@ -128,7 +128,7 @@ func TestGetAPIPath(t *testing.T) {
for _, testcase := range testcases {
c := Client{version: testcase.version, basePath: "/"}
actual := c.getAPIPath(testcase.path, testcase.query)
- assert.Equal(t, actual, testcase.expected)
+ assert.Check(t, is.Equal(actual, testcase.expected))
}
}
@@ -165,7 +165,7 @@ func TestParseHostURL(t *testing.T) {
if testcase.expectedErr != "" {
testutil.ErrorContains(t, err, testcase.expectedErr)
}
- assert.Equal(t, testcase.expected, actual)
+ assert.Check(t, is.DeepEqual(testcase.expected, actual))
}
}
@@ -181,7 +181,7 @@ func TestNewEnvClientSetsDefaultVersion(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- assert.Equal(t, client.version, api.DefaultVersion)
+ assert.Check(t, is.Equal(client.version, api.DefaultVersion))
expected := "1.22"
os.Setenv("DOCKER_API_VERSION", expected)
@@ -189,7 +189,7 @@ func TestNewEnvClientSetsDefaultVersion(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- assert.Equal(t, expected, client.version)
+ assert.Check(t, is.Equal(expected, client.version))
}
// TestNegotiateAPIVersionEmpty asserts that client.Client can
@@ -198,7 +198,7 @@ func TestNegotiateAPIVersionEmpty(t *testing.T) {
defer env.PatchAll(t, map[string]string{"DOCKER_API_VERSION": ""})
client, err := NewEnvClient()
- require.NoError(t, err)
+ assert.NilError(t, err)
ping := types.Ping{
APIVersion: "",
@@ -215,14 +215,14 @@ func TestNegotiateAPIVersionEmpty(t *testing.T) {
// test downgrade
client.NegotiateAPIVersionPing(ping)
- assert.Equal(t, expected, client.version)
+ assert.Check(t, is.Equal(expected, client.version))
}
// TestNegotiateAPIVersion asserts that client.Client can
// negotiate a compatible APIVersion with the server
func TestNegotiateAPIVersion(t *testing.T) {
client, err := NewEnvClient()
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := "1.21"
ping := types.Ping{
@@ -236,14 +236,14 @@ func TestNegotiateAPIVersion(t *testing.T) {
// test downgrade
client.NegotiateAPIVersionPing(ping)
- assert.Equal(t, expected, client.version)
+ assert.Check(t, is.Equal(expected, client.version))
// set the client version to something older, and verify that we keep the
// original setting.
expected = "1.20"
client.version = expected
client.NegotiateAPIVersionPing(ping)
- assert.Equal(t, expected, client.version)
+ assert.Check(t, is.Equal(expected, client.version))
}
@@ -254,7 +254,7 @@ func TestNegotiateAPVersionOverride(t *testing.T) {
defer env.PatchAll(t, map[string]string{"DOCKER_API_VERSION": expected})()
client, err := NewEnvClient()
- require.NoError(t, err)
+ assert.NilError(t, err)
ping := types.Ping{
APIVersion: "1.24",
@@ -264,7 +264,7 @@ func TestNegotiateAPVersionOverride(t *testing.T) {
// test that we honored the env var
client.NegotiateAPIVersionPing(ping)
- assert.Equal(t, expected, client.version)
+ assert.Check(t, is.Equal(expected, client.version))
}
type roundTripFunc func(*http.Request) (*http.Response, error)
@@ -309,9 +309,9 @@ func TestClientRedirect(t *testing.T) {
for _, tc := range cases {
req, err := http.NewRequest(tc.httpMethod, "/redirectme", nil)
- assert.NoError(t, err)
+ assert.Check(t, err)
resp, err := client.Do(req)
- assert.Equal(t, tc.expectedErr, err)
- assert.Equal(t, tc.statusCode, resp.StatusCode)
+ assert.Check(t, is.DeepEqual(tc.expectedErr, err))
+ assert.Check(t, is.Equal(tc.statusCode, resp.StatusCode))
}
}
diff --git a/client/config_create_test.go b/client/config_create_test.go
index 3f3cb3fc56..2ee8f1fd40 100644
--- a/client/config_create_test.go
+++ b/client/config_create_test.go
@@ -11,7 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/swarm"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -21,7 +22,7 @@ func TestConfigCreateUnsupported(t *testing.T) {
client: &http.Client{},
}
_, err := client.ConfigCreate(context.Background(), swarm.ConfigSpec{})
- assert.EqualError(t, err, `"config create" requires API version 1.30, but the Docker daemon API version is 1.29`)
+ assert.Check(t, is.Error(err, `"config create" requires API version 1.30, but the Docker daemon API version is 1.29`))
}
func TestConfigCreateError(t *testing.T) {
diff --git a/client/config_inspect_test.go b/client/config_inspect_test.go
index c6d73e5c02..9d5af0bf8c 100644
--- a/client/config_inspect_test.go
+++ b/client/config_inspect_test.go
@@ -10,8 +10,9 @@ import (
"testing"
"github.com/docker/docker/api/types/swarm"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@@ -44,7 +45,7 @@ func TestConfigInspectUnsupported(t *testing.T) {
client: &http.Client{},
}
_, _, err := client.ConfigInspectWithRaw(context.Background(), "nothing")
- assert.EqualError(t, err, `"config inspect" requires API version 1.30, but the Docker daemon API version is 1.29`)
+ assert.Check(t, is.Error(err, `"config inspect" requires API version 1.30, but the Docker daemon API version is 1.29`))
}
func TestConfigInspectError(t *testing.T) {
diff --git a/client/config_list_test.go b/client/config_list_test.go
index 4b4a5e84ce..0cd99c50d1 100644
--- a/client/config_list_test.go
+++ b/client/config_list_test.go
@@ -12,7 +12,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/swarm"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -22,7 +23,7 @@ func TestConfigListUnsupported(t *testing.T) {
client: &http.Client{},
}
_, err := client.ConfigList(context.Background(), types.ConfigListOptions{})
- assert.EqualError(t, err, `"config list" requires API version 1.30, but the Docker daemon API version is 1.29`)
+ assert.Check(t, is.Error(err, `"config list" requires API version 1.30, but the Docker daemon API version is 1.29`))
}
func TestConfigListError(t *testing.T) {
diff --git a/client/config_remove_test.go b/client/config_remove_test.go
index 290395aae5..25a5c4ac87 100644
--- a/client/config_remove_test.go
+++ b/client/config_remove_test.go
@@ -8,7 +8,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -18,7 +19,7 @@ func TestConfigRemoveUnsupported(t *testing.T) {
client: &http.Client{},
}
err := client.ConfigRemove(context.Background(), "config_id")
- assert.EqualError(t, err, `"config remove" requires API version 1.30, but the Docker daemon API version is 1.29`)
+ assert.Check(t, is.Error(err, `"config remove" requires API version 1.30, but the Docker daemon API version is 1.29`))
}
func TestConfigRemoveError(t *testing.T) {
diff --git a/client/config_update_test.go b/client/config_update_test.go
index 99f2e173c2..a7eea2f8b1 100644
--- a/client/config_update_test.go
+++ b/client/config_update_test.go
@@ -9,7 +9,8 @@ import (
"testing"
"github.com/docker/docker/api/types/swarm"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -19,7 +20,7 @@ func TestConfigUpdateUnsupported(t *testing.T) {
client: &http.Client{},
}
err := client.ConfigUpdate(context.Background(), "config_id", swarm.Version{}, swarm.ConfigSpec{})
- assert.EqualError(t, err, `"config update" requires API version 1.30, but the Docker daemon API version is 1.29`)
+ assert.Check(t, is.Error(err, `"config update" requires API version 1.30, but the Docker daemon API version is 1.29`))
}
func TestConfigUpdateError(t *testing.T) {
diff --git a/client/container_prune_test.go b/client/container_prune_test.go
index 1f8c22cbfe..7ffd9c7ecf 100644
--- a/client/container_prune_test.go
+++ b/client/container_prune_test.go
@@ -11,7 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -24,7 +25,7 @@ func TestContainersPruneError(t *testing.T) {
filters := filters.NewArgs()
_, err := client.ContainersPrune(context.Background(), filters)
- assert.EqualError(t, err, "Error response from daemon: Server error")
+ assert.Check(t, is.Error(err, "Error response from daemon: Server error"))
}
func TestContainersPrune(t *testing.T) {
@@ -99,7 +100,7 @@ func TestContainersPrune(t *testing.T) {
query := req.URL.Query()
for key, expected := range listCase.expectedQueryParams {
actual := query.Get(key)
- assert.Equal(t, expected, actual)
+ assert.Check(t, is.Equal(expected, actual))
}
content, err := json.Marshal(types.ContainersPruneReport{
ContainersDeleted: []string{"container_id1", "container_id2"},
@@ -117,8 +118,8 @@ func TestContainersPrune(t *testing.T) {
}
report, err := client.ContainersPrune(context.Background(), listCase.filters)
- assert.NoError(t, err)
- assert.Len(t, report.ContainersDeleted, 2)
- assert.Equal(t, uint64(9999), report.SpaceReclaimed)
+ assert.Check(t, err)
+ assert.Check(t, is.Len(report.ContainersDeleted, 2))
+ assert.Check(t, is.Equal(uint64(9999), report.SpaceReclaimed))
}
}
diff --git a/client/container_remove_test.go b/client/container_remove_test.go
index 0b1b64fa3a..537272cd1d 100644
--- a/client/container_remove_test.go
+++ b/client/container_remove_test.go
@@ -9,7 +9,8 @@ import (
"testing"
"github.com/docker/docker/api/types"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -18,7 +19,7 @@ func TestContainerRemoveError(t *testing.T) {
client: newMockClient(errorMock(http.StatusInternalServerError, "Server error")),
}
err := client.ContainerRemove(context.Background(), "container_id", types.ContainerRemoveOptions{})
- assert.EqualError(t, err, "Error response from daemon: Server error")
+ assert.Check(t, is.Error(err, "Error response from daemon: Server error"))
}
func TestContainerRemoveNotFoundError(t *testing.T) {
@@ -26,8 +27,8 @@ func TestContainerRemoveNotFoundError(t *testing.T) {
client: newMockClient(errorMock(http.StatusNotFound, "missing")),
}
err := client.ContainerRemove(context.Background(), "container_id", types.ContainerRemoveOptions{})
- assert.EqualError(t, err, "Error: No such container: container_id")
- assert.True(t, IsErrNotFound(err))
+ assert.Check(t, is.Error(err, "Error: No such container: container_id"))
+ assert.Check(t, IsErrNotFound(err))
}
func TestContainerRemove(t *testing.T) {
@@ -61,5 +62,5 @@ func TestContainerRemove(t *testing.T) {
RemoveVolumes: true,
Force: true,
})
- assert.NoError(t, err)
+ assert.Check(t, err)
}
diff --git a/client/distribution_inspect_test.go b/client/distribution_inspect_test.go
index 90b35a285b..d4124bfa15 100644
--- a/client/distribution_inspect_test.go
+++ b/client/distribution_inspect_test.go
@@ -4,8 +4,9 @@ import (
"net/http"
"testing"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@@ -15,7 +16,7 @@ func TestDistributionInspectUnsupported(t *testing.T) {
client: &http.Client{},
}
_, err := client.DistributionInspect(context.Background(), "foobar:1.0", "")
- assert.EqualError(t, err, `"distribution inspect" requires API version 1.30, but the Docker daemon API version is 1.29`)
+ assert.Check(t, is.Error(err, `"distribution inspect" requires API version 1.30, but the Docker daemon API version is 1.29`))
}
func TestDistributionInspectWithEmptyID(t *testing.T) {
diff --git a/client/image_prune_test.go b/client/image_prune_test.go
index f165e5c746..9b161531f2 100644
--- a/client/image_prune_test.go
+++ b/client/image_prune_test.go
@@ -11,7 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -24,7 +25,7 @@ func TestImagesPruneError(t *testing.T) {
filters := filters.NewArgs()
_, err := client.ImagesPrune(context.Background(), filters)
- assert.EqualError(t, err, "Error response from daemon: Server error")
+ assert.Check(t, is.Error(err, "Error response from daemon: Server error"))
}
func TestImagesPrune(t *testing.T) {
@@ -87,7 +88,7 @@ func TestImagesPrune(t *testing.T) {
query := req.URL.Query()
for key, expected := range listCase.expectedQueryParams {
actual := query.Get(key)
- assert.Equal(t, expected, actual)
+ assert.Check(t, is.Equal(expected, actual))
}
content, err := json.Marshal(types.ImagesPruneReport{
ImagesDeleted: []types.ImageDeleteResponseItem{
@@ -112,8 +113,8 @@ func TestImagesPrune(t *testing.T) {
}
report, err := client.ImagesPrune(context.Background(), listCase.filters)
- assert.NoError(t, err)
- assert.Len(t, report.ImagesDeleted, 2)
- assert.Equal(t, uint64(9999), report.SpaceReclaimed)
+ assert.Check(t, err)
+ assert.Check(t, is.Len(report.ImagesDeleted, 2))
+ assert.Check(t, is.Equal(uint64(9999), report.SpaceReclaimed))
}
}
diff --git a/client/image_remove_test.go b/client/image_remove_test.go
index 8f5aa0120d..a1686e6496 100644
--- a/client/image_remove_test.go
+++ b/client/image_remove_test.go
@@ -10,7 +10,8 @@ import (
"testing"
"github.com/docker/docker/api/types"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -20,7 +21,7 @@ func TestImageRemoveError(t *testing.T) {
}
_, err := client.ImageRemove(context.Background(), "image_id", types.ImageRemoveOptions{})
- assert.EqualError(t, err, "Error response from daemon: Server error")
+ assert.Check(t, is.Error(err, "Error response from daemon: Server error"))
}
func TestImageRemoveImageNotFound(t *testing.T) {
@@ -29,8 +30,8 @@ func TestImageRemoveImageNotFound(t *testing.T) {
}
_, err := client.ImageRemove(context.Background(), "unknown", types.ImageRemoveOptions{})
- assert.EqualError(t, err, "Error: No such image: unknown")
- assert.True(t, IsErrNotFound(err))
+ assert.Check(t, is.Error(err, "Error: No such image: unknown"))
+ assert.Check(t, IsErrNotFound(err))
}
func TestImageRemove(t *testing.T) {
diff --git a/client/network_inspect_test.go b/client/network_inspect_test.go
index 7031611911..8778021ed9 100644
--- a/client/network_inspect_test.go
+++ b/client/network_inspect_test.go
@@ -11,8 +11,9 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/network"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@@ -22,7 +23,7 @@ func TestNetworkInspectError(t *testing.T) {
}
_, err := client.NetworkInspect(context.Background(), "nothing", types.NetworkInspectOptions{})
- assert.EqualError(t, err, "Error response from daemon: Server error")
+ assert.Check(t, is.Error(err, "Error response from daemon: Server error"))
}
func TestNetworkInspectNotFoundError(t *testing.T) {
@@ -31,8 +32,8 @@ func TestNetworkInspectNotFoundError(t *testing.T) {
}
_, err := client.NetworkInspect(context.Background(), "unknown", types.NetworkInspectOptions{})
- assert.EqualError(t, err, "Error: No such network: unknown")
- assert.True(t, IsErrNotFound(err))
+ assert.Check(t, is.Error(err, "Error: No such network: unknown"))
+ assert.Check(t, IsErrNotFound(err))
}
func TestNetworkInspectWithEmptyID(t *testing.T) {
@@ -113,5 +114,5 @@ func TestNetworkInspect(t *testing.T) {
}
_, err = client.NetworkInspect(context.Background(), "network_id", types.NetworkInspectOptions{Scope: "global"})
- assert.EqualError(t, err, "Error: No such network: network_id")
+ assert.Check(t, is.Error(err, "Error: No such network: network_id"))
}
diff --git a/client/network_prune_test.go b/client/network_prune_test.go
index 8bba3751e7..85908f0cf3 100644
--- a/client/network_prune_test.go
+++ b/client/network_prune_test.go
@@ -11,7 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -89,7 +90,7 @@ func TestNetworksPrune(t *testing.T) {
query := req.URL.Query()
for key, expected := range listCase.expectedQueryParams {
actual := query.Get(key)
- assert.Equal(t, expected, actual)
+ assert.Check(t, is.Equal(expected, actual))
}
content, err := json.Marshal(types.NetworksPruneReport{
NetworksDeleted: []string{"network_id1", "network_id2"},
@@ -106,7 +107,7 @@ func TestNetworksPrune(t *testing.T) {
}
report, err := client.NetworksPrune(context.Background(), listCase.filters)
- assert.NoError(t, err)
- assert.Len(t, report.NetworksDeleted, 2)
+ assert.Check(t, err)
+ assert.Check(t, is.Len(report.NetworksDeleted, 2))
}
}
diff --git a/client/ping_test.go b/client/ping_test.go
index 69ff86269d..f83233aceb 100644
--- a/client/ping_test.go
+++ b/client/ping_test.go
@@ -7,7 +7,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -31,15 +32,15 @@ func TestPingFail(t *testing.T) {
}
ping, err := client.Ping(context.Background())
- assert.Error(t, err)
- assert.Equal(t, false, ping.Experimental)
- assert.Equal(t, "", ping.APIVersion)
+ assert.Check(t, is.ErrorContains(err, ""))
+ assert.Check(t, is.Equal(false, ping.Experimental))
+ assert.Check(t, is.Equal("", ping.APIVersion))
withHeader = true
ping2, err := client.Ping(context.Background())
- assert.Error(t, err)
- assert.Equal(t, true, ping2.Experimental)
- assert.Equal(t, "awesome", ping2.APIVersion)
+ assert.Check(t, is.ErrorContains(err, ""))
+ assert.Check(t, is.Equal(true, ping2.Experimental))
+ assert.Check(t, is.Equal("awesome", ping2.APIVersion))
}
// TestPingWithError tests the case where there is a protocol error in the ping.
@@ -57,9 +58,9 @@ func TestPingWithError(t *testing.T) {
}
ping, err := client.Ping(context.Background())
- assert.Error(t, err)
- assert.Equal(t, false, ping.Experimental)
- assert.Equal(t, "", ping.APIVersion)
+ assert.Check(t, is.ErrorContains(err, ""))
+ assert.Check(t, is.Equal(false, ping.Experimental))
+ assert.Check(t, is.Equal("", ping.APIVersion))
}
// TestPingSuccess tests that we are able to get the expected API headers/ping
@@ -76,7 +77,7 @@ func TestPingSuccess(t *testing.T) {
}),
}
ping, err := client.Ping(context.Background())
- assert.Error(t, err)
- assert.Equal(t, true, ping.Experimental)
- assert.Equal(t, "awesome", ping.APIVersion)
+ assert.Check(t, is.ErrorContains(err, ""))
+ assert.Check(t, is.Equal(true, ping.Experimental))
+ assert.Check(t, is.Equal("awesome", ping.APIVersion))
}
diff --git a/client/request_test.go b/client/request_test.go
index 1dbfed62c7..1a0a87e2f4 100644
--- a/client/request_test.go
+++ b/client/request_test.go
@@ -9,7 +9,7 @@ import (
"testing"
"github.com/docker/docker/api/types"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
"golang.org/x/net/context"
)
@@ -46,7 +46,7 @@ func TestSetHostHeader(t *testing.T) {
for c, test := range testCases {
hostURL, err := ParseHostURL(test.host)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &Client{
client: newMockClient(func(req *http.Request) (*http.Response, error) {
@@ -71,7 +71,7 @@ func TestSetHostHeader(t *testing.T) {
}
_, err = client.sendRequest(context.Background(), "GET", testURL, nil, nil, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
}
diff --git a/client/secret_create_test.go b/client/secret_create_test.go
index 7d54e1aeb0..b31cab509f 100644
--- a/client/secret_create_test.go
+++ b/client/secret_create_test.go
@@ -11,7 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/swarm"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -21,7 +22,7 @@ func TestSecretCreateUnsupported(t *testing.T) {
client: &http.Client{},
}
_, err := client.SecretCreate(context.Background(), swarm.SecretSpec{})
- assert.EqualError(t, err, `"secret create" requires API version 1.25, but the Docker daemon API version is 1.24`)
+ assert.Check(t, is.Error(err, `"secret create" requires API version 1.25, but the Docker daemon API version is 1.24`))
}
func TestSecretCreateError(t *testing.T) {
diff --git a/client/secret_inspect_test.go b/client/secret_inspect_test.go
index eb63162c18..0bb3ae24cc 100644
--- a/client/secret_inspect_test.go
+++ b/client/secret_inspect_test.go
@@ -10,8 +10,9 @@ import (
"testing"
"github.com/docker/docker/api/types/swarm"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@@ -21,7 +22,7 @@ func TestSecretInspectUnsupported(t *testing.T) {
client: &http.Client{},
}
_, _, err := client.SecretInspectWithRaw(context.Background(), "nothing")
- assert.EqualError(t, err, `"secret inspect" requires API version 1.25, but the Docker daemon API version is 1.24`)
+ assert.Check(t, is.Error(err, `"secret inspect" requires API version 1.25, but the Docker daemon API version is 1.24`))
}
func TestSecretInspectError(t *testing.T) {
diff --git a/client/secret_list_test.go b/client/secret_list_test.go
index 2bd427898b..36d8e8e2f0 100644
--- a/client/secret_list_test.go
+++ b/client/secret_list_test.go
@@ -12,7 +12,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/swarm"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -22,7 +23,7 @@ func TestSecretListUnsupported(t *testing.T) {
client: &http.Client{},
}
_, err := client.SecretList(context.Background(), types.SecretListOptions{})
- assert.EqualError(t, err, `"secret list" requires API version 1.25, but the Docker daemon API version is 1.24`)
+ assert.Check(t, is.Error(err, `"secret list" requires API version 1.25, but the Docker daemon API version is 1.24`))
}
func TestSecretListError(t *testing.T) {
diff --git a/client/secret_remove_test.go b/client/secret_remove_test.go
index 44cc0cbcc4..37c22650d1 100644
--- a/client/secret_remove_test.go
+++ b/client/secret_remove_test.go
@@ -8,7 +8,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -18,7 +19,7 @@ func TestSecretRemoveUnsupported(t *testing.T) {
client: &http.Client{},
}
err := client.SecretRemove(context.Background(), "secret_id")
- assert.EqualError(t, err, `"secret remove" requires API version 1.25, but the Docker daemon API version is 1.24`)
+ assert.Check(t, is.Error(err, `"secret remove" requires API version 1.25, but the Docker daemon API version is 1.24`))
}
func TestSecretRemoveError(t *testing.T) {
diff --git a/client/secret_update_test.go b/client/secret_update_test.go
index d2fca4b2d5..3ff172ba53 100644
--- a/client/secret_update_test.go
+++ b/client/secret_update_test.go
@@ -9,7 +9,8 @@ import (
"testing"
"github.com/docker/docker/api/types/swarm"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -19,7 +20,7 @@ func TestSecretUpdateUnsupported(t *testing.T) {
client: &http.Client{},
}
err := client.SecretUpdate(context.Background(), "secret_id", swarm.Version{}, swarm.SecretSpec{})
- assert.EqualError(t, err, `"secret update" requires API version 1.25, but the Docker daemon API version is 1.24`)
+ assert.Check(t, is.Error(err, `"secret update" requires API version 1.25, but the Docker daemon API version is 1.24`))
}
func TestSecretUpdateError(t *testing.T) {
diff --git a/client/service_create_test.go b/client/service_create_test.go
index 9e859b18ac..c5d8ae4ff9 100644
--- a/client/service_create_test.go
+++ b/client/service_create_test.go
@@ -12,9 +12,10 @@ import (
"github.com/docker/docker/api/types"
registrytypes "github.com/docker/docker/api/types/registry"
"github.com/docker/docker/api/types/swarm"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/opencontainers/go-digest"
"github.com/opencontainers/image-spec/specs-go/v1"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@@ -73,8 +74,8 @@ func TestServiceCreateCompatiblePlatforms(t *testing.T) {
return nil, err
}
- assert.Equal(t, "foobar:1.0@sha256:c0537ff6a5218ef531ece93d4984efc99bbf3f7497c0a7726c88e2bb7584dc96", serviceSpec.TaskTemplate.ContainerSpec.Image)
- assert.Len(t, serviceSpec.TaskTemplate.Placement.Platforms, 1)
+ assert.Check(t, is.Equal("foobar:1.0@sha256:c0537ff6a5218ef531ece93d4984efc99bbf3f7497c0a7726c88e2bb7584dc96", serviceSpec.TaskTemplate.ContainerSpec.Image))
+ assert.Check(t, is.Len(serviceSpec.TaskTemplate.Placement.Platforms, 1))
p := serviceSpec.TaskTemplate.Placement.Platforms[0]
b, err := json.Marshal(types.ServiceCreateResponse{
@@ -115,8 +116,8 @@ func TestServiceCreateCompatiblePlatforms(t *testing.T) {
spec := swarm.ServiceSpec{TaskTemplate: swarm.TaskSpec{ContainerSpec: &swarm.ContainerSpec{Image: "foobar:1.0"}}}
r, err := client.ServiceCreate(context.Background(), spec, types.ServiceCreateOptions{QueryRegistry: true})
- assert.NoError(t, err)
- assert.Equal(t, "service_linux_amd64", r.ID)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("service_linux_amd64", r.ID))
}
func TestServiceCreateDigestPinning(t *testing.T) {
diff --git a/client/service_remove_test.go b/client/service_remove_test.go
index 0909c9e064..9198763f8e 100644
--- a/client/service_remove_test.go
+++ b/client/service_remove_test.go
@@ -8,7 +8,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -18,7 +19,7 @@ func TestServiceRemoveError(t *testing.T) {
}
err := client.ServiceRemove(context.Background(), "service_id")
- assert.EqualError(t, err, "Error response from daemon: Server error")
+ assert.Check(t, is.Error(err, "Error response from daemon: Server error"))
}
func TestServiceRemoveNotFoundError(t *testing.T) {
@@ -27,8 +28,8 @@ func TestServiceRemoveNotFoundError(t *testing.T) {
}
err := client.ServiceRemove(context.Background(), "service_id")
- assert.EqualError(t, err, "Error: No such service: service_id")
- assert.True(t, IsErrNotFound(err))
+ assert.Check(t, is.Error(err, "Error: No such service: service_id"))
+ assert.Check(t, IsErrNotFound(err))
}
func TestServiceRemove(t *testing.T) {
diff --git a/client/swarm_get_unlock_key_test.go b/client/swarm_get_unlock_key_test.go
index c4ac70738a..aff79440fe 100644
--- a/client/swarm_get_unlock_key_test.go
+++ b/client/swarm_get_unlock_key_test.go
@@ -11,8 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -55,6 +55,6 @@ func TestSwarmGetUnlockKey(t *testing.T) {
}
resp, err := client.SwarmGetUnlockKey(context.Background())
- require.NoError(t, err)
- assert.Equal(t, unlockKey, resp.UnlockKey)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(unlockKey, resp.UnlockKey))
}
diff --git a/client/volume_inspect_test.go b/client/volume_inspect_test.go
index c97f5c7215..4a2cf7c7d7 100644
--- a/client/volume_inspect_test.go
+++ b/client/volume_inspect_test.go
@@ -11,9 +11,9 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -32,7 +32,7 @@ func TestVolumeInspectNotFound(t *testing.T) {
}
_, err := client.VolumeInspect(context.Background(), "unknown")
- assert.True(t, IsErrNotFound(err))
+ assert.Check(t, IsErrNotFound(err))
}
func TestVolumeInspectWithEmptyID(t *testing.T) {
@@ -75,6 +75,6 @@ func TestVolumeInspect(t *testing.T) {
}
volume, err := client.VolumeInspect(context.Background(), "volume_id")
- require.NoError(t, err)
- assert.Equal(t, expected, volume)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(expected, volume))
}
diff --git a/cmd/dockerd/config_unix_test.go b/cmd/dockerd/config_unix_test.go
index 2705d671ba..eaa53d8f6f 100644
--- a/cmd/dockerd/config_unix_test.go
+++ b/cmd/dockerd/config_unix_test.go
@@ -6,8 +6,9 @@ import (
"testing"
"github.com/docker/docker/daemon/config"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/spf13/pflag"
- "github.com/stretchr/testify/assert"
)
func TestDaemonParseShmSize(t *testing.T) {
@@ -16,7 +17,7 @@ func TestDaemonParseShmSize(t *testing.T) {
conf := &config.Config{}
installConfigFlags(conf, flags)
// By default `--default-shm-size=64M`
- assert.Equal(t, int64(64*1024*1024), conf.ShmSize.Value())
- assert.NoError(t, flags.Set("default-shm-size", "128M"))
- assert.Equal(t, int64(128*1024*1024), conf.ShmSize.Value())
+ assert.Check(t, is.Equal(int64(64*1024*1024), conf.ShmSize.Value()))
+ assert.Check(t, flags.Set("default-shm-size", "128M"))
+ assert.Check(t, is.Equal(int64(128*1024*1024), conf.ShmSize.Value()))
}
diff --git a/cmd/dockerd/daemon_test.go b/cmd/dockerd/daemon_test.go
index b065831871..e5c2c2ec7c 100644
--- a/cmd/dockerd/daemon_test.go
+++ b/cmd/dockerd/daemon_test.go
@@ -5,11 +5,11 @@ import (
"github.com/docker/docker/daemon/config"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
"github.com/sirupsen/logrus"
"github.com/spf13/pflag"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func defaultOptions(configFile string) *daemonOptions {
@@ -27,8 +27,8 @@ func TestLoadDaemonCliConfigWithoutOverriding(t *testing.T) {
opts.Debug = true
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
if !loadedConfig.Debug {
t.Fatalf("expected debug to be copied from the common flags, got false")
}
@@ -40,9 +40,9 @@ func TestLoadDaemonCliConfigWithTLS(t *testing.T) {
opts.TLS = true
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.Equal(t, "/tmp/ca.pem", loadedConfig.CommonTLSOptions.CAFile)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, is.Equal("/tmp/ca.pem", loadedConfig.CommonTLSOptions.CAFile))
}
func TestLoadDaemonCliConfigWithConflicts(t *testing.T) {
@@ -53,9 +53,9 @@ func TestLoadDaemonCliConfigWithConflicts(t *testing.T) {
opts := defaultOptions(configFile)
flags := opts.flags
- assert.NoError(t, flags.Set("config-file", configFile))
- assert.NoError(t, flags.Set("label", "l1=bar"))
- assert.NoError(t, flags.Set("label", "l2=baz"))
+ assert.Check(t, flags.Set("config-file", configFile))
+ assert.Check(t, flags.Set("label", "l1=bar"))
+ assert.Check(t, flags.Set("label", "l2=baz"))
_, err := loadDaemonCliConfig(opts)
testutil.ErrorContains(t, err, "as a flag and in the configuration file: labels")
@@ -69,9 +69,9 @@ func TestLoadDaemonCliWithConflictingNodeGenericResources(t *testing.T) {
opts := defaultOptions(configFile)
flags := opts.flags
- assert.NoError(t, flags.Set("config-file", configFile))
- assert.NoError(t, flags.Set("node-generic-resource", "r1=bar"))
- assert.NoError(t, flags.Set("node-generic-resource", "r2=baz"))
+ assert.Check(t, flags.Set("config-file", configFile))
+ assert.Check(t, flags.Set("node-generic-resource", "r1=bar"))
+ assert.Check(t, flags.Set("node-generic-resource", "r2=baz"))
_, err := loadDaemonCliConfig(opts)
testutil.ErrorContains(t, err, "as a flag and in the configuration file: node-generic-resources")
@@ -81,22 +81,22 @@ func TestLoadDaemonCliWithConflictingLabels(t *testing.T) {
opts := defaultOptions("")
flags := opts.flags
- assert.NoError(t, flags.Set("label", "foo=bar"))
- assert.NoError(t, flags.Set("label", "foo=baz"))
+ assert.Check(t, flags.Set("label", "foo=bar"))
+ assert.Check(t, flags.Set("label", "foo=baz"))
_, err := loadDaemonCliConfig(opts)
- assert.EqualError(t, err, "conflict labels for foo=baz and foo=bar")
+ assert.Check(t, is.Error(err, "conflict labels for foo=baz and foo=bar"))
}
func TestLoadDaemonCliWithDuplicateLabels(t *testing.T) {
opts := defaultOptions("")
flags := opts.flags
- assert.NoError(t, flags.Set("label", "foo=the-same"))
- assert.NoError(t, flags.Set("label", "foo=the-same"))
+ assert.Check(t, flags.Set("label", "foo=the-same"))
+ assert.Check(t, flags.Set("label", "foo=the-same"))
_, err := loadDaemonCliConfig(opts)
- assert.NoError(t, err)
+ assert.Check(t, err)
}
func TestLoadDaemonCliConfigWithTLSVerify(t *testing.T) {
@@ -107,9 +107,9 @@ func TestLoadDaemonCliConfigWithTLSVerify(t *testing.T) {
opts.TLSOptions.CAFile = "/tmp/ca.pem"
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.Equal(t, loadedConfig.TLS, true)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, is.Equal(loadedConfig.TLS, true))
}
func TestLoadDaemonCliConfigWithExplicitTLSVerifyFalse(t *testing.T) {
@@ -120,9 +120,9 @@ func TestLoadDaemonCliConfigWithExplicitTLSVerifyFalse(t *testing.T) {
opts.TLSOptions.CAFile = "/tmp/ca.pem"
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.True(t, loadedConfig.TLS)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, loadedConfig.TLS)
}
func TestLoadDaemonCliConfigWithoutTLSVerify(t *testing.T) {
@@ -133,9 +133,9 @@ func TestLoadDaemonCliConfigWithoutTLSVerify(t *testing.T) {
opts.TLSOptions.CAFile = "/tmp/ca.pem"
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.False(t, loadedConfig.TLS)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, !loadedConfig.TLS)
}
func TestLoadDaemonCliConfigWithLogLevel(t *testing.T) {
@@ -144,10 +144,10 @@ func TestLoadDaemonCliConfigWithLogLevel(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.Equal(t, "warn", loadedConfig.LogLevel)
- assert.Equal(t, logrus.WarnLevel, logrus.GetLevel())
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, is.Equal("warn", loadedConfig.LogLevel))
+ assert.Check(t, is.Equal(logrus.WarnLevel, logrus.GetLevel()))
}
func TestLoadDaemonConfigWithEmbeddedOptions(t *testing.T) {
@@ -157,10 +157,10 @@ func TestLoadDaemonConfigWithEmbeddedOptions(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.Equal(t, "/etc/certs/ca.pem", loadedConfig.CommonTLSOptions.CAFile)
- assert.Equal(t, "syslog", loadedConfig.LogConfig.Type)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, is.Equal("/etc/certs/ca.pem", loadedConfig.CommonTLSOptions.CAFile))
+ assert.Check(t, is.Equal("syslog", loadedConfig.LogConfig.Type))
}
func TestLoadDaemonConfigWithRegistryOptions(t *testing.T) {
@@ -174,10 +174,10 @@ func TestLoadDaemonConfigWithRegistryOptions(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
- assert.Len(t, loadedConfig.AllowNondistributableArtifacts, 1)
- assert.Len(t, loadedConfig.Mirrors, 1)
- assert.Len(t, loadedConfig.InsecureRegistries, 1)
+ assert.Check(t, is.Len(loadedConfig.AllowNondistributableArtifacts, 1))
+ assert.Check(t, is.Len(loadedConfig.Mirrors, 1))
+ assert.Check(t, is.Len(loadedConfig.InsecureRegistries, 1))
}
diff --git a/cmd/dockerd/daemon_unix_test.go b/cmd/dockerd/daemon_unix_test.go
index 41c392e1b1..39ff1e6822 100644
--- a/cmd/dockerd/daemon_unix_test.go
+++ b/cmd/dockerd/daemon_unix_test.go
@@ -6,9 +6,9 @@ import (
"testing"
"github.com/docker/docker/daemon/config"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) {
@@ -19,17 +19,17 @@ func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) {
opts := defaultOptions(tempFile.Path())
opts.Debug = true
opts.LogLevel = "info"
- assert.NoError(t, opts.flags.Set("selinux-enabled", "true"))
+ assert.Check(t, opts.flags.Set("selinux-enabled", "true"))
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
- assert.True(t, loadedConfig.Debug)
- assert.Equal(t, "info", loadedConfig.LogLevel)
- assert.True(t, loadedConfig.EnableSelinuxSupport)
- assert.Equal(t, "json-file", loadedConfig.LogConfig.Type)
- assert.Equal(t, "1k", loadedConfig.LogConfig.Config["max-size"])
+ assert.Check(t, loadedConfig.Debug)
+ assert.Check(t, is.Equal("info", loadedConfig.LogLevel))
+ assert.Check(t, loadedConfig.EnableSelinuxSupport)
+ assert.Check(t, is.Equal("json-file", loadedConfig.LogConfig.Type))
+ assert.Check(t, is.Equal("1k", loadedConfig.LogConfig.Config["max-size"]))
}
func TestLoadDaemonConfigWithNetwork(t *testing.T) {
@@ -39,11 +39,11 @@ func TestLoadDaemonConfigWithNetwork(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
- assert.Equal(t, "127.0.0.2", loadedConfig.IP)
- assert.Equal(t, "127.0.0.1", loadedConfig.DefaultIP.String())
+ assert.Check(t, is.Equal("127.0.0.2", loadedConfig.IP))
+ assert.Check(t, is.Equal("127.0.0.1", loadedConfig.DefaultIP.String()))
}
func TestLoadDaemonConfigWithMapOptions(t *testing.T) {
@@ -56,14 +56,14 @@ func TestLoadDaemonConfigWithMapOptions(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
- assert.NotNil(t, loadedConfig.ClusterOpts)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
+ assert.Check(t, loadedConfig.ClusterOpts != nil)
expectedPath := "/var/lib/docker/discovery_certs/ca.pem"
- assert.Equal(t, expectedPath, loadedConfig.ClusterOpts["kv.cacertfile"])
- assert.NotNil(t, loadedConfig.LogConfig.Config)
- assert.Equal(t, "test", loadedConfig.LogConfig.Config["tag"])
+ assert.Check(t, is.Equal(expectedPath, loadedConfig.ClusterOpts["kv.cacertfile"]))
+ assert.Check(t, loadedConfig.LogConfig.Config != nil)
+ assert.Check(t, is.Equal("test", loadedConfig.LogConfig.Config["tag"]))
}
func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) {
@@ -73,17 +73,17 @@ func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
- assert.False(t, loadedConfig.EnableUserlandProxy)
+ assert.Check(t, !loadedConfig.EnableUserlandProxy)
// make sure reloading doesn't generate configuration
// conflicts after normalizing boolean values.
reload := func(reloadedConfig *config.Config) {
- assert.False(t, reloadedConfig.EnableUserlandProxy)
+ assert.Check(t, !reloadedConfig.EnableUserlandProxy)
}
- assert.NoError(t, config.Reload(opts.configFile, opts.flags, reload))
+ assert.Check(t, config.Reload(opts.configFile, opts.flags, reload))
}
func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) {
@@ -92,8 +92,8 @@ func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) {
opts := defaultOptions(tempFile.Path())
loadedConfig, err := loadDaemonCliConfig(opts)
- require.NoError(t, err)
- require.NotNil(t, loadedConfig)
+ assert.NilError(t, err)
+ assert.Assert(t, loadedConfig != nil)
- assert.True(t, loadedConfig.EnableUserlandProxy)
+ assert.Check(t, loadedConfig.EnableUserlandProxy)
}
diff --git a/cmd/dockerd/options_test.go b/cmd/dockerd/options_test.go
index c3298a0ac6..2a4e63b6b6 100644
--- a/cmd/dockerd/options_test.go
+++ b/cmd/dockerd/options_test.go
@@ -6,8 +6,9 @@ import (
cliconfig "github.com/docker/docker/cli/config"
"github.com/docker/docker/daemon/config"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/spf13/pflag"
- "github.com/stretchr/testify/assert"
)
func TestCommonOptionsInstallFlags(t *testing.T) {
@@ -20,10 +21,10 @@ func TestCommonOptionsInstallFlags(t *testing.T) {
"--tlscert=\"/foo/cert\"",
"--tlskey=\"/foo/key\"",
})
- assert.NoError(t, err)
- assert.Equal(t, "/foo/cafile", opts.TLSOptions.CAFile)
- assert.Equal(t, "/foo/cert", opts.TLSOptions.CertFile)
- assert.Equal(t, opts.TLSOptions.KeyFile, "/foo/key")
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("/foo/cafile", opts.TLSOptions.CAFile))
+ assert.Check(t, is.Equal("/foo/cert", opts.TLSOptions.CertFile))
+ assert.Check(t, is.Equal(opts.TLSOptions.KeyFile, "/foo/key"))
}
func defaultPath(filename string) string {
@@ -36,8 +37,8 @@ func TestCommonOptionsInstallFlagsWithDefaults(t *testing.T) {
opts.InstallFlags(flags)
err := flags.Parse([]string{})
- assert.NoError(t, err)
- assert.Equal(t, defaultPath("ca.pem"), opts.TLSOptions.CAFile)
- assert.Equal(t, defaultPath("cert.pem"), opts.TLSOptions.CertFile)
- assert.Equal(t, defaultPath("key.pem"), opts.TLSOptions.KeyFile)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(defaultPath("ca.pem"), opts.TLSOptions.CAFile))
+ assert.Check(t, is.Equal(defaultPath("cert.pem"), opts.TLSOptions.CertFile))
+ assert.Check(t, is.Equal(defaultPath("key.pem"), opts.TLSOptions.KeyFile))
}
diff --git a/container/container_unit_test.go b/container/container_unit_test.go
index 863a47a1f2..bf45df942e 100644
--- a/container/container_unit_test.go
+++ b/container/container_unit_test.go
@@ -11,7 +11,7 @@ import (
swarmtypes "github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/daemon/logger/jsonfilelog"
"github.com/docker/docker/pkg/signal"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestContainerStopSignal(t *testing.T) {
@@ -74,7 +74,7 @@ func TestContainerSecretReferenceDestTarget(t *testing.T) {
func TestContainerLogPathSetForJSONFileLogger(t *testing.T) {
containerRoot, err := ioutil.TempDir("", "TestContainerLogPathSetForJSONFileLogger")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(containerRoot)
c := &Container{
@@ -89,17 +89,17 @@ func TestContainerLogPathSetForJSONFileLogger(t *testing.T) {
}
logger, err := c.StartLogger()
- require.NoError(t, err)
+ assert.NilError(t, err)
defer logger.Close()
expectedLogPath, err := filepath.Abs(filepath.Join(containerRoot, fmt.Sprintf("%s-json.log", c.ID)))
- require.NoError(t, err)
- require.Equal(t, c.LogPath, expectedLogPath)
+ assert.NilError(t, err)
+ assert.Equal(t, c.LogPath, expectedLogPath)
}
func TestContainerLogPathSetForRingLogger(t *testing.T) {
containerRoot, err := ioutil.TempDir("", "TestContainerLogPathSetForRingLogger")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(containerRoot)
c := &Container{
@@ -117,10 +117,10 @@ func TestContainerLogPathSetForRingLogger(t *testing.T) {
}
logger, err := c.StartLogger()
- require.NoError(t, err)
+ assert.NilError(t, err)
defer logger.Close()
expectedLogPath, err := filepath.Abs(filepath.Join(containerRoot, fmt.Sprintf("%s-json.log", c.ID)))
- require.NoError(t, err)
- require.Equal(t, c.LogPath, expectedLogPath)
+ assert.NilError(t, err)
+ assert.Equal(t, c.LogPath, expectedLogPath)
}
diff --git a/container/view_test.go b/container/view_test.go
index 26803b04e6..a872dffea6 100644
--- a/container/view_test.go
+++ b/container/view_test.go
@@ -8,8 +8,9 @@ import (
"github.com/docker/docker/api/types"
containertypes "github.com/docker/docker/api/types/container"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pborman/uuid"
- "github.com/stretchr/testify/assert"
)
var root string
@@ -109,56 +110,56 @@ func TestNames(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- assert.NoError(t, db.ReserveName("name1", "containerid1"))
- assert.NoError(t, db.ReserveName("name1", "containerid1")) // idempotent
- assert.NoError(t, db.ReserveName("name2", "containerid2"))
- assert.EqualError(t, db.ReserveName("name2", "containerid3"), ErrNameReserved.Error())
+ assert.Check(t, db.ReserveName("name1", "containerid1"))
+ assert.Check(t, db.ReserveName("name1", "containerid1")) // idempotent
+ assert.Check(t, db.ReserveName("name2", "containerid2"))
+ assert.Check(t, is.Error(db.ReserveName("name2", "containerid3"), ErrNameReserved.Error()))
// Releasing a name allows the name to point to something else later.
- assert.NoError(t, db.ReleaseName("name2"))
- assert.NoError(t, db.ReserveName("name2", "containerid3"))
+ assert.Check(t, db.ReleaseName("name2"))
+ assert.Check(t, db.ReserveName("name2", "containerid3"))
view := db.Snapshot()
id, err := view.GetID("name1")
- assert.NoError(t, err)
- assert.Equal(t, "containerid1", id)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("containerid1", id))
id, err = view.GetID("name2")
- assert.NoError(t, err)
- assert.Equal(t, "containerid3", id)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("containerid3", id))
_, err = view.GetID("notreserved")
- assert.EqualError(t, err, ErrNameNotReserved.Error())
+ assert.Check(t, is.Error(err, ErrNameNotReserved.Error()))
// Releasing and re-reserving a name doesn't affect the snapshot.
- assert.NoError(t, db.ReleaseName("name2"))
- assert.NoError(t, db.ReserveName("name2", "containerid4"))
+ assert.Check(t, db.ReleaseName("name2"))
+ assert.Check(t, db.ReserveName("name2", "containerid4"))
id, err = view.GetID("name1")
- assert.NoError(t, err)
- assert.Equal(t, "containerid1", id)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("containerid1", id))
id, err = view.GetID("name2")
- assert.NoError(t, err)
- assert.Equal(t, "containerid3", id)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("containerid3", id))
// GetAllNames
- assert.Equal(t, map[string][]string{"containerid1": {"name1"}, "containerid3": {"name2"}}, view.GetAllNames())
+ assert.Check(t, is.DeepEqual(map[string][]string{"containerid1": {"name1"}, "containerid3": {"name2"}}, view.GetAllNames()))
- assert.NoError(t, db.ReserveName("name3", "containerid1"))
- assert.NoError(t, db.ReserveName("name4", "containerid1"))
+ assert.Check(t, db.ReserveName("name3", "containerid1"))
+ assert.Check(t, db.ReserveName("name4", "containerid1"))
view = db.Snapshot()
- assert.Equal(t, map[string][]string{"containerid1": {"name1", "name3", "name4"}, "containerid4": {"name2"}}, view.GetAllNames())
+ assert.Check(t, is.DeepEqual(map[string][]string{"containerid1": {"name1", "name3", "name4"}, "containerid4": {"name2"}}, view.GetAllNames()))
// Release containerid1's names with Delete even though no container exists
- assert.NoError(t, db.Delete(&Container{ID: "containerid1"}))
+ assert.Check(t, db.Delete(&Container{ID: "containerid1"}))
// Reusing one of those names should work
- assert.NoError(t, db.ReserveName("name1", "containerid4"))
+ assert.Check(t, db.ReserveName("name1", "containerid4"))
view = db.Snapshot()
- assert.Equal(t, map[string][]string{"containerid4": {"name1", "name2"}}, view.GetAllNames())
+ assert.Check(t, is.DeepEqual(map[string][]string{"containerid4": {"name1", "name2"}}, view.GetAllNames()))
}
// Test case for GitHub issue 35920
diff --git a/daemon/cluster/convert/service_test.go b/daemon/cluster/convert/service_test.go
index 347aa028be..0794af99a6 100644
--- a/daemon/cluster/convert/service_test.go
+++ b/daemon/cluster/convert/service_test.go
@@ -8,7 +8,7 @@ import (
"github.com/docker/docker/api/types/swarm/runtime"
swarmapi "github.com/docker/swarmkit/api"
google_protobuf3 "github.com/gogo/protobuf/types"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestServiceConvertFromGRPCRuntimeContainer(t *testing.T) {
@@ -178,12 +178,12 @@ func TestServiceConvertToGRPCIsolation(t *testing.T) {
},
}
res, err := ServiceSpecToGRPC(s)
- require.NoError(t, err)
+ assert.NilError(t, err)
v, ok := res.Task.Runtime.(*swarmapi.TaskSpec_Container)
if !ok {
t.Fatal("expected type swarmapi.TaskSpec_Container")
}
- require.Equal(t, c.to, v.Container.Isolation)
+ assert.Equal(t, c.to, v.Container.Isolation)
})
}
}
@@ -228,7 +228,7 @@ func TestServiceConvertFromGRPCIsolation(t *testing.T) {
t.Fatal(err)
}
- require.Equal(t, c.to, svc.Spec.TaskTemplate.ContainerSpec.Isolation)
+ assert.Equal(t, c.to, svc.Spec.TaskTemplate.ContainerSpec.Isolation)
})
}
}
diff --git a/daemon/cluster/executor/container/container_test.go b/daemon/cluster/executor/container/container_test.go
index 456cd403b1..1e94171974 100644
--- a/daemon/cluster/executor/container/container_test.go
+++ b/daemon/cluster/executor/container/container_test.go
@@ -5,7 +5,7 @@ import (
container "github.com/docker/docker/api/types/container"
swarmapi "github.com/docker/swarmkit/api"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestIsolationConversion(t *testing.T) {
@@ -31,7 +31,7 @@ func TestIsolationConversion(t *testing.T) {
},
}
config := containerConfig{task: &task}
- require.Equal(t, c.to, config.hostConfig().Isolation)
+ assert.Equal(t, c.to, config.hostConfig().Isolation)
})
}
}
diff --git a/daemon/config/config_test.go b/daemon/config/config_test.go
index 53db2922cb..2fe2b3805c 100644
--- a/daemon/config/config_test.go
+++ b/daemon/config/config_test.go
@@ -9,9 +9,10 @@ import (
"github.com/docker/docker/daemon/discovery"
"github.com/docker/docker/internal/testutil"
"github.com/docker/docker/opts"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
"github.com/spf13/pflag"
- "github.com/stretchr/testify/assert"
)
func TestDaemonConfigurationNotFound(t *testing.T) {
@@ -59,7 +60,7 @@ func TestFindConfigurationConflicts(t *testing.T) {
flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
flags.String("authorization-plugins", "", "")
- assert.NoError(t, flags.Set("authorization-plugins", "asdf"))
+ assert.Check(t, flags.Set("authorization-plugins", "asdf"))
testutil.ErrorContains(t,
findConfigurationConflicts(config, flags),
@@ -72,8 +73,8 @@ func TestFindConfigurationConflictsWithNamedOptions(t *testing.T) {
var hosts []string
flags.VarP(opts.NewNamedListOptsRef("hosts", &hosts, opts.ValidateHost), "host", "H", "Daemon socket(s) to connect to")
- assert.NoError(t, flags.Set("host", "tcp://127.0.0.1:4444"))
- assert.NoError(t, flags.Set("host", "unix:///var/run/docker.sock"))
+ assert.Check(t, flags.Set("host", "tcp://127.0.0.1:4444"))
+ assert.Check(t, flags.Set("host", "unix:///var/run/docker.sock"))
testutil.ErrorContains(t, findConfigurationConflicts(config, flags), "hosts")
}
@@ -424,7 +425,7 @@ func TestReloadSetConfigFileNotExist(t *testing.T) {
flags.Set("config-file", configFile)
err := Reload(configFile, flags, func(c *Config) {})
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
testutil.ErrorContains(t, err, "unable to configure the Docker daemon with file")
}
@@ -438,8 +439,8 @@ func TestReloadDefaultConfigNotExist(t *testing.T) {
err := Reload(configFile, flags, func(c *Config) {
reloaded = true
})
- assert.Nil(t, err)
- assert.True(t, reloaded)
+ assert.Check(t, err)
+ assert.Check(t, reloaded)
}
// TestReloadBadDefaultConfig tests that when `--config-file` is not set
@@ -457,7 +458,7 @@ func TestReloadBadDefaultConfig(t *testing.T) {
flags := pflag.NewFlagSet("test", pflag.ContinueOnError)
flags.String("config-file", configFile, "")
err = Reload(configFile, flags, func(c *Config) {})
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
testutil.ErrorContains(t, err, "unable to configure the Docker daemon with file")
}
@@ -484,5 +485,5 @@ func TestReloadWithDuplicateLabels(t *testing.T) {
flags.String("config-file", configFile, "")
flags.StringSlice("labels", lbls, "")
err := Reload(configFile, flags, func(c *Config) {})
- assert.NoError(t, err)
+ assert.Check(t, err)
}
diff --git a/daemon/config/config_unix_test.go b/daemon/config/config_unix_test.go
index b4efa95e0e..53eb428264 100644
--- a/daemon/config/config_unix_test.go
+++ b/daemon/config/config_unix_test.go
@@ -7,10 +7,10 @@ import (
"github.com/docker/docker/opts"
units "github.com/docker/go-units"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
"github.com/spf13/pflag"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestGetConflictFreeConfiguration(t *testing.T) {
@@ -39,9 +39,9 @@ func TestGetConflictFreeConfiguration(t *testing.T) {
flags.Var(opts.NewNamedMapOpts("log-opts", nil, nil), "log-opt", "")
cc, err := getConflictFreeConfiguration(file.Path(), flags)
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.True(t, cc.Debug)
+ assert.Check(t, cc.Debug)
expectedUlimits := map[string]*units.Ulimit{
"nofile": {
@@ -51,7 +51,7 @@ func TestGetConflictFreeConfiguration(t *testing.T) {
},
}
- assert.Equal(t, expectedUlimits, cc.Ulimits)
+ assert.Check(t, is.DeepEqual(expectedUlimits, cc.Ulimits))
}
func TestDaemonConfigurationMerge(t *testing.T) {
@@ -91,17 +91,17 @@ func TestDaemonConfigurationMerge(t *testing.T) {
flags.Var(opts.NewNamedMapOpts("log-opts", nil, nil), "log-opt", "")
cc, err := MergeDaemonConfigurations(c, flags, file.Path())
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.True(t, cc.Debug)
- assert.True(t, cc.AutoRestart)
+ assert.Check(t, cc.Debug)
+ assert.Check(t, cc.AutoRestart)
expectedLogConfig := LogConfig{
Type: "syslog",
Config: map[string]string{"tag": "test_tag"},
}
- assert.Equal(t, expectedLogConfig, cc.LogConfig)
+ assert.Check(t, is.DeepEqual(expectedLogConfig, cc.LogConfig))
expectedUlimits := map[string]*units.Ulimit{
"nofile": {
@@ -111,7 +111,7 @@ func TestDaemonConfigurationMerge(t *testing.T) {
},
}
- assert.Equal(t, expectedUlimits, cc.Ulimits)
+ assert.Check(t, is.DeepEqual(expectedUlimits, cc.Ulimits))
}
func TestDaemonConfigurationMergeShmSize(t *testing.T) {
@@ -127,8 +127,8 @@ func TestDaemonConfigurationMergeShmSize(t *testing.T) {
flags.Var(&shmSize, "default-shm-size", "")
cc, err := MergeDaemonConfigurations(c, flags, file.Path())
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedValue := 1 * 1024 * 1024 * 1024
- assert.Equal(t, int64(expectedValue), cc.ShmSize.Value())
+ assert.Check(t, is.Equal(int64(expectedValue), cc.ShmSize.Value()))
}
diff --git a/daemon/config/config_windows_test.go b/daemon/config/config_windows_test.go
index 5382bb3b77..fff98014f9 100644
--- a/daemon/config/config_windows_test.go
+++ b/daemon/config/config_windows_test.go
@@ -7,9 +7,9 @@ import (
"testing"
"github.com/docker/docker/opts"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/spf13/pflag"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestDaemonConfigurationMerge(t *testing.T) {
@@ -46,15 +46,15 @@ func TestDaemonConfigurationMerge(t *testing.T) {
flags.Var(opts.NewNamedMapOpts("log-opts", nil, nil), "log-opt", "")
cc, err := MergeDaemonConfigurations(c, flags, configFile)
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.True(t, cc.Debug)
- assert.True(t, cc.AutoRestart)
+ assert.Check(t, cc.Debug)
+ assert.Check(t, cc.AutoRestart)
expectedLogConfig := LogConfig{
Type: "syslog",
Config: map[string]string{"tag": "test_tag"},
}
- assert.Equal(t, expectedLogConfig, cc.LogConfig)
+ assert.Check(t, is.DeepEqual(expectedLogConfig, cc.LogConfig))
}
diff --git a/daemon/container_unix_test.go b/daemon/container_unix_test.go
index e102be6cdc..12075f8b8d 100644
--- a/daemon/container_unix_test.go
+++ b/daemon/container_unix_test.go
@@ -9,7 +9,7 @@ import (
containertypes "github.com/docker/docker/api/types/container"
"github.com/docker/docker/daemon/config"
"github.com/docker/go-connections/nat"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// TestContainerWarningHostAndPublishPorts that a warning is returned when setting network mode to host and specifying published ports.
@@ -38,7 +38,7 @@ func TestContainerWarningHostAndPublishPorts(t *testing.T) {
}
d := &Daemon{configStore: cs}
wrns, err := d.verifyContainerSettings("", hostConfig, &containertypes.Config{}, false)
- require.NoError(t, err)
- require.Equal(t, tc.warnings, wrns)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, tc.warnings, wrns)
}
}
diff --git a/daemon/create_test.go b/daemon/create_test.go
index 3e355f6473..7ef49d7623 100644
--- a/daemon/create_test.go
+++ b/daemon/create_test.go
@@ -5,7 +5,7 @@ import (
"github.com/docker/docker/api/types/network"
"github.com/docker/docker/errdefs"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// Test case for 35752
@@ -17,5 +17,5 @@ func TestVerifyNetworkingConfig(t *testing.T) {
EndpointsConfig: endpoints,
}
err := verifyNetworkingConfig(nwConfig)
- assert.True(t, errdefs.IsInvalidParameter(err))
+ assert.Check(t, errdefs.IsInvalidParameter(err))
}
diff --git a/daemon/daemon_linux_test.go b/daemon/daemon_linux_test.go
index ad651e3e1c..195afb1e0f 100644
--- a/daemon/daemon_linux_test.go
+++ b/daemon/daemon_linux_test.go
@@ -11,8 +11,8 @@ import (
"github.com/docker/docker/oci"
"github.com/docker/docker/pkg/idtools"
"github.com/docker/docker/pkg/mount"
-
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
const mountsFixture = `142 78 0:38 / / rw,relatime - aufs none rw,si=573b861da0b3a05b,dio
@@ -138,7 +138,7 @@ func TestTmpfsDevShmSizeOverride(t *testing.T) {
// convert ms to spec
spec := oci.DefaultSpec()
err := setMounts(&d, &spec, c, ms)
- assert.NoError(t, err)
+ assert.Check(t, err)
// Check the resulting spec for the correct size
found := false
@@ -149,7 +149,7 @@ func TestTmpfsDevShmSizeOverride(t *testing.T) {
continue
}
t.Logf("%+v\n", m.Options)
- assert.Equal(t, "size="+size, o)
+ assert.Check(t, is.Equal("size="+size, o))
found = true
}
}
@@ -163,7 +163,7 @@ func TestValidateContainerIsolationLinux(t *testing.T) {
d := Daemon{}
_, err := d.verifyContainerSettings("linux", &containertypes.HostConfig{Isolation: containertypes.IsolationHyperV}, nil, false)
- assert.EqualError(t, err, "invalid isolation 'hyperv' on linux")
+ assert.Check(t, is.Error(err, "invalid isolation 'hyperv' on linux"))
}
func TestShouldUnmountRoot(t *testing.T) {
@@ -222,7 +222,7 @@ func TestShouldUnmountRoot(t *testing.T) {
if test.info != nil {
test.info.Optional = options.Optional
}
- assert.Equal(t, expect, shouldUnmountRoot(test.root, test.info))
+ assert.Check(t, is.Equal(expect, shouldUnmountRoot(test.root, test.info)))
})
}
})
diff --git a/daemon/daemon_test.go b/daemon/daemon_test.go
index 5d40e11143..2fb4ff902a 100644
--- a/daemon/daemon_test.go
+++ b/daemon/daemon_test.go
@@ -19,8 +19,9 @@ import (
"github.com/docker/docker/volume/store"
"github.com/docker/go-connections/nat"
"github.com/docker/libnetwork"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
)
//
@@ -312,7 +313,7 @@ func TestValidateContainerIsolation(t *testing.T) {
d := Daemon{}
_, err := d.verifyContainerSettings(runtime.GOOS, &containertypes.HostConfig{Isolation: containertypes.Isolation("invalid")}, nil, false)
- assert.EqualError(t, err, "invalid isolation 'invalid' on "+runtime.GOOS)
+ assert.Check(t, is.Error(err, "invalid isolation 'invalid' on "+runtime.GOOS))
}
func TestFindNetworkErrorType(t *testing.T) {
@@ -320,6 +321,6 @@ func TestFindNetworkErrorType(t *testing.T) {
_, err := d.FindNetwork("fakeNet")
_, ok := errors.Cause(err).(libnetwork.ErrNoSuchNetwork)
if !errdefs.IsNotFound(err) || !ok {
- assert.Fail(t, "The FindNetwork method MUST always return an error that implements the NotFound interface and is ErrNoSuchNetwork")
+ t.Error("The FindNetwork method MUST always return an error that implements the NotFound interface and is ErrNoSuchNetwork")
}
}
diff --git a/daemon/daemon_unix_test.go b/daemon/daemon_unix_test.go
index cd88b38335..84281c0b8c 100644
--- a/daemon/daemon_unix_test.go
+++ b/daemon/daemon_unix_test.go
@@ -17,7 +17,7 @@ import (
"github.com/docker/docker/volume/drivers"
"github.com/docker/docker/volume/local"
"github.com/docker/docker/volume/store"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
type fakeContainerGetter struct {
@@ -290,12 +290,12 @@ func TestMigratePre17Volumes(t *testing.T) {
containerRoot := filepath.Join(rootDir, "containers")
cid := "1234"
err = os.MkdirAll(filepath.Join(containerRoot, cid), 0755)
- require.NoError(t, err)
+ assert.NilError(t, err)
vid := "5678"
vfsPath := filepath.Join(rootDir, "vfs", "dir", vid)
err = os.MkdirAll(vfsPath, 0755)
- require.NoError(t, err)
+ assert.NilError(t, err)
config := []byte(`
{
diff --git a/daemon/delete_test.go b/daemon/delete_test.go
index 48a8afec48..8bfa5d8170 100644
--- a/daemon/delete_test.go
+++ b/daemon/delete_test.go
@@ -10,12 +10,12 @@ import (
containertypes "github.com/docker/docker/api/types/container"
"github.com/docker/docker/container"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func newDaemonWithTmpRoot(t *testing.T) (*Daemon, func()) {
tmp, err := ioutil.TempDir("", "docker-daemon-unix-test-")
- require.NoError(t, err)
+ assert.NilError(t, err)
d := &Daemon{
repository: tmp,
root: tmp,
diff --git a/daemon/discovery/discovery_test.go b/daemon/discovery/discovery_test.go
index 4560af2878..d00e02e10b 100644
--- a/daemon/discovery/discovery_test.go
+++ b/daemon/discovery/discovery_test.go
@@ -5,8 +5,8 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestDiscoveryOptsErrors(t *testing.T) {
@@ -42,26 +42,26 @@ func TestDiscoveryOptsErrors(t *testing.T) {
for _, testcase := range testcases {
_, _, err := discoveryOpts(testcase.opts)
- assert.Error(t, err, testcase.doc)
+ assert.Check(t, is.ErrorContains(err, ""), testcase.doc)
}
}
func TestDiscoveryOpts(t *testing.T) {
clusterOpts := map[string]string{"discovery.heartbeat": "10", "discovery.ttl": "20"}
heartbeat, ttl, err := discoveryOpts(clusterOpts)
- require.NoError(t, err)
- assert.Equal(t, 10*time.Second, heartbeat)
- assert.Equal(t, 20*time.Second, ttl)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(10*time.Second, heartbeat))
+ assert.Check(t, is.Equal(20*time.Second, ttl))
clusterOpts = map[string]string{"discovery.heartbeat": "10"}
heartbeat, ttl, err = discoveryOpts(clusterOpts)
- require.NoError(t, err)
- assert.Equal(t, 10*time.Second, heartbeat)
- assert.Equal(t, 10*defaultDiscoveryTTLFactor*time.Second, ttl)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(10*time.Second, heartbeat))
+ assert.Check(t, is.Equal(10*defaultDiscoveryTTLFactor*time.Second, ttl))
clusterOpts = map[string]string{"discovery.ttl": "30"}
heartbeat, ttl, err = discoveryOpts(clusterOpts)
- require.NoError(t, err)
+ assert.NilError(t, err)
if ttl != 30*time.Second {
t.Fatalf("TTL - Expected : %v, Actual : %v", 30*time.Second, ttl)
diff --git a/daemon/graphdriver/aufs/aufs_test.go b/daemon/graphdriver/aufs/aufs_test.go
index d0641abe35..2338ad320d 100644
--- a/daemon/graphdriver/aufs/aufs_test.go
+++ b/daemon/graphdriver/aufs/aufs_test.go
@@ -17,8 +17,8 @@ import (
"github.com/docker/docker/pkg/archive"
"github.com/docker/docker/pkg/reexec"
"github.com/docker/docker/pkg/stringid"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
var (
@@ -189,7 +189,7 @@ func TestCleanupWithNoDirs(t *testing.T) {
defer os.RemoveAll(tmp)
err := d.Cleanup()
- assert.NoError(t, err)
+ assert.Check(t, err)
}
func TestCleanupWithDir(t *testing.T) {
@@ -210,11 +210,11 @@ func TestMountedFalseResponse(t *testing.T) {
defer os.RemoveAll(tmp)
err := d.Create("1", "", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
response, err := d.mounted(d.getDiffPath("1"))
- require.NoError(t, err)
- assert.False(t, response)
+ assert.NilError(t, err)
+ assert.Check(t, !response)
}
func TestMountedTrueResponse(t *testing.T) {
@@ -223,16 +223,16 @@ func TestMountedTrueResponse(t *testing.T) {
defer d.Cleanup()
err := d.Create("1", "", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = d.Create("2", "1", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = d.Get("2", "")
- require.NoError(t, err)
+ assert.NilError(t, err)
response, err := d.mounted(d.pathCache["2"])
- require.NoError(t, err)
- assert.True(t, response)
+ assert.NilError(t, err)
+ assert.Check(t, response)
}
func TestMountWithParent(t *testing.T) {
@@ -567,7 +567,7 @@ func TestStatus(t *testing.T) {
}
status := d.Status()
- assert.Len(t, status, 4)
+ assert.Check(t, is.Len(status, 4))
rootDir := status[0]
dirs := status[2]
@@ -670,18 +670,18 @@ func testMountMoreThan42Layers(t *testing.T, mountPath string) {
current = hash(current)
err := d.CreateReadWrite(current, parent, nil)
- require.NoError(t, err, "current layer %d", i)
+ assert.NilError(t, err, "current layer %d", i)
point, err := driverGet(d, current, "")
- require.NoError(t, err, "current layer %d", i)
+ assert.NilError(t, err, "current layer %d", i)
f, err := os.Create(path.Join(point, current))
- require.NoError(t, err, "current layer %d", i)
+ assert.NilError(t, err, "current layer %d", i)
f.Close()
if i%10 == 0 {
err := os.Remove(path.Join(point, parent))
- require.NoError(t, err, "current layer %d", i)
+ assert.NilError(t, err, "current layer %d", i)
expected--
}
last = current
@@ -689,10 +689,10 @@ func testMountMoreThan42Layers(t *testing.T, mountPath string) {
// Perform the actual mount for the top most image
point, err := driverGet(d, last, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
files, err := ioutil.ReadDir(point)
- require.NoError(t, err)
- assert.Len(t, files, expected)
+ assert.NilError(t, err)
+ assert.Check(t, is.Len(files, expected))
}
func TestMountMoreThan42Layers(t *testing.T) {
diff --git a/daemon/graphdriver/copy/copy_test.go b/daemon/graphdriver/copy/copy_test.go
index 6d4387c94e..a09bb2637e 100644
--- a/daemon/graphdriver/copy/copy_test.go
+++ b/daemon/graphdriver/copy/copy_test.go
@@ -14,8 +14,8 @@ import (
"github.com/docker/docker/pkg/parsers/kernel"
"github.com/docker/docker/pkg/system"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/sys/unix"
)
@@ -24,16 +24,16 @@ func TestIsCopyFileRangeSyscallAvailable(t *testing.T) {
// 1. That copyFileRangeEnabled is being set to true when copy_file_range syscall is available
// 2. That isCopyFileRangeSyscallAvailable() works on "new" kernels
v, err := kernel.GetKernelVersion()
- require.NoError(t, err)
+ assert.NilError(t, err)
copyWithFileRange := true
copyWithFileClone := false
doCopyTest(t, ©WithFileRange, ©WithFileClone)
if kernel.CompareKernelVersion(*v, kernel.VersionInfo{Kernel: 4, Major: 5, Minor: 0}) < 0 {
- assert.False(t, copyWithFileRange)
+ assert.Check(t, !copyWithFileRange)
} else {
- assert.True(t, copyWithFileRange)
+ assert.Check(t, copyWithFileRange)
}
}
@@ -52,47 +52,47 @@ func TestCopyWithoutRange(t *testing.T) {
func TestCopyDir(t *testing.T) {
srcDir, err := ioutil.TempDir("", "srcDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
populateSrcDir(t, srcDir, 3)
dstDir, err := ioutil.TempDir("", "testdst")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dstDir)
- assert.NoError(t, DirCopy(srcDir, dstDir, Content, false))
- require.NoError(t, filepath.Walk(srcDir, func(srcPath string, f os.FileInfo, err error) error {
+ assert.Check(t, DirCopy(srcDir, dstDir, Content, false))
+ assert.NilError(t, filepath.Walk(srcDir, func(srcPath string, f os.FileInfo, err error) error {
if err != nil {
return err
}
// Rebase path
relPath, err := filepath.Rel(srcDir, srcPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
if relPath == "." {
return nil
}
dstPath := filepath.Join(dstDir, relPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
// If we add non-regular dirs and files to the test
// then we need to add more checks here.
dstFileInfo, err := os.Lstat(dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
srcFileSys := f.Sys().(*syscall.Stat_t)
dstFileSys := dstFileInfo.Sys().(*syscall.Stat_t)
t.Log(relPath)
if srcFileSys.Dev == dstFileSys.Dev {
- assert.NotEqual(t, srcFileSys.Ino, dstFileSys.Ino)
+ assert.Check(t, srcFileSys.Ino != dstFileSys.Ino)
}
// Todo: check size, and ctim is not equal
/// on filesystems that have granular ctimes
- assert.Equal(t, srcFileSys.Mode, dstFileSys.Mode)
- assert.Equal(t, srcFileSys.Uid, dstFileSys.Uid)
- assert.Equal(t, srcFileSys.Gid, dstFileSys.Gid)
- assert.Equal(t, srcFileSys.Mtim, dstFileSys.Mtim)
+ assert.Check(t, is.DeepEqual(srcFileSys.Mode, dstFileSys.Mode))
+ assert.Check(t, is.DeepEqual(srcFileSys.Uid, dstFileSys.Uid))
+ assert.Check(t, is.DeepEqual(srcFileSys.Gid, dstFileSys.Gid))
+ assert.Check(t, is.DeepEqual(srcFileSys.Mtim, dstFileSys.Mtim))
return nil
}))
@@ -115,22 +115,22 @@ func populateSrcDir(t *testing.T, srcDir string, remainingDepth int) {
for i := 0; i < 10; i++ {
dirName := filepath.Join(srcDir, fmt.Sprintf("srcdir-%d", i))
// Owner all bits set
- require.NoError(t, os.Mkdir(dirName, randomMode(0700)))
+ assert.NilError(t, os.Mkdir(dirName, randomMode(0700)))
populateSrcDir(t, dirName, remainingDepth-1)
- require.NoError(t, system.Chtimes(dirName, aTime, mTime))
+ assert.NilError(t, system.Chtimes(dirName, aTime, mTime))
}
for i := 0; i < 10; i++ {
fileName := filepath.Join(srcDir, fmt.Sprintf("srcfile-%d", i))
// Owner read bit set
- require.NoError(t, ioutil.WriteFile(fileName, []byte{}, randomMode(0400)))
- require.NoError(t, system.Chtimes(fileName, aTime, mTime))
+ assert.NilError(t, ioutil.WriteFile(fileName, []byte{}, randomMode(0400)))
+ assert.NilError(t, system.Chtimes(fileName, aTime, mTime))
}
}
func doCopyTest(t *testing.T, copyWithFileRange, copyWithFileClone *bool) {
dir, err := ioutil.TempDir("", "docker-copy-check")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dir)
srcFilename := filepath.Join(dir, "srcFilename")
dstFilename := filepath.Join(dir, "dstilename")
@@ -138,42 +138,42 @@ func doCopyTest(t *testing.T, copyWithFileRange, copyWithFileClone *bool) {
r := rand.New(rand.NewSource(0))
buf := make([]byte, 1024)
_, err = r.Read(buf)
- require.NoError(t, err)
- require.NoError(t, ioutil.WriteFile(srcFilename, buf, 0777))
+ assert.NilError(t, err)
+ assert.NilError(t, ioutil.WriteFile(srcFilename, buf, 0777))
fileinfo, err := os.Stat(srcFilename)
- require.NoError(t, err)
+ assert.NilError(t, err)
- require.NoError(t, copyRegular(srcFilename, dstFilename, fileinfo, copyWithFileRange, copyWithFileClone))
+ assert.NilError(t, copyRegular(srcFilename, dstFilename, fileinfo, copyWithFileRange, copyWithFileClone))
readBuf, err := ioutil.ReadFile(dstFilename)
- require.NoError(t, err)
- assert.Equal(t, buf, readBuf)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(buf, readBuf))
}
func TestCopyHardlink(t *testing.T) {
var srcFile1FileInfo, srcFile2FileInfo, dstFile1FileInfo, dstFile2FileInfo unix.Stat_t
srcDir, err := ioutil.TempDir("", "srcDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(srcDir)
dstDir, err := ioutil.TempDir("", "dstDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dstDir)
srcFile1 := filepath.Join(srcDir, "file1")
srcFile2 := filepath.Join(srcDir, "file2")
dstFile1 := filepath.Join(dstDir, "file1")
dstFile2 := filepath.Join(dstDir, "file2")
- require.NoError(t, ioutil.WriteFile(srcFile1, []byte{}, 0777))
- require.NoError(t, os.Link(srcFile1, srcFile2))
+ assert.NilError(t, ioutil.WriteFile(srcFile1, []byte{}, 0777))
+ assert.NilError(t, os.Link(srcFile1, srcFile2))
- assert.NoError(t, DirCopy(srcDir, dstDir, Content, false))
+ assert.Check(t, DirCopy(srcDir, dstDir, Content, false))
- require.NoError(t, unix.Stat(srcFile1, &srcFile1FileInfo))
- require.NoError(t, unix.Stat(srcFile2, &srcFile2FileInfo))
- require.Equal(t, srcFile1FileInfo.Ino, srcFile2FileInfo.Ino)
+ assert.NilError(t, unix.Stat(srcFile1, &srcFile1FileInfo))
+ assert.NilError(t, unix.Stat(srcFile2, &srcFile2FileInfo))
+ assert.Equal(t, srcFile1FileInfo.Ino, srcFile2FileInfo.Ino)
- require.NoError(t, unix.Stat(dstFile1, &dstFile1FileInfo))
- require.NoError(t, unix.Stat(dstFile2, &dstFile2FileInfo))
- assert.Equal(t, dstFile1FileInfo.Ino, dstFile2FileInfo.Ino)
+ assert.NilError(t, unix.Stat(dstFile1, &dstFile1FileInfo))
+ assert.NilError(t, unix.Stat(dstFile2, &dstFile2FileInfo))
+ assert.Check(t, is.Equal(dstFile1FileInfo.Ino, dstFile2FileInfo.Ino))
}
diff --git a/daemon/graphdriver/driver_test.go b/daemon/graphdriver/driver_test.go
index 777bac7af9..4a29465f15 100644
--- a/daemon/graphdriver/driver_test.go
+++ b/daemon/graphdriver/driver_test.go
@@ -6,32 +6,31 @@ import (
"path/filepath"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestIsEmptyDir(t *testing.T) {
tmp, err := ioutil.TempDir("", "test-is-empty-dir")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmp)
d := filepath.Join(tmp, "empty-dir")
err = os.Mkdir(d, 0755)
- require.NoError(t, err)
+ assert.NilError(t, err)
empty := isEmptyDir(d)
- assert.True(t, empty)
+ assert.Check(t, empty)
d = filepath.Join(tmp, "dir-with-subdir")
err = os.MkdirAll(filepath.Join(d, "subdir"), 0755)
- require.NoError(t, err)
+ assert.NilError(t, err)
empty = isEmptyDir(d)
- assert.False(t, empty)
+ assert.Check(t, !empty)
d = filepath.Join(tmp, "dir-with-empty-file")
err = os.Mkdir(d, 0755)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = ioutil.TempFile(d, "file")
- require.NoError(t, err)
+ assert.NilError(t, err)
empty = isEmptyDir(d)
- assert.False(t, empty)
+ assert.Check(t, !empty)
}
diff --git a/daemon/graphdriver/graphtest/graphbench_unix.go b/daemon/graphdriver/graphtest/graphbench_unix.go
index 2eb4184c0f..1b221dabef 100644
--- a/daemon/graphdriver/graphtest/graphbench_unix.go
+++ b/daemon/graphdriver/graphtest/graphbench_unix.go
@@ -9,7 +9,7 @@ import (
contdriver "github.com/containerd/continuity/driver"
"github.com/docker/docker/pkg/stringid"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// DriverBenchExists benchmarks calls to exist
@@ -251,7 +251,7 @@ func DriverBenchDeepLayerRead(b *testing.B, layerCount int, drivername string, d
}
b.StopTimer()
- require.Equal(b, content, c)
+ assert.DeepEqual(b, content, c)
b.StartTimer()
}
}
diff --git a/daemon/graphdriver/graphtest/graphtest_unix.go b/daemon/graphdriver/graphtest/graphtest_unix.go
index a7bdd8cdaa..5ac3979752 100644
--- a/daemon/graphdriver/graphtest/graphtest_unix.go
+++ b/daemon/graphdriver/graphtest/graphtest_unix.go
@@ -16,8 +16,8 @@ import (
"github.com/docker/docker/daemon/graphdriver/quota"
"github.com/docker/docker/pkg/stringid"
"github.com/docker/go-units"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/sys/unix"
)
@@ -36,9 +36,9 @@ type Driver struct {
func newDriver(t testing.TB, name string, options []string) *Driver {
root, err := ioutil.TempDir("", "docker-graphtest-")
- require.NoError(t, err)
+ assert.NilError(t, err)
- require.NoError(t, os.MkdirAll(root, 0755))
+ assert.NilError(t, os.MkdirAll(root, 0755))
d, err := graphdriver.GetDriver(name, nil, graphdriver.Options{DriverOptions: options, Root: root})
if err != nil {
t.Logf("graphdriver: %v\n", err)
@@ -85,10 +85,10 @@ func DriverTestCreateEmpty(t testing.TB, drivername string, driverOptions ...str
defer PutDriver(t)
err := driver.Create("empty", "", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer func() {
- require.NoError(t, driver.Remove("empty"))
+ assert.NilError(t, driver.Remove("empty"))
}()
if !driver.Exists("empty") {
@@ -96,14 +96,14 @@ func DriverTestCreateEmpty(t testing.TB, drivername string, driverOptions ...str
}
dir, err := driver.Get("empty", "")
- require.NoError(t, err)
+ assert.NilError(t, err)
verifyFile(t, dir.Path(), 0755|os.ModeDir, 0, 0)
// Verify that the directory is empty
fis, err := readDir(dir, dir.Path())
- require.NoError(t, err)
- assert.Len(t, fis, 0)
+ assert.NilError(t, err)
+ assert.Check(t, is.Len(fis, 0))
driver.Put("empty")
}
@@ -115,7 +115,7 @@ func DriverTestCreateBase(t testing.TB, drivername string, driverOptions ...stri
createBase(t, driver, "Base")
defer func() {
- require.NoError(t, driver.Remove("Base"))
+ assert.NilError(t, driver.Remove("Base"))
}()
verifyBase(t, driver, "Base")
}
@@ -127,13 +127,13 @@ func DriverTestCreateSnap(t testing.TB, drivername string, driverOptions ...stri
createBase(t, driver, "Base")
defer func() {
- require.NoError(t, driver.Remove("Base"))
+ assert.NilError(t, driver.Remove("Base"))
}()
err := driver.Create("Snap", "Base", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer func() {
- require.NoError(t, driver.Remove("Snap"))
+ assert.NilError(t, driver.Remove("Snap"))
}()
verifyBase(t, driver, "Snap")
diff --git a/daemon/graphdriver/graphtest/testutil_unix.go b/daemon/graphdriver/graphtest/testutil_unix.go
index 4659bf2a19..3103df150d 100644
--- a/daemon/graphdriver/graphtest/testutil_unix.go
+++ b/daemon/graphdriver/graphtest/testutil_unix.go
@@ -9,25 +9,25 @@ import (
contdriver "github.com/containerd/continuity/driver"
"github.com/docker/docker/daemon/graphdriver"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/sys/unix"
)
func verifyFile(t testing.TB, path string, mode os.FileMode, uid, gid uint32) {
fi, err := os.Stat(path)
- require.NoError(t, err)
+ assert.NilError(t, err)
actual := fi.Mode()
- assert.Equal(t, mode&os.ModeType, actual&os.ModeType, path)
- assert.Equal(t, mode&os.ModePerm, actual&os.ModePerm, path)
- assert.Equal(t, mode&os.ModeSticky, actual&os.ModeSticky, path)
- assert.Equal(t, mode&os.ModeSetuid, actual&os.ModeSetuid, path)
- assert.Equal(t, mode&os.ModeSetgid, actual&os.ModeSetgid, path)
+ assert.Check(t, is.Equal(mode&os.ModeType, actual&os.ModeType), path)
+ assert.Check(t, is.Equal(mode&os.ModePerm, actual&os.ModePerm), path)
+ assert.Check(t, is.Equal(mode&os.ModeSticky, actual&os.ModeSticky), path)
+ assert.Check(t, is.Equal(mode&os.ModeSetuid, actual&os.ModeSetuid), path)
+ assert.Check(t, is.Equal(mode&os.ModeSetgid, actual&os.ModeSetgid), path)
if stat, ok := fi.Sys().(*syscall.Stat_t); ok {
- assert.Equal(t, uid, stat.Uid, path)
- assert.Equal(t, gid, stat.Gid, path)
+ assert.Check(t, is.Equal(uid, stat.Uid), path)
+ assert.Check(t, is.Equal(gid, stat.Gid), path)
}
}
@@ -37,24 +37,24 @@ func createBase(t testing.TB, driver graphdriver.Driver, name string) {
defer unix.Umask(oldmask)
err := driver.CreateReadWrite(name, "", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
dirFS, err := driver.Get(name, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer driver.Put(name)
subdir := dirFS.Join(dirFS.Path(), "a subdir")
- require.NoError(t, dirFS.Mkdir(subdir, 0705|os.ModeSticky))
- require.NoError(t, dirFS.Lchown(subdir, 1, 2))
+ assert.NilError(t, dirFS.Mkdir(subdir, 0705|os.ModeSticky))
+ assert.NilError(t, dirFS.Lchown(subdir, 1, 2))
file := dirFS.Join(dirFS.Path(), "a file")
err = contdriver.WriteFile(dirFS, file, []byte("Some data"), 0222|os.ModeSetuid)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func verifyBase(t testing.TB, driver graphdriver.Driver, name string) {
dirFS, err := driver.Get(name, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer driver.Put(name)
subdir := dirFS.Join(dirFS.Path(), "a subdir")
@@ -64,6 +64,6 @@ func verifyBase(t testing.TB, driver graphdriver.Driver, name string) {
verifyFile(t, file, 0222|os.ModeSetuid, 0, 0)
files, err := readDir(dirFS, dirFS.Path())
- require.NoError(t, err)
- assert.Len(t, files, 2)
+ assert.NilError(t, err)
+ assert.Check(t, is.Len(files, 2))
}
diff --git a/daemon/graphdriver/quota/projectquota_test.go b/daemon/graphdriver/quota/projectquota_test.go
index 939044fdc3..b7debf79e2 100644
--- a/daemon/graphdriver/quota/projectquota_test.go
+++ b/daemon/graphdriver/quota/projectquota_test.go
@@ -10,9 +10,9 @@ import (
"path/filepath"
"testing"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
@@ -80,14 +80,14 @@ func wrapMountTest(imageFileName string, enableQuota bool, testFunc func(t *test
}
}
- require.NoError(t, err, "mount failed: %s", out)
+ assert.NilError(t, err, "mount failed: %s", out)
defer func() {
- require.NoError(t, unix.Unmount(mountPoint, 0))
+ assert.NilError(t, unix.Unmount(mountPoint, 0))
}()
backingFsDev, err := makeBackingFsDev(mountPoint)
- require.NoError(t, err)
+ assert.NilError(t, err)
testFunc(t, mountPoint, backingFsDev)
}
@@ -95,58 +95,58 @@ func wrapMountTest(imageFileName string, enableQuota bool, testFunc func(t *test
func testBlockDevQuotaDisabled(t *testing.T, mountPoint, backingFsDev string) {
hasSupport, err := hasQuotaSupport(backingFsDev)
- require.NoError(t, err)
- assert.False(t, hasSupport)
+ assert.NilError(t, err)
+ assert.Check(t, !hasSupport)
}
func testBlockDevQuotaEnabled(t *testing.T, mountPoint, backingFsDev string) {
hasSupport, err := hasQuotaSupport(backingFsDev)
- require.NoError(t, err)
- assert.True(t, hasSupport)
+ assert.NilError(t, err)
+ assert.Check(t, hasSupport)
}
func wrapQuotaTest(testFunc func(t *testing.T, ctrl *Control, mountPoint, testDir, testSubDir string)) func(t *testing.T, mountPoint, backingFsDev string) {
return func(t *testing.T, mountPoint, backingFsDev string) {
testDir, err := ioutil.TempDir(mountPoint, "per-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(testDir)
ctrl, err := NewControl(testDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
testSubDir, err := ioutil.TempDir(testDir, "quota-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
testFunc(t, ctrl, mountPoint, testDir, testSubDir)
}
}
func testSmallerThanQuota(t *testing.T, ctrl *Control, homeDir, testDir, testSubDir string) {
- require.NoError(t, ctrl.SetQuota(testSubDir, Quota{testQuotaSize}))
+ assert.NilError(t, ctrl.SetQuota(testSubDir, Quota{testQuotaSize}))
smallerThanQuotaFile := filepath.Join(testSubDir, "smaller-than-quota")
- require.NoError(t, ioutil.WriteFile(smallerThanQuotaFile, make([]byte, testQuotaSize/2), 0644))
- require.NoError(t, os.Remove(smallerThanQuotaFile))
+ assert.NilError(t, ioutil.WriteFile(smallerThanQuotaFile, make([]byte, testQuotaSize/2), 0644))
+ assert.NilError(t, os.Remove(smallerThanQuotaFile))
}
func testBiggerThanQuota(t *testing.T, ctrl *Control, homeDir, testDir, testSubDir string) {
// Make sure the quota is being enforced
// TODO: When we implement this under EXT4, we need to shed CAP_SYS_RESOURCE, otherwise
// we're able to violate quota without issue
- require.NoError(t, ctrl.SetQuota(testSubDir, Quota{testQuotaSize}))
+ assert.NilError(t, ctrl.SetQuota(testSubDir, Quota{testQuotaSize}))
biggerThanQuotaFile := filepath.Join(testSubDir, "bigger-than-quota")
err := ioutil.WriteFile(biggerThanQuotaFile, make([]byte, testQuotaSize+1), 0644)
- require.Error(t, err)
+ assert.Assert(t, is.ErrorContains(err, ""))
if err == io.ErrShortWrite {
- require.NoError(t, os.Remove(biggerThanQuotaFile))
+ assert.NilError(t, os.Remove(biggerThanQuotaFile))
}
}
func testRetrieveQuota(t *testing.T, ctrl *Control, homeDir, testDir, testSubDir string) {
// Validate that we can retrieve quota
- require.NoError(t, ctrl.SetQuota(testSubDir, Quota{testQuotaSize}))
+ assert.NilError(t, ctrl.SetQuota(testSubDir, Quota{testQuotaSize}))
var q Quota
- require.NoError(t, ctrl.GetQuota(testSubDir, &q))
- assert.EqualValues(t, testQuotaSize, q.Size)
+ assert.NilError(t, ctrl.GetQuota(testSubDir, &q))
+ assert.Check(t, is.Equal(testQuotaSize, q.Size))
}
diff --git a/daemon/info_unix_test.go b/daemon/info_unix_test.go
index 92a336162a..7ff1009326 100644
--- a/daemon/info_unix_test.go
+++ b/daemon/info_unix_test.go
@@ -7,7 +7,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/dockerversion"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestParseInitVersion(t *testing.T) {
@@ -43,10 +44,10 @@ func TestParseInitVersion(t *testing.T) {
for _, test := range tests {
ver, err := parseInitVersion(string(test.version))
if test.invalid {
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
} else {
- assert.NoError(t, err)
+ assert.Check(t, err)
}
- assert.Equal(t, test.result, ver)
+ assert.Check(t, is.DeepEqual(test.result, ver))
}
}
diff --git a/daemon/inspect_test.go b/daemon/inspect_test.go
index c10cc56796..d1ad5b0e0a 100644
--- a/daemon/inspect_test.go
+++ b/daemon/inspect_test.go
@@ -7,8 +7,8 @@ import (
"github.com/docker/docker/container"
"github.com/docker/docker/daemon/config"
"github.com/docker/docker/daemon/exec"
-
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestGetInspectData(t *testing.T) {
@@ -25,9 +25,9 @@ func TestGetInspectData(t *testing.T) {
}
_, err := d.getInspectData(c)
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
c.Dead = true
_, err = d.getInspectData(c)
- assert.NoError(t, err)
+ assert.Check(t, err)
}
diff --git a/daemon/logger/adapter_test.go b/daemon/logger/adapter_test.go
index 25abab5717..7c1db6f575 100644
--- a/daemon/logger/adapter_test.go
+++ b/daemon/logger/adapter_test.go
@@ -10,7 +10,8 @@ import (
"github.com/docker/docker/api/types/plugins/logdriver"
protoio "github.com/gogo/protobuf/io"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
// mockLoggingPlugin implements the loggingPlugin interface for testing purposes
@@ -88,7 +89,7 @@ func (l *mockLoggingPlugin) ReadLogs(info Info, config ReadConfig) (io.ReadClose
func newMockPluginAdapter(t *testing.T) Logger {
r, w := io.Pipe()
f, err := ioutil.TempFile("", "mock-plugin-adapter")
- assert.NoError(t, err)
+ assert.Check(t, err)
enc := logdriver.NewLogEntryEncoder(w)
a := &pluginAdapterWithRead{
@@ -116,11 +117,11 @@ func TestAdapterReadLogs(t *testing.T) {
}
for _, msg := range testMsg {
m := msg.copy()
- assert.NoError(t, l.Log(m))
+ assert.Check(t, l.Log(m))
}
lr, ok := l.(LogReader)
- assert.NotNil(t, ok)
+ assert.Check(t, ok != nil)
lw := lr.ReadLogs(ReadConfig{})
@@ -135,7 +136,7 @@ func TestAdapterReadLogs(t *testing.T) {
select {
case _, ok := <-lw.Msg:
- assert.False(t, ok, "expected message channel to be closed")
+ assert.Check(t, !ok, "expected message channel to be closed")
case <-time.After(10 * time.Second):
t.Fatal("timeout waiting for message channel to close")
@@ -153,11 +154,11 @@ func TestAdapterReadLogs(t *testing.T) {
}
x := Message{Line: []byte("Too infinity and beyond!"), Timestamp: time.Now()}
- assert.NoError(t, l.Log(x.copy()))
+ assert.Check(t, l.Log(x.copy()))
select {
case msg, ok := <-lw.Msg:
- assert.NotNil(t, ok, "message channel unexpectedly closed")
+ assert.Check(t, ok != nil, "message channel unexpectedly closed")
testMessageEqual(t, &x, msg)
case <-time.After(10 * time.Second):
t.Fatal("timeout reading logs")
@@ -166,15 +167,15 @@ func TestAdapterReadLogs(t *testing.T) {
l.Close()
select {
case msg, ok := <-lw.Msg:
- assert.False(t, ok, "expected message channel to be closed")
- assert.Nil(t, msg)
+ assert.Check(t, !ok, "expected message channel to be closed")
+ assert.Check(t, is.Nil(msg))
case <-time.After(10 * time.Second):
t.Fatal("timeout waiting for logger to close")
}
}
func testMessageEqual(t *testing.T, a, b *Message) {
- assert.Equal(t, a.Line, b.Line)
- assert.Equal(t, a.Timestamp.UnixNano(), b.Timestamp.UnixNano())
- assert.Equal(t, a.Source, b.Source)
+ assert.Check(t, is.DeepEqual(a.Line, b.Line))
+ assert.Check(t, is.DeepEqual(a.Timestamp.UnixNano(), b.Timestamp.UnixNano()))
+ assert.Check(t, is.Equal(a.Source, b.Source))
}
diff --git a/daemon/logger/awslogs/cloudwatchlogs_test.go b/daemon/logger/awslogs/cloudwatchlogs_test.go
index 99d0f907f8..4a37d98167 100644
--- a/daemon/logger/awslogs/cloudwatchlogs_test.go
+++ b/daemon/logger/awslogs/cloudwatchlogs_test.go
@@ -21,7 +21,8 @@ import (
"github.com/docker/docker/daemon/logger"
"github.com/docker/docker/daemon/logger/loggerutils"
"github.com/docker/docker/dockerversion"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
const (
@@ -544,17 +545,17 @@ func TestCollectBatchMultilinePattern(t *testing.T) {
// Verify single multiline event
argument := <-mockClient.putLogEventsArgument
- assert.NotNil(t, argument, "Expected non-nil PutLogEventsInput")
- assert.Equal(t, 1, len(argument.LogEvents), "Expected single multiline event")
- assert.Equal(t, logline+"\n"+logline+"\n", *argument.LogEvents[0].Message, "Received incorrect multiline message")
+ assert.Check(t, argument != nil, "Expected non-nil PutLogEventsInput")
+ assert.Check(t, is.Equal(1, len(argument.LogEvents)), "Expected single multiline event")
+ assert.Check(t, is.Equal(logline+"\n"+logline+"\n", *argument.LogEvents[0].Message), "Received incorrect multiline message")
stream.Close()
// Verify single event
argument = <-mockClient.putLogEventsArgument
- assert.NotNil(t, argument, "Expected non-nil PutLogEventsInput")
- assert.Equal(t, 1, len(argument.LogEvents), "Expected single multiline event")
- assert.Equal(t, "xxxx "+logline+"\n", *argument.LogEvents[0].Message, "Received incorrect multiline message")
+ assert.Check(t, argument != nil, "Expected non-nil PutLogEventsInput")
+ assert.Check(t, is.Equal(1, len(argument.LogEvents)), "Expected single multiline event")
+ assert.Check(t, is.Equal("xxxx "+logline+"\n", *argument.LogEvents[0].Message), "Received incorrect multiline message")
}
func BenchmarkCollectBatch(b *testing.B) {
@@ -657,9 +658,9 @@ func TestCollectBatchMultilinePatternMaxEventAge(t *testing.T) {
// Verify single multiline event is flushed after maximum event buffer age (batchPublishFrequency)
argument := <-mockClient.putLogEventsArgument
- assert.NotNil(t, argument, "Expected non-nil PutLogEventsInput")
- assert.Equal(t, 1, len(argument.LogEvents), "Expected single multiline event")
- assert.Equal(t, logline+"\n"+logline+"\n", *argument.LogEvents[0].Message, "Received incorrect multiline message")
+ assert.Check(t, argument != nil, "Expected non-nil PutLogEventsInput")
+ assert.Check(t, is.Equal(1, len(argument.LogEvents)), "Expected single multiline event")
+ assert.Check(t, is.Equal(logline+"\n"+logline+"\n", *argument.LogEvents[0].Message), "Received incorrect multiline message")
// Log an event 1 second later
stream.Log(&logger.Message{
@@ -672,9 +673,9 @@ func TestCollectBatchMultilinePatternMaxEventAge(t *testing.T) {
// Verify the event buffer is truly flushed - we should only receive a single event
argument = <-mockClient.putLogEventsArgument
- assert.NotNil(t, argument, "Expected non-nil PutLogEventsInput")
- assert.Equal(t, 1, len(argument.LogEvents), "Expected single multiline event")
- assert.Equal(t, logline+"\n", *argument.LogEvents[0].Message, "Received incorrect multiline message")
+ assert.Check(t, argument != nil, "Expected non-nil PutLogEventsInput")
+ assert.Check(t, is.Equal(1, len(argument.LogEvents)), "Expected single multiline event")
+ assert.Check(t, is.Equal(logline+"\n", *argument.LogEvents[0].Message), "Received incorrect multiline message")
stream.Close()
}
@@ -719,9 +720,9 @@ func TestCollectBatchMultilinePatternNegativeEventAge(t *testing.T) {
// Verify single multiline event is flushed with a negative event buffer age
argument := <-mockClient.putLogEventsArgument
- assert.NotNil(t, argument, "Expected non-nil PutLogEventsInput")
- assert.Equal(t, 1, len(argument.LogEvents), "Expected single multiline event")
- assert.Equal(t, logline+"\n"+logline+"\n", *argument.LogEvents[0].Message, "Received incorrect multiline message")
+ assert.Check(t, argument != nil, "Expected non-nil PutLogEventsInput")
+ assert.Check(t, is.Equal(1, len(argument.LogEvents)), "Expected single multiline event")
+ assert.Check(t, is.Equal(logline+"\n"+logline+"\n", *argument.LogEvents[0].Message), "Received incorrect multiline message")
stream.Close()
}
@@ -772,10 +773,10 @@ func TestCollectBatchMultilinePatternMaxEventSize(t *testing.T) {
// We expect a maximum sized event with no new line characters and a
// second short event with a new line character at the end
argument := <-mockClient.putLogEventsArgument
- assert.NotNil(t, argument, "Expected non-nil PutLogEventsInput")
- assert.Equal(t, 2, len(argument.LogEvents), "Expected two events")
- assert.Equal(t, longline, *argument.LogEvents[0].Message, "Received incorrect multiline message")
- assert.Equal(t, shortline+"\n", *argument.LogEvents[1].Message, "Received incorrect multiline message")
+ assert.Check(t, argument != nil, "Expected non-nil PutLogEventsInput")
+ assert.Check(t, is.Equal(2, len(argument.LogEvents)), "Expected two events")
+ assert.Check(t, is.Equal(longline, *argument.LogEvents[0].Message), "Received incorrect multiline message")
+ assert.Check(t, is.Equal(shortline+"\n", *argument.LogEvents[1].Message), "Received incorrect multiline message")
stream.Close()
}
@@ -1069,8 +1070,8 @@ func TestParseLogOptionsMultilinePattern(t *testing.T) {
}
multilinePattern, err := parseMultilineOptions(info)
- assert.Nil(t, err, "Received unexpected error")
- assert.True(t, multilinePattern.MatchString("xxxx"), "No multiline pattern match found")
+ assert.Check(t, err, "Received unexpected error")
+ assert.Check(t, multilinePattern.MatchString("xxxx"), "No multiline pattern match found")
}
func TestParseLogOptionsDatetimeFormat(t *testing.T) {
@@ -1094,8 +1095,8 @@ func TestParseLogOptionsDatetimeFormat(t *testing.T) {
},
}
multilinePattern, err := parseMultilineOptions(info)
- assert.Nil(t, err, "Received unexpected error")
- assert.True(t, multilinePattern.MatchString(dt.match), "No multiline pattern match found")
+ assert.Check(t, err, "Received unexpected error")
+ assert.Check(t, multilinePattern.MatchString(dt.match), "No multiline pattern match found")
})
}
}
@@ -1109,8 +1110,8 @@ func TestValidateLogOptionsDatetimeFormatAndMultilinePattern(t *testing.T) {
conflictingLogOptionsError := "you cannot configure log opt 'awslogs-datetime-format' and 'awslogs-multiline-pattern' at the same time"
err := ValidateLogOpt(cfg)
- assert.NotNil(t, err, "Expected an error")
- assert.Equal(t, err.Error(), conflictingLogOptionsError, "Received invalid error")
+ assert.Check(t, err != nil, "Expected an error")
+ assert.Check(t, is.Equal(err.Error(), conflictingLogOptionsError), "Received invalid error")
}
func TestCreateTagSuccess(t *testing.T) {
@@ -1155,7 +1156,7 @@ func BenchmarkUnwrapEvents(b *testing.B) {
b.ResetTimer()
for i := 0; i < b.N; i++ {
res := unwrapEvents(events)
- assert.Len(b, res, maximumLogEventsPerPut)
+ assert.Check(b, is.Len(res, maximumLogEventsPerPut))
}
}
@@ -1188,15 +1189,15 @@ func TestNewAWSLogsClientCredentialEndpointDetect(t *testing.T) {
info.Config["awslogs-credentials-endpoint"] = "/creds"
c, err := newAWSLogsClient(info)
- assert.NoError(t, err)
+ assert.Check(t, err)
client := c.(*cloudwatchlogs.CloudWatchLogs)
creds, err := client.Config.Credentials.Get()
- assert.NoError(t, err)
+ assert.Check(t, err)
- assert.Equal(t, expectedAccessKeyID, creds.AccessKeyID)
- assert.Equal(t, expectedSecretAccessKey, creds.SecretAccessKey)
+ assert.Check(t, is.Equal(expectedAccessKeyID, creds.AccessKeyID))
+ assert.Check(t, is.Equal(expectedSecretAccessKey, creds.SecretAccessKey))
}
func TestNewAWSLogsClientCredentialEnvironmentVariable(t *testing.T) {
@@ -1218,15 +1219,15 @@ func TestNewAWSLogsClientCredentialEnvironmentVariable(t *testing.T) {
}
c, err := newAWSLogsClient(info)
- assert.NoError(t, err)
+ assert.Check(t, err)
client := c.(*cloudwatchlogs.CloudWatchLogs)
creds, err := client.Config.Credentials.Get()
- assert.NoError(t, err)
+ assert.Check(t, err)
- assert.Equal(t, expectedAccessKeyID, creds.AccessKeyID)
- assert.Equal(t, expectedSecretAccessKey, creds.SecretAccessKey)
+ assert.Check(t, is.Equal(expectedAccessKeyID, creds.AccessKeyID))
+ assert.Check(t, is.Equal(expectedSecretAccessKey, creds.SecretAccessKey))
}
@@ -1247,13 +1248,13 @@ func TestNewAWSLogsClientCredentialSharedFile(t *testing.T) {
tmpfile, err := ioutil.TempFile("", "example")
defer os.Remove(tmpfile.Name()) // clean up
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = tmpfile.Write(content)
- assert.NoError(t, err)
+ assert.Check(t, err)
err = tmpfile.Close()
- assert.NoError(t, err)
+ assert.Check(t, err)
os.Unsetenv("AWS_ACCESS_KEY_ID")
os.Unsetenv("AWS_SECRET_ACCESS_KEY")
@@ -1266,13 +1267,13 @@ func TestNewAWSLogsClientCredentialSharedFile(t *testing.T) {
}
c, err := newAWSLogsClient(info)
- assert.NoError(t, err)
+ assert.Check(t, err)
client := c.(*cloudwatchlogs.CloudWatchLogs)
creds, err := client.Config.Credentials.Get()
- assert.NoError(t, err)
+ assert.Check(t, err)
- assert.Equal(t, expectedAccessKeyID, creds.AccessKeyID)
- assert.Equal(t, expectedSecretAccessKey, creds.SecretAccessKey)
+ assert.Check(t, is.Equal(expectedAccessKeyID, creds.AccessKeyID))
+ assert.Check(t, is.Equal(expectedSecretAccessKey, creds.SecretAccessKey))
}
diff --git a/daemon/logger/jsonfilelog/jsonfilelog_test.go b/daemon/logger/jsonfilelog/jsonfilelog_test.go
index 2f74e26091..0174d88c0d 100644
--- a/daemon/logger/jsonfilelog/jsonfilelog_test.go
+++ b/daemon/logger/jsonfilelog/jsonfilelog_test.go
@@ -13,9 +13,9 @@ import (
"github.com/docker/docker/daemon/logger"
"github.com/docker/docker/daemon/logger/jsonfilelog/jsonlog"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestJSONFileLogger(t *testing.T) {
@@ -63,7 +63,7 @@ func TestJSONFileLoggerWithTags(t *testing.T) {
cname := "test-container"
tmp, err := ioutil.TempDir("", "docker-logger-")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmp)
filename := filepath.Join(tmp, "container.log")
@@ -76,26 +76,26 @@ func TestJSONFileLoggerWithTags(t *testing.T) {
LogPath: filename,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
defer l.Close()
err = l.Log(&logger.Message{Line: []byte("line1"), Source: "src1"})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = l.Log(&logger.Message{Line: []byte("line2"), Source: "src2"})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = l.Log(&logger.Message{Line: []byte("line3"), Source: "src3"})
- require.NoError(t, err)
+ assert.NilError(t, err)
res, err := ioutil.ReadFile(filename)
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := `{"log":"line1\n","stream":"src1","attrs":{"tag":"a7317399f3f8/test-container"},"time":"0001-01-01T00:00:00Z"}
{"log":"line2\n","stream":"src2","attrs":{"tag":"a7317399f3f8/test-container"},"time":"0001-01-01T00:00:00Z"}
{"log":"line3\n","stream":"src3","attrs":{"tag":"a7317399f3f8/test-container"},"time":"0001-01-01T00:00:00Z"}
`
- assert.Equal(t, expected, string(res))
+ assert.Check(t, is.Equal(expected, string(res)))
}
func BenchmarkJSONFileLoggerLog(b *testing.B) {
@@ -113,7 +113,7 @@ func BenchmarkJSONFileLoggerLog(b *testing.B) {
"second": "label_foo",
},
})
- require.NoError(b, err)
+ assert.NilError(b, err)
defer jsonlogger.Close()
msg := &logger.Message{
@@ -123,7 +123,7 @@ func BenchmarkJSONFileLoggerLog(b *testing.B) {
}
buf := bytes.NewBuffer(nil)
- require.NoError(b, marshalMessage(msg, nil, buf))
+ assert.NilError(b, marshalMessage(msg, nil, buf))
b.SetBytes(int64(buf.Len()))
b.ResetTimer()
diff --git a/daemon/logger/jsonfilelog/jsonlog/jsonlogbytes_test.go b/daemon/logger/jsonfilelog/jsonlog/jsonlogbytes_test.go
index 3701124354..d3e56df8cc 100644
--- a/daemon/logger/jsonfilelog/jsonlog/jsonlogbytes_test.go
+++ b/daemon/logger/jsonfilelog/jsonlog/jsonlogbytes_test.go
@@ -7,8 +7,7 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestJSONLogsMarshalJSONBuf(t *testing.T) {
@@ -35,8 +34,8 @@ func TestJSONLogsMarshalJSONBuf(t *testing.T) {
for jsonLog, expression := range logs {
var buf bytes.Buffer
err := jsonLog.MarshalJSONBuf(&buf)
- require.NoError(t, err)
+ assert.NilError(t, err)
assert.Regexp(t, regexp.MustCompile(expression), buf.String())
- assert.NoError(t, json.Unmarshal(buf.Bytes(), &map[string]interface{}{}))
+ assert.Check(t, json.Unmarshal(buf.Bytes(), &map[string]interface{}{}))
}
}
diff --git a/daemon/logger/jsonfilelog/jsonlog/time_marshalling_test.go b/daemon/logger/jsonfilelog/jsonlog/time_marshalling_test.go
index fee091eb6c..76f299a0f6 100644
--- a/daemon/logger/jsonfilelog/jsonlog/time_marshalling_test.go
+++ b/daemon/logger/jsonfilelog/jsonlog/time_marshalling_test.go
@@ -5,8 +5,8 @@ import (
"time"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestFastTimeMarshalJSONWithInvalidYear(t *testing.T) {
@@ -22,14 +22,14 @@ func TestFastTimeMarshalJSONWithInvalidYear(t *testing.T) {
func TestFastTimeMarshalJSON(t *testing.T) {
aTime := time.Date(2015, 5, 29, 11, 1, 2, 3, time.UTC)
json, err := fastTimeMarshalJSON(aTime)
- require.NoError(t, err)
- assert.Equal(t, "\"2015-05-29T11:01:02.000000003Z\"", json)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("\"2015-05-29T11:01:02.000000003Z\"", json))
location, err := time.LoadLocation("Europe/Paris")
- require.NoError(t, err)
+ assert.NilError(t, err)
aTime = time.Date(2015, 5, 29, 11, 1, 2, 3, location)
json, err = fastTimeMarshalJSON(aTime)
- require.NoError(t, err)
- assert.Equal(t, "\"2015-05-29T11:01:02.000000003+02:00\"", json)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("\"2015-05-29T11:01:02.000000003+02:00\"", json))
}
diff --git a/daemon/logger/jsonfilelog/read_test.go b/daemon/logger/jsonfilelog/read_test.go
index 342b538c28..f89fabfe1c 100644
--- a/daemon/logger/jsonfilelog/read_test.go
+++ b/daemon/logger/jsonfilelog/read_test.go
@@ -6,8 +6,8 @@ import (
"time"
"github.com/docker/docker/daemon/logger"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/require"
)
func BenchmarkJSONFileLoggerReadLogs(b *testing.B) {
@@ -25,7 +25,7 @@ func BenchmarkJSONFileLoggerReadLogs(b *testing.B) {
"second": "label_foo",
},
})
- require.NoError(b, err)
+ assert.NilError(b, err)
defer jsonlogger.Close()
msg := &logger.Message{
@@ -35,7 +35,7 @@ func BenchmarkJSONFileLoggerReadLogs(b *testing.B) {
}
buf := bytes.NewBuffer(nil)
- require.NoError(b, marshalMessage(msg, nil, buf))
+ assert.NilError(b, marshalMessage(msg, nil, buf))
b.SetBytes(int64(buf.Len()))
b.ResetTimer()
diff --git a/daemon/logger/splunk/splunk_test.go b/daemon/logger/splunk/splunk_test.go
index 9744cb561a..62895a6dd6 100644
--- a/daemon/logger/splunk/splunk_test.go
+++ b/daemon/logger/splunk/splunk_test.go
@@ -11,8 +11,8 @@ import (
"time"
"github.com/docker/docker/daemon/logger"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/env"
- "github.com/stretchr/testify/require"
)
// Validate options
@@ -99,19 +99,19 @@ func TestNewWithProxy(t *testing.T) {
},
ContainerID: "containeriid",
})
- require.NoError(t, err)
+ assert.NilError(t, err)
splunkLogger := logger.(*splunkLoggerInline)
proxyFunc := splunkLogger.transport.Proxy
- require.NotNil(t, proxyFunc)
+ assert.Assert(t, proxyFunc != nil)
req, err := http.NewRequest("GET", splunkURL, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
proxyURL, err := proxyFunc(req)
- require.NoError(t, err)
- require.NotNil(t, proxyURL)
- require.Equal(t, proxy, proxyURL.String())
+ assert.NilError(t, err)
+ assert.Assert(t, proxyURL != nil)
+ assert.Equal(t, proxy, proxyURL.String())
}
// Test default settings
@@ -483,10 +483,10 @@ func TestRawFormat(t *testing.T) {
}
hostname, err := info.Hostname()
- require.NoError(t, err)
+ assert.NilError(t, err)
loggerDriver, err := New(info)
- require.NoError(t, err)
+ assert.NilError(t, err)
if !hec.connectionVerified {
t.Fatal("By default connection should be verified")
diff --git a/daemon/logger/templates/templates_test.go b/daemon/logger/templates/templates_test.go
index 5e71d96f26..b767037477 100644
--- a/daemon/logger/templates/templates_test.go
+++ b/daemon/logger/templates/templates_test.go
@@ -4,15 +4,16 @@ import (
"bytes"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestNewParse(t *testing.T) {
tm, err := NewParse("foo", "this is a {{ . }}")
- assert.NoError(t, err)
+ assert.Check(t, err)
var b bytes.Buffer
- assert.NoError(t, tm.Execute(&b, "string"))
+ assert.Check(t, tm.Execute(&b, "string"))
want := "this is a string"
- assert.Equal(t, want, b.String())
+ assert.Check(t, is.Equal(want, b.String()))
}
diff --git a/daemon/oci_linux_test.go b/daemon/oci_linux_test.go
index f6bda79745..5f2731b8d6 100644
--- a/daemon/oci_linux_test.go
+++ b/daemon/oci_linux_test.go
@@ -8,8 +8,8 @@ import (
"github.com/docker/docker/daemon/config"
"github.com/docker/docker/oci"
"github.com/docker/docker/pkg/idtools"
-
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
// TestTmpfsDevShmNoDupMount checks that a user-specified /dev/shm tmpfs
@@ -36,17 +36,17 @@ func TestTmpfsDevShmNoDupMount(t *testing.T) {
// Mimick the code flow of daemon.createSpec(), enough to reproduce the issue
ms, err := d.setupMounts(c)
- assert.NoError(t, err)
+ assert.Check(t, err)
ms = append(ms, c.IpcMounts()...)
tmpfsMounts, err := c.TmpfsMounts()
- assert.NoError(t, err)
+ assert.Check(t, err)
ms = append(ms, tmpfsMounts...)
s := oci.DefaultSpec()
err = setMounts(&d, &s, c, ms)
- assert.NoError(t, err)
+ assert.Check(t, err)
}
// TestIpcPrivateVsReadonly checks that in case of IpcMode: private
@@ -70,19 +70,19 @@ func TestIpcPrivateVsReadonly(t *testing.T) {
// We can't call createSpec() so mimick the minimal part
// of its code flow, just enough to reproduce the issue.
ms, err := d.setupMounts(c)
- assert.NoError(t, err)
+ assert.Check(t, err)
s := oci.DefaultSpec()
s.Root.Readonly = c.HostConfig.ReadonlyRootfs
err = setMounts(&d, &s, c, ms)
- assert.NoError(t, err)
+ assert.Check(t, err)
// Find the /dev/shm mount in ms, check it does not have ro
for _, m := range s.Mounts {
if m.Destination != "/dev/shm" {
continue
}
- assert.Equal(t, false, inSlice(m.Options, "ro"))
+ assert.Check(t, is.Equal(false, inSlice(m.Options, "ro")))
}
}
diff --git a/daemon/reload_test.go b/daemon/reload_test.go
index a2500b2bb2..9174bfba54 100644
--- a/daemon/reload_test.go
+++ b/daemon/reload_test.go
@@ -12,7 +12,8 @@ import (
_ "github.com/docker/docker/pkg/discovery/memory"
"github.com/docker/docker/registry"
"github.com/docker/libnetwork"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestDaemonReloadLabels(t *testing.T) {
@@ -97,7 +98,7 @@ func TestDaemonReloadAllowNondistributableArtifacts(t *testing.T) {
sort.Strings(registries)
sort.Strings(actual)
- assert.Equal(t, registries, actual)
+ assert.Check(t, is.DeepEqual(registries, actual))
}
func TestDaemonReloadMirrors(t *testing.T) {
diff --git a/daemon/trustkey_test.go b/daemon/trustkey_test.go
index c49341d2a9..ebc7e28ee3 100644
--- a/daemon/trustkey_test.go
+++ b/daemon/trustkey_test.go
@@ -7,19 +7,19 @@ import (
"testing"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
// LoadOrCreateTrustKey
func TestLoadOrCreateTrustKeyInvalidKeyFile(t *testing.T) {
tmpKeyFolderPath, err := ioutil.TempDir("", "api-trustkey-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmpKeyFolderPath)
tmpKeyFile, err := ioutil.TempFile(tmpKeyFolderPath, "keyfile")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = loadOrCreateTrustKey(tmpKeyFile.Name())
testutil.ErrorContains(t, err, "Error loading key file")
@@ -33,11 +33,11 @@ func TestLoadOrCreateTrustKeyCreateKeyWhenFileDoesNotExist(t *testing.T) {
tmpKeyFile := tmpKeyFolderPath.Join("keyfile")
key, err := loadOrCreateTrustKey(tmpKeyFile)
- require.NoError(t, err)
- assert.NotNil(t, key)
+ assert.NilError(t, err)
+ assert.Check(t, key != nil)
_, err = os.Stat(tmpKeyFile)
- require.NoError(t, err, "key file doesn't exist")
+ assert.NilError(t, err, "key file doesn't exist")
}
func TestLoadOrCreateTrustKeyCreateKeyWhenDirectoryDoesNotExist(t *testing.T) {
@@ -46,27 +46,27 @@ func TestLoadOrCreateTrustKeyCreateKeyWhenDirectoryDoesNotExist(t *testing.T) {
tmpKeyFile := tmpKeyFolderPath.Join("folder/hierarchy/keyfile")
key, err := loadOrCreateTrustKey(tmpKeyFile)
- require.NoError(t, err)
- assert.NotNil(t, key)
+ assert.NilError(t, err)
+ assert.Check(t, key != nil)
_, err = os.Stat(tmpKeyFile)
- require.NoError(t, err, "key file doesn't exist")
+ assert.NilError(t, err, "key file doesn't exist")
}
func TestLoadOrCreateTrustKeyCreateKeyNoPath(t *testing.T) {
defer os.Remove("keyfile")
key, err := loadOrCreateTrustKey("keyfile")
- require.NoError(t, err)
- assert.NotNil(t, key)
+ assert.NilError(t, err)
+ assert.Check(t, key != nil)
_, err = os.Stat("keyfile")
- require.NoError(t, err, "key file doesn't exist")
+ assert.NilError(t, err, "key file doesn't exist")
}
func TestLoadOrCreateTrustKeyLoadValidKey(t *testing.T) {
tmpKeyFile := filepath.Join("testdata", "keyfile")
key, err := loadOrCreateTrustKey(tmpKeyFile)
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := "AWX2:I27X:WQFX:IOMK:CNAK:O7PW:VYNB:ZLKC:CVAE:YJP2:SI4A:XXAY"
- assert.Contains(t, key.String(), expected)
+ assert.Check(t, is.Contains(key.String(), expected))
}
diff --git a/distribution/metadata/v1_id_service_test.go b/distribution/metadata/v1_id_service_test.go
index 8a3647b3b3..7bac8e8212 100644
--- a/distribution/metadata/v1_id_service_test.go
+++ b/distribution/metadata/v1_id_service_test.go
@@ -6,7 +6,7 @@ import (
"testing"
"github.com/docker/docker/layer"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestV1IDService(t *testing.T) {
@@ -24,7 +24,7 @@ func TestV1IDService(t *testing.T) {
ns := v1IDService.namespace()
- require.Equal(t, "v1id", ns)
+ assert.Equal(t, "v1id", ns)
testVectors := []struct {
registry string
diff --git a/image/fs_test.go b/image/fs_test.go
index 6a634377e7..dcf4da75f8 100644
--- a/image/fs_test.go
+++ b/image/fs_test.go
@@ -11,16 +11,17 @@ import (
"testing"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
digest "github.com/opencontainers/go-digest"
- "github.com/stretchr/testify/assert"
)
func defaultFSStoreBackend(t *testing.T) (StoreBackend, func()) {
tmpdir, err := ioutil.TempDir("", "images-fs-store")
- assert.NoError(t, err)
+ assert.Check(t, err)
fsBackend, err := NewFSStoreBackend(tmpdir)
- assert.NoError(t, err)
+ assert.Check(t, err)
return fsBackend, func() { os.RemoveAll(tmpdir) }
}
@@ -30,12 +31,12 @@ func TestFSGetInvalidData(t *testing.T) {
defer cleanup()
id, err := store.Set([]byte("foobar"))
- assert.NoError(t, err)
+ assert.Check(t, err)
dgst := digest.Digest(id)
err = ioutil.WriteFile(filepath.Join(store.(*fs).root, contentDirName, string(dgst.Algorithm()), dgst.Hex()), []byte("foobar2"), 0600)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = store.Get(id)
testutil.ErrorContains(t, err, "failed to verify")
@@ -47,7 +48,7 @@ func TestFSInvalidSet(t *testing.T) {
id := digest.FromBytes([]byte("foobar"))
err := os.Mkdir(filepath.Join(store.(*fs).root, contentDirName, string(id.Algorithm()), id.Hex()), 0700)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = store.Set([]byte("foobar"))
testutil.ErrorContains(t, err, "failed to write digest data")
@@ -55,7 +56,7 @@ func TestFSInvalidSet(t *testing.T) {
func TestFSInvalidRoot(t *testing.T) {
tmpdir, err := ioutil.TempDir("", "images-fs-store")
- assert.NoError(t, err)
+ assert.Check(t, err)
defer os.RemoveAll(tmpdir)
tcases := []struct {
@@ -70,10 +71,10 @@ func TestFSInvalidRoot(t *testing.T) {
root := filepath.Join(tmpdir, tc.root)
filePath := filepath.Join(tmpdir, tc.invalidFile)
err := os.MkdirAll(filepath.Dir(filePath), 0700)
- assert.NoError(t, err)
+ assert.Check(t, err)
f, err := os.Create(filePath)
- assert.NoError(t, err)
+ assert.Check(t, err)
f.Close()
_, err = NewFSStoreBackend(root)
@@ -89,10 +90,10 @@ func TestFSMetadataGetSet(t *testing.T) {
defer cleanup()
id, err := store.Set([]byte("foo"))
- assert.NoError(t, err)
+ assert.Check(t, err)
id2, err := store.Set([]byte("bar"))
- assert.NoError(t, err)
+ assert.Check(t, err)
tcases := []struct {
id digest.Digest
@@ -106,12 +107,12 @@ func TestFSMetadataGetSet(t *testing.T) {
for _, tc := range tcases {
err = store.SetMetadata(tc.id, tc.key, tc.value)
- assert.NoError(t, err)
+ assert.Check(t, err)
actual, err := store.GetMetadata(tc.id, tc.key)
- assert.NoError(t, err)
+ assert.Check(t, err)
- assert.Equal(t, tc.value, actual)
+ assert.Check(t, is.DeepEqual(tc.value, actual))
}
_, err = store.GetMetadata(id2, "tkey2")
@@ -130,19 +131,19 @@ func TestFSInvalidWalker(t *testing.T) {
defer cleanup()
fooID, err := store.Set([]byte("foo"))
- assert.NoError(t, err)
+ assert.Check(t, err)
err = ioutil.WriteFile(filepath.Join(store.(*fs).root, contentDirName, "sha256/foobar"), []byte("foobar"), 0600)
- assert.NoError(t, err)
+ assert.Check(t, err)
n := 0
err = store.Walk(func(id digest.Digest) error {
- assert.Equal(t, fooID, id)
+ assert.Check(t, is.Equal(fooID, id))
n++
return nil
})
- assert.NoError(t, err)
- assert.Equal(t, 1, n)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(1, n))
}
func TestFSGetSet(t *testing.T) {
@@ -159,12 +160,12 @@ func TestFSGetSet(t *testing.T) {
randomInput := make([]byte, 8*1024)
_, err := rand.Read(randomInput)
- assert.NoError(t, err)
+ assert.Check(t, err)
// skipping use of digest pkg because it is used by the implementation
h := sha256.New()
_, err = h.Write(randomInput)
- assert.NoError(t, err)
+ assert.Check(t, err)
tcases = append(tcases, tcase{
input: randomInput,
@@ -173,14 +174,14 @@ func TestFSGetSet(t *testing.T) {
for _, tc := range tcases {
id, err := store.Set([]byte(tc.input))
- assert.NoError(t, err)
- assert.Equal(t, tc.expected, id)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(tc.expected, id))
}
for _, tc := range tcases {
data, err := store.Get(tc.expected)
- assert.NoError(t, err)
- assert.Equal(t, tc.input, data)
+ assert.Check(t, err)
+ assert.Check(t, is.DeepEqual(tc.input, data))
}
}
@@ -209,22 +210,22 @@ func TestFSDelete(t *testing.T) {
defer cleanup()
id, err := store.Set([]byte("foo"))
- assert.NoError(t, err)
+ assert.Check(t, err)
id2, err := store.Set([]byte("bar"))
- assert.NoError(t, err)
+ assert.Check(t, err)
err = store.Delete(id)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = store.Get(id)
testutil.ErrorContains(t, err, "failed to get digest")
_, err = store.Get(id2)
- assert.NoError(t, err)
+ assert.Check(t, err)
err = store.Delete(id2)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = store.Get(id2)
testutil.ErrorContains(t, err, "failed to get digest")
@@ -235,10 +236,10 @@ func TestFSWalker(t *testing.T) {
defer cleanup()
id, err := store.Set([]byte("foo"))
- assert.NoError(t, err)
+ assert.Check(t, err)
id2, err := store.Set([]byte("bar"))
- assert.NoError(t, err)
+ assert.Check(t, err)
tcases := make(map[digest.Digest]struct{})
tcases[id] = struct{}{}
@@ -249,9 +250,9 @@ func TestFSWalker(t *testing.T) {
n++
return nil
})
- assert.NoError(t, err)
- assert.Equal(t, 2, n)
- assert.Len(t, tcases, 0)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(2, n))
+ assert.Check(t, is.Len(tcases, 0))
}
func TestFSWalkerStopOnError(t *testing.T) {
@@ -259,7 +260,7 @@ func TestFSWalkerStopOnError(t *testing.T) {
defer cleanup()
id, err := store.Set([]byte("foo"))
- assert.NoError(t, err)
+ assert.Check(t, err)
tcases := make(map[digest.Digest]struct{})
tcases[id] = struct{}{}
diff --git a/image/image_test.go b/image/image_test.go
index 429f202978..265db0167c 100644
--- a/image/image_test.go
+++ b/image/image_test.go
@@ -9,8 +9,8 @@ import (
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/layer"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
const sampleImageJSON = `{
@@ -25,13 +25,13 @@ const sampleImageJSON = `{
func TestNewFromJSON(t *testing.T) {
img, err := NewFromJSON([]byte(sampleImageJSON))
- require.NoError(t, err)
- assert.Equal(t, sampleImageJSON, string(img.RawJSON()))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(sampleImageJSON, string(img.RawJSON())))
}
func TestNewFromJSONWithInvalidJSON(t *testing.T) {
_, err := NewFromJSON([]byte("{}"))
- assert.EqualError(t, err, "invalid image JSON, no RootFS key")
+ assert.Check(t, is.Error(err, "invalid image JSON, no RootFS key"))
}
func TestMarshalKeyOrder(t *testing.T) {
@@ -42,7 +42,7 @@ func TestMarshalKeyOrder(t *testing.T) {
Architecture: "c",
},
})
- assert.NoError(t, err)
+ assert.Check(t, err)
expectedOrder := []string{"architecture", "author", "comment"}
var indexes []int
@@ -71,10 +71,10 @@ func TestImage(t *testing.T) {
computedID: ID(cid),
}
- assert.Equal(t, cid, img.ImageID())
- assert.Equal(t, cid, img.ID().String())
- assert.Equal(t, os, img.OperatingSystem())
- assert.Equal(t, config, img.RunConfig())
+ assert.Check(t, is.Equal(cid, img.ImageID()))
+ assert.Check(t, is.Equal(cid, img.ID().String()))
+ assert.Check(t, is.Equal(os, img.OperatingSystem()))
+ assert.Check(t, is.DeepEqual(config, img.RunConfig()))
}
func TestImageOSNotEmpty(t *testing.T) {
@@ -85,7 +85,7 @@ func TestImageOSNotEmpty(t *testing.T) {
},
OSVersion: "osversion",
}
- assert.Equal(t, os, img.OperatingSystem())
+ assert.Check(t, is.Equal(os, img.OperatingSystem()))
}
func TestNewChildImageFromImageWithRootFS(t *testing.T) {
@@ -109,16 +109,16 @@ func TestNewChildImageFromImageWithRootFS(t *testing.T) {
newImage := NewChildImage(parent, childConfig, "platform")
expectedDiffIDs := []layer.DiffID{layer.DiffID("ba5e"), layer.DiffID("abcdef")}
- assert.Equal(t, expectedDiffIDs, newImage.RootFS.DiffIDs)
- assert.Equal(t, childConfig.Author, newImage.Author)
- assert.Equal(t, childConfig.Config, newImage.Config)
- assert.Equal(t, *childConfig.ContainerConfig, newImage.ContainerConfig)
- assert.Equal(t, "platform", newImage.OS)
- assert.Equal(t, childConfig.Config, newImage.Config)
+ assert.Check(t, is.DeepEqual(expectedDiffIDs, newImage.RootFS.DiffIDs))
+ assert.Check(t, is.Equal(childConfig.Author, newImage.Author))
+ assert.Check(t, is.DeepEqual(childConfig.Config, newImage.Config))
+ assert.Check(t, is.DeepEqual(*childConfig.ContainerConfig, newImage.ContainerConfig))
+ assert.Check(t, is.Equal("platform", newImage.OS))
+ assert.Check(t, is.DeepEqual(childConfig.Config, newImage.Config))
- assert.Len(t, newImage.History, 2)
- assert.Equal(t, childConfig.Comment, newImage.History[1].Comment)
+ assert.Check(t, is.Len(newImage.History, 2))
+ assert.Check(t, is.Equal(childConfig.Comment, newImage.History[1].Comment))
// RootFS should be copied not mutated
- assert.NotEqual(t, parent.RootFS.DiffIDs, newImage.RootFS.DiffIDs)
+ assert.Check(t, parent.RootFS.DiffIDs != newImage.RootFS.DiffIDs)
}
diff --git a/image/store_test.go b/image/store_test.go
index b1300657a0..f43839923b 100644
--- a/image/store_test.go
+++ b/image/store_test.go
@@ -7,8 +7,9 @@ import (
"github.com/docker/docker/internal/testutil"
"github.com/docker/docker/layer"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/opencontainers/go-digest"
- "github.com/stretchr/testify/assert"
)
func TestRestore(t *testing.T) {
@@ -16,53 +17,53 @@ func TestRestore(t *testing.T) {
defer cleanup()
id1, err := fs.Set([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = fs.Set([]byte(`invalid`))
- assert.NoError(t, err)
+ assert.Check(t, err)
id2, err := fs.Set([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
err = fs.SetMetadata(id2, "parent", []byte(id1))
- assert.NoError(t, err)
+ assert.Check(t, err)
mlgrMap := make(map[string]LayerGetReleaser)
mlgrMap[runtime.GOOS] = &mockLayerGetReleaser{}
is, err := NewImageStore(fs, mlgrMap)
- assert.NoError(t, err)
+ assert.Check(t, err)
- assert.Len(t, is.Map(), 2)
+ assert.Check(t, is.Len(is.Map(), 2))
img1, err := is.Get(ID(id1))
- assert.NoError(t, err)
- assert.Equal(t, ID(id1), img1.computedID)
- assert.Equal(t, string(id1), img1.computedID.String())
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(ID(id1), img1.computedID))
+ assert.Check(t, is.Equal(string(id1), img1.computedID.String()))
img2, err := is.Get(ID(id2))
- assert.NoError(t, err)
- assert.Equal(t, "abc", img1.Comment)
- assert.Equal(t, "def", img2.Comment)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("abc", img1.Comment))
+ assert.Check(t, is.Equal("def", img2.Comment))
_, err = is.GetParent(ID(id1))
testutil.ErrorContains(t, err, "failed to read metadata")
p, err := is.GetParent(ID(id2))
- assert.NoError(t, err)
- assert.Equal(t, ID(id1), p)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(ID(id1), p))
children := is.Children(ID(id1))
- assert.Len(t, children, 1)
- assert.Equal(t, ID(id2), children[0])
- assert.Len(t, is.Heads(), 1)
+ assert.Check(t, is.Len(children, 1))
+ assert.Check(t, is.Equal(ID(id2), children[0]))
+ assert.Check(t, is.Len(is.Heads(), 1))
sid1, err := is.Search(string(id1)[:10])
- assert.NoError(t, err)
- assert.Equal(t, ID(id1), sid1)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(ID(id1), sid1))
sid1, err = is.Search(digest.Digest(id1).Hex()[:6])
- assert.NoError(t, err)
- assert.Equal(t, ID(id1), sid1)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(ID(id1), sid1))
invalidPattern := digest.Digest(id1).Hex()[1:6]
_, err = is.Search(invalidPattern)
@@ -74,31 +75,31 @@ func TestAddDelete(t *testing.T) {
defer cleanup()
id1, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
- assert.NoError(t, err)
- assert.Equal(t, ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1))
img, err := is.Get(id1)
- assert.NoError(t, err)
- assert.Equal(t, "abc", img.Comment)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal("abc", img.Comment))
id2, err := is.Create([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
err = is.SetParent(id2, id1)
- assert.NoError(t, err)
+ assert.Check(t, err)
pid1, err := is.GetParent(id2)
- assert.NoError(t, err)
- assert.Equal(t, pid1, id1)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(pid1, id1))
_, err = is.Delete(id1)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = is.Get(id1)
testutil.ErrorContains(t, err, "failed to get digest")
_, err = is.Get(id2)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = is.GetParent(id2)
testutil.ErrorContains(t, err, "failed to read metadata")
@@ -109,14 +110,14 @@ func TestSearchAfterDelete(t *testing.T) {
defer cleanup()
id, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
id1, err := is.Search(string(id)[:15])
- assert.NoError(t, err)
- assert.Equal(t, id1, id)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(id1, id))
_, err = is.Delete(id)
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = is.Search(string(id)[:15])
testutil.ErrorContains(t, err, "No such image")
@@ -127,20 +128,20 @@ func TestParentReset(t *testing.T) {
defer cleanup()
id, err := is.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
id2, err := is.Create([]byte(`{"comment": "abc2", "rootfs": {"type": "layers"}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
id3, err := is.Create([]byte(`{"comment": "abc3", "rootfs": {"type": "layers"}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
- assert.NoError(t, is.SetParent(id, id2))
- assert.Len(t, is.Children(id2), 1)
+ assert.Check(t, is.SetParent(id, id2))
+ assert.Check(t, is.Len(is.Children(id2), 1))
- assert.NoError(t, is.SetParent(id, id3))
- assert.Len(t, is.Children(id2), 0)
- assert.Len(t, is.Children(id3), 1)
+ assert.Check(t, is.SetParent(id, id3))
+ assert.Check(t, is.Len(is.Children(id2), 0))
+ assert.Check(t, is.Len(is.Children(id3), 1))
}
func defaultImageStore(t *testing.T) (Store, func()) {
@@ -149,7 +150,7 @@ func defaultImageStore(t *testing.T) (Store, func()) {
mlgrMap := make(map[string]LayerGetReleaser)
mlgrMap[runtime.GOOS] = &mockLayerGetReleaser{}
store, err := NewImageStore(fsBackend, mlgrMap)
- assert.NoError(t, err)
+ assert.Check(t, err)
return store, cleanup
}
@@ -159,17 +160,17 @@ func TestGetAndSetLastUpdated(t *testing.T) {
defer cleanup()
id, err := store.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`))
- assert.NoError(t, err)
+ assert.Check(t, err)
updated, err := store.GetLastUpdated(id)
- assert.NoError(t, err)
- assert.Equal(t, updated.IsZero(), true)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(updated.IsZero(), true))
- assert.NoError(t, store.SetLastUpdated(id))
+ assert.Check(t, store.SetLastUpdated(id))
updated, err = store.GetLastUpdated(id)
- assert.NoError(t, err)
- assert.Equal(t, updated.IsZero(), false)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(updated.IsZero(), false))
}
func TestStoreLen(t *testing.T) {
@@ -179,7 +180,7 @@ func TestStoreLen(t *testing.T) {
expected := 10
for i := 0; i < expected; i++ {
_, err := store.Create([]byte(fmt.Sprintf(`{"comment": "abc%d", "rootfs": {"type": "layers"}}`, i)))
- assert.NoError(t, err)
+ assert.NilError(t, err)
}
numImages := store.Len()
assert.Equal(t, expected, numImages)
diff --git a/integration-cli/cli/build/fakegit/fakegit.go b/integration-cli/cli/build/fakegit/fakegit.go
index eb175365a5..b05bfc322b 100644
--- a/integration-cli/cli/build/fakegit/fakegit.go
+++ b/integration-cli/cli/build/fakegit/fakegit.go
@@ -11,11 +11,11 @@ import (
"github.com/docker/docker/integration-cli/cli/build/fakecontext"
"github.com/docker/docker/integration-cli/cli/build/fakestorage"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
type testingT interface {
- require.TestingT
+ assert.TestingT
logT
Fatal(args ...interface{})
Fatalf(string, ...interface{})
diff --git a/integration-cli/cli/build/fakestorage/storage.go b/integration-cli/cli/build/fakestorage/storage.go
index c8c837ed2a..bd49a33cfe 100644
--- a/integration-cli/cli/build/fakestorage/storage.go
+++ b/integration-cli/cli/build/fakestorage/storage.go
@@ -15,13 +15,13 @@ import (
"github.com/docker/docker/integration-cli/request"
"github.com/docker/docker/internal/test/environment"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
var testEnv *environment.Execution
type testingT interface {
- require.TestingT
+ assert.TestingT
logT
Fatal(args ...interface{})
Fatalf(string, ...interface{})
diff --git a/integration-cli/daemon/daemon.go b/integration-cli/daemon/daemon.go
index 9672d160f8..9ca54236f4 100644
--- a/integration-cli/daemon/daemon.go
+++ b/integration-cli/daemon/daemon.go
@@ -24,14 +24,14 @@ import (
"github.com/docker/go-connections/sockets"
"github.com/docker/go-connections/tlsconfig"
"github.com/go-check/check"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/icmd"
"github.com/pkg/errors"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
type testingT interface {
- require.TestingT
+ assert.TestingT
logT
Fatalf(string, ...interface{})
}
@@ -487,20 +487,20 @@ func (d *Daemon) handleUserns() {
// LoadBusybox image into the daemon
func (d *Daemon) LoadBusybox(t testingT) {
clientHost, err := client.NewEnvClient()
- require.NoError(t, err, "failed to create client")
+ assert.NilError(t, err, "failed to create client")
defer clientHost.Close()
ctx := context.Background()
reader, err := clientHost.ImageSave(ctx, []string{"busybox:latest"})
- require.NoError(t, err, "failed to download busybox")
+ assert.NilError(t, err, "failed to download busybox")
defer reader.Close()
client, err := d.NewClient()
- require.NoError(t, err, "failed to create client")
+ assert.NilError(t, err, "failed to create client")
defer client.Close()
resp, err := client.ImageLoad(ctx, reader, true)
- require.NoError(t, err, "failed to load busybox")
+ assert.NilError(t, err, "failed to load busybox")
defer resp.Body.Close()
}
@@ -563,11 +563,11 @@ func (d *Daemon) WaitRun(contID string) error {
}
// Info returns the info struct for this daemon
-func (d *Daemon) Info(t require.TestingT) types.Info {
+func (d *Daemon) Info(t assert.TestingT) types.Info {
apiclient, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
info, err := apiclient.Info(context.Background())
- require.NoError(t, err)
+ assert.NilError(t, err)
return info
}
diff --git a/integration-cli/daemon/daemon_swarm.go b/integration-cli/daemon/daemon_swarm.go
index cb44f63f23..be0ddef99e 100644
--- a/integration-cli/daemon/daemon_swarm.go
+++ b/integration-cli/daemon/daemon_swarm.go
@@ -11,8 +11,8 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration-cli/checker"
"github.com/go-check/check"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/pkg/errors"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -235,12 +235,12 @@ func (d *Swarm) CheckServiceUpdateState(service string) func(*check.C) (interfac
func (d *Swarm) CheckPluginRunning(plugin string) func(c *check.C) (interface{}, check.CommentInterface) {
return func(c *check.C) (interface{}, check.CommentInterface) {
apiclient, err := d.NewClient()
- require.NoError(c, err)
+ assert.NilError(c, err)
resp, _, err := apiclient.PluginInspectWithRaw(context.Background(), plugin)
if client.IsErrNotFound(err) {
return false, check.Commentf("%v", err)
}
- require.NoError(c, err)
+ assert.NilError(c, err)
return resp.Enabled, check.Commentf("%+v", resp)
}
}
@@ -249,12 +249,12 @@ func (d *Swarm) CheckPluginRunning(plugin string) func(c *check.C) (interface{},
func (d *Swarm) CheckPluginImage(plugin string) func(c *check.C) (interface{}, check.CommentInterface) {
return func(c *check.C) (interface{}, check.CommentInterface) {
apiclient, err := d.NewClient()
- require.NoError(c, err)
+ assert.NilError(c, err)
resp, _, err := apiclient.PluginInspectWithRaw(context.Background(), plugin)
if client.IsErrNotFound(err) {
return false, check.Commentf("%v", err)
}
- require.NoError(c, err)
+ assert.NilError(c, err)
return resp.PluginReference, check.Commentf("%+v", resp)
}
}
diff --git a/integration-cli/docker_api_build_test.go b/integration-cli/docker_api_build_test.go
index e5423a4741..cae7c1afe7 100644
--- a/integration-cli/docker_api_build_test.go
+++ b/integration-cli/docker_api_build_test.go
@@ -18,10 +18,10 @@ import (
"github.com/docker/docker/integration-cli/cli/build/fakestorage"
"github.com/docker/docker/integration-cli/request"
"github.com/go-check/check"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/moby/buildkit/session"
"github.com/moby/buildkit/session/filesync"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
"golang.org/x/sync/errgroup"
)
@@ -296,12 +296,12 @@ func (s *DockerSuite) TestBuildOnBuildCache(c *check.C) {
"/build",
request.RawContent(ctx.AsTarReader(c)),
request.ContentType("application/x-tar"))
- require.NoError(c, err)
- assert.Equal(c, http.StatusOK, res.StatusCode)
+ assert.NilError(c, err)
+ assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
out, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(out), "Successfully built")
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(out), "Successfully built"))
return out
}
@@ -316,15 +316,15 @@ func (s *DockerSuite) TestBuildOnBuildCache(c *check.C) {
out := build(dockerfile)
imageIDs := getImageIDsFromBuild(c, out)
- assert.Len(c, imageIDs, 2)
+ assert.Check(c, is.Len(imageIDs, 2))
parentID, childID := imageIDs[0], imageIDs[1]
client := testEnv.APIClient()
// check parentID is correct
image, _, err := client.ImageInspectWithRaw(context.Background(), childID)
- require.NoError(c, err)
- assert.Equal(c, parentID, image.Parent)
+ assert.NilError(c, err)
+ assert.Check(c, is.Equal(parentID, image.Parent))
}
func (s *DockerRegistrySuite) TestBuildCopyFromForcePull(c *check.C) {
@@ -333,12 +333,12 @@ func (s *DockerRegistrySuite) TestBuildCopyFromForcePull(c *check.C) {
repoName := fmt.Sprintf("%v/dockercli/busybox", privateRegistryURL)
// tag the image to upload it to the private registry
err := client.ImageTag(context.TODO(), "busybox", repoName)
- assert.Nil(c, err)
+ assert.Check(c, err)
// push the image to the registry
rc, err := client.ImagePush(context.TODO(), repoName, types.ImagePushOptions{RegistryAuth: "{}"})
- assert.Nil(c, err)
+ assert.Check(c, err)
_, err = io.Copy(ioutil.Discard, rc)
- assert.Nil(c, err)
+ assert.Check(c, err)
dockerfile := fmt.Sprintf(`
FROM %s AS foo
@@ -356,12 +356,12 @@ func (s *DockerRegistrySuite) TestBuildCopyFromForcePull(c *check.C) {
"/build?pull=1",
request.RawContent(ctx.AsTarReader(c)),
request.ContentType("application/x-tar"))
- require.NoError(c, err)
- assert.Equal(c, http.StatusOK, res.StatusCode)
+ assert.NilError(c, err)
+ assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
out, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(out), "Successfully built")
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(out), "Successfully built"))
}
func (s *DockerSuite) TestBuildAddRemoteNoDecompress(c *check.C) {
@@ -374,11 +374,11 @@ func (s *DockerSuite) TestBuildAddRemoteNoDecompress(c *check.C) {
Mode: 0600,
Typeflag: tar.TypeReg,
})
- require.NoError(c, err)
+ assert.NilError(c, err)
_, err = tw.Write(dt)
- require.NoError(c, err)
+ assert.NilError(c, err)
err = tw.Close()
- require.NoError(c, err)
+ assert.NilError(c, err)
server := fakestorage.New(c, "", fakecontext.WithBinaryFiles(map[string]*bytes.Buffer{
"test.tar": buffer,
@@ -400,12 +400,12 @@ func (s *DockerSuite) TestBuildAddRemoteNoDecompress(c *check.C) {
"/build",
request.RawContent(ctx.AsTarReader(c)),
request.ContentType("application/x-tar"))
- require.NoError(c, err)
- assert.Equal(c, http.StatusOK, res.StatusCode)
+ assert.NilError(c, err)
+ assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
out, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(out), "Successfully built")
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(out), "Successfully built"))
}
func (s *DockerSuite) TestBuildChownOnCopy(c *check.C) {
@@ -433,8 +433,8 @@ func (s *DockerSuite) TestBuildChownOnCopy(c *check.C) {
c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
out, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(out), "Successfully built")
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(out), "Successfully built"))
}
func (s *DockerSuite) TestBuildCopyCacheOnFileChange(c *check.C) {
@@ -454,11 +454,11 @@ COPY file /file`
request.RawContent(ctx.AsTarReader(c)),
request.ContentType("application/x-tar"))
- require.NoError(c, err)
- assert.Equal(c, http.StatusOK, res.StatusCode)
+ assert.NilError(c, err)
+ assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
out, err := request.ReadBody(body)
- require.NoError(c, err)
+ assert.NilError(c, err)
ids := getImageIDsFromBuild(c, out)
return ids[len(ids)-1]
@@ -493,11 +493,11 @@ ADD file /file`
request.RawContent(ctx.AsTarReader(c)),
request.ContentType("application/x-tar"))
- require.NoError(c, err)
- assert.Equal(c, http.StatusOK, res.StatusCode)
+ assert.NilError(c, err)
+ assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
out, err := request.ReadBody(body)
- require.NoError(c, err)
+ assert.NilError(c, err)
ids := getImageIDsFromBuild(c, out)
return ids[len(ids)-1]
@@ -530,7 +530,7 @@ func (s *DockerSuite) TestBuildWithSession(c *check.C) {
defer fctx.Close()
out := testBuildWithSession(c, fctx.Dir, dockerfile)
- assert.Contains(c, out, "some content")
+ assert.Check(c, is.Contains(out, "some content"))
fctx.Add("second", "contentcontent")
@@ -540,20 +540,20 @@ func (s *DockerSuite) TestBuildWithSession(c *check.C) {
`
out = testBuildWithSession(c, fctx.Dir, dockerfile)
- assert.Equal(c, strings.Count(out, "Using cache"), 2)
- assert.Contains(c, out, "contentcontent")
+ assert.Check(c, is.Equal(strings.Count(out, "Using cache"), 2))
+ assert.Check(c, is.Contains(out, "contentcontent"))
client := testEnv.APIClient()
du, err := client.DiskUsage(context.TODO())
- assert.Nil(c, err)
- assert.True(c, du.BuilderSize > 10)
+ assert.Check(c, err)
+ assert.Check(c, du.BuilderSize > 10)
out = testBuildWithSession(c, fctx.Dir, dockerfile)
- assert.Equal(c, strings.Count(out, "Using cache"), 4)
+ assert.Check(c, is.Equal(strings.Count(out, "Using cache"), 4))
du2, err := client.DiskUsage(context.TODO())
- assert.Nil(c, err)
- assert.Equal(c, du.BuilderSize, du2.BuilderSize)
+ assert.Check(c, err)
+ assert.Check(c, is.Equal(du.BuilderSize, du2.BuilderSize))
// rebuild with regular tar, confirm cache still applies
fctx.Add("Dockerfile", dockerfile)
@@ -561,26 +561,26 @@ func (s *DockerSuite) TestBuildWithSession(c *check.C) {
"/build",
request.RawContent(fctx.AsTarReader(c)),
request.ContentType("application/x-tar"))
- require.NoError(c, err)
- assert.Equal(c, http.StatusOK, res.StatusCode)
+ assert.NilError(c, err)
+ assert.Check(c, is.DeepEqual(http.StatusOK, res.StatusCode))
outBytes, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(outBytes), "Successfully built")
- assert.Equal(c, strings.Count(string(outBytes), "Using cache"), 4)
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(outBytes), "Successfully built"))
+ assert.Check(c, is.Equal(strings.Count(string(outBytes), "Using cache"), 4))
_, err = client.BuildCachePrune(context.TODO())
- assert.Nil(c, err)
+ assert.Check(c, err)
du, err = client.DiskUsage(context.TODO())
- assert.Nil(c, err)
- assert.Equal(c, du.BuilderSize, int64(0))
+ assert.Check(c, err)
+ assert.Check(c, is.Equal(du.BuilderSize, int64(0)))
}
func testBuildWithSession(c *check.C, dir, dockerfile string) (outStr string) {
client := testEnv.APIClient()
sess, err := session.NewSession("foo1", "foo")
- assert.Nil(c, err)
+ assert.Check(c, err)
fsProvider := filesync.NewFSSyncProvider([]filesync.SyncedDir{
{Dir: dir},
@@ -601,17 +601,17 @@ func testBuildWithSession(c *check.C, dir, dockerfile string) (outStr string) {
if err != nil {
return err
}
- assert.Equal(c, res.StatusCode, http.StatusOK)
+ assert.Check(c, is.DeepEqual(res.StatusCode, http.StatusOK))
out, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(out), "Successfully built")
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(out), "Successfully built"))
sess.Close()
outStr = string(out)
return nil
})
err = g.Wait()
- assert.Nil(c, err)
+ assert.Check(c, err)
return
}
@@ -633,8 +633,8 @@ ENV foo bar`
c.Assert(res.StatusCode, checker.Equals, http.StatusOK)
out, err := request.ReadBody(body)
- require.NoError(c, err)
- assert.Contains(c, string(out), "Successfully built")
+ assert.NilError(c, err)
+ assert.Check(c, is.Contains(string(out), "Successfully built"))
}
type buildLine struct {
@@ -651,7 +651,7 @@ func getImageIDsFromBuild(c *check.C, output []byte) []string {
continue
}
entry := buildLine{}
- require.NoError(c, json.Unmarshal(line, &entry))
+ assert.NilError(c, json.Unmarshal(line, &entry))
if entry.Aux.ID != "" {
ids = append(ids, entry.Aux.ID)
}
diff --git a/integration-cli/docker_api_containers_test.go b/integration-cli/docker_api_containers_test.go
index ed1941022e..c0e5ff5b17 100644
--- a/integration-cli/docker_api_containers_test.go
+++ b/integration-cli/docker_api_containers_test.go
@@ -31,9 +31,9 @@ import (
"github.com/docker/docker/volume"
"github.com/docker/go-connections/nat"
"github.com/go-check/check"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -2027,47 +2027,47 @@ func (s *DockerSuite) TestContainersAPICreateMountsCreate(c *check.C) {
&containertypes.HostConfig{Mounts: []mounttypes.Mount{x.spec}},
&networktypes.NetworkingConfig{},
"")
- require.NoError(c, err)
+ assert.NilError(c, err)
containerInspect, err := apiclient.ContainerInspect(ctx, container.ID)
- require.NoError(c, err)
+ assert.NilError(c, err)
mps := containerInspect.Mounts
- require.Len(c, mps, 1)
+ assert.Assert(c, is.Len(mps, 1))
mountPoint := mps[0]
if x.expected.Source != "" {
- assert.Equal(c, x.expected.Source, mountPoint.Source)
+ assert.Check(c, is.Equal(x.expected.Source, mountPoint.Source))
}
if x.expected.Name != "" {
- assert.Equal(c, x.expected.Name, mountPoint.Name)
+ assert.Check(c, is.Equal(x.expected.Name, mountPoint.Name))
}
if x.expected.Driver != "" {
- assert.Equal(c, x.expected.Driver, mountPoint.Driver)
+ assert.Check(c, is.Equal(x.expected.Driver, mountPoint.Driver))
}
if x.expected.Propagation != "" {
- assert.Equal(c, x.expected.Propagation, mountPoint.Propagation)
+ assert.Check(c, is.Equal(x.expected.Propagation, mountPoint.Propagation))
}
- assert.Equal(c, x.expected.RW, mountPoint.RW)
- assert.Equal(c, x.expected.Type, mountPoint.Type)
- assert.Equal(c, x.expected.Mode, mountPoint.Mode)
- assert.Equal(c, x.expected.Destination, mountPoint.Destination)
+ assert.Check(c, is.Equal(x.expected.RW, mountPoint.RW))
+ assert.Check(c, is.Equal(x.expected.Type, mountPoint.Type))
+ assert.Check(c, is.Equal(x.expected.Mode, mountPoint.Mode))
+ assert.Check(c, is.Equal(x.expected.Destination, mountPoint.Destination))
err = apiclient.ContainerStart(ctx, container.ID, types.ContainerStartOptions{})
- require.NoError(c, err)
+ assert.NilError(c, err)
poll.WaitOn(c, containerExit(apiclient, container.ID), poll.WithDelay(time.Second))
err = apiclient.ContainerRemove(ctx, container.ID, types.ContainerRemoveOptions{
RemoveVolumes: true,
Force: true,
})
- require.NoError(c, err)
+ assert.NilError(c, err)
switch {
// Named volumes still exist after the container is removed
case x.spec.Type == "volume" && len(x.spec.Source) > 0:
_, err := apiclient.VolumeInspect(ctx, mountPoint.Name)
- require.NoError(c, err)
+ assert.NilError(c, err)
// Bind mounts are never removed with the container
case x.spec.Type == "bind":
@@ -2075,7 +2075,7 @@ func (s *DockerSuite) TestContainersAPICreateMountsCreate(c *check.C) {
// anonymous volumes are removed
default:
_, err := apiclient.VolumeInspect(ctx, mountPoint.Name)
- assert.True(c, client.IsErrNotFound(err))
+ assert.Check(c, client.IsErrNotFound(err))
}
}
}
diff --git a/integration-cli/docker_api_containers_windows_test.go b/integration-cli/docker_api_containers_windows_test.go
index eb2892575c..4c8ace4842 100644
--- a/integration-cli/docker_api_containers_windows_test.go
+++ b/integration-cli/docker_api_containers_windows_test.go
@@ -13,8 +13,8 @@ import (
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/mount"
"github.com/go-check/check"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -65,12 +65,12 @@ func (s *DockerSuite) TestContainersAPICreateMountsBindNamedPipe(c *check.C) {
},
},
nil, name)
- require.NoError(c, err)
+ assert.NilError(c, err)
err = client.ContainerStart(ctx, name, types.ContainerStartOptions{})
- require.NoError(c, err)
+ assert.NilError(c, err)
err = <-ch
- require.NoError(c, err)
- assert.Equal(c, text, strings.TrimSpace(string(b)))
+ assert.NilError(c, err)
+ assert.Check(c, is.Equal(text, strings.TrimSpace(string(b))))
}
diff --git a/integration-cli/docker_api_inspect_test.go b/integration-cli/docker_api_inspect_test.go
index 52a889f08b..2f81d6e1eb 100644
--- a/integration-cli/docker_api_inspect_test.go
+++ b/integration-cli/docker_api_inspect_test.go
@@ -11,7 +11,8 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration-cli/checker"
"github.com/go-check/check"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func (s *DockerSuite) TestInspectAPIContainerResponse(c *check.C) {
@@ -115,8 +116,8 @@ func (s *DockerSuite) TestInspectAPIImageResponse(c *check.C) {
c.Assert(err, checker.IsNil)
c.Assert(imageJSON.RepoTags, checker.HasLen, 2)
- assert.Contains(c, imageJSON.RepoTags, "busybox:latest")
- assert.Contains(c, imageJSON.RepoTags, "busybox:mytag")
+ assert.Check(c, is.Contains(imageJSON.RepoTags, "busybox:latest"))
+ assert.Check(c, is.Contains(imageJSON.RepoTags, "busybox:mytag"))
}
// #17131, #17139, #17173
diff --git a/integration-cli/docker_api_swarm_test.go b/integration-cli/docker_api_swarm_test.go
index b5edfd2c04..2ba69acdb8 100644
--- a/integration-cli/docker_api_swarm_test.go
+++ b/integration-cli/docker_api_swarm_test.go
@@ -25,8 +25,8 @@ import (
"github.com/docker/docker/integration-cli/request"
"github.com/docker/swarmkit/ca"
"github.com/go-check/check"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -1012,16 +1012,16 @@ func (s *DockerSwarmSuite) TestAPINetworkInspectWithScope(c *check.C) {
name := "test-scoped-network"
ctx := context.Background()
apiclient, err := d.NewClient()
- require.NoError(c, err)
+ assert.NilError(c, err)
resp, err := apiclient.NetworkCreate(ctx, name, types.NetworkCreate{Driver: "overlay"})
- require.NoError(c, err)
+ assert.NilError(c, err)
network, err := apiclient.NetworkInspect(ctx, name, types.NetworkInspectOptions{})
- require.NoError(c, err)
- assert.Equal(c, "swarm", network.Scope)
- assert.Equal(c, resp.ID, network.ID)
+ assert.NilError(c, err)
+ assert.Check(c, is.Equal("swarm", network.Scope))
+ assert.Check(c, is.Equal(resp.ID, network.ID))
_, err = apiclient.NetworkInspect(ctx, name, types.NetworkInspectOptions{Scope: "local"})
- assert.True(c, client.IsErrNotFound(err))
+ assert.Check(c, client.IsErrNotFound(err))
}
diff --git a/integration-cli/docker_cli_by_digest_test.go b/integration-cli/docker_cli_by_digest_test.go
index 2d5dd486e7..ac97e0aecc 100644
--- a/integration-cli/docker_cli_by_digest_test.go
+++ b/integration-cli/docker_cli_by_digest_test.go
@@ -15,8 +15,9 @@ import (
"github.com/docker/docker/integration-cli/cli"
"github.com/docker/docker/integration-cli/cli/build"
"github.com/go-check/check"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/opencontainers/go-digest"
- "github.com/stretchr/testify/assert"
)
var (
@@ -403,7 +404,7 @@ func (s *DockerRegistrySuite) TestInspectImageWithDigests(c *check.C) {
c.Assert(err, checker.IsNil)
c.Assert(imageJSON, checker.HasLen, 1)
c.Assert(imageJSON[0].RepoDigests, checker.HasLen, 1)
- assert.Contains(c, imageJSON[0].RepoDigests, imageReference)
+ assert.Check(c, is.Contains(imageJSON[0].RepoDigests, imageReference))
}
func (s *DockerRegistrySuite) TestPsListContainersFilterAncestorImageByDigest(c *check.C) {
diff --git a/integration/build/build_test.go b/integration/build/build_test.go
index 124f1107fb..daede7bc33 100644
--- a/integration/build/build_test.go
+++ b/integration/build/build_test.go
@@ -15,8 +15,8 @@ import (
"github.com/docker/docker/integration-cli/cli/build/fakecontext"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/pkg/jsonmessage"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestBuildWithRemoveAndForceRemove(t *testing.T) {
@@ -94,21 +94,21 @@ func TestBuildWithRemoveAndForceRemove(t *testing.T) {
buff := bytes.NewBuffer(nil)
tw := tar.NewWriter(buff)
- require.NoError(t, tw.WriteHeader(&tar.Header{
+ assert.NilError(t, tw.WriteHeader(&tar.Header{
Name: "Dockerfile",
Size: int64(len(dockerfile)),
}))
_, err := tw.Write(dockerfile)
- require.NoError(t, err)
- require.NoError(t, tw.Close())
+ assert.NilError(t, err)
+ assert.NilError(t, tw.Close())
resp, err := client.ImageBuild(ctx, buff, types.ImageBuildOptions{Remove: c.rm, ForceRemove: c.forceRm, NoCache: true})
- require.NoError(t, err)
+ assert.NilError(t, err)
defer resp.Body.Close()
filter, err := buildContainerIdsFilter(resp.Body)
- require.NoError(t, err)
+ assert.NilError(t, err)
remainingContainers, err := client.ContainerList(ctx, types.ContainerListOptions{Filters: filter, All: true})
- require.NoError(t, err)
- require.Equal(t, c.numberOfIntermediateContainers, len(remainingContainers), "Expected %v remaining intermediate containers, got %v", c.numberOfIntermediateContainers, len(remainingContainers))
+ assert.NilError(t, err)
+ assert.Equal(t, c.numberOfIntermediateContainers, len(remainingContainers), "Expected %v remaining intermediate containers, got %v", c.numberOfIntermediateContainers, len(remainingContainers))
})
}
}
@@ -158,16 +158,16 @@ func TestBuildMultiStageParentConfig(t *testing.T) {
ForceRemove: true,
Tags: []string{"build1"},
})
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = io.Copy(ioutil.Discard, resp.Body)
resp.Body.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
image, _, err := apiclient.ImageInspectWithRaw(ctx, "build1")
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, "/foo/sub2", image.Config.WorkingDir)
- assert.Contains(t, image.Config.Env, "WHO=parent")
+ assert.Check(t, is.Equal("/foo/sub2", image.Config.WorkingDir))
+ assert.Check(t, is.Contains(image.Config.Env, "WHO=parent"))
}
func TestBuildWithEmptyLayers(t *testing.T) {
@@ -192,10 +192,10 @@ func TestBuildWithEmptyLayers(t *testing.T) {
Remove: true,
ForceRemove: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = io.Copy(ioutil.Discard, resp.Body)
resp.Body.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// TestBuildMultiStageOnBuild checks that ONBUILD commands are applied to
@@ -228,20 +228,20 @@ RUN cat somefile`
})
out := bytes.NewBuffer(nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = io.Copy(out, resp.Body)
resp.Body.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Contains(t, out.String(), "Successfully built")
+ assert.Check(t, is.Contains(out.String(), "Successfully built"))
imageIDs, err := getImageIDsFromBuild(out.Bytes())
- require.NoError(t, err)
- assert.Equal(t, 3, len(imageIDs))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(3, len(imageIDs)))
image, _, err := apiclient.ImageInspectWithRaw(context.Background(), imageIDs[2])
- require.NoError(t, err)
- assert.Contains(t, image.Config.Env, "bar=baz")
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(image.Config.Env, "bar=baz"))
}
// #35403 #36122
@@ -260,7 +260,7 @@ COPY bar /`
writeTarRecord(t, w, "../foo", "foocontents0")
writeTarRecord(t, w, "/bar", "barcontents0")
err := w.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
apiclient := testEnv.APIClient()
resp, err := apiclient.ImageBuild(ctx,
@@ -271,10 +271,10 @@ COPY bar /`
})
out := bytes.NewBuffer(nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = io.Copy(out, resp.Body)
resp.Body.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
// repeat with changed data should not cause cache hits
@@ -284,7 +284,7 @@ COPY bar /`
writeTarRecord(t, w, "../foo", "foocontents1")
writeTarRecord(t, w, "/bar", "barcontents1")
err = w.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
resp, err = apiclient.ImageBuild(ctx,
buf,
@@ -294,10 +294,10 @@ COPY bar /`
})
out = bytes.NewBuffer(nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = io.Copy(out, resp.Body)
resp.Body.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
require.NotContains(t, out.String(), "Using cache")
}
@@ -333,12 +333,12 @@ RUN [ ! -f foo ]
})
out := bytes.NewBuffer(nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = io.Copy(out, resp.Body)
resp.Body.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Contains(t, out.String(), "Successfully built")
+ assert.Check(t, is.Contains(out.String(), "Successfully built"))
}
func writeTarRecord(t *testing.T, w *tar.Writer, fn, contents string) {
@@ -348,9 +348,9 @@ func writeTarRecord(t *testing.T, w *tar.Writer, fn, contents string) {
Size: int64(len(contents)),
Typeflag: '0',
})
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = w.Write([]byte(contents))
- require.NoError(t, err)
+ assert.NilError(t, err)
}
type buildLine struct {
diff --git a/integration/config/config_test.go b/integration/config/config_test.go
index 912f55a12a..65323e2e59 100644
--- a/integration/config/config_test.go
+++ b/integration/config/config_test.go
@@ -14,9 +14,9 @@ import (
"github.com/docker/docker/integration/internal/swarm"
"github.com/docker/docker/internal/testutil"
"github.com/docker/docker/pkg/stdcopy"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -27,14 +27,14 @@ func TestConfigList(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
// This test case is ported from the original TestConfigsEmptyList
configs, err := client.ConfigList(ctx, types.ConfigListOptions{})
- require.NoError(t, err)
- assert.Equal(t, len(configs), 0)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(configs), 0))
testName0 := "test0"
testName1 := "test1"
@@ -57,8 +57,8 @@ func TestConfigList(t *testing.T) {
// test by `config ls`
entries, err := client.ConfigList(ctx, types.ConfigListOptions{})
- require.NoError(t, err)
- assert.Equal(t, names(entries), testNames)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(names(entries), testNames))
testCases := []struct {
filters filters.Args
@@ -92,8 +92,8 @@ func TestConfigList(t *testing.T) {
entries, err = client.ConfigList(ctx, types.ConfigListOptions{
Filters: tc.filters,
})
- require.NoError(t, err)
- assert.Equal(t, names(entries), tc.expected)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(names(entries), tc.expected))
}
}
@@ -106,8 +106,8 @@ func createConfig(ctx context.Context, t *testing.T, client client.APIClient, na
},
Data: data,
})
- require.NoError(t, err)
- assert.NotEqual(t, config.ID, "")
+ assert.NilError(t, err)
+ assert.Check(t, config.ID != "")
return config.ID
}
@@ -118,7 +118,7 @@ func TestConfigsCreateAndDelete(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -128,12 +128,12 @@ func TestConfigsCreateAndDelete(t *testing.T) {
configID := createConfig(ctx, t, client, testName, []byte("TESTINGDATA"), nil)
insp, _, err := client.ConfigInspectWithRaw(ctx, configID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Name, testName)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Name, testName))
// This test case is ported from the original TestConfigsDelete
err = client.ConfigRemove(ctx, configID)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.ConfigInspectWithRaw(ctx, configID)
testutil.ErrorContains(t, err, "No such config")
@@ -146,7 +146,7 @@ func TestConfigsUpdate(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -156,35 +156,35 @@ func TestConfigsUpdate(t *testing.T) {
configID := createConfig(ctx, t, client, testName, []byte("TESTINGDATA"), nil)
insp, _, err := client.ConfigInspectWithRaw(ctx, configID)
- require.NoError(t, err)
- assert.Equal(t, insp.ID, configID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.ID, configID))
// test UpdateConfig with full ID
insp.Spec.Labels = map[string]string{"test": "test1"}
err = client.ConfigUpdate(ctx, configID, insp.Version, insp.Spec)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.ConfigInspectWithRaw(ctx, configID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Labels["test"], "test1")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Labels["test"], "test1"))
// test UpdateConfig with full name
insp.Spec.Labels = map[string]string{"test": "test2"}
err = client.ConfigUpdate(ctx, testName, insp.Version, insp.Spec)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.ConfigInspectWithRaw(ctx, configID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Labels["test"], "test2")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Labels["test"], "test2"))
// test UpdateConfig with prefix ID
insp.Spec.Labels = map[string]string{"test": "test3"}
err = client.ConfigUpdate(ctx, configID[:1], insp.Version, insp.Spec)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.ConfigInspectWithRaw(ctx, configID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Labels["test"], "test3")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Labels["test"], "test3"))
// test UpdateConfig in updating Data which is not supported in daemon
// this test will produce an error in func UpdateConfig
@@ -207,7 +207,7 @@ func TestTemplatedConfig(t *testing.T) {
Data: []byte("this is a secret"),
}
referencedSecret, err := client.SecretCreate(ctx, referencedSecretSpec)
- assert.NoError(t, err)
+ assert.Check(t, err)
referencedConfigSpec := swarmtypes.ConfigSpec{
Annotations: swarmtypes.Annotations{
@@ -216,7 +216,7 @@ func TestTemplatedConfig(t *testing.T) {
Data: []byte("this is a config"),
}
referencedConfig, err := client.ConfigCreate(ctx, referencedConfigSpec)
- assert.NoError(t, err)
+ assert.Check(t, err)
configSpec := swarmtypes.ConfigSpec{
Annotations: swarmtypes.Annotations{
@@ -231,7 +231,7 @@ func TestTemplatedConfig(t *testing.T) {
}
templatedConfig, err := client.ConfigCreate(ctx, configSpec)
- assert.NoError(t, err)
+ assert.Check(t, err)
serviceID := swarm.CreateService(t, d,
swarm.ServiceWithConfig(
@@ -309,8 +309,8 @@ func TestTemplatedConfig(t *testing.T) {
func assertAttachedStream(t *testing.T, attach types.HijackedResponse, expect string) {
buf := bytes.NewBuffer(nil)
_, err := stdcopy.StdCopy(buf, buf, attach.Reader)
- require.NoError(t, err)
- assert.Contains(t, buf.String(), expect)
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(buf.String(), expect))
}
func waitAndAssert(t *testing.T, timeout time.Duration, f func(*testing.T) bool) {
@@ -336,7 +336,7 @@ func TestConfigInspect(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -344,11 +344,11 @@ func TestConfigInspect(t *testing.T) {
configID := createConfig(ctx, t, client, testName, []byte("TESTINGDATA"), nil)
insp, body, err := client.ConfigInspectWithRaw(ctx, configID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Name, testName)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Name, testName))
var config swarmtypes.Config
err = json.Unmarshal(body, &config)
- require.NoError(t, err)
- assert.Equal(t, config, insp)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(config, insp))
}
diff --git a/integration/container/copy_test.go b/integration/container/copy_test.go
index 43dc31f2f2..766c0a1762 100644
--- a/integration/container/copy_test.go
+++ b/integration/container/copy_test.go
@@ -9,8 +9,9 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/require"
)
func TestCopyFromContainerPathDoesNotExist(t *testing.T) {
@@ -21,7 +22,7 @@ func TestCopyFromContainerPathDoesNotExist(t *testing.T) {
cid := container.Create(t, ctx, apiclient)
_, _, err := apiclient.CopyFromContainer(ctx, cid, "/dne")
- require.True(t, client.IsErrNotFound(err))
+ assert.Assert(t, client.IsErrNotFound(err))
expected := fmt.Sprintf("No such container:path: %s:%s", cid, "/dne")
testutil.ErrorContains(t, err, expected)
}
@@ -35,7 +36,7 @@ func TestCopyFromContainerPathIsNotDir(t *testing.T) {
cid := container.Create(t, ctx, apiclient)
_, _, err := apiclient.CopyFromContainer(ctx, cid, "/etc/passwd/")
- require.Contains(t, err.Error(), "not a directory")
+ assert.Assert(t, is.Contains(err.Error(), "not a directory"))
}
func TestCopyToContainerPathDoesNotExist(t *testing.T) {
@@ -47,7 +48,7 @@ func TestCopyToContainerPathDoesNotExist(t *testing.T) {
cid := container.Create(t, ctx, apiclient)
err := apiclient.CopyToContainer(ctx, cid, "/dne", nil, types.CopyToContainerOptions{})
- require.True(t, client.IsErrNotFound(err))
+ assert.Assert(t, client.IsErrNotFound(err))
expected := fmt.Sprintf("No such container:path: %s:%s", cid, "/dne")
testutil.ErrorContains(t, err, expected)
}
@@ -61,5 +62,5 @@ func TestCopyToContainerPathIsNotDir(t *testing.T) {
cid := container.Create(t, ctx, apiclient)
err := apiclient.CopyToContainer(ctx, cid, "/etc/passwd/", nil, types.CopyToContainerOptions{})
- require.Contains(t, err.Error(), "not a directory")
+ assert.Assert(t, is.Contains(err.Error(), "not a directory"))
}
diff --git a/integration/container/daemon_linux_test.go b/integration/container/daemon_linux_test.go
index 5077770f53..c2920502e3 100644
--- a/integration/container/daemon_linux_test.go
+++ b/integration/container/daemon_linux_test.go
@@ -11,8 +11,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration-cli/daemon"
"github.com/docker/docker/integration/internal/container"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
"golang.org/x/sys/unix"
)
@@ -35,7 +35,7 @@ func TestContainerStartOnDaemonRestart(t *testing.T) {
defer d.Stop(t)
client, err := d.NewClient()
- assert.NoError(t, err, "error creating client")
+ assert.Check(t, err, "error creating client")
ctx := context.Background()
@@ -43,36 +43,36 @@ func TestContainerStartOnDaemonRestart(t *testing.T) {
defer client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{Force: true})
err = client.ContainerStart(ctx, cID, types.ContainerStartOptions{})
- assert.NoError(t, err, "error starting test container")
+ assert.Check(t, err, "error starting test container")
inspect, err := client.ContainerInspect(ctx, cID)
- assert.NoError(t, err, "error getting inspect data")
+ assert.Check(t, err, "error getting inspect data")
ppid := getContainerdShimPid(t, inspect)
err = d.Kill()
- assert.NoError(t, err, "failed to kill test daemon")
+ assert.Check(t, err, "failed to kill test daemon")
err = unix.Kill(inspect.State.Pid, unix.SIGKILL)
- assert.NoError(t, err, "failed to kill container process")
+ assert.Check(t, err, "failed to kill container process")
err = unix.Kill(ppid, unix.SIGKILL)
- assert.NoError(t, err, "failed to kill containerd-shim")
+ assert.Check(t, err, "failed to kill containerd-shim")
d.Start(t, "--iptables=false")
err = client.ContainerStart(ctx, cID, types.ContainerStartOptions{})
- assert.NoError(t, err, "failed to start test container")
+ assert.Check(t, err, "failed to start test container")
}
func getContainerdShimPid(t *testing.T, c types.ContainerJSON) int {
statB, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/stat", c.State.Pid))
- assert.NoError(t, err, "error looking up containerd-shim pid")
+ assert.Check(t, err, "error looking up containerd-shim pid")
// ppid is the 4th entry in `/proc/pid/stat`
ppid, err := strconv.Atoi(strings.Fields(string(statB))[3])
- assert.NoError(t, err, "error converting ppid field to int")
+ assert.Check(t, err, "error converting ppid field to int")
- assert.NotEqual(t, ppid, 1, "got unexpected ppid")
+ assert.Check(t, ppid != 1, "got unexpected ppid")
return ppid
}
diff --git a/integration/container/diff_test.go b/integration/container/diff_test.go
index de5ff4e21a..1cc63ebdde 100644
--- a/integration/container/diff_test.go
+++ b/integration/container/diff_test.go
@@ -9,9 +9,9 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/pkg/archive"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestDiff(t *testing.T) {
@@ -38,6 +38,6 @@ func TestDiff(t *testing.T) {
}
items, err := client.ContainerDiff(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, expected, items)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(expected, items))
}
diff --git a/integration/container/exec_test.go b/integration/container/exec_test.go
index 06835678f0..1b710432d1 100644
--- a/integration/container/exec_test.go
+++ b/integration/container/exec_test.go
@@ -9,7 +9,8 @@ import (
"github.com/docker/docker/api/types/strslice"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestExec(t *testing.T) {
@@ -27,7 +28,7 @@ func TestExec(t *testing.T) {
Cmd: strslice.StrSlice([]string{"sh", "-c", "env"}),
},
)
- require.NoError(t, err)
+ assert.NilError(t, err)
resp, err := client.ContainerExecAttach(ctx, id.ID,
types.ExecStartCheck{
@@ -35,12 +36,12 @@ func TestExec(t *testing.T) {
Tty: false,
},
)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer resp.Close()
r, err := ioutil.ReadAll(resp.Reader)
- require.NoError(t, err)
+ assert.NilError(t, err)
out := string(r)
- require.NoError(t, err)
- require.Contains(t, out, "PWD=/tmp", "exec command not running in expected /tmp working directory")
- require.Contains(t, out, "FOO=BAR", "exec command not running with expected environment variable FOO")
+ assert.NilError(t, err)
+ assert.Assert(t, is.Contains(out, "PWD=/tmp"), "exec command not running in expected /tmp working directory")
+ assert.Assert(t, is.Contains(out, "FOO=BAR"), "exec command not running with expected environment variable FOO")
}
diff --git a/integration/container/export_test.go b/integration/container/export_test.go
index 8f846b5a29..f7f0295ce5 100644
--- a/integration/container/export_test.go
+++ b/integration/container/export_test.go
@@ -13,10 +13,10 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/pkg/jsonmessage"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
// export an image and try to import it into a new one
@@ -32,12 +32,12 @@ func TestExportContainerAndImportImage(t *testing.T) {
reference := "repo/testexp:v1"
exportResp, err := client.ContainerExport(ctx, cID)
- require.NoError(t, err)
+ assert.NilError(t, err)
importResp, err := client.ImageImport(ctx, types.ImageImportSource{
Source: exportResp,
SourceName: "-",
}, reference, types.ImageImportOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
// If the import is successfully, then the message output should contain
// the image ID and match with the output from `docker images`.
@@ -45,13 +45,13 @@ func TestExportContainerAndImportImage(t *testing.T) {
dec := json.NewDecoder(importResp)
var jm jsonmessage.JSONMessage
err = dec.Decode(&jm)
- require.NoError(t, err)
+ assert.NilError(t, err)
images, err := client.ImageList(ctx, types.ImageListOptions{
Filters: filters.NewArgs(filters.Arg("reference", reference)),
})
- require.NoError(t, err)
- assert.Equal(t, jm.Status, images[0].ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(jm.Status, images[0].ID))
}
// TestExportContainerAfterDaemonRestart checks that a container
@@ -64,7 +64,7 @@ func TestExportContainerAfterDaemonRestart(t *testing.T) {
d := daemon.New(t, "", "dockerd", daemon.Config{})
client, err := d.NewClient()
- require.NoError(t, err)
+ assert.NilError(t, err)
d.StartWithBusybox(t)
defer d.Stop(t)
@@ -75,10 +75,10 @@ func TestExportContainerAfterDaemonRestart(t *testing.T) {
Cmd: []string{"top"},
}
ctr, err := client.ContainerCreate(ctx, &cfg, nil, nil, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
d.Restart(t)
_, err = client.ContainerExport(ctx, ctr.ID)
- assert.NoError(t, err)
+ assert.NilError(t, err)
}
diff --git a/integration/container/inspect_test.go b/integration/container/inspect_test.go
index c7ea23b517..03b9e45319 100644
--- a/integration/container/inspect_test.go
+++ b/integration/container/inspect_test.go
@@ -9,10 +9,10 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestInspectCpusetInConfigPre120(t *testing.T) {
@@ -33,16 +33,16 @@ func TestInspectCpusetInConfigPre120(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, name, "exited"), poll.WithDelay(100*time.Millisecond))
_, body, err := client.ContainerInspectWithRaw(ctx, name, false)
- require.NoError(t, err)
+ assert.NilError(t, err)
var inspectJSON map[string]interface{}
err = json.Unmarshal(body, &inspectJSON)
- require.NoError(t, err, "unable to unmarshal body for version 1.19: %s", err)
+ assert.NilError(t, err, "unable to unmarshal body for version 1.19: %s", err)
config, ok := inspectJSON["Config"]
- assert.Equal(t, true, ok, "Unable to find 'Config'")
+ assert.Check(t, is.Equal(true, ok), "Unable to find 'Config'")
cfg := config.(map[string]interface{})
_, ok = cfg["Cpuset"]
- assert.Equal(t, true, ok, "API version 1.19 expected to include Cpuset in 'Config'")
+ assert.Check(t, is.Equal(true, ok), "API version 1.19 expected to include Cpuset in 'Config'")
}
diff --git a/integration/container/kill_test.go b/integration/container/kill_test.go
index 5fae912671..4df28966f0 100644
--- a/integration/container/kill_test.go
+++ b/integration/container/kill_test.go
@@ -9,10 +9,10 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestKillContainerInvalidSignal(t *testing.T) {
@@ -22,11 +22,11 @@ func TestKillContainerInvalidSignal(t *testing.T) {
id := container.Run(t, ctx, client)
err := client.ContainerKill(ctx, id, "0")
- require.EqualError(t, err, "Error response from daemon: Invalid signal: 0")
+ assert.Error(t, err, "Error response from daemon: Invalid signal: 0")
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
err = client.ContainerKill(ctx, id, "SIG42")
- require.EqualError(t, err, "Error response from daemon: Invalid signal: SIG42")
+ assert.Error(t, err, "Error response from daemon: Invalid signal: SIG42")
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
}
@@ -62,7 +62,7 @@ func TestKillContainer(t *testing.T) {
ctx := context.Background()
id := container.Run(t, ctx, client)
err := client.ContainerKill(ctx, id, tc.signal)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, tc.status), poll.WithDelay(100*time.Millisecond))
})
@@ -102,7 +102,7 @@ func TestKillWithStopSignalAndRestartPolicies(t *testing.T) {
}
})
err := client.ContainerKill(ctx, id, "TERM")
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, tc.status), poll.WithDelay(100*time.Millisecond))
})
@@ -116,8 +116,8 @@ func TestKillStoppedContainer(t *testing.T) {
client := request.NewAPIClient(t)
id := container.Create(t, ctx, client)
err := client.ContainerKill(ctx, id, "SIGKILL")
- require.Error(t, err)
- require.Contains(t, err.Error(), "is not running")
+ assert.Assert(t, is.ErrorContains(err, ""))
+ assert.Assert(t, is.Contains(err.Error(), "is not running"))
}
func TestKillStoppedContainerAPIPre120(t *testing.T) {
@@ -127,7 +127,7 @@ func TestKillStoppedContainerAPIPre120(t *testing.T) {
client := request.NewAPIClient(t, client.WithVersion("1.19"))
id := container.Create(t, ctx, client)
err := client.ContainerKill(ctx, id, "SIGKILL")
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestKillDifferentUserContainer(t *testing.T) {
@@ -144,7 +144,7 @@ func TestKillDifferentUserContainer(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, id, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerKill(ctx, id, "SIGKILL")
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, id, "exited"), poll.WithDelay(100*time.Millisecond))
}
@@ -162,8 +162,8 @@ func TestInspectOomKilledTrue(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, true, inspect.State.OOMKilled)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(true, inspect.State.OOMKilled))
}
func TestInspectOomKilledFalse(t *testing.T) {
@@ -178,6 +178,6 @@ func TestInspectOomKilledFalse(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, false, inspect.State.OOMKilled)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(false, inspect.State.OOMKilled))
}
diff --git a/integration/container/links_linux_test.go b/integration/container/links_linux_test.go
index c844c4916f..ed5966bc7b 100644
--- a/integration/container/links_linux_test.go
+++ b/integration/container/links_linux_test.go
@@ -10,9 +10,9 @@ import (
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestLinksEtcHostsContentMatch(t *testing.T) {
@@ -27,11 +27,11 @@ func TestLinksEtcHostsContentMatch(t *testing.T) {
cID := container.Run(t, ctx, client, container.WithNetworkMode("host"))
res, err := container.Exec(ctx, client, cID, []string{"cat", "/etc/hosts"})
- require.NoError(t, err)
- require.Empty(t, res.Stderr())
- require.Equal(t, 0, res.ExitCode)
+ assert.NilError(t, err)
+ assert.Assert(t, is.Len(res.Stderr(), 0))
+ assert.Equal(t, 0, res.ExitCode)
- assert.Equal(t, string(hosts), res.Stdout())
+ assert.Check(t, is.Equal(string(hosts), res.Stdout()))
}
func TestLinksContainerNames(t *testing.T) {
@@ -49,7 +49,7 @@ func TestLinksContainerNames(t *testing.T) {
containers, err := client.ContainerList(ctx, types.ContainerListOptions{
Filters: f,
})
- require.NoError(t, err)
- assert.Equal(t, 1, len(containers))
- assert.Equal(t, []string{"/first", "/second/first"}, containers[0].Names)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(1, len(containers)))
+ assert.Check(t, is.DeepEqual([]string{"/first", "/second/first"}, containers[0].Names))
}
diff --git a/integration/container/logs_test.go b/integration/container/logs_test.go
index bae4315272..9f536742b9 100644
--- a/integration/container/logs_test.go
+++ b/integration/container/logs_test.go
@@ -9,7 +9,7 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/pkg/stdcopy"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// Regression test for #35370
@@ -25,8 +25,8 @@ func TestLogsFollowTailEmpty(t *testing.T) {
if logs != nil {
defer logs.Close()
}
- assert.NoError(t, err)
+ assert.Check(t, err)
_, err = stdcopy.StdCopy(ioutil.Discard, ioutil.Discard, logs)
- assert.NoError(t, err)
+ assert.Check(t, err)
}
diff --git a/integration/container/mounts_linux_test.go b/integration/container/mounts_linux_test.go
index c36dd2761c..e15786f8a6 100644
--- a/integration/container/mounts_linux_test.go
+++ b/integration/container/mounts_linux_test.go
@@ -16,10 +16,10 @@ import (
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/pkg/stdcopy"
"github.com/docker/docker/pkg/system"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestContainerShmNoLeak(t *testing.T) {
@@ -130,14 +130,14 @@ func TestContainerNetworkMountsNoChown(t *testing.T) {
}
cli, err := client.NewEnvClient()
- require.NoError(t, err)
+ assert.NilError(t, err)
defer cli.Close()
ctrCreate, err := cli.ContainerCreate(ctx, &config, &hostConfig, &network.NetworkingConfig{}, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
// container will exit immediately because of no tty, but we only need the start sequence to test the condition
err = cli.ContainerStart(ctx, ctrCreate.ID, types.ContainerStartOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
// Check that host-located bind mount network file did not change ownership when the container was started
// Note: If the user specifies a mountpath from the host, we should not be
@@ -150,8 +150,8 @@ func TestContainerNetworkMountsNoChown(t *testing.T) {
// same line--we don't chown host file content.
// See GitHub PR 34224 for details.
statT, err := system.Stat(tmpNWFileMount)
- require.NoError(t, err)
- assert.Equal(t, uint32(0), statT.UID(), "bind mounted network file should not change ownership from root")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(uint32(0), statT.UID()), "bind mounted network file should not change ownership from root")
}
func TestMountDaemonRoot(t *testing.T) {
diff --git a/integration/container/nat_test.go b/integration/container/nat_test.go
index 293ba9bba6..5574db779e 100644
--- a/integration/container/nat_test.go
+++ b/integration/container/nat_test.go
@@ -15,10 +15,10 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/go-connections/nat"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestNetworkNat(t *testing.T) {
@@ -31,12 +31,12 @@ func TestNetworkNat(t *testing.T) {
endpoint := getExternalAddress(t)
conn, err := net.Dial("tcp", fmt.Sprintf("%s:%d", endpoint.String(), 8080))
- require.NoError(t, err)
+ assert.NilError(t, err)
defer conn.Close()
data, err := ioutil.ReadAll(conn)
- require.NoError(t, err)
- assert.Equal(t, msg, strings.TrimSpace(string(data)))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(msg, strings.TrimSpace(string(data))))
}
func TestNetworkLocalhostTCPNat(t *testing.T) {
@@ -48,12 +48,12 @@ func TestNetworkLocalhostTCPNat(t *testing.T) {
startServerContainer(t, msg, 8081)
conn, err := net.Dial("tcp", "localhost:8081")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer conn.Close()
data, err := ioutil.ReadAll(conn)
- require.NoError(t, err)
- assert.Equal(t, msg, strings.TrimSpace(string(data)))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(msg, strings.TrimSpace(string(data))))
}
func TestNetworkLoopbackNat(t *testing.T) {
@@ -74,14 +74,14 @@ func TestNetworkLoopbackNat(t *testing.T) {
body, err := client.ContainerLogs(ctx, cID, types.ContainerLogsOptions{
ShowStdout: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
defer body.Close()
var b bytes.Buffer
_, err = io.Copy(&b, body)
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, msg, strings.TrimSpace(b.String()))
+ assert.Check(t, is.Equal(msg, strings.TrimSpace(b.String())))
}
func startServerContainer(t *testing.T, msg string, port int) string {
@@ -108,11 +108,11 @@ func getExternalAddress(t *testing.T) net.IP {
skip.If(t, err != nil, "Test not running with `make test-integration`. Interface eth0 not found: %s", err)
ifaceAddrs, err := iface.Addrs()
- require.NoError(t, err)
- assert.NotEqual(t, 0, len(ifaceAddrs))
+ assert.NilError(t, err)
+ assert.Check(t, 0 != len(ifaceAddrs))
ifaceIP, _, err := net.ParseCIDR(ifaceAddrs[0].String())
- require.NoError(t, err)
+ assert.NilError(t, err)
return ifaceIP
}
diff --git a/integration/container/pause_test.go b/integration/container/pause_test.go
index bf9f9c3d8f..dd8356f853 100644
--- a/integration/container/pause_test.go
+++ b/integration/container/pause_test.go
@@ -12,10 +12,10 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestPause(t *testing.T) {
@@ -31,14 +31,14 @@ func TestPause(t *testing.T) {
since := request.DaemonUnixTime(ctx, t, client, testEnv)
err := client.ContainerPause(ctx, cID)
- require.NoError(t, err)
+ assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, true, inspect.State.Paused)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(true, inspect.State.Paused))
err = client.ContainerUnpause(ctx, cID)
- require.NoError(t, err)
+ assert.NilError(t, err)
until := request.DaemonUnixTime(ctx, t, client, testEnv)
@@ -47,7 +47,7 @@ func TestPause(t *testing.T) {
Until: until,
Filters: filters.NewArgs(filters.Arg("container", cID)),
})
- assert.Equal(t, []string{"pause", "unpause"}, getEventActions(t, messages, errs))
+ assert.Check(t, is.DeepEqual([]string{"pause", "unpause"}, getEventActions(t, messages, errs)))
}
func TestPauseFailsOnWindowsServerContainers(t *testing.T) {
@@ -75,10 +75,10 @@ func TestPauseStopPausedContainer(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerPause(ctx, cID)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ContainerStop(ctx, cID, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, container.IsStopped(ctx, client, cID), poll.WithDelay(100*time.Millisecond))
}
@@ -88,7 +88,7 @@ func getEventActions(t *testing.T, messages <-chan events.Message, errs <-chan e
for {
select {
case err := <-errs:
- assert.True(t, err == nil || err == io.EOF)
+ assert.Check(t, err == nil || err == io.EOF)
return actions
case e := <-messages:
actions = append(actions, e.Status)
diff --git a/integration/container/ps_test.go b/integration/container/ps_test.go
index 358276b36a..45bcaca239 100644
--- a/integration/container/ps_test.go
+++ b/integration/container/ps_test.go
@@ -8,8 +8,8 @@ import (
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestPsFilter(t *testing.T) {
@@ -35,8 +35,8 @@ func TestPsFilter(t *testing.T) {
All: true,
Filters: f1,
})
- require.NoError(t, err)
- assert.Contains(t, containerIDs(q1), next)
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(containerIDs(q1), next))
f2 := filters.NewArgs()
f2.Add("before", "top")
@@ -44,6 +44,6 @@ func TestPsFilter(t *testing.T) {
All: true,
Filters: f2,
})
- require.NoError(t, err)
- assert.Contains(t, containerIDs(q2), prev)
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(containerIDs(q2), prev))
}
diff --git a/integration/container/remove_test.go b/integration/container/remove_test.go
index 98aacdd205..bbc521b059 100644
--- a/integration/container/remove_test.go
+++ b/integration/container/remove_test.go
@@ -11,11 +11,11 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/fs"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func getPrefixAndSlashFromDaemonPlatform() (prefix, slash string) {
@@ -42,12 +42,12 @@ func TestRemoveContainerWithRemovedVolume(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
err := os.RemoveAll(tempDir.Path())
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
RemoveVolumes: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
_, _, err = client.ContainerInspectWithRaw(ctx, cID, true)
testutil.ErrorContains(t, err, "No such container")
@@ -65,18 +65,18 @@ func TestRemoveContainerWithVolume(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
insp, _, err := client.ContainerInspectWithRaw(ctx, cID, true)
- require.NoError(t, err)
- assert.Equal(t, 1, len(insp.Mounts))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(1, len(insp.Mounts)))
volName := insp.Mounts[0].Name
err = client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
RemoveVolumes: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
volumes, err := client.VolumeList(ctx, filters.NewArgs(filters.Arg("name", volName)))
- require.NoError(t, err)
- assert.Equal(t, 0, len(volumes.Volumes))
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(0, len(volumes.Volumes)))
}
func TestRemoveContainerRunning(t *testing.T) {
@@ -100,7 +100,7 @@ func TestRemoveContainerForceRemoveRunning(t *testing.T) {
err := client.ContainerRemove(ctx, cID, types.ContainerRemoveOptions{
Force: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestRemoveInvalidContainer(t *testing.T) {
diff --git a/integration/container/rename_test.go b/integration/container/rename_test.go
index 3567aee1f5..a27fd78acc 100644
--- a/integration/container/rename_test.go
+++ b/integration/container/rename_test.go
@@ -11,10 +11,10 @@ import (
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
"github.com/docker/docker/pkg/stringid"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
// This test simulates the scenario mentioned in #31392:
@@ -30,18 +30,18 @@ func TestRenameLinkedContainer(t *testing.T) {
bID := container.Run(t, ctx, client, container.WithName("b0"), container.WithLinks("a0"))
err := client.ContainerRename(ctx, aID, "a1")
- require.NoError(t, err)
+ assert.NilError(t, err)
container.Run(t, ctx, client, container.WithName("a0"))
err = client.ContainerRemove(ctx, bID, types.ContainerRemoveOptions{Force: true})
- require.NoError(t, err)
+ assert.NilError(t, err)
bID = container.Run(t, ctx, client, container.WithName("b0"), container.WithLinks("a0"))
inspect, err := client.ContainerInspect(ctx, bID)
- require.NoError(t, err)
- assert.Equal(t, []string{"/a0:/b0/a0"}, inspect.HostConfig.Links)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual([]string{"/a0:/b0/a0"}, inspect.HostConfig.Links))
}
func TestRenameStoppedContainer(t *testing.T) {
@@ -54,16 +54,16 @@ func TestRenameStoppedContainer(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, "/"+oldName, inspect.Name)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("/"+oldName, inspect.Name))
newName := "new_name" + stringid.GenerateNonCryptoID()
err = client.ContainerRename(ctx, oldName, newName)
- require.NoError(t, err)
+ assert.NilError(t, err)
inspect, err = client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, "/"+newName, inspect.Name)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("/"+newName, inspect.Name))
}
func TestRenameRunningContainerAndReuse(t *testing.T) {
@@ -77,11 +77,11 @@ func TestRenameRunningContainerAndReuse(t *testing.T) {
newName := "new_name" + stringid.GenerateNonCryptoID()
err := client.ContainerRename(ctx, oldName, newName)
- require.NoError(t, err)
+ assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, "/"+newName, inspect.Name)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("/"+newName, inspect.Name))
_, err = client.ContainerInspect(ctx, oldName)
testutil.ErrorContains(t, err, "No such container: "+oldName)
@@ -90,8 +90,8 @@ func TestRenameRunningContainerAndReuse(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
inspect, err = client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, "/"+oldName, inspect.Name)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal("/"+oldName, inspect.Name))
}
func TestRenameInvalidName(t *testing.T) {
@@ -107,8 +107,8 @@ func TestRenameInvalidName(t *testing.T) {
testutil.ErrorContains(t, err, "Invalid container name")
inspect, err := client.ContainerInspect(ctx, oldName)
- require.NoError(t, err)
- assert.Equal(t, cID, inspect.ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(cID, inspect.ID))
}
// Test case for GitHub issue 22466
@@ -124,7 +124,7 @@ func TestRenameAnonymousContainer(t *testing.T) {
client := request.NewAPIClient(t)
_, err := client.NetworkCreate(ctx, "network1", types.NetworkCreate{})
- require.NoError(t, err)
+ assert.NilError(t, err)
cID := container.Run(t, ctx, client, func(c *container.TestContainerConfig) {
c.NetworkingConfig.EndpointsConfig = map[string]*network.EndpointSettings{
"network1": {},
@@ -132,13 +132,13 @@ func TestRenameAnonymousContainer(t *testing.T) {
c.HostConfig.NetworkMode = "network1"
})
err = client.ContainerRename(ctx, cID, "container1")
- require.NoError(t, err)
+ assert.NilError(t, err)
// Stop/Start the container to get registered
// FIXME(vdemeester) this is a really weird behavior as it fails otherwise
err = client.ContainerStop(ctx, "container1", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ContainerStart(ctx, "container1", types.ContainerStartOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
@@ -155,8 +155,8 @@ func TestRenameAnonymousContainer(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, 0, inspect.State.ExitCode, "container %s exited with the wrong exitcode: %+v", cID, inspect)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(0, inspect.State.ExitCode), "container %s exited with the wrong exitcode: %+v", cID, inspect)
}
// TODO: should be a unit test
@@ -192,9 +192,9 @@ func TestRenameContainerWithLinkedContainer(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, app1ID, "running"), poll.WithDelay(100*time.Millisecond))
err := client.ContainerRename(ctx, "app1", "app2")
- require.NoError(t, err)
+ assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, "app2/mysql")
- require.NoError(t, err)
- assert.Equal(t, db1ID, inspect.ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(db1ID, inspect.ID))
}
diff --git a/integration/container/resize_test.go b/integration/container/resize_test.go
index 18438ea825..149ac3afd1 100644
--- a/integration/container/resize_test.go
+++ b/integration/container/resize_test.go
@@ -11,9 +11,9 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestResize(t *testing.T) {
@@ -29,7 +29,7 @@ func TestResize(t *testing.T) {
Height: 40,
Width: 40,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestResizeWithInvalidSize(t *testing.T) {
@@ -43,8 +43,8 @@ func TestResizeWithInvalidSize(t *testing.T) {
endpoint := "/containers/" + cID + "/resize?h=foo&w=bar"
res, _, err := req.Post(endpoint)
- require.NoError(t, err)
- assert.Equal(t, http.StatusBadRequest, res.StatusCode)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(http.StatusBadRequest, res.StatusCode))
}
func TestResizeWhenContainerNotStarted(t *testing.T) {
diff --git a/integration/container/stats_test.go b/integration/container/stats_test.go
index 9c0b948498..d10808f8f7 100644
--- a/integration/container/stats_test.go
+++ b/integration/container/stats_test.go
@@ -10,10 +10,10 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestStats(t *testing.T) {
@@ -24,20 +24,20 @@ func TestStats(t *testing.T) {
ctx := context.Background()
info, err := client.Info(ctx)
- require.NoError(t, err)
+ assert.NilError(t, err)
cID := container.Run(t, ctx, client)
poll.WaitOn(t, container.IsInState(ctx, client, cID, "running"), poll.WithDelay(100*time.Millisecond))
resp, err := client.ContainerStats(ctx, cID, false)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer resp.Body.Close()
var v *types.Stats
err = json.NewDecoder(resp.Body).Decode(&v)
- require.NoError(t, err)
- assert.Equal(t, int64(v.MemoryStats.Limit), info.MemTotal)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(int64(v.MemoryStats.Limit), info.MemTotal))
err = json.NewDecoder(resp.Body).Decode(&v)
- require.Error(t, err, io.EOF)
+ assert.Assert(t, is.ErrorContains(err, ""), io.EOF)
}
diff --git a/integration/container/stop_test.go b/integration/container/stop_test.go
index 4ecd06dd2c..2cc9b82512 100644
--- a/integration/container/stop_test.go
+++ b/integration/container/stop_test.go
@@ -10,10 +10,10 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/icmd"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/require"
)
func TestStopContainerWithRestartPolicyAlways(t *testing.T) {
@@ -34,7 +34,7 @@ func TestStopContainerWithRestartPolicyAlways(t *testing.T) {
for _, name := range names {
err := client.ContainerStop(ctx, name, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
for _, name := range names {
@@ -54,7 +54,7 @@ func TestDeleteDevicemapper(t *testing.T) {
poll.WaitOn(t, container.IsStopped(ctx, client, id), poll.WithDelay(100*time.Millisecond))
inspect, err := client.ContainerInspect(ctx, id)
- require.NoError(t, err)
+ assert.NilError(t, err)
deviceID := inspect.GraphDriver.Data["DeviceId"]
@@ -67,5 +67,5 @@ func TestDeleteDevicemapper(t *testing.T) {
result.Assert(t, icmd.Success)
err = client.ContainerRemove(ctx, id, types.ContainerRemoveOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
}
diff --git a/integration/container/update_linux_test.go b/integration/container/update_linux_test.go
index c898dc1d3b..a08417ea24 100644
--- a/integration/container/update_linux_test.go
+++ b/integration/container/update_linux_test.go
@@ -10,10 +10,10 @@ import (
containertypes "github.com/docker/docker/api/types/container"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestUpdateMemory(t *testing.T) {
@@ -44,26 +44,26 @@ func TestUpdateMemory(t *testing.T) {
MemorySwap: setMemorySwap,
},
})
- require.NoError(t, err)
+ assert.NilError(t, err)
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, setMemory, inspect.HostConfig.Memory)
- assert.Equal(t, setMemorySwap, inspect.HostConfig.MemorySwap)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(setMemory, inspect.HostConfig.Memory))
+ assert.Check(t, is.Equal(setMemorySwap, inspect.HostConfig.MemorySwap))
res, err := container.Exec(ctx, client, cID,
[]string{"cat", "/sys/fs/cgroup/memory/memory.limit_in_bytes"})
- require.NoError(t, err)
- require.Empty(t, res.Stderr())
- require.Equal(t, 0, res.ExitCode)
- assert.Equal(t, strconv.FormatInt(setMemory, 10), strings.TrimSpace(res.Stdout()))
+ assert.NilError(t, err)
+ assert.Assert(t, is.Len(res.Stderr(), 0))
+ assert.Equal(t, 0, res.ExitCode)
+ assert.Check(t, is.Equal(strconv.FormatInt(setMemory, 10), strings.TrimSpace(res.Stdout())))
res, err = container.Exec(ctx, client, cID,
[]string{"cat", "/sys/fs/cgroup/memory/memory.memsw.limit_in_bytes"})
- require.NoError(t, err)
- require.Empty(t, res.Stderr())
- require.Equal(t, 0, res.ExitCode)
- assert.Equal(t, strconv.FormatInt(setMemorySwap, 10), strings.TrimSpace(res.Stdout()))
+ assert.NilError(t, err)
+ assert.Assert(t, is.Len(res.Stderr(), 0))
+ assert.Equal(t, 0, res.ExitCode)
+ assert.Check(t, is.Equal(strconv.FormatInt(setMemorySwap, 10), strings.TrimSpace(res.Stdout())))
}
func TestUpdateCPUQuota(t *testing.T) {
@@ -93,15 +93,15 @@ func TestUpdateCPUQuota(t *testing.T) {
}
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, test.update, inspect.HostConfig.CPUQuota)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(test.update, inspect.HostConfig.CPUQuota))
res, err := container.Exec(ctx, client, cID,
[]string{"/bin/cat", "/sys/fs/cgroup/cpu/cpu.cfs_quota_us"})
- require.NoError(t, err)
- require.Empty(t, res.Stderr())
- require.Equal(t, 0, res.ExitCode)
+ assert.NilError(t, err)
+ assert.Assert(t, is.Len(res.Stderr(), 0))
+ assert.Equal(t, 0, res.ExitCode)
- assert.Equal(t, strconv.FormatInt(test.update, 10), strings.TrimSpace(res.Stdout()))
+ assert.Check(t, is.Equal(strconv.FormatInt(test.update, 10), strings.TrimSpace(res.Stdout())))
}
}
diff --git a/integration/container/update_test.go b/integration/container/update_test.go
index 651e84cb22..03dcc635c6 100644
--- a/integration/container/update_test.go
+++ b/integration/container/update_test.go
@@ -9,9 +9,9 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestUpdateRestartPolicy(t *testing.T) {
@@ -32,7 +32,7 @@ func TestUpdateRestartPolicy(t *testing.T) {
MaximumRetryCount: 5,
},
})
- require.NoError(t, err)
+ assert.NilError(t, err)
timeout := 60 * time.Second
if testEnv.OSType == "windows" {
@@ -42,9 +42,9 @@ func TestUpdateRestartPolicy(t *testing.T) {
poll.WaitOn(t, container.IsInState(ctx, client, cID, "exited"), poll.WithDelay(100*time.Millisecond), poll.WithTimeout(timeout))
inspect, err := client.ContainerInspect(ctx, cID)
- require.NoError(t, err)
- assert.Equal(t, inspect.RestartCount, 5)
- assert.Equal(t, inspect.HostConfig.RestartPolicy.MaximumRetryCount, 5)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(inspect.RestartCount, 5))
+ assert.Check(t, is.Equal(inspect.HostConfig.RestartPolicy.MaximumRetryCount, 5))
}
func TestUpdateRestartWithAutoRemove(t *testing.T) {
diff --git a/integration/image/commit_test.go b/integration/image/commit_test.go
index 39fc956db1..e13719b532 100644
--- a/integration/image/commit_test.go
+++ b/integration/image/commit_test.go
@@ -7,8 +7,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestCommitInheritsEnv(t *testing.T) {
@@ -22,13 +22,13 @@ func TestCommitInheritsEnv(t *testing.T) {
Changes: []string{"ENV PATH=/bin"},
Reference: "test-commit-image",
})
- require.NoError(t, err)
+ assert.NilError(t, err)
image1, _, err := client.ImageInspectWithRaw(ctx, commitResp1.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedEnv1 := []string{"PATH=/bin"}
- assert.Equal(t, expectedEnv1, image1.Config.Env)
+ assert.Check(t, is.DeepEqual(expectedEnv1, image1.Config.Env))
cID2 := container.Create(t, ctx, client, container.WithImage(image1.ID))
@@ -36,10 +36,10 @@ func TestCommitInheritsEnv(t *testing.T) {
Changes: []string{"ENV PATH=/usr/bin:$PATH"},
Reference: "test-commit-image",
})
- require.NoError(t, err)
+ assert.NilError(t, err)
image2, _, err := client.ImageInspectWithRaw(ctx, commitResp2.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedEnv2 := []string{"PATH=/usr/bin:/bin"}
- assert.Equal(t, expectedEnv2, image2.Config.Env)
+ assert.Check(t, is.DeepEqual(expectedEnv2, image2.Config.Env))
}
diff --git a/integration/image/remove_test.go b/integration/image/remove_test.go
index 825724bd03..c89f6f7a03 100644
--- a/integration/image/remove_test.go
+++ b/integration/image/remove_test.go
@@ -8,8 +8,8 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestRemoveImageOrphaning(t *testing.T) {
@@ -25,12 +25,12 @@ func TestRemoveImageOrphaning(t *testing.T) {
Changes: []string{`ENTRYPOINT ["true"]`},
Reference: img,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
// verifies that reference now points to first image
resp, _, err := client.ImageInspectWithRaw(ctx, img)
- require.NoError(t, err)
- assert.Equal(t, resp.ID, commitResp1.ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(resp.ID, commitResp1.ID))
// Create a container from created image, and commit a small change with same reference name
cID2 := container.Create(t, ctx, client, container.WithImage(img), container.WithCmd(""))
@@ -38,21 +38,21 @@ func TestRemoveImageOrphaning(t *testing.T) {
Changes: []string{`LABEL Maintainer="Integration Tests"`},
Reference: img,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
// verifies that reference now points to second image
resp, _, err = client.ImageInspectWithRaw(ctx, img)
- require.NoError(t, err)
- assert.Equal(t, resp.ID, commitResp2.ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(resp.ID, commitResp2.ID))
// try to remove the image, should not error out.
_, err = client.ImageRemove(ctx, img, types.ImageRemoveOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
// check if the first image is still there
resp, _, err = client.ImageInspectWithRaw(ctx, commitResp1.ID)
- require.NoError(t, err)
- assert.Equal(t, resp.ID, commitResp1.ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(resp.ID, commitResp1.ID))
// check if the second image has been deleted
_, _, err = client.ImageInspectWithRaw(ctx, commitResp2.ID)
diff --git a/integration/internal/container/container.go b/integration/internal/container/container.go
index 8d8fe28791..0c76571769 100644
--- a/integration/internal/container/container.go
+++ b/integration/internal/container/container.go
@@ -8,7 +8,7 @@ import (
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/network"
"github.com/docker/docker/client"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// TestContainerConfig holds container configuration struct that
@@ -37,7 +37,7 @@ func Create(t *testing.T, ctx context.Context, client client.APIClient, ops ...f
}
c, err := client.ContainerCreate(ctx, config.Config, config.HostConfig, config.NetworkingConfig, config.Name)
- require.NoError(t, err)
+ assert.NilError(t, err)
return c.ID
}
@@ -48,7 +48,7 @@ func Run(t *testing.T, ctx context.Context, client client.APIClient, ops ...func
id := Create(t, ctx, client, ops...)
err := client.ContainerStart(ctx, id, types.ContainerStartOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
return id
}
diff --git a/integration/internal/request/client.go b/integration/internal/request/client.go
index 34e589ec86..07dc2e33c3 100644
--- a/integration/internal/request/client.go
+++ b/integration/internal/request/client.go
@@ -9,14 +9,14 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/internal/test/environment"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// NewAPIClient returns a docker API client configured from environment variables
func NewAPIClient(t *testing.T, ops ...func(*client.Client) error) client.APIClient {
ops = append([]func(*client.Client) error{client.FromEnv}, ops...)
clt, err := client.NewClientWithOpts(ops...)
- require.NoError(t, err)
+ assert.NilError(t, err)
return clt
}
@@ -27,10 +27,10 @@ func DaemonTime(ctx context.Context, t *testing.T, client client.APIClient, test
}
info, err := client.Info(ctx)
- require.NoError(t, err)
+ assert.NilError(t, err)
dt, err := time.Parse(time.RFC3339Nano, info.SystemTime)
- require.NoError(t, err, "invalid time format in GET /info response")
+ assert.NilError(t, err, "invalid time format in GET /info response")
return dt
}
diff --git a/integration/internal/swarm/service.go b/integration/internal/swarm/service.go
index a46b02e146..0ec4d5175e 100644
--- a/integration/internal/swarm/service.go
+++ b/integration/internal/swarm/service.go
@@ -11,7 +11,7 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration-cli/daemon"
"github.com/docker/docker/internal/test/environment"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
const (
@@ -35,7 +35,7 @@ func NewSwarm(t *testing.T, testEnv *environment.Execution) *daemon.Swarm {
args := []string{"--iptables=false", "--swarm-default-advertise-addr=lo"}
d.StartWithBusybox(t, args...)
- require.NoError(t, d.Init(swarmtypes.InitRequest{}))
+ assert.NilError(t, d.Init(swarmtypes.InitRequest{}))
return d
}
@@ -52,7 +52,7 @@ func CreateService(t *testing.T, d *daemon.Swarm, opts ...ServiceSpecOpt) string
client := GetClient(t, d)
resp, err := client.ServiceCreate(context.Background(), spec, types.ServiceCreateOptions{})
- require.NoError(t, err, "error creating service")
+ assert.NilError(t, err, "error creating service")
return resp.ID
}
@@ -126,7 +126,7 @@ func GetRunningTasks(t *testing.T, d *daemon.Swarm, serviceID string) []swarmtyp
Filters: filterArgs,
}
tasks, err := client.TaskList(context.Background(), options)
- require.NoError(t, err)
+ assert.NilError(t, err)
return tasks
}
@@ -136,11 +136,11 @@ func ExecTask(t *testing.T, d *daemon.Swarm, task swarmtypes.Task, config types.
ctx := context.Background()
resp, err := client.ContainerExecCreate(ctx, task.Status.ContainerStatus.ContainerID, config)
- require.NoError(t, err, "error creating exec")
+ assert.NilError(t, err, "error creating exec")
startCheck := types.ExecStartCheck{}
attach, err := client.ContainerExecAttach(ctx, resp.ID, startCheck)
- require.NoError(t, err, "error attaching to exec")
+ assert.NilError(t, err, "error attaching to exec")
return attach
}
@@ -153,6 +153,6 @@ func ensureContainerSpec(spec *swarmtypes.ServiceSpec) {
// GetClient creates a new client for the passed in swarm daemon.
func GetClient(t *testing.T, d *daemon.Swarm) client.APIClient {
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
return client
}
diff --git a/integration/network/delete_test.go b/integration/network/delete_test.go
index 0877d8bc8c..e2af49de7e 100644
--- a/integration/network/delete_test.go
+++ b/integration/network/delete_test.go
@@ -6,8 +6,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func containsNetwork(nws []types.NetworkResource, nw types.NetworkCreateResponse) bool {
@@ -29,18 +29,18 @@ func createAmbiguousNetworks(t *testing.T) (types.NetworkCreateResponse, types.N
ctx := context.Background()
testNet, err := client.NetworkCreate(ctx, "testNet", types.NetworkCreate{})
- require.NoError(t, err)
+ assert.NilError(t, err)
idPrefixNet, err := client.NetworkCreate(ctx, testNet.ID[:12], types.NetworkCreate{})
- require.NoError(t, err)
+ assert.NilError(t, err)
fullIDNet, err := client.NetworkCreate(ctx, testNet.ID, types.NetworkCreate{})
- require.NoError(t, err)
+ assert.NilError(t, err)
nws, err := client.NetworkList(ctx, types.NetworkListOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, true, containsNetwork(nws, testNet), "failed to create network testNet")
- assert.Equal(t, true, containsNetwork(nws, idPrefixNet), "failed to create network idPrefixNet")
- assert.Equal(t, true, containsNetwork(nws, fullIDNet), "failed to create network fullIDNet")
+ assert.Check(t, is.Equal(true, containsNetwork(nws, testNet)), "failed to create network testNet")
+ assert.Check(t, is.Equal(true, containsNetwork(nws, idPrefixNet)), "failed to create network idPrefixNet")
+ assert.Check(t, is.Equal(true, containsNetwork(nws, fullIDNet)), "failed to create network fullIDNet")
return testNet, idPrefixNet, fullIDNet
}
@@ -56,17 +56,17 @@ func TestDockerNetworkDeletePreferID(t *testing.T) {
// Delete the network using a prefix of the first network's ID as name.
// This should the network name with the id-prefix, not the original network.
err := client.NetworkRemove(ctx, testNet.ID[:12])
- require.NoError(t, err)
+ assert.NilError(t, err)
// Delete the network using networkID. This should remove the original
// network, not the network with the name equal to the networkID
err = client.NetworkRemove(ctx, testNet.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
// networks "testNet" and "idPrefixNet" should be removed, but "fullIDNet" should still exist
nws, err := client.NetworkList(ctx, types.NetworkListOptions{})
- require.NoError(t, err)
- assert.Equal(t, false, containsNetwork(nws, testNet), "Network testNet not removed")
- assert.Equal(t, false, containsNetwork(nws, idPrefixNet), "Network idPrefixNet not removed")
- assert.Equal(t, true, containsNetwork(nws, fullIDNet), "Network fullIDNet not found")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(false, containsNetwork(nws, testNet)), "Network testNet not removed")
+ assert.Check(t, is.Equal(false, containsNetwork(nws, idPrefixNet)), "Network idPrefixNet not removed")
+ assert.Check(t, is.Equal(true, containsNetwork(nws, fullIDNet)), "Network fullIDNet not found")
}
diff --git a/integration/network/inspect_test.go b/integration/network/inspect_test.go
index df586224a1..3afdcf1ac4 100644
--- a/integration/network/inspect_test.go
+++ b/integration/network/inspect_test.go
@@ -11,8 +11,8 @@ import (
"github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/client"
"github.com/docker/docker/integration-cli/daemon"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -24,7 +24,7 @@ func TestInspectNetwork(t *testing.T) {
d := newSwarm(t)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
overlayName := "overlay1"
networkCreate := types.NetworkCreate{
@@ -33,7 +33,7 @@ func TestInspectNetwork(t *testing.T) {
}
netResp, err := client.NetworkCreate(context.Background(), overlayName, networkCreate)
- require.NoError(t, err)
+ assert.NilError(t, err)
overlayID := netResp.ID
var instances uint64 = 4
@@ -44,7 +44,7 @@ func TestInspectNetwork(t *testing.T) {
serviceResp, err := client.ServiceCreate(context.Background(), serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
pollSettings := func(config *poll.Settings) {
if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
@@ -57,32 +57,32 @@ func TestInspectNetwork(t *testing.T) {
poll.WaitOn(t, serviceRunningTasksCount(client, serviceID, instances), pollSettings)
_, _, err = client.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
// Test inspect verbose with full NetworkID
networkVerbose, err := client.NetworkInspect(context.Background(), overlayID, types.NetworkInspectOptions{
Verbose: true,
})
- require.NoError(t, err)
- require.True(t, validNetworkVerbose(networkVerbose, serviceName, instances))
+ assert.NilError(t, err)
+ assert.Assert(t, validNetworkVerbose(networkVerbose, serviceName, instances))
// Test inspect verbose with partial NetworkID
networkVerbose, err = client.NetworkInspect(context.Background(), overlayID[0:11], types.NetworkInspectOptions{
Verbose: true,
})
- require.NoError(t, err)
- require.True(t, validNetworkVerbose(networkVerbose, serviceName, instances))
+ assert.NilError(t, err)
+ assert.Assert(t, validNetworkVerbose(networkVerbose, serviceName, instances))
// Test inspect verbose with Network name and swarm scope
networkVerbose, err = client.NetworkInspect(context.Background(), overlayName, types.NetworkInspectOptions{
Verbose: true,
Scope: "swarm",
})
- require.NoError(t, err)
- require.True(t, validNetworkVerbose(networkVerbose, serviceName, instances))
+ assert.NilError(t, err)
+ assert.Assert(t, validNetworkVerbose(networkVerbose, serviceName, instances))
err = client.ServiceRemove(context.Background(), serviceID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceID), pollSettings)
poll.WaitOn(t, noTasks(client), pollSettings)
@@ -90,19 +90,19 @@ func TestInspectNetwork(t *testing.T) {
serviceResp, err = client.ServiceCreate(context.Background(), serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
serviceID2 := serviceResp.ID
poll.WaitOn(t, serviceRunningTasksCount(client, serviceID2, instances), pollSettings)
err = client.ServiceRemove(context.Background(), serviceID2)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceID2), pollSettings)
poll.WaitOn(t, noTasks(client), pollSettings)
err = client.NetworkRemove(context.Background(), overlayID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, networkIsRemoved(client, overlayID), poll.WithTimeout(1*time.Minute), poll.WithDelay(10*time.Second))
}
@@ -122,7 +122,7 @@ func newSwarm(t *testing.T) *daemon.Swarm {
args := []string{"--iptables=false", "--swarm-default-advertise-addr=lo"}
d.StartWithBusybox(t, args...)
- require.NoError(t, d.Init(swarm.InitRequest{}))
+ assert.NilError(t, d.Init(swarm.InitRequest{}))
return d
}
diff --git a/integration/network/service_test.go b/integration/network/service_test.go
index f1c0950988..87e1fe00fd 100644
--- a/integration/network/service_test.go
+++ b/integration/network/service_test.go
@@ -9,8 +9,8 @@ import (
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/client"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -19,7 +19,7 @@ func TestServiceWithPredefinedNetwork(t *testing.T) {
d := newSwarm(t)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
hostName := "host"
var instances uint64 = 1
@@ -30,7 +30,7 @@ func TestServiceWithPredefinedNetwork(t *testing.T) {
serviceResp, err := client.ServiceCreate(context.Background(), serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
pollSettings := func(config *poll.Settings) {
if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
@@ -101,10 +101,10 @@ func TestServiceWithIngressNetwork(t *testing.T) {
poll.WaitOn(t, serviceRunningCount(client, serviceID, instances), pollSettings)
_, _, err = client.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ServiceRemove(context.Background(), serviceID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceID), pollSettings)
poll.WaitOn(t, noTasks(client), pollSettings)
diff --git a/integration/plugin/authz/authz_plugin_test.go b/integration/plugin/authz/authz_plugin_test.go
index 667fc3d3cc..5bca6c138d 100644
--- a/integration/plugin/authz/authz_plugin_test.go
+++ b/integration/plugin/authz/authz_plugin_test.go
@@ -24,8 +24,8 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/internal/test/environment"
"github.com/docker/docker/pkg/authorization"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/require"
)
const (
@@ -55,15 +55,15 @@ func setupTestV1(t *testing.T) func() {
teardown := setupTest(t)
err := os.MkdirAll("/etc/docker/plugins", 0755)
- require.Nil(t, err)
+ assert.NilError(t, err)
fileName := fmt.Sprintf("/etc/docker/plugins/%s.spec", testAuthZPlugin)
err = ioutil.WriteFile(fileName, []byte(server.URL), 0644)
- require.Nil(t, err)
+ assert.NilError(t, err)
return func() {
err := os.RemoveAll("/etc/docker/plugins")
- require.Nil(t, err)
+ assert.NilError(t, err)
teardown()
ctrl = nil
@@ -87,7 +87,7 @@ func TestAuthZPluginAllowRequest(t *testing.T) {
d.StartWithBusybox(t, "--authorization-plugin="+testAuthZPlugin)
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -98,9 +98,9 @@ func TestAuthZPluginAllowRequest(t *testing.T) {
assertURIRecorded(t, ctrl.requestsURIs, fmt.Sprintf("/containers/%s/start", cID))
_, err = client.ServerVersion(ctx)
- require.Nil(t, err)
- require.Equal(t, 1, ctrl.versionReqCount)
- require.Equal(t, 1, ctrl.versionResCount)
+ assert.NilError(t, err)
+ assert.Equal(t, 1, ctrl.versionReqCount)
+ assert.Equal(t, 1, ctrl.versionResCount)
}
func TestAuthZPluginTLS(t *testing.T) {
@@ -126,13 +126,13 @@ func TestAuthZPluginTLS(t *testing.T) {
ctrl.resRes.Allow = true
client, err := newTLSAPIClient(testDaemonHTTPSAddr, cacertPath, clientCertPath, clientKeyPath)
- require.Nil(t, err)
+ assert.NilError(t, err)
_, err = client.ServerVersion(context.Background())
- require.Nil(t, err)
+ assert.NilError(t, err)
- require.Equal(t, "client", ctrl.reqUser)
- require.Equal(t, "client", ctrl.resUser)
+ assert.Equal(t, "client", ctrl.reqUser)
+ assert.Equal(t, "client", ctrl.resUser)
}
func newTLSAPIClient(host, cacertPath, certPath, keyPath string) (client.APIClient, error) {
@@ -153,16 +153,16 @@ func TestAuthZPluginDenyRequest(t *testing.T) {
ctrl.reqRes.Msg = unauthorizedMessage
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Ensure command is blocked
_, err = client.ServerVersion(context.Background())
- require.NotNil(t, err)
- require.Equal(t, 1, ctrl.versionReqCount)
- require.Equal(t, 0, ctrl.versionResCount)
+ assert.Assert(t, err != nil)
+ assert.Equal(t, 1, ctrl.versionReqCount)
+ assert.Equal(t, 0, ctrl.versionResCount)
// Ensure unauthorized message appears in response
- require.Equal(t, fmt.Sprintf("Error response from daemon: authorization denied by plugin %s: %s", testAuthZPlugin, unauthorizedMessage), err.Error())
+ assert.Equal(t, fmt.Sprintf("Error response from daemon: authorization denied by plugin %s: %s", testAuthZPlugin, unauthorizedMessage), err.Error())
}
// TestAuthZPluginAPIDenyResponse validates that when authorization
@@ -174,17 +174,17 @@ func TestAuthZPluginAPIDenyResponse(t *testing.T) {
ctrl.resRes.Msg = unauthorizedMessage
daemonURL, err := url.Parse(d.Sock())
- require.Nil(t, err)
+ assert.NilError(t, err)
conn, err := net.DialTimeout(daemonURL.Scheme, daemonURL.Path, time.Second*10)
- require.Nil(t, err)
+ assert.NilError(t, err)
client := httputil.NewClientConn(conn, nil)
req, err := http.NewRequest("GET", "/version", nil)
- require.Nil(t, err)
+ assert.NilError(t, err)
resp, err := client.Do(req)
- require.Nil(t, err)
- require.Equal(t, http.StatusForbidden, resp.StatusCode)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, http.StatusForbidden, resp.StatusCode)
}
func TestAuthZPluginDenyResponse(t *testing.T) {
@@ -195,16 +195,16 @@ func TestAuthZPluginDenyResponse(t *testing.T) {
ctrl.resRes.Msg = unauthorizedMessage
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Ensure command is blocked
_, err = client.ServerVersion(context.Background())
- require.NotNil(t, err)
- require.Equal(t, 1, ctrl.versionReqCount)
- require.Equal(t, 1, ctrl.versionResCount)
+ assert.Assert(t, err != nil)
+ assert.Equal(t, 1, ctrl.versionReqCount)
+ assert.Equal(t, 1, ctrl.versionResCount)
// Ensure unauthorized message appears in response
- require.Equal(t, fmt.Sprintf("Error response from daemon: authorization denied by plugin %s: %s", testAuthZPlugin, unauthorizedMessage), err.Error())
+ assert.Equal(t, fmt.Sprintf("Error response from daemon: authorization denied by plugin %s: %s", testAuthZPlugin, unauthorizedMessage), err.Error())
}
// TestAuthZPluginAllowEventStream verifies event stream propagates
@@ -218,7 +218,7 @@ func TestAuthZPluginAllowEventStream(t *testing.T) {
d.StartWithBusybox(t, "--authorization-plugin="+testAuthZPlugin)
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -231,7 +231,7 @@ func TestAuthZPluginAllowEventStream(t *testing.T) {
for i := 0; i < 100; i++ {
c, err := client.ContainerInspect(ctx, cID)
- require.Nil(t, err)
+ assert.NilError(t, err)
if c.State.Running {
break
}
@@ -258,7 +258,7 @@ func TestAuthZPluginAllowEventStream(t *testing.T) {
if err == io.EOF {
t.Fatal("premature end of event stream")
}
- require.Nil(t, err)
+ assert.NilError(t, err)
case <-time.After(30 * time.Second):
// Fail the test
t.Fatal("event stream timeout")
@@ -279,10 +279,10 @@ func systemTime(t *testing.T, client client.APIClient, testEnv *environment.Exec
ctx := context.Background()
info, err := client.Info(ctx)
- require.Nil(t, err)
+ assert.NilError(t, err)
dt, err := time.Parse(time.RFC3339Nano, info.SystemTime)
- require.Nil(t, err, "invalid time format in GET /info response")
+ assert.NilError(t, err, "invalid time format in GET /info response")
return dt
}
@@ -303,12 +303,12 @@ func TestAuthZPluginErrorResponse(t *testing.T) {
ctrl.resRes.Err = errorMessage
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Ensure command is blocked
_, err = client.ServerVersion(context.Background())
- require.NotNil(t, err)
- require.Equal(t, fmt.Sprintf("Error response from daemon: plugin %s failed with error: %s: %s", testAuthZPlugin, authorization.AuthZApiResponse, errorMessage), err.Error())
+ assert.Assert(t, err != nil)
+ assert.Equal(t, fmt.Sprintf("Error response from daemon: plugin %s failed with error: %s: %s", testAuthZPlugin, authorization.AuthZApiResponse, errorMessage), err.Error())
}
func TestAuthZPluginErrorRequest(t *testing.T) {
@@ -317,12 +317,12 @@ func TestAuthZPluginErrorRequest(t *testing.T) {
ctrl.reqRes.Err = errorMessage
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Ensure command is blocked
_, err = client.ServerVersion(context.Background())
- require.NotNil(t, err)
- require.Equal(t, fmt.Sprintf("Error response from daemon: plugin %s failed with error: %s: %s", testAuthZPlugin, authorization.AuthZApiRequest, errorMessage), err.Error())
+ assert.Assert(t, err != nil)
+ assert.Equal(t, fmt.Sprintf("Error response from daemon: plugin %s failed with error: %s: %s", testAuthZPlugin, authorization.AuthZApiRequest, errorMessage), err.Error())
}
func TestAuthZPluginEnsureNoDuplicatePluginRegistration(t *testing.T) {
@@ -333,14 +333,14 @@ func TestAuthZPluginEnsureNoDuplicatePluginRegistration(t *testing.T) {
ctrl.resRes.Allow = true
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
_, err = client.ServerVersion(context.Background())
- require.Nil(t, err)
+ assert.NilError(t, err)
// assert plugin is only called once..
- require.Equal(t, 1, ctrl.versionReqCount)
- require.Equal(t, 1, ctrl.versionResCount)
+ assert.Equal(t, 1, ctrl.versionReqCount)
+ assert.Equal(t, 1, ctrl.versionResCount)
}
func TestAuthZPluginEnsureLoadImportWorking(t *testing.T) {
@@ -350,36 +350,36 @@ func TestAuthZPluginEnsureLoadImportWorking(t *testing.T) {
d.StartWithBusybox(t, "--authorization-plugin="+testAuthZPlugin, "--authorization-plugin="+testAuthZPlugin)
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
tmp, err := ioutil.TempDir("", "test-authz-load-import")
- require.Nil(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmp)
savedImagePath := filepath.Join(tmp, "save.tar")
err = imageSave(client, savedImagePath, "busybox")
- require.Nil(t, err)
+ assert.NilError(t, err)
err = imageLoad(client, savedImagePath)
- require.Nil(t, err)
+ assert.NilError(t, err)
exportedImagePath := filepath.Join(tmp, "export.tar")
cID := container.Run(t, ctx, client)
responseReader, err := client.ContainerExport(context.Background(), cID)
- require.Nil(t, err)
+ assert.NilError(t, err)
defer responseReader.Close()
file, err := os.Create(exportedImagePath)
- require.Nil(t, err)
+ assert.NilError(t, err)
defer file.Close()
_, err = io.Copy(file, responseReader)
- require.Nil(t, err)
+ assert.NilError(t, err)
err = imageImport(client, exportedImagePath)
- require.Nil(t, err)
+ assert.NilError(t, err)
}
func imageSave(client client.APIClient, path, image string) error {
@@ -442,16 +442,16 @@ func TestAuthZPluginHeader(t *testing.T) {
d.StartWithBusybox(t, "--debug", "--authorization-plugin="+testAuthZPlugin)
daemonURL, err := url.Parse(d.Sock())
- require.Nil(t, err)
+ assert.NilError(t, err)
conn, err := net.DialTimeout(daemonURL.Scheme, daemonURL.Path, time.Second*10)
- require.Nil(t, err)
+ assert.NilError(t, err)
client := httputil.NewClientConn(conn, nil)
req, err := http.NewRequest("GET", "/version", nil)
- require.Nil(t, err)
+ assert.NilError(t, err)
resp, err := client.Do(req)
- require.Nil(t, err)
- require.Equal(t, "application/json", resp.Header["Content-Type"][0])
+ assert.NilError(t, err)
+ assert.Equal(t, "application/json", resp.Header["Content-Type"][0])
}
// assertURIRecorded verifies that the given URI was sent and recorded
diff --git a/integration/plugin/authz/authz_plugin_v2_test.go b/integration/plugin/authz/authz_plugin_v2_test.go
index 5efa421e88..fa3d37dc8c 100644
--- a/integration/plugin/authz/authz_plugin_v2_test.go
+++ b/integration/plugin/authz/authz_plugin_v2_test.go
@@ -16,8 +16,8 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/requirement"
+ "github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/require"
)
var (
@@ -44,13 +44,13 @@ func TestAuthZPluginV2AllowNonVolumeRequest(t *testing.T) {
defer setupTestV2(t)()
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
// Install authz plugin
err = pluginInstallGrantAllPermissions(client, authzPluginNameWithTag)
- require.Nil(t, err)
+ assert.NilError(t, err)
// start the daemon with the plugin and load busybox, --net=none build fails otherwise
// because it needs to pull busybox
d.Restart(t, "--authorization-plugin="+authzPluginNameWithTag)
@@ -60,7 +60,7 @@ func TestAuthZPluginV2AllowNonVolumeRequest(t *testing.T) {
cID := container.Run(t, ctx, client)
_, err = client.ContainerInspect(ctx, cID)
- require.Nil(t, err)
+ assert.NilError(t, err)
}
func TestAuthZPluginV2Disable(t *testing.T) {
@@ -68,26 +68,26 @@ func TestAuthZPluginV2Disable(t *testing.T) {
defer setupTestV2(t)()
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Install authz plugin
err = pluginInstallGrantAllPermissions(client, authzPluginNameWithTag)
- require.Nil(t, err)
+ assert.NilError(t, err)
d.Restart(t, "--authorization-plugin="+authzPluginNameWithTag)
d.LoadBusybox(t)
_, err = client.VolumeCreate(context.Background(), volumetypes.VolumesCreateBody{Driver: "local"})
- require.NotNil(t, err)
- require.True(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
+ assert.Assert(t, err != nil)
+ assert.Assert(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
// disable the plugin
err = client.PluginDisable(context.Background(), authzPluginNameWithTag, types.PluginDisableOptions{})
- require.Nil(t, err)
+ assert.NilError(t, err)
// now test to see if the docker api works.
_, err = client.VolumeCreate(context.Background(), volumetypes.VolumesCreateBody{Driver: "local"})
- require.Nil(t, err)
+ assert.NilError(t, err)
}
func TestAuthZPluginV2RejectVolumeRequests(t *testing.T) {
@@ -95,35 +95,35 @@ func TestAuthZPluginV2RejectVolumeRequests(t *testing.T) {
defer setupTestV2(t)()
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Install authz plugin
err = pluginInstallGrantAllPermissions(client, authzPluginNameWithTag)
- require.Nil(t, err)
+ assert.NilError(t, err)
// restart the daemon with the plugin
d.Restart(t, "--authorization-plugin="+authzPluginNameWithTag)
_, err = client.VolumeCreate(context.Background(), volumetypes.VolumesCreateBody{Driver: "local"})
- require.NotNil(t, err)
- require.True(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
+ assert.Assert(t, err != nil)
+ assert.Assert(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
_, err = client.VolumeList(context.Background(), filters.Args{})
- require.NotNil(t, err)
- require.True(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
+ assert.Assert(t, err != nil)
+ assert.Assert(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
// The plugin will block the command before it can determine the volume does not exist
err = client.VolumeRemove(context.Background(), "test", false)
- require.NotNil(t, err)
- require.True(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
+ assert.Assert(t, err != nil)
+ assert.Assert(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
_, err = client.VolumeInspect(context.Background(), "test")
- require.NotNil(t, err)
- require.True(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
+ assert.Assert(t, err != nil)
+ assert.Assert(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
_, err = client.VolumesPrune(context.Background(), filters.Args{})
- require.NotNil(t, err)
- require.True(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
+ assert.Assert(t, err != nil)
+ assert.Assert(t, strings.Contains(err.Error(), fmt.Sprintf("Error response from daemon: plugin %s failed with error:", authzPluginNameWithTag)))
}
func TestAuthZPluginV2BadManifestFailsDaemonStart(t *testing.T) {
@@ -131,15 +131,15 @@ func TestAuthZPluginV2BadManifestFailsDaemonStart(t *testing.T) {
defer setupTestV2(t)()
client, err := d.NewClient()
- require.Nil(t, err)
+ assert.NilError(t, err)
// Install authz plugin with bad manifest
err = pluginInstallGrantAllPermissions(client, authzPluginBadManifestName)
- require.Nil(t, err)
+ assert.NilError(t, err)
// start the daemon with the plugin, it will error
err = d.RestartWithError("--authorization-plugin=" + authzPluginBadManifestName)
- require.NotNil(t, err)
+ assert.Assert(t, err != nil)
// restarting the daemon without requiring the plugin will succeed
d.Start(t)
@@ -150,7 +150,7 @@ func TestAuthZPluginV2NonexistentFailsDaemonStart(t *testing.T) {
// start the daemon with a non-existent authz plugin, it will error
err := d.RestartWithError("--authorization-plugin=" + nonexistentAuthzPluginName)
- require.NotNil(t, err)
+ assert.Assert(t, err != nil)
// restarting the daemon without requiring the plugin will succeed
d.Start(t)
diff --git a/integration/plugin/logging/validation_test.go b/integration/plugin/logging/validation_test.go
index 6607321613..eb3fe7a029 100644
--- a/integration/plugin/logging/validation_test.go
+++ b/integration/plugin/logging/validation_test.go
@@ -6,7 +6,7 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration-cli/daemon"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// Regression test for #35553
@@ -20,12 +20,12 @@ func TestDaemonStartWithLogOpt(t *testing.T) {
defer d.Stop(t)
client, err := d.NewClient()
- assert.NoError(t, err)
+ assert.Check(t, err)
ctx := context.Background()
createPlugin(t, client, "test", "dummy", asLogDriver)
err = client.PluginEnable(ctx, "test", types.PluginEnableOptions{Timeout: 30})
- assert.NoError(t, err)
+ assert.Check(t, err)
defer client.PluginRemove(ctx, "test", types.PluginRemoveOptions{Force: true})
d.Stop(t)
diff --git a/integration/secret/secret_test.go b/integration/secret/secret_test.go
index 27c8fd3d0e..4a1e1b3dc7 100644
--- a/integration/secret/secret_test.go
+++ b/integration/secret/secret_test.go
@@ -13,9 +13,9 @@ import (
"github.com/docker/docker/integration/internal/swarm"
"github.com/docker/docker/internal/testutil"
"github.com/docker/docker/pkg/stdcopy"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -26,7 +26,7 @@ func TestSecretInspect(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -34,12 +34,12 @@ func TestSecretInspect(t *testing.T) {
secretID := createSecret(ctx, t, client, testName, []byte("TESTINGDATA"), nil)
secret, _, err := client.SecretInspectWithRaw(context.Background(), secretID)
- require.NoError(t, err)
- assert.Equal(t, secret.Spec.Name, testName)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(secret.Spec.Name, testName))
secret, _, err = client.SecretInspectWithRaw(context.Background(), testName)
- require.NoError(t, err)
- assert.Equal(t, secretID, secretID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(secretID, secretID))
}
func TestSecretList(t *testing.T) {
@@ -49,7 +49,7 @@ func TestSecretList(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -75,8 +75,8 @@ func TestSecretList(t *testing.T) {
// test by `secret ls`
entries, err := client.SecretList(ctx, types.SecretListOptions{})
- require.NoError(t, err)
- assert.Equal(t, names(entries), testNames)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(names(entries), testNames))
testCases := []struct {
filters filters.Args
@@ -110,8 +110,8 @@ func TestSecretList(t *testing.T) {
entries, err = client.SecretList(ctx, types.SecretListOptions{
Filters: tc.filters,
})
- require.NoError(t, err)
- assert.Equal(t, names(entries), tc.expected)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(names(entries), tc.expected))
}
}
@@ -124,8 +124,8 @@ func createSecret(ctx context.Context, t *testing.T, client client.APIClient, na
},
Data: data,
})
- require.NoError(t, err)
- assert.NotEqual(t, secret.ID, "")
+ assert.NilError(t, err)
+ assert.Check(t, secret.ID != "")
return secret.ID
}
@@ -136,7 +136,7 @@ func TestSecretsCreateAndDelete(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
@@ -154,7 +154,7 @@ func TestSecretsCreateAndDelete(t *testing.T) {
// Ported from original TestSecretsDelete
err = client.SecretRemove(ctx, secretID)
- require.NoError(t, err)
+ assert.NilError(t, err)
_, _, err = client.SecretInspectWithRaw(ctx, secretID)
testutil.ErrorContains(t, err, "No such secret")
@@ -170,11 +170,11 @@ func TestSecretsCreateAndDelete(t *testing.T) {
})
insp, _, err := client.SecretInspectWithRaw(ctx, secretID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Name, testName)
- assert.Equal(t, len(insp.Spec.Labels), 2)
- assert.Equal(t, insp.Spec.Labels["key1"], "value1")
- assert.Equal(t, insp.Spec.Labels["key2"], "value2")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Name, testName))
+ assert.Check(t, is.Equal(len(insp.Spec.Labels), 2))
+ assert.Check(t, is.Equal(insp.Spec.Labels["key1"], "value1"))
+ assert.Check(t, is.Equal(insp.Spec.Labels["key2"], "value2"))
}
func TestSecretsUpdate(t *testing.T) {
@@ -184,44 +184,44 @@ func TestSecretsUpdate(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
testName := "test_secret"
secretID := createSecret(ctx, t, client, testName, []byte("TESTINGDATA"), nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err := client.SecretInspectWithRaw(ctx, secretID)
- require.NoError(t, err)
- assert.Equal(t, insp.ID, secretID)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.ID, secretID))
// test UpdateSecret with full ID
insp.Spec.Labels = map[string]string{"test": "test1"}
err = client.SecretUpdate(ctx, secretID, insp.Version, insp.Spec)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.SecretInspectWithRaw(ctx, secretID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Labels["test"], "test1")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Labels["test"], "test1"))
// test UpdateSecret with full name
insp.Spec.Labels = map[string]string{"test": "test2"}
err = client.SecretUpdate(ctx, testName, insp.Version, insp.Spec)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.SecretInspectWithRaw(ctx, secretID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Labels["test"], "test2")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Labels["test"], "test2"))
// test UpdateSecret with prefix ID
insp.Spec.Labels = map[string]string{"test": "test3"}
err = client.SecretUpdate(ctx, secretID[:1], insp.Version, insp.Spec)
- require.NoError(t, err)
+ assert.NilError(t, err)
insp, _, err = client.SecretInspectWithRaw(ctx, secretID)
- require.NoError(t, err)
- assert.Equal(t, insp.Spec.Labels["test"], "test3")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(insp.Spec.Labels["test"], "test3"))
// test UpdateSecret in updating Data which is not supported in daemon
// this test will produce an error in func UpdateSecret
@@ -244,7 +244,7 @@ func TestTemplatedSecret(t *testing.T) {
Data: []byte("this is a secret"),
}
referencedSecret, err := client.SecretCreate(ctx, referencedSecretSpec)
- assert.NoError(t, err)
+ assert.Check(t, err)
referencedConfigSpec := swarmtypes.ConfigSpec{
Annotations: swarmtypes.Annotations{
@@ -253,7 +253,7 @@ func TestTemplatedSecret(t *testing.T) {
Data: []byte("this is a config"),
}
referencedConfig, err := client.ConfigCreate(ctx, referencedConfigSpec)
- assert.NoError(t, err)
+ assert.Check(t, err)
secretSpec := swarmtypes.SecretSpec{
Annotations: swarmtypes.Annotations{
@@ -268,7 +268,7 @@ func TestTemplatedSecret(t *testing.T) {
}
templatedSecret, err := client.SecretCreate(ctx, secretSpec)
- assert.NoError(t, err)
+ assert.Check(t, err)
serviceID := swarm.CreateService(t, d,
swarm.ServiceWithSecret(
@@ -346,8 +346,8 @@ func TestTemplatedSecret(t *testing.T) {
func assertAttachedStream(t *testing.T, attach types.HijackedResponse, expect string) {
buf := bytes.NewBuffer(nil)
_, err := stdcopy.StdCopy(buf, buf, attach.Reader)
- require.NoError(t, err)
- assert.Contains(t, buf.String(), expect)
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(buf.String(), expect))
}
func waitAndAssert(t *testing.T, timeout time.Duration, f func(*testing.T) bool) {
diff --git a/integration/service/create_test.go b/integration/service/create_test.go
index eb66cfc2f1..7170bda492 100644
--- a/integration/service/create_test.go
+++ b/integration/service/create_test.go
@@ -11,9 +11,9 @@ import (
swarmtypes "github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/swarm"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -22,7 +22,7 @@ func TestCreateServiceMultipleTimes(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
overlayName := "overlay1"
networkCreate := types.NetworkCreate{
@@ -31,7 +31,7 @@ func TestCreateServiceMultipleTimes(t *testing.T) {
}
netResp, err := client.NetworkCreate(context.Background(), overlayName, networkCreate)
- require.NoError(t, err)
+ assert.NilError(t, err)
overlayID := netResp.ID
var instances uint64 = 4
@@ -41,7 +41,7 @@ func TestCreateServiceMultipleTimes(t *testing.T) {
serviceResp, err := client.ServiceCreate(context.Background(), serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
pollSettings := func(config *poll.Settings) {
// It takes about ~25s to finish the multi services creation in this case per the pratical observation on arm64/arm platform
@@ -55,10 +55,10 @@ func TestCreateServiceMultipleTimes(t *testing.T) {
poll.WaitOn(t, serviceRunningTasksCount(client, serviceID, instances), pollSettings)
_, _, err = client.ServiceInspectWithRaw(context.Background(), serviceID, types.ServiceInspectOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ServiceRemove(context.Background(), serviceID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceID), pollSettings)
poll.WaitOn(t, noTasks(client), pollSettings)
@@ -66,19 +66,19 @@ func TestCreateServiceMultipleTimes(t *testing.T) {
serviceResp, err = client.ServiceCreate(context.Background(), serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
serviceID2 := serviceResp.ID
poll.WaitOn(t, serviceRunningTasksCount(client, serviceID2, instances), pollSettings)
err = client.ServiceRemove(context.Background(), serviceID2)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceID2), pollSettings)
poll.WaitOn(t, noTasks(client), pollSettings)
err = client.NetworkRemove(context.Background(), overlayID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, networkIsRemoved(client, overlayID), poll.WithTimeout(1*time.Minute), poll.WithDelay(10*time.Second))
}
@@ -88,7 +88,7 @@ func TestCreateWithDuplicateNetworkNames(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
name := "foo"
networkCreate := types.NetworkCreate{
@@ -97,15 +97,15 @@ func TestCreateWithDuplicateNetworkNames(t *testing.T) {
}
n1, err := client.NetworkCreate(context.Background(), name, networkCreate)
- require.NoError(t, err)
+ assert.NilError(t, err)
n2, err := client.NetworkCreate(context.Background(), name, networkCreate)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Dupliates with name but with different driver
networkCreate.Driver = "overlay"
n3, err := client.NetworkCreate(context.Background(), name, networkCreate)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Create Service with the same name
var instances uint64 = 1
@@ -114,30 +114,30 @@ func TestCreateWithDuplicateNetworkNames(t *testing.T) {
serviceSpec.TaskTemplate.Networks = append(serviceSpec.TaskTemplate.Networks, swarmtypes.NetworkAttachmentConfig{Target: name})
service, err := client.ServiceCreate(context.Background(), serviceSpec, types.ServiceCreateOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceRunningTasksCount(client, service.ID, instances))
resp, _, err := client.ServiceInspectWithRaw(context.Background(), service.ID, types.ServiceInspectOptions{})
- require.NoError(t, err)
- assert.Equal(t, n3.ID, resp.Spec.TaskTemplate.Networks[0].Target)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(n3.ID, resp.Spec.TaskTemplate.Networks[0].Target))
// Remove Service
err = client.ServiceRemove(context.Background(), service.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Make sure task has been destroyed.
poll.WaitOn(t, serviceIsRemoved(client, service.ID))
// Remove networks
err = client.NetworkRemove(context.Background(), n3.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.NetworkRemove(context.Background(), n2.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.NetworkRemove(context.Background(), n1.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Make sure networks have been destroyed.
poll.WaitOn(t, networkIsRemoved(client, n3.ID), poll.WithTimeout(1*time.Minute), poll.WithDelay(10*time.Second))
@@ -150,7 +150,7 @@ func TestCreateServiceSecretFileMode(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
secretResp, err := client.SecretCreate(ctx, swarmtypes.SecretSpec{
@@ -159,7 +159,7 @@ func TestCreateServiceSecretFileMode(t *testing.T) {
},
Data: []byte("TESTSECRET"),
})
- require.NoError(t, err)
+ assert.NilError(t, err)
var instances uint64 = 1
serviceSpec := swarmtypes.ServiceSpec{
@@ -194,7 +194,7 @@ func TestCreateServiceSecretFileMode(t *testing.T) {
serviceResp, err := client.ServiceCreate(ctx, serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceRunningTasksCount(client, serviceResp.ID, instances))
@@ -203,27 +203,27 @@ func TestCreateServiceSecretFileMode(t *testing.T) {
tasks, err := client.TaskList(ctx, types.TaskListOptions{
Filters: filter,
})
- require.NoError(t, err)
- assert.Equal(t, len(tasks), 1)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(tasks), 1))
body, err := client.ContainerLogs(ctx, tasks[0].Status.ContainerStatus.ContainerID, types.ContainerLogsOptions{
ShowStdout: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
defer body.Close()
content, err := ioutil.ReadAll(body)
- require.NoError(t, err)
- assert.Contains(t, string(content), "-rwxrwxrwx")
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(string(content), "-rwxrwxrwx"))
err = client.ServiceRemove(ctx, serviceResp.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceResp.ID))
poll.WaitOn(t, noTasks(client))
err = client.SecretRemove(ctx, "TestSecret")
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestCreateServiceConfigFileMode(t *testing.T) {
@@ -231,7 +231,7 @@ func TestCreateServiceConfigFileMode(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
configResp, err := client.ConfigCreate(ctx, swarmtypes.ConfigSpec{
@@ -240,7 +240,7 @@ func TestCreateServiceConfigFileMode(t *testing.T) {
},
Data: []byte("TESTCONFIG"),
})
- require.NoError(t, err)
+ assert.NilError(t, err)
var instances uint64 = 1
serviceSpec := swarmtypes.ServiceSpec{
@@ -275,7 +275,7 @@ func TestCreateServiceConfigFileMode(t *testing.T) {
serviceResp, err := client.ServiceCreate(ctx, serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceRunningTasksCount(client, serviceResp.ID, instances))
@@ -284,27 +284,27 @@ func TestCreateServiceConfigFileMode(t *testing.T) {
tasks, err := client.TaskList(ctx, types.TaskListOptions{
Filters: filter,
})
- require.NoError(t, err)
- assert.Equal(t, len(tasks), 1)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(tasks), 1))
body, err := client.ContainerLogs(ctx, tasks[0].Status.ContainerStatus.ContainerID, types.ContainerLogsOptions{
ShowStdout: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
defer body.Close()
content, err := ioutil.ReadAll(body)
- require.NoError(t, err)
- assert.Contains(t, string(content), "-rwxrwxrwx")
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(string(content), "-rwxrwxrwx"))
err = client.ServiceRemove(ctx, serviceResp.ID)
- require.NoError(t, err)
+ assert.NilError(t, err)
poll.WaitOn(t, serviceIsRemoved(client, serviceResp.ID))
poll.WaitOn(t, noTasks(client))
err = client.ConfigRemove(ctx, "TestConfig")
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func swarmServiceSpec(name string, replicas uint64) swarmtypes.ServiceSpec {
diff --git a/integration/service/inspect_test.go b/integration/service/inspect_test.go
index 8cd24bc31b..3a5b99d3ac 100644
--- a/integration/service/inspect_test.go
+++ b/integration/service/inspect_test.go
@@ -10,10 +10,10 @@ import (
swarmtypes "github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/swarm"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/poll"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/net/context"
)
@@ -23,7 +23,7 @@ func TestInspect(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
var before = time.Now()
var instances uint64 = 2
@@ -33,16 +33,16 @@ func TestInspect(t *testing.T) {
resp, err := client.ServiceCreate(ctx, serviceSpec, types.ServiceCreateOptions{
QueryRegistry: false,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
id := resp.ID
poll.WaitOn(t, serviceContainerCount(client, id, instances))
service, _, err := client.ServiceInspectWithRaw(ctx, id, types.ServiceInspectOptions{})
- require.NoError(t, err)
- assert.Equal(t, serviceSpec, service.Spec)
- assert.Equal(t, uint64(11), service.Meta.Version.Index)
- assert.Equal(t, id, service.ID)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(serviceSpec, service.Spec))
+ assert.Check(t, is.Equal(uint64(11), service.Meta.Version.Index))
+ assert.Check(t, is.Equal(id, service.ID))
assert.WithinDuration(t, before, service.CreatedAt, 30*time.Second)
assert.WithinDuration(t, before, service.UpdatedAt, 30*time.Second)
}
diff --git a/integration/service/network_test.go b/integration/service/network_test.go
index 09b0a1f12b..6b8c891cd8 100644
--- a/integration/service/network_test.go
+++ b/integration/service/network_test.go
@@ -9,8 +9,8 @@ import (
"github.com/docker/docker/client"
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/swarm"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestDockerNetworkConnectAlias(t *testing.T) {
@@ -18,7 +18,7 @@ func TestDockerNetworkConnectAlias(t *testing.T) {
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client, err := client.NewClientWithOpts(client.WithHost((d.Sock())))
- require.NoError(t, err)
+ assert.NilError(t, err)
ctx := context.Background()
name := "test-alias"
@@ -26,7 +26,7 @@ func TestDockerNetworkConnectAlias(t *testing.T) {
Driver: "overlay",
Attachable: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
container.Create(t, ctx, client, container.WithName("ng1"), func(c *container.TestContainerConfig) {
c.NetworkingConfig = &network.NetworkingConfig{
@@ -41,15 +41,15 @@ func TestDockerNetworkConnectAlias(t *testing.T) {
"aaa",
},
})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ContainerStart(ctx, "ng1", types.ContainerStartOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
ng1, err := client.ContainerInspect(ctx, "ng1")
- require.NoError(t, err)
- assert.Equal(t, len(ng1.NetworkSettings.Networks[name].Aliases), 2)
- assert.Equal(t, ng1.NetworkSettings.Networks[name].Aliases[0], "aaa")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(ng1.NetworkSettings.Networks[name].Aliases), 2))
+ assert.Check(t, is.Equal(ng1.NetworkSettings.Networks[name].Aliases[0], "aaa"))
container.Create(t, ctx, client, container.WithName("ng2"), func(c *container.TestContainerConfig) {
c.NetworkingConfig = &network.NetworkingConfig{
@@ -64,13 +64,13 @@ func TestDockerNetworkConnectAlias(t *testing.T) {
"bbb",
},
})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.ContainerStart(ctx, "ng2", types.ContainerStartOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
ng2, err := client.ContainerInspect(ctx, "ng2")
- require.NoError(t, err)
- assert.Equal(t, len(ng2.NetworkSettings.Networks[name].Aliases), 2)
- assert.Equal(t, ng2.NetworkSettings.Networks[name].Aliases[0], "bbb")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(ng2.NetworkSettings.Networks[name].Aliases), 2))
+ assert.Check(t, is.Equal(ng2.NetworkSettings.Networks[name].Aliases[0], "bbb"))
}
diff --git a/integration/session/session_test.go b/integration/session/session_test.go
index 310f544554..de9319436e 100644
--- a/integration/session/session_test.go
+++ b/integration/session/session_test.go
@@ -5,9 +5,9 @@ import (
"testing"
req "github.com/docker/docker/integration-cli/request"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
func TestSessionCreate(t *testing.T) {
@@ -20,29 +20,29 @@ func TestSessionCreate(t *testing.T) {
r.Header.Set("Upgrade", "h2c")
return nil
})
- require.NoError(t, err)
- require.NoError(t, body.Close())
- assert.Equal(t, res.StatusCode, http.StatusSwitchingProtocols)
- assert.Equal(t, res.Header.Get("Upgrade"), "h2c")
+ assert.NilError(t, err)
+ assert.NilError(t, body.Close())
+ assert.Check(t, is.DeepEqual(res.StatusCode, http.StatusSwitchingProtocols))
+ assert.Check(t, is.Equal(res.Header.Get("Upgrade"), "h2c"))
}
func TestSessionCreateWithBadUpgrade(t *testing.T) {
skip.If(t, !testEnv.DaemonInfo.ExperimentalBuild)
res, body, err := req.Post("/session")
- require.NoError(t, err)
- assert.Equal(t, res.StatusCode, http.StatusBadRequest)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(res.StatusCode, http.StatusBadRequest))
buf, err := req.ReadBody(body)
- require.NoError(t, err)
- assert.Contains(t, string(buf), "no upgrade")
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(string(buf), "no upgrade"))
res, body, err = req.Post("/session", func(r *http.Request) error {
r.Header.Set("Upgrade", "foo")
return nil
})
- require.NoError(t, err)
- assert.Equal(t, res.StatusCode, http.StatusBadRequest)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(res.StatusCode, http.StatusBadRequest))
buf, err = req.ReadBody(body)
- require.NoError(t, err)
- assert.Contains(t, string(buf), "not supported")
+ assert.NilError(t, err)
+ assert.Check(t, is.Contains(string(buf), "not supported"))
}
diff --git a/integration/system/event_test.go b/integration/system/event_test.go
index 688d7c27de..b270ffcb91 100644
--- a/integration/system/event_test.go
+++ b/integration/system/event_test.go
@@ -17,8 +17,8 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/pkg/jsonmessage"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestEvents(t *testing.T) {
@@ -33,7 +33,7 @@ func TestEvents(t *testing.T) {
Cmd: strslice.StrSlice([]string{"echo", "hello"}),
},
)
- require.NoError(t, err)
+ assert.NilError(t, err)
filters := filters.NewArgs(
filters.Arg("container", cID),
@@ -49,15 +49,15 @@ func TestEvents(t *testing.T) {
Tty: false,
},
)
- require.NoError(t, err)
+ assert.NilError(t, err)
select {
case m := <-msg:
- require.Equal(t, m.Type, "container")
- require.Equal(t, m.Actor.ID, cID)
- require.Equal(t, m.Action, "exec_die")
- require.Equal(t, m.Actor.Attributes["execID"], id.ID)
- require.Equal(t, m.Actor.Attributes["exitCode"], "0")
+ assert.Equal(t, m.Type, "container")
+ assert.Equal(t, m.Actor.ID, cID)
+ assert.Equal(t, m.Action, "exec_die")
+ assert.Equal(t, m.Actor.Attributes["execID"], id.ID)
+ assert.Equal(t, m.Actor.Attributes["exitCode"], "0")
case err = <-errors:
t.Fatal(err)
case <-time.After(time.Second * 3):
@@ -84,16 +84,16 @@ func TestEventsBackwardsCompatible(t *testing.T) {
// The test here makes sure the response time is less than 3 sec.
expectedTime := time.Now().Add(3 * time.Second)
emptyResp, emptyBody, err := req.Get("/events")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer emptyBody.Close()
- assert.Equal(t, http.StatusOK, emptyResp.StatusCode)
- assert.True(t, time.Now().Before(expectedTime), "timeout waiting for events api to respond, should have responded immediately")
+ assert.Check(t, is.DeepEqual(http.StatusOK, emptyResp.StatusCode))
+ assert.Check(t, time.Now().Before(expectedTime), "timeout waiting for events api to respond, should have responded immediately")
// We also test to make sure the `events.Message` is compatible with `JSONMessage`
q := url.Values{}
q.Set("since", ts)
_, body, err := req.Get("/events?" + q.Encode())
- require.NoError(t, err)
+ assert.NilError(t, err)
defer body.Close()
dec := json.NewDecoder(body)
@@ -112,8 +112,8 @@ func TestEventsBackwardsCompatible(t *testing.T) {
}
}
- assert.NotNil(t, containerCreateEvent)
- assert.Equal(t, "create", containerCreateEvent.Status)
- assert.Equal(t, cID, containerCreateEvent.ID)
- assert.Equal(t, "busybox", containerCreateEvent.From)
+ assert.Check(t, containerCreateEvent != nil)
+ assert.Check(t, is.Equal("create", containerCreateEvent.Status))
+ assert.Check(t, is.Equal(cID, containerCreateEvent.ID))
+ assert.Check(t, is.Equal("busybox", containerCreateEvent.From))
}
diff --git a/integration/system/info_linux_test.go b/integration/system/info_linux_test.go
index 8f0271e7a6..ad8dc2f9e2 100644
--- a/integration/system/info_linux_test.go
+++ b/integration/system/info_linux_test.go
@@ -8,8 +8,8 @@ import (
req "github.com/docker/docker/integration-cli/request"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -17,35 +17,35 @@ func TestInfoBinaryCommits(t *testing.T) {
client := request.NewAPIClient(t)
info, err := client.Info(context.Background())
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.NotNil(t, info.ContainerdCommit)
- assert.NotEqual(t, "N/A", info.ContainerdCommit.ID)
- assert.Equal(t, testEnv.DaemonInfo.ContainerdCommit.Expected, info.ContainerdCommit.Expected)
- assert.Equal(t, info.ContainerdCommit.Expected, info.ContainerdCommit.ID)
+ assert.Check(t, info.ContainerdCommit != nil)
+ assert.Check(t, "N/A" != info.ContainerdCommit.ID)
+ assert.Check(t, is.Equal(testEnv.DaemonInfo.ContainerdCommit.Expected, info.ContainerdCommit.Expected))
+ assert.Check(t, is.Equal(info.ContainerdCommit.Expected, info.ContainerdCommit.ID))
- assert.NotNil(t, info.InitCommit)
- assert.NotEqual(t, "N/A", info.InitCommit.ID)
- assert.Equal(t, testEnv.DaemonInfo.InitCommit.Expected, info.InitCommit.Expected)
- assert.Equal(t, info.InitCommit.Expected, info.InitCommit.ID)
+ assert.Check(t, info.InitCommit != nil)
+ assert.Check(t, "N/A" != info.InitCommit.ID)
+ assert.Check(t, is.Equal(testEnv.DaemonInfo.InitCommit.Expected, info.InitCommit.Expected))
+ assert.Check(t, is.Equal(info.InitCommit.Expected, info.InitCommit.ID))
- assert.NotNil(t, info.RuncCommit)
- assert.NotEqual(t, "N/A", info.RuncCommit.ID)
- assert.Equal(t, testEnv.DaemonInfo.RuncCommit.Expected, info.RuncCommit.Expected)
- assert.Equal(t, info.RuncCommit.Expected, info.RuncCommit.ID)
+ assert.Check(t, info.RuncCommit != nil)
+ assert.Check(t, "N/A" != info.RuncCommit.ID)
+ assert.Check(t, is.Equal(testEnv.DaemonInfo.RuncCommit.Expected, info.RuncCommit.Expected))
+ assert.Check(t, is.Equal(info.RuncCommit.Expected, info.RuncCommit.ID))
}
func TestInfoAPIVersioned(t *testing.T) {
// Windows only supports 1.25 or later
res, body, err := req.Get("/v1.20/info")
- require.NoError(t, err)
- assert.Equal(t, res.StatusCode, http.StatusOK)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual(res.StatusCode, http.StatusOK))
b, err := req.ReadBody(body)
- require.NoError(t, err)
+ assert.NilError(t, err)
out := string(b)
- assert.Contains(t, out, "ExecutionDriver")
- assert.Contains(t, out, "not supported")
+ assert.Check(t, is.Contains(out, "ExecutionDriver"))
+ assert.Check(t, is.Contains(out, "not supported"))
}
diff --git a/integration/system/info_test.go b/integration/system/info_test.go
index d04fdcdc84..e19ba9ba3d 100644
--- a/integration/system/info_test.go
+++ b/integration/system/info_test.go
@@ -5,8 +5,8 @@ import (
"testing"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -14,7 +14,7 @@ func TestInfoAPI(t *testing.T) {
client := request.NewAPIClient(t)
info, err := client.Info(context.Background())
- require.NoError(t, err)
+ assert.NilError(t, err)
// always shown fields
stringsToCheck := []string{
@@ -37,6 +37,6 @@ func TestInfoAPI(t *testing.T) {
out := fmt.Sprintf("%+v", info)
for _, linePrefix := range stringsToCheck {
- assert.Contains(t, out, linePrefix)
+ assert.Check(t, is.Contains(out, linePrefix))
}
}
diff --git a/integration/system/login_test.go b/integration/system/login_test.go
index c075109d2b..e8ef10c30c 100644
--- a/integration/system/login_test.go
+++ b/integration/system/login_test.go
@@ -6,8 +6,9 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/integration/internal/requirement"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@@ -23,5 +24,5 @@ func TestLoginFailsWithBadCredentials(t *testing.T) {
}
_, err := client.RegistryLogin(context.Background(), config)
expected := "Error response from daemon: Get https://registry-1.docker.io/v2/: unauthorized: incorrect username or password"
- assert.EqualError(t, err, expected)
+ assert.Check(t, is.Error(err, expected))
}
diff --git a/integration/system/version_test.go b/integration/system/version_test.go
index 04888a604a..a676c31802 100644
--- a/integration/system/version_test.go
+++ b/integration/system/version_test.go
@@ -4,8 +4,8 @@ import (
"testing"
"github.com/docker/docker/integration/internal/request"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -13,11 +13,11 @@ func TestVersion(t *testing.T) {
client := request.NewAPIClient(t)
version, err := client.ServerVersion(context.Background())
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.NotNil(t, version.APIVersion)
- assert.NotNil(t, version.Version)
- assert.NotNil(t, version.MinAPIVersion)
- assert.Equal(t, testEnv.DaemonInfo.ExperimentalBuild, version.Experimental)
- assert.Equal(t, testEnv.OSType, version.Os)
+ assert.Check(t, version.APIVersion != nil)
+ assert.Check(t, version.Version != nil)
+ assert.Check(t, version.MinAPIVersion != nil)
+ assert.Check(t, is.Equal(testEnv.DaemonInfo.ExperimentalBuild, version.Experimental))
+ assert.Check(t, is.Equal(testEnv.OSType, version.Os))
}
diff --git a/integration/volume/volume_test.go b/integration/volume/volume_test.go
index 20dcfef9a6..2fe35cf5ed 100644
--- a/integration/volume/volume_test.go
+++ b/integration/volume/volume_test.go
@@ -13,8 +13,8 @@ import (
"github.com/docker/docker/integration/internal/container"
"github.com/docker/docker/integration/internal/request"
"github.com/docker/docker/internal/testutil"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestVolumesCreateAndList(t *testing.T) {
@@ -26,7 +26,7 @@ func TestVolumesCreateAndList(t *testing.T) {
vol, err := client.VolumeCreate(ctx, volumetypes.VolumesCreateBody{
Name: name,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := types.Volume{
// Ignore timestamp of CreatedAt
@@ -36,14 +36,14 @@ func TestVolumesCreateAndList(t *testing.T) {
Name: name,
Mountpoint: fmt.Sprintf("%s/volumes/%s/_data", testEnv.DaemonInfo.DockerRootDir, name),
}
- assert.Equal(t, vol, expected)
+ assert.Check(t, is.DeepEqual(vol, expected))
volumes, err := client.VolumeList(ctx, filters.Args{})
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, len(volumes.Volumes), 1)
- assert.NotNil(t, volumes.Volumes[0])
- assert.Equal(t, *volumes.Volumes[0], expected)
+ assert.Check(t, is.Equal(len(volumes.Volumes), 1))
+ assert.Check(t, volumes.Volumes[0] != nil)
+ assert.Check(t, is.DeepEqual(*volumes.Volumes[0], expected))
}
func TestVolumesRemove(t *testing.T) {
@@ -56,7 +56,7 @@ func TestVolumesRemove(t *testing.T) {
id := container.Create(t, ctx, client, container.WithVolume(prefix+"foo"))
c, err := client.ContainerInspect(ctx, id)
- require.NoError(t, err)
+ assert.NilError(t, err)
vname := c.Mounts[0].Name
err = client.VolumeRemove(ctx, vname, false)
@@ -65,10 +65,10 @@ func TestVolumesRemove(t *testing.T) {
err = client.ContainerRemove(ctx, id, types.ContainerRemoveOptions{
Force: true,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
err = client.VolumeRemove(ctx, vname, false)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestVolumesInspect(t *testing.T) {
@@ -83,10 +83,10 @@ func TestVolumesInspect(t *testing.T) {
_, err := client.VolumeCreate(ctx, volumetypes.VolumesCreateBody{
Name: name,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
vol, err := client.VolumeInspect(ctx, name)
- require.NoError(t, err)
+ assert.NilError(t, err)
expected := types.Volume{
// Ignore timestamp of CreatedAt
@@ -96,13 +96,13 @@ func TestVolumesInspect(t *testing.T) {
Name: name,
Mountpoint: fmt.Sprintf("%s/volumes/%s/_data", testEnv.DaemonInfo.DockerRootDir, name),
}
- assert.Equal(t, vol, expected)
+ assert.Check(t, is.DeepEqual(vol, expected))
// comparing CreatedAt field time for the new volume to now. Removing a minute from both to avoid false positive
testCreatedAt, err := time.Parse(time.RFC3339, strings.TrimSpace(vol.CreatedAt))
- require.NoError(t, err)
+ assert.NilError(t, err)
testCreatedAt = testCreatedAt.Truncate(time.Minute)
- assert.Equal(t, testCreatedAt.Equal(now), true, "Time Volume is CreatedAt not equal to current time")
+ assert.Check(t, is.Equal(testCreatedAt.Equal(now), true), "Time Volume is CreatedAt not equal to current time")
}
func getPrefixAndSlashFromDaemonPlatform() (prefix, slash string) {
diff --git a/internal/test/environment/clean.go b/internal/test/environment/clean.go
index 065b46bee8..d83175c845 100644
--- a/internal/test/environment/clean.go
+++ b/internal/test/environment/clean.go
@@ -7,13 +7,12 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/client"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
"golang.org/x/net/context"
)
type testingT interface {
- require.TestingT
+ assert.TestingT
logT
Fatalf(string, ...interface{})
}
@@ -47,7 +46,7 @@ func unpauseAllContainers(t assert.TestingT, client client.ContainerAPIClient) {
if len(containers) > 0 {
for _, container := range containers {
err := client.ContainerUnpause(ctx, container.ID)
- assert.NoError(t, err, "failed to unpause container %s", container.ID)
+ assert.Check(t, err, "failed to unpause container %s", container.ID)
}
}
}
@@ -60,7 +59,7 @@ func getPausedContainers(ctx context.Context, t assert.TestingT, client client.C
Quiet: true,
All: true,
})
- assert.NoError(t, err, "failed to list containers")
+ assert.Check(t, err, "failed to list containers")
return containers
}
@@ -84,7 +83,7 @@ func deleteAllContainers(t assert.TestingT, apiclient client.ContainerAPIClient,
if err == nil || client.IsErrNotFound(err) || alreadyExists.MatchString(err.Error()) || isErrNotFoundSwarmClassic(err) {
continue
}
- assert.NoError(t, err, "failed to remove %s", container.ID)
+ assert.Check(t, err, "failed to remove %s", container.ID)
}
}
@@ -93,13 +92,13 @@ func getAllContainers(ctx context.Context, t assert.TestingT, client client.Cont
Quiet: true,
All: true,
})
- assert.NoError(t, err, "failed to list containers")
+ assert.Check(t, err, "failed to list containers")
return containers
}
func deleteAllImages(t testingT, apiclient client.ImageAPIClient, protectedImages map[string]struct{}) {
images, err := apiclient.ImageList(context.Background(), types.ImageListOptions{})
- assert.NoError(t, err, "failed to list images")
+ assert.Check(t, err, "failed to list images")
ctx := context.Background()
for _, image := range images {
@@ -126,12 +125,12 @@ func removeImage(ctx context.Context, t assert.TestingT, apiclient client.ImageA
if client.IsErrNotFound(err) {
return
}
- assert.NoError(t, err, "failed to remove image %s", ref)
+ assert.Check(t, err, "failed to remove image %s", ref)
}
func deleteAllVolumes(t assert.TestingT, c client.VolumeAPIClient, protectedVolumes map[string]struct{}) {
volumes, err := c.VolumeList(context.Background(), filters.Args{})
- assert.NoError(t, err, "failed to list volumes")
+ assert.Check(t, err, "failed to list volumes")
for _, v := range volumes.Volumes {
if _, ok := protectedVolumes[v.Name]; ok {
@@ -142,13 +141,13 @@ func deleteAllVolumes(t assert.TestingT, c client.VolumeAPIClient, protectedVolu
if isErrNotFoundSwarmClassic(err) {
continue
}
- assert.NoError(t, err, "failed to remove volume %s", v.Name)
+ assert.Check(t, err, "failed to remove volume %s", v.Name)
}
}
func deleteAllNetworks(t assert.TestingT, c client.NetworkAPIClient, daemonPlatform string, protectedNetworks map[string]struct{}) {
networks, err := c.NetworkList(context.Background(), types.NetworkListOptions{})
- assert.NoError(t, err, "failed to list networks")
+ assert.Check(t, err, "failed to list networks")
for _, n := range networks {
if n.Name == "bridge" || n.Name == "none" || n.Name == "host" {
@@ -162,7 +161,7 @@ func deleteAllNetworks(t assert.TestingT, c client.NetworkAPIClient, daemonPlatf
continue
}
err := c.NetworkRemove(context.Background(), n.ID)
- assert.NoError(t, err, "failed to remove network %s", n.ID)
+ assert.Check(t, err, "failed to remove network %s", n.ID)
}
}
@@ -172,14 +171,14 @@ func deleteAllPlugins(t assert.TestingT, c client.PluginAPIClient, protectedPlug
if client.IsErrNotImplemented(err) {
return
}
- assert.NoError(t, err, "failed to list plugins")
+ assert.Check(t, err, "failed to list plugins")
for _, p := range plugins {
if _, ok := protectedPlugins[p.Name]; ok {
continue
}
err := c.PluginRemove(context.Background(), p.Name, types.PluginRemoveOptions{Force: true})
- assert.NoError(t, err, "failed to remove plugin %s", p.ID)
+ assert.Check(t, err, "failed to remove plugin %s", p.ID)
}
}
diff --git a/internal/test/environment/protect.go b/internal/test/environment/protect.go
index ffbf985b73..3dfe606cea 100644
--- a/internal/test/environment/protect.go
+++ b/internal/test/environment/protect.go
@@ -6,7 +6,7 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
dclient "github.com/docker/docker/client"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
var frozenImages = []string{"busybox:latest", "busybox:glibc", "hello-world:frozen", "debian:jessie"}
@@ -57,12 +57,12 @@ func ProtectContainers(t testingT, testEnv *Execution) {
testEnv.ProtectContainer(t, containers...)
}
-func getExistingContainers(t require.TestingT, testEnv *Execution) []string {
+func getExistingContainers(t assert.TestingT, testEnv *Execution) []string {
client := testEnv.APIClient()
containerList, err := client.ContainerList(context.Background(), types.ContainerListOptions{
All: true,
})
- require.NoError(t, err, "failed to list containers")
+ assert.NilError(t, err, "failed to list containers")
containers := []string{}
for _, container := range containerList {
@@ -89,7 +89,7 @@ func ProtectImages(t testingT, testEnv *Execution) {
testEnv.ProtectImage(t, images...)
}
-func getExistingImages(t require.TestingT, testEnv *Execution) []string {
+func getExistingImages(t assert.TestingT, testEnv *Execution) []string {
client := testEnv.APIClient()
filter := filters.NewArgs()
filter.Add("dangling", "false")
@@ -97,7 +97,7 @@ func getExistingImages(t require.TestingT, testEnv *Execution) []string {
All: true,
Filters: filter,
})
- require.NoError(t, err, "failed to list images")
+ assert.NilError(t, err, "failed to list images")
images := []string{}
for _, image := range imageList {
@@ -136,10 +136,10 @@ func ProtectNetworks(t testingT, testEnv *Execution) {
testEnv.ProtectNetwork(t, networks...)
}
-func getExistingNetworks(t require.TestingT, testEnv *Execution) []string {
+func getExistingNetworks(t assert.TestingT, testEnv *Execution) []string {
client := testEnv.APIClient()
networkList, err := client.NetworkList(context.Background(), types.NetworkListOptions{})
- require.NoError(t, err, "failed to list networks")
+ assert.NilError(t, err, "failed to list networks")
networks := []string{}
for _, network := range networkList {
@@ -162,14 +162,14 @@ func ProtectPlugins(t testingT, testEnv *Execution) {
testEnv.ProtectPlugin(t, plugins...)
}
-func getExistingPlugins(t require.TestingT, testEnv *Execution) []string {
+func getExistingPlugins(t assert.TestingT, testEnv *Execution) []string {
client := testEnv.APIClient()
pluginList, err := client.PluginList(context.Background(), filters.Args{})
// Docker EE does not allow cluster-wide plugin management.
if dclient.IsErrNotImplemented(err) {
return []string{}
}
- require.NoError(t, err, "failed to list plugins")
+ assert.NilError(t, err, "failed to list plugins")
plugins := []string{}
for _, plugin := range pluginList {
@@ -192,10 +192,10 @@ func ProtectVolumes(t testingT, testEnv *Execution) {
testEnv.ProtectVolume(t, volumes...)
}
-func getExistingVolumes(t require.TestingT, testEnv *Execution) []string {
+func getExistingVolumes(t assert.TestingT, testEnv *Execution) []string {
client := testEnv.APIClient()
volumeList, err := client.VolumeList(context.Background(), filters.Args{})
- require.NoError(t, err, "failed to list volumes")
+ assert.NilError(t, err, "failed to list volumes")
volumes := []string{}
for _, volume := range volumeList.Volumes {
diff --git a/internal/testutil/helpers.go b/internal/testutil/helpers.go
index 77224a0071..b1d8f44e3e 100644
--- a/internal/testutil/helpers.go
+++ b/internal/testutil/helpers.go
@@ -3,15 +3,15 @@ package testutil // import "github.com/docker/docker/internal/testutil"
import (
"io"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
// ErrorContains checks that the error is not nil, and contains the expected
// substring.
-func ErrorContains(t require.TestingT, err error, expectedError string, msgAndArgs ...interface{}) {
- require.Error(t, err, msgAndArgs...)
- assert.Contains(t, err.Error(), expectedError, msgAndArgs...)
+func ErrorContains(t assert.TestingT, err error, expectedError string, msgAndArgs ...interface{}) {
+ assert.Assert(t, is.ErrorContains(err, ""), msgAndArgs)
+ assert.Check(t, is.Contains(err.Error(), expectedError), msgAndArgs)
}
// DevZero acts like /dev/zero but in an OS-independent fashion.
diff --git a/internal/testutil/stringutils_test.go b/internal/testutil/stringutils_test.go
index a0f95755c7..1dd09af95f 100644
--- a/internal/testutil/stringutils_test.go
+++ b/internal/testutil/stringutils_test.go
@@ -3,13 +3,14 @@ package testutil // import "github.com/docker/docker/internal/testutil"
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func testLengthHelper(generator func(int) string, t *testing.T) {
expectedLength := 20
s := generator(expectedLength)
- assert.Equal(t, expectedLength, len(s))
+ assert.Check(t, is.Equal(expectedLength, len(s)))
}
func testUniquenessHelper(generator func(int) string, t *testing.T) {
@@ -17,9 +18,9 @@ func testUniquenessHelper(generator func(int) string, t *testing.T) {
set := make(map[string]struct{}, repeats)
for i := 0; i < repeats; i = i + 1 {
str := generator(64)
- assert.Equal(t, 64, len(str))
+ assert.Check(t, is.Equal(64, len(str)))
_, ok := set[str]
- assert.False(t, ok, "Random number is repeated")
+ assert.Check(t, !ok, "Random number is repeated")
set[str] = struct{}{}
}
}
diff --git a/libcontainerd/queue_test.go b/libcontainerd/queue_test.go
index 92ee22a9f3..df5332c128 100644
--- a/libcontainerd/queue_test.go
+++ b/libcontainerd/queue_test.go
@@ -4,7 +4,7 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestSerialization(t *testing.T) {
@@ -16,15 +16,15 @@ func TestSerialization(t *testing.T) {
q.append("aaa", func() {
//simulate a long time task
time.Sleep(10 * time.Millisecond)
- require.EqualValues(t, serialization, 1)
+ assert.Equal(t, serialization, 1)
serialization = 2
})
q.append("aaa", func() {
- require.EqualValues(t, serialization, 2)
+ assert.Equal(t, serialization, 2)
serialization = 3
})
q.append("aaa", func() {
- require.EqualValues(t, serialization, 3)
+ assert.Equal(t, serialization, 3)
serialization = 4
})
time.Sleep(20 * time.Millisecond)
diff --git a/opts/quotedstring_test.go b/opts/quotedstring_test.go
index e24257a5d4..21e6e4c85a 100644
--- a/opts/quotedstring_test.go
+++ b/opts/quotedstring_test.go
@@ -3,27 +3,28 @@ package opts // import "github.com/docker/docker/opts"
import (
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestQuotedStringSetWithQuotes(t *testing.T) {
value := ""
qs := NewQuotedString(&value)
- assert.NoError(t, qs.Set(`"something"`))
- assert.Equal(t, "something", qs.String())
- assert.Equal(t, "something", value)
+ assert.Check(t, qs.Set(`"something"`))
+ assert.Check(t, is.Equal("something", qs.String()))
+ assert.Check(t, is.Equal("something", value))
}
func TestQuotedStringSetWithMismatchedQuotes(t *testing.T) {
value := ""
qs := NewQuotedString(&value)
- assert.NoError(t, qs.Set(`"something'`))
- assert.Equal(t, `"something'`, qs.String())
+ assert.Check(t, qs.Set(`"something'`))
+ assert.Check(t, is.Equal(`"something'`, qs.String()))
}
func TestQuotedStringSetWithNoQuotes(t *testing.T) {
value := ""
qs := NewQuotedString(&value)
- assert.NoError(t, qs.Set("something"))
- assert.Equal(t, "something", qs.String())
+ assert.Check(t, qs.Set("something"))
+ assert.Check(t, is.Equal("something", qs.String()))
}
diff --git a/pkg/archive/archive_linux_test.go b/pkg/archive/archive_linux_test.go
index e48ef1aa11..b397c8abfa 100644
--- a/pkg/archive/archive_linux_test.go
+++ b/pkg/archive/archive_linux_test.go
@@ -8,7 +8,7 @@ import (
"testing"
"github.com/docker/docker/pkg/system"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
"golang.org/x/sys/unix"
)
@@ -24,35 +24,35 @@ import (
func setupOverlayTestDir(t *testing.T, src string) {
// Create opaque directory containing single file and permission 0700
err := os.Mkdir(filepath.Join(src, "d1"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Lsetxattr(filepath.Join(src, "d1"), "trusted.overlay.opaque", []byte("y"), 0)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(src, "d1", "f1"), []byte{}, 0600)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Create another opaque directory containing single file but with permission 0750
err = os.Mkdir(filepath.Join(src, "d2"), 0750)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Lsetxattr(filepath.Join(src, "d2"), "trusted.overlay.opaque", []byte("y"), 0)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(src, "d2", "f1"), []byte{}, 0660)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Create regular directory with deleted file
err = os.Mkdir(filepath.Join(src, "d3"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Mknod(filepath.Join(src, "d3", "f1"), unix.S_IFCHR, 0)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func checkOpaqueness(t *testing.T, path string, opaque string) {
xattrOpaque, err := system.Lgetxattr(path, "trusted.overlay.opaque")
- require.NoError(t, err)
+ assert.NilError(t, err)
if string(xattrOpaque) != opaque {
t.Fatalf("Unexpected opaque value: %q, expected %q", string(xattrOpaque), opaque)
@@ -62,7 +62,7 @@ func checkOpaqueness(t *testing.T, path string, opaque string) {
func checkOverlayWhiteout(t *testing.T, path string) {
stat, err := os.Stat(path)
- require.NoError(t, err)
+ assert.NilError(t, err)
statT, ok := stat.Sys().(*syscall.Stat_t)
if !ok {
@@ -75,7 +75,7 @@ func checkOverlayWhiteout(t *testing.T, path string) {
func checkFileMode(t *testing.T, path string, perm os.FileMode) {
stat, err := os.Stat(path)
- require.NoError(t, err)
+ assert.NilError(t, err)
if stat.Mode() != perm {
t.Fatalf("Unexpected file mode for %s: %o, expected %o", path, stat.Mode(), perm)
@@ -84,17 +84,17 @@ func checkFileMode(t *testing.T, path string, perm os.FileMode) {
func TestOverlayTarUntar(t *testing.T) {
oldmask, err := system.Umask(0)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer system.Umask(oldmask)
src, err := ioutil.TempDir("", "docker-test-overlay-tar-src")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(src)
setupOverlayTestDir(t, src)
dst, err := ioutil.TempDir("", "docker-test-overlay-tar-dst")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dst)
options := &TarOptions{
@@ -102,11 +102,11 @@ func TestOverlayTarUntar(t *testing.T) {
WhiteoutFormat: OverlayWhiteoutFormat,
}
archive, err := TarWithOptions(src, options)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer archive.Close()
err = Untar(archive, dst, options)
- require.NoError(t, err)
+ assert.NilError(t, err)
checkFileMode(t, filepath.Join(dst, "d1"), 0700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d2"), 0750|os.ModeDir)
@@ -123,31 +123,31 @@ func TestOverlayTarUntar(t *testing.T) {
func TestOverlayTarAUFSUntar(t *testing.T) {
oldmask, err := system.Umask(0)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer system.Umask(oldmask)
src, err := ioutil.TempDir("", "docker-test-overlay-tar-src")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(src)
setupOverlayTestDir(t, src)
dst, err := ioutil.TempDir("", "docker-test-overlay-tar-dst")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dst)
archive, err := TarWithOptions(src, &TarOptions{
Compression: Uncompressed,
WhiteoutFormat: OverlayWhiteoutFormat,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
defer archive.Close()
err = Untar(archive, dst, &TarOptions{
Compression: Uncompressed,
WhiteoutFormat: AUFSWhiteoutFormat,
})
- require.NoError(t, err)
+ assert.NilError(t, err)
checkFileMode(t, filepath.Join(dst, "d1"), 0700|os.ModeDir)
checkFileMode(t, filepath.Join(dst, "d1", WhiteoutOpaqueDir), 0700)
diff --git a/pkg/archive/archive_test.go b/pkg/archive/archive_test.go
index 70db8d4a1b..296b636a6e 100644
--- a/pkg/archive/archive_test.go
+++ b/pkg/archive/archive_test.go
@@ -17,8 +17,8 @@ import (
"github.com/docker/docker/pkg/idtools"
"github.com/docker/docker/pkg/ioutils"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
var tmp string
@@ -263,7 +263,7 @@ func TestCmdStreamGood(t *testing.T) {
func TestUntarPathWithInvalidDest(t *testing.T) {
tempFolder, err := ioutil.TempDir("", "docker-archive-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tempFolder)
invalidDestFolder := filepath.Join(tempFolder, "invalidDest")
// Create a src file
@@ -282,7 +282,7 @@ func TestUntarPathWithInvalidDest(t *testing.T) {
cmd := exec.Command("sh", "-c", "tar cf "+tarFileU+" "+srcFileU)
_, err = cmd.CombinedOutput()
- require.NoError(t, err)
+ assert.NilError(t, err)
err = defaultUntarPath(tarFile, invalidDestFolder)
if err == nil {
@@ -304,7 +304,7 @@ func TestUntarPathWithInvalidSrc(t *testing.T) {
func TestUntarPath(t *testing.T) {
tmpFolder, err := ioutil.TempDir("", "docker-archive-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmpFolder)
srcFile := filepath.Join(tmpFolder, "src")
tarFile := filepath.Join(tmpFolder, "src.tar")
@@ -325,7 +325,7 @@ func TestUntarPath(t *testing.T) {
}
cmd := exec.Command("sh", "-c", "tar cf "+tarFileU+" "+srcFileU)
_, err = cmd.CombinedOutput()
- require.NoError(t, err)
+ assert.NilError(t, err)
err = defaultUntarPath(tarFile, destFolder)
if err != nil {
@@ -726,12 +726,12 @@ func TestTarUntar(t *testing.T) {
func TestTarWithOptionsChownOptsAlwaysOverridesIdPair(t *testing.T) {
origin, err := ioutil.TempDir("", "docker-test-tar-chown-opt")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(origin)
filePath := filepath.Join(origin, "1")
err = ioutil.WriteFile(filePath, []byte("hello world"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
idMaps := []idtools.IDMap{
0: {
@@ -759,7 +759,7 @@ func TestTarWithOptionsChownOptsAlwaysOverridesIdPair(t *testing.T) {
}
for _, testCase := range cases {
reader, err := TarWithOptions(filePath, testCase.opts)
- require.NoError(t, err)
+ assert.NilError(t, err)
tr := tar.NewReader(reader)
defer reader.Close()
for {
@@ -768,9 +768,9 @@ func TestTarWithOptionsChownOptsAlwaysOverridesIdPair(t *testing.T) {
// end of tar archive
break
}
- require.NoError(t, err)
- assert.Equal(t, hdr.Uid, testCase.expectedUID, "Uid equals expected value")
- assert.Equal(t, hdr.Gid, testCase.expectedGID, "Gid equals expected value")
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(hdr.Uid, testCase.expectedUID), "Uid equals expected value")
+ assert.Check(t, is.Equal(hdr.Gid, testCase.expectedGID), "Gid equals expected value")
}
}
}
@@ -1182,10 +1182,10 @@ func TestUntarInvalidSymlink(t *testing.T) {
func TestTempArchiveCloseMultipleTimes(t *testing.T) {
reader := ioutil.NopCloser(strings.NewReader("hello"))
tempArchive, err := NewTempArchive(reader, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
buf := make([]byte, 10)
n, err := tempArchive.Read(buf)
- require.NoError(t, err)
+ assert.NilError(t, err)
if n != 5 {
t.Fatalf("Expected to read 5 bytes. Read %d instead", n)
}
@@ -1244,7 +1244,7 @@ func TestReplaceFileTarWrapper(t *testing.T) {
map[string]TarModifierFunc{testcase.filename: testcase.modifier})
actual := readFileFromArchive(t, resultArchive, testcase.filename, testcase.fileCount, testcase.doc)
- assert.Equal(t, testcase.expected, actual, testcase.doc)
+ assert.Check(t, is.Equal(testcase.expected, actual), testcase.doc)
}
}
@@ -1255,27 +1255,27 @@ func TestPrefixHeaderReadable(t *testing.T) {
var testFile = []byte("\x1f\x8b\x08\x08\x44\x21\x68\x59\x00\x03\x74\x2e\x74\x61\x72\x00\x4b\xcb\xcf\x67\xa0\x35\x30\x80\x00\x86\x06\x10\x47\x01\xc1\x37\x40\x00\x54\xb6\xb1\xa1\xa9\x99\x09\x48\x25\x1d\x40\x69\x71\x49\x62\x91\x02\xe5\x76\xa1\x79\x84\x21\x91\xd6\x80\x72\xaf\x8f\x82\x51\x30\x0a\x46\x36\x00\x00\xf0\x1c\x1e\x95\x00\x06\x00\x00")
tmpDir, err := ioutil.TempDir("", "prefix-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmpDir)
err = Untar(bytes.NewReader(testFile), tmpDir, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
baseName := "foo"
pth := strings.Repeat("a", 100-len(baseName)) + "/" + baseName
_, err = os.Lstat(filepath.Join(tmpDir, pth))
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func buildSourceArchive(t *testing.T, numberOfFiles int) (io.ReadCloser, func()) {
srcDir, err := ioutil.TempDir("", "docker-test-srcDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = prepareUntarSourceDirectory(numberOfFiles, srcDir, false)
- require.NoError(t, err)
+ assert.NilError(t, err)
sourceArchive, err := TarWithOptions(srcDir, &TarOptions{})
- require.NoError(t, err)
+ assert.NilError(t, err)
return sourceArchive, func() {
os.RemoveAll(srcDir)
sourceArchive.Close()
@@ -1291,7 +1291,7 @@ func createOrReplaceModifier(path string, header *tar.Header, content io.Reader)
func createModifier(t *testing.T) TarModifierFunc {
return func(path string, header *tar.Header, content io.Reader) (*tar.Header, []byte, error) {
- assert.Nil(t, content)
+ assert.Check(t, is.Nil(content))
return createOrReplaceModifier(path, header, content)
}
}
@@ -1309,17 +1309,17 @@ func appendModifier(path string, header *tar.Header, content io.Reader) (*tar.He
func readFileFromArchive(t *testing.T, archive io.ReadCloser, name string, expectedCount int, doc string) string {
destDir, err := ioutil.TempDir("", "docker-test-destDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(destDir)
err = Untar(archive, destDir, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
files, _ := ioutil.ReadDir(destDir)
- assert.Len(t, files, expectedCount, doc)
+ assert.Check(t, is.Len(files, expectedCount), doc)
content, err := ioutil.ReadFile(filepath.Join(destDir, name))
- assert.NoError(t, err)
+ assert.Check(t, err)
return string(content)
}
diff --git a/pkg/archive/archive_unix_test.go b/pkg/archive/archive_unix_test.go
index 17de96e94d..5d13c3542b 100644
--- a/pkg/archive/archive_unix_test.go
+++ b/pkg/archive/archive_unix_test.go
@@ -13,8 +13,8 @@ import (
"testing"
"github.com/docker/docker/pkg/system"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/sys/unix"
)
@@ -72,18 +72,18 @@ func TestChmodTarEntry(t *testing.T) {
func TestTarWithHardLink(t *testing.T) {
origin, err := ioutil.TempDir("", "docker-test-tar-hardlink")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(origin)
err = ioutil.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
var i1, i2 uint64
i1, err = getNlink(filepath.Join(origin, "1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// sanity check that we can hardlink
if i1 != 2 {
@@ -91,48 +91,48 @@ func TestTarWithHardLink(t *testing.T) {
}
dest, err := ioutil.TempDir("", "docker-test-tar-hardlink-dest")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dest)
// we'll do this in two steps to separate failure
fh, err := Tar(origin, Uncompressed)
- require.NoError(t, err)
+ assert.NilError(t, err)
// ensure we can read the whole thing with no error, before writing back out
buf, err := ioutil.ReadAll(fh)
- require.NoError(t, err)
+ assert.NilError(t, err)
bRdr := bytes.NewReader(buf)
err = Untar(bRdr, dest, &TarOptions{Compression: Uncompressed})
- require.NoError(t, err)
+ assert.NilError(t, err)
i1, err = getInode(filepath.Join(dest, "1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
i2, err = getInode(filepath.Join(dest, "2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, i1, i2)
+ assert.Check(t, is.Equal(i1, i2))
}
func TestTarWithHardLinkAndRebase(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "docker-test-tar-hardlink-rebase")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmpDir)
origin := filepath.Join(tmpDir, "origin")
err = os.Mkdir(origin, 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = os.Link(filepath.Join(origin, "1"), filepath.Join(origin, "2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
var i1, i2 uint64
i1, err = getNlink(filepath.Join(origin, "1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// sanity check that we can hardlink
if i1 != 2 {
@@ -141,20 +141,20 @@ func TestTarWithHardLinkAndRebase(t *testing.T) {
dest := filepath.Join(tmpDir, "dest")
bRdr, err := TarResourceRebase(origin, "origin")
- require.NoError(t, err)
+ assert.NilError(t, err)
dstDir, srcBase := SplitPathDirEntry(origin)
_, dstBase := SplitPathDirEntry(dest)
content := RebaseArchiveEntries(bRdr, srcBase, dstBase)
err = Untar(content, dstDir, &TarOptions{Compression: Uncompressed, NoLchown: true, NoOverwriteDirNonDir: true})
- require.NoError(t, err)
+ assert.NilError(t, err)
i1, err = getInode(filepath.Join(dest, "1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
i2, err = getInode(filepath.Join(dest, "2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, i1, i2)
+ assert.Check(t, is.Equal(i1, i2))
}
func getNlink(path string) (uint64, error) {
@@ -184,37 +184,37 @@ func getInode(path string) (uint64, error) {
func TestTarWithBlockCharFifo(t *testing.T) {
origin, err := ioutil.TempDir("", "docker-test-tar-hardlink")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(origin)
err = ioutil.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Mknod(filepath.Join(origin, "2"), unix.S_IFBLK, int(system.Mkdev(int64(12), int64(5))))
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Mknod(filepath.Join(origin, "3"), unix.S_IFCHR, int(system.Mkdev(int64(12), int64(5))))
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Mknod(filepath.Join(origin, "4"), unix.S_IFIFO, int(system.Mkdev(int64(12), int64(5))))
- require.NoError(t, err)
+ assert.NilError(t, err)
dest, err := ioutil.TempDir("", "docker-test-tar-hardlink-dest")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dest)
// we'll do this in two steps to separate failure
fh, err := Tar(origin, Uncompressed)
- require.NoError(t, err)
+ assert.NilError(t, err)
// ensure we can read the whole thing with no error, before writing back out
buf, err := ioutil.ReadAll(fh)
- require.NoError(t, err)
+ assert.NilError(t, err)
bRdr := bytes.NewReader(buf)
err = Untar(bRdr, dest, &TarOptions{Compression: Uncompressed})
- require.NoError(t, err)
+ assert.NilError(t, err)
changes, err := ChangesDirs(origin, dest)
- require.NoError(t, err)
+ assert.NilError(t, err)
if len(changes) > 0 {
t.Fatalf("Tar with special device (block, char, fifo) should keep them (recreate them when untar) : %v", changes)
@@ -224,17 +224,17 @@ func TestTarWithBlockCharFifo(t *testing.T) {
// TestTarUntarWithXattr is Unix as Lsetxattr is not supported on Windows
func TestTarUntarWithXattr(t *testing.T) {
origin, err := ioutil.TempDir("", "docker-test-untar-origin")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(origin)
err = ioutil.WriteFile(filepath.Join(origin, "1"), []byte("hello world"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(origin, "2"), []byte("welcome!"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(filepath.Join(origin, "3"), []byte("will be ignored"), 0700)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = system.Lsetxattr(filepath.Join(origin, "2"), "security.capability", []byte{0x00}, 0)
- require.NoError(t, err)
+ assert.NilError(t, err)
for _, c := range []Compression{
Uncompressed,
@@ -309,7 +309,7 @@ func TestCopyInfoDestinationPathSymlink(t *testing.T) {
for _, info := range testData {
p := filepath.Join(tmpDir, info.resource.path, info.file)
ci, err := CopyInfoDestinationPath(p)
- assert.NoError(t, err)
- assert.Equal(t, info.expected, ci)
+ assert.Check(t, err)
+ assert.Check(t, is.DeepEqual(info.expected, ci))
}
}
diff --git a/pkg/archive/changes_test.go b/pkg/archive/changes_test.go
index f316cd3203..2d316e77be 100644
--- a/pkg/archive/changes_test.go
+++ b/pkg/archive/changes_test.go
@@ -11,7 +11,7 @@ import (
"time"
"github.com/docker/docker/pkg/system"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func max(x, y int) int {
@@ -76,19 +76,19 @@ func provisionSampleDir(t *testing.T, root string, files []FileData) {
p := path.Join(root, info.path)
if info.filetype == Dir {
err := os.MkdirAll(p, info.permissions)
- require.NoError(t, err)
+ assert.NilError(t, err)
} else if info.filetype == Regular {
err := ioutil.WriteFile(p, []byte(info.contents), info.permissions)
- require.NoError(t, err)
+ assert.NilError(t, err)
} else if info.filetype == Symlink {
err := os.Symlink(info.contents, p)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
if info.filetype != Symlink {
// Set a consistent ctime, atime for all files and dirs
err := system.Chtimes(p, now, now)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
}
}
@@ -118,14 +118,14 @@ func TestChangesWithNoChanges(t *testing.T) {
t.Skip("symlinks on Windows")
}
rwLayer, err := ioutil.TempDir("", "docker-changes-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(rwLayer)
layer, err := ioutil.TempDir("", "docker-changes-test-layer")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(layer)
createSampleDir(t, layer)
changes, err := Changes([]string{layer}, rwLayer)
- require.NoError(t, err)
+ assert.NilError(t, err)
if len(changes) != 0 {
t.Fatalf("Changes with no difference should have detect no changes, but detected %d", len(changes))
}
@@ -139,14 +139,14 @@ func TestChangesWithChanges(t *testing.T) {
}
// Mock the readonly layer
layer, err := ioutil.TempDir("", "docker-changes-test-layer")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(layer)
createSampleDir(t, layer)
os.MkdirAll(path.Join(layer, "dir1/subfolder"), 0740)
// Mock the RW layer
rwLayer, err := ioutil.TempDir("", "docker-changes-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(rwLayer)
// Create a folder in RW layer
@@ -163,7 +163,7 @@ func TestChangesWithChanges(t *testing.T) {
ioutil.WriteFile(newFile, []byte{}, 0740)
changes, err := Changes([]string{layer}, rwLayer)
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedChanges := []Change{
{"/dir1", ChangeModify},
@@ -183,7 +183,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
t.Skip("symlinks on Windows")
}
baseLayer, err := ioutil.TempDir("", "docker-changes-test.")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(baseLayer)
dir3 := path.Join(baseLayer, "dir1/dir2/dir3")
@@ -193,7 +193,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
ioutil.WriteFile(file, []byte("hello"), 0666)
layer, err := ioutil.TempDir("", "docker-changes-test2.")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(layer)
// Test creating a new file
@@ -206,7 +206,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
ioutil.WriteFile(file, []byte("bye"), 0666)
changes, err := Changes([]string{baseLayer}, layer)
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedChanges := []Change{
{"/dir1/dir2/dir3", ChangeModify},
@@ -216,7 +216,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
// Now test changing a file
layer, err = ioutil.TempDir("", "docker-changes-test3.")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(layer)
if err := copyDir(baseLayer+"/dir1", layer+"/"); err != nil {
@@ -227,7 +227,7 @@ func TestChangesWithChangesGH13590(t *testing.T) {
ioutil.WriteFile(file, []byte("bye"), 0666)
changes, err = Changes([]string{baseLayer}, layer)
- require.NoError(t, err)
+ assert.NilError(t, err)
expectedChanges = []Change{
{"/dir1/dir2/dir3/file.txt", ChangeModify},
@@ -243,15 +243,15 @@ func TestChangesDirsEmpty(t *testing.T) {
t.Skip("symlinks on Windows")
}
src, err := ioutil.TempDir("", "docker-changes-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(src)
createSampleDir(t, src)
dst := src + "-copy"
err = copyDir(src, dst)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dst)
changes, err := ChangesDirs(dst, src)
- require.NoError(t, err)
+ assert.NilError(t, err)
if len(changes) != 0 {
t.Fatalf("Reported changes for identical dirs: %v", changes)
@@ -263,64 +263,64 @@ func TestChangesDirsEmpty(t *testing.T) {
func mutateSampleDir(t *testing.T, root string) {
// Remove a regular file
err := os.RemoveAll(path.Join(root, "file1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// Remove a directory
err = os.RemoveAll(path.Join(root, "dir1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// Remove a symlink
err = os.RemoveAll(path.Join(root, "symlink1"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// Rewrite a file
err = ioutil.WriteFile(path.Join(root, "file2"), []byte("fileNN\n"), 0777)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Replace a file
err = os.RemoveAll(path.Join(root, "file3"))
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(path.Join(root, "file3"), []byte("fileMM\n"), 0404)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Touch file
err = system.Chtimes(path.Join(root, "file4"), time.Now().Add(time.Second), time.Now().Add(time.Second))
- require.NoError(t, err)
+ assert.NilError(t, err)
// Replace file with dir
err = os.RemoveAll(path.Join(root, "file5"))
- require.NoError(t, err)
+ assert.NilError(t, err)
err = os.MkdirAll(path.Join(root, "file5"), 0666)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Create new file
err = ioutil.WriteFile(path.Join(root, "filenew"), []byte("filenew\n"), 0777)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Create new dir
err = os.MkdirAll(path.Join(root, "dirnew"), 0766)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Create a new symlink
err = os.Symlink("targetnew", path.Join(root, "symlinknew"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// Change a symlink
err = os.RemoveAll(path.Join(root, "symlink2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
err = os.Symlink("target2change", path.Join(root, "symlink2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
// Replace dir with file
err = os.RemoveAll(path.Join(root, "dir2"))
- require.NoError(t, err)
+ assert.NilError(t, err)
err = ioutil.WriteFile(path.Join(root, "dir2"), []byte("dir2\n"), 0777)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Touch dir
err = system.Chtimes(path.Join(root, "dir3"), time.Now().Add(time.Second), time.Now().Add(time.Second))
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestChangesDirsMutated(t *testing.T) {
@@ -330,18 +330,18 @@ func TestChangesDirsMutated(t *testing.T) {
t.Skip("symlinks on Windows")
}
src, err := ioutil.TempDir("", "docker-changes-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
createSampleDir(t, src)
dst := src + "-copy"
err = copyDir(src, dst)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(src)
defer os.RemoveAll(dst)
mutateSampleDir(t, dst)
changes, err := ChangesDirs(dst, src)
- require.NoError(t, err)
+ assert.NilError(t, err)
sort.Sort(changesByPath(changes))
@@ -386,29 +386,29 @@ func TestApplyLayer(t *testing.T) {
t.Skip("symlinks on Windows")
}
src, err := ioutil.TempDir("", "docker-changes-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
createSampleDir(t, src)
defer os.RemoveAll(src)
dst := src + "-copy"
err = copyDir(src, dst)
- require.NoError(t, err)
+ assert.NilError(t, err)
mutateSampleDir(t, dst)
defer os.RemoveAll(dst)
changes, err := ChangesDirs(dst, src)
- require.NoError(t, err)
+ assert.NilError(t, err)
layer, err := ExportChanges(dst, changes, nil, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
layerCopy, err := NewTempArchive(layer, "")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = ApplyLayer(src, layerCopy)
- require.NoError(t, err)
+ assert.NilError(t, err)
changes2, err := ChangesDirs(src, dst)
- require.NoError(t, err)
+ assert.NilError(t, err)
if len(changes2) != 0 {
t.Fatalf("Unexpected differences after reapplying mutation: %v", changes2)
@@ -422,18 +422,18 @@ func TestChangesSizeWithHardlinks(t *testing.T) {
t.Skip("hardlinks on Windows")
}
srcDir, err := ioutil.TempDir("", "docker-test-srcDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(srcDir)
destDir, err := ioutil.TempDir("", "docker-test-destDir")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(destDir)
creationSize, err := prepareUntarSourceDirectory(100, destDir, true)
- require.NoError(t, err)
+ assert.NilError(t, err)
changes, err := ChangesDirs(destDir, srcDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
got := ChangesSize(destDir, changes)
if got != int64(creationSize) {
@@ -460,14 +460,14 @@ func TestChangesSizeWithOnlyDeleteChanges(t *testing.T) {
func TestChangesSize(t *testing.T) {
parentPath, err := ioutil.TempDir("", "docker-changes-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(parentPath)
addition := path.Join(parentPath, "addition")
err = ioutil.WriteFile(addition, []byte{0x01, 0x01, 0x01}, 0744)
- require.NoError(t, err)
+ assert.NilError(t, err)
modification := path.Join(parentPath, "modification")
err = ioutil.WriteFile(modification, []byte{0x01, 0x01, 0x01}, 0744)
- require.NoError(t, err)
+ assert.NilError(t, err)
changes := []Change{
{Path: "addition", Kind: ChangeAdd},
diff --git a/pkg/archive/copy_unix_test.go b/pkg/archive/copy_unix_test.go
index 3126d8b51e..08b1702cf1 100644
--- a/pkg/archive/copy_unix_test.go
+++ b/pkg/archive/copy_unix_test.go
@@ -16,7 +16,7 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func removeAllPaths(paths ...string) {
@@ -29,10 +29,10 @@ func getTestTempDirs(t *testing.T) (tmpDirA, tmpDirB string) {
var err error
tmpDirA, err = ioutil.TempDir("", "archive-copy-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
tmpDirB, err = ioutil.TempDir("", "archive-copy-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
return
}
@@ -119,7 +119,7 @@ func logDirContents(t *testing.T, dirPath string) {
t.Logf("logging directory contents: %q", dirPath)
err := filepath.Walk(dirPath, logWalkedPaths)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func testCopyHelper(t *testing.T, srcPath, dstPath string) (err error) {
@@ -293,7 +293,7 @@ func TestCopyCaseA(t *testing.T) {
}
err = fileContentsEqual(t, srcPath, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
os.Remove(dstPath)
symlinkPath := filepath.Join(tmpDirA, "symlink3")
@@ -305,14 +305,14 @@ func TestCopyCaseA(t *testing.T) {
}
err = fileContentsEqual(t, linkTarget, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
os.Remove(dstPath)
if err = testCopyHelperFSym(t, symlinkPath1, dstPath); err != nil {
t.Fatalf("unexpected error %T: %s", err, err)
}
err = fileContentsEqual(t, linkTarget, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// B. SRC specifies a file and DST (with trailing path separator) doesn't
@@ -374,7 +374,7 @@ func TestCopyCaseC(t *testing.T) {
}
err = fileContentsEqual(t, srcPath, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// C. Symbol link following version:
@@ -411,7 +411,7 @@ func TestCopyCaseCFSym(t *testing.T) {
}
err = fileContentsEqual(t, linkTarget, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// D. SRC specifies a file and DST exists as a directory. This should place
@@ -441,7 +441,7 @@ func TestCopyCaseD(t *testing.T) {
}
err = fileContentsEqual(t, srcPath, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Now try again but using a trailing path separator for dstDir.
@@ -460,7 +460,7 @@ func TestCopyCaseD(t *testing.T) {
}
err = fileContentsEqual(t, srcPath, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// D. Symbol link following version:
@@ -492,7 +492,7 @@ func TestCopyCaseDFSym(t *testing.T) {
}
err = fileContentsEqual(t, linkTarget, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Now try again but using a trailing path separator for dstDir.
@@ -511,7 +511,7 @@ func TestCopyCaseDFSym(t *testing.T) {
}
err = fileContentsEqual(t, linkTarget, dstPath)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// E. SRC specifies a directory and DST does not exist. This should create a
@@ -554,7 +554,7 @@ func TestCopyCaseE(t *testing.T) {
}
err = dirContentsEqual(t, dstDir, srcDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// E. Symbol link following version:
@@ -599,7 +599,7 @@ func TestCopyCaseEFSym(t *testing.T) {
}
err = dirContentsEqual(t, dstDir, linkTarget)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// F. SRC specifies a directory and DST exists as a file. This should cause an
@@ -658,7 +658,7 @@ func TestCopyCaseG(t *testing.T) {
}
err = dirContentsEqual(t, resultDir, srcDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Now try again but using a trailing path separator for dstDir.
@@ -677,7 +677,7 @@ func TestCopyCaseG(t *testing.T) {
}
err = dirContentsEqual(t, resultDir, srcDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// G. Symbol link version:
@@ -704,7 +704,7 @@ func TestCopyCaseGFSym(t *testing.T) {
}
err = dirContentsEqual(t, resultDir, linkTarget)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Now try again but using a trailing path separator for dstDir.
@@ -723,7 +723,7 @@ func TestCopyCaseGFSym(t *testing.T) {
}
err = dirContentsEqual(t, resultDir, linkTarget)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// H. SRC specifies a directory's contents only and DST does not exist. This
@@ -884,7 +884,7 @@ func TestCopyCaseJ(t *testing.T) {
}
err = dirContentsEqual(t, dstDir, srcDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Now try again but using a trailing path separator for dstDir.
@@ -903,7 +903,7 @@ func TestCopyCaseJ(t *testing.T) {
}
err = dirContentsEqual(t, dstDir, srcDir)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
// J. Symbol link following version:
@@ -935,7 +935,7 @@ func TestCopyCaseJFSym(t *testing.T) {
}
err = dirContentsEqual(t, dstDir, linkTarget)
- require.NoError(t, err)
+ assert.NilError(t, err)
// Now try again but using a trailing path separator for dstDir.
@@ -954,5 +954,5 @@ func TestCopyCaseJFSym(t *testing.T) {
}
err = dirContentsEqual(t, dstDir, linkTarget)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
diff --git a/pkg/archive/wrap_test.go b/pkg/archive/wrap_test.go
index 6decf8fccb..979536777f 100644
--- a/pkg/archive/wrap_test.go
+++ b/pkg/archive/wrap_test.go
@@ -6,12 +6,12 @@ import (
"io"
"testing"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestGenerateEmptyFile(t *testing.T) {
archive, err := Generate("emptyFile")
- require.NoError(t, err)
+ assert.NilError(t, err)
if archive == nil {
t.Fatal("The generated archive should not be nil.")
}
@@ -28,7 +28,7 @@ func TestGenerateEmptyFile(t *testing.T) {
if err == io.EOF {
break
}
- require.NoError(t, err)
+ assert.NilError(t, err)
buf := new(bytes.Buffer)
buf.ReadFrom(tr)
content := buf.String()
@@ -52,7 +52,7 @@ func TestGenerateEmptyFile(t *testing.T) {
func TestGenerateWithContent(t *testing.T) {
archive, err := Generate("file", "content")
- require.NoError(t, err)
+ assert.NilError(t, err)
if archive == nil {
t.Fatal("The generated archive should not be nil.")
}
@@ -69,7 +69,7 @@ func TestGenerateWithContent(t *testing.T) {
if err == io.EOF {
break
}
- require.NoError(t, err)
+ assert.NilError(t, err)
buf := new(bytes.Buffer)
buf.ReadFrom(tr)
content := buf.String()
diff --git a/pkg/authorization/api_test.go b/pkg/authorization/api_test.go
index 90a984276d..84964d2c5e 100644
--- a/pkg/authorization/api_test.go
+++ b/pkg/authorization/api_test.go
@@ -11,7 +11,8 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestPeerCertificateMarshalJSON(t *testing.T) {
@@ -32,21 +33,21 @@ func TestPeerCertificateMarshalJSON(t *testing.T) {
}
// generate private key
privatekey, err := rsa.GenerateKey(rand.Reader, 2048)
- require.NoError(t, err)
+ assert.NilError(t, err)
publickey := &privatekey.PublicKey
// create a self-signed certificate. template = parent
var parent = template
raw, err := x509.CreateCertificate(rand.Reader, template, parent, publickey, privatekey)
- require.NoError(t, err)
+ assert.NilError(t, err)
cert, err := x509.ParseCertificate(raw)
- require.NoError(t, err)
+ assert.NilError(t, err)
var certs = []*x509.Certificate{cert}
addr := "www.authz.com/auth"
req, err := http.NewRequest("GET", addr, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
req.RequestURI = addr
req.TLS = &tls.ConnectionState{}
@@ -58,15 +59,15 @@ func TestPeerCertificateMarshalJSON(t *testing.T) {
t.Run("Marshalling :", func(t *testing.T) {
raw, err = pcObj.MarshalJSON()
- require.NotNil(t, raw)
- require.Nil(t, err)
+ assert.Assert(t, raw != nil)
+ assert.NilError(t, err)
})
t.Run("UnMarshalling :", func(t *testing.T) {
err := pcObj.UnmarshalJSON(raw)
- require.Nil(t, err)
- require.Equal(t, "Earth", pcObj.Subject.Country[0])
- require.Equal(t, true, pcObj.IsCA)
+ assert.Assert(t, is.Nil(err))
+ assert.Equal(t, "Earth", pcObj.Subject.Country[0])
+ assert.Equal(t, true, pcObj.IsCA)
})
diff --git a/pkg/authorization/middleware_test.go b/pkg/authorization/middleware_test.go
index 3812d804e3..e32e4bf427 100644
--- a/pkg/authorization/middleware_test.go
+++ b/pkg/authorization/middleware_test.go
@@ -7,7 +7,7 @@ import (
"testing"
"github.com/docker/docker/pkg/plugingetter"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestMiddleware(t *testing.T) {
@@ -15,9 +15,9 @@ func TestMiddleware(t *testing.T) {
var pluginGetter plugingetter.PluginGetter
m := NewMiddleware(pluginNames, pluginGetter)
authPlugins := m.getAuthzPlugins()
- require.Equal(t, 2, len(authPlugins))
- require.EqualValues(t, pluginNames[0], authPlugins[0].Name())
- require.EqualValues(t, pluginNames[1], authPlugins[1].Name())
+ assert.Equal(t, 2, len(authPlugins))
+ assert.Equal(t, pluginNames[0], authPlugins[0].Name())
+ assert.Equal(t, pluginNames[1], authPlugins[1].Name())
}
func TestNewResponseModifier(t *testing.T) {
@@ -25,17 +25,17 @@ func TestNewResponseModifier(t *testing.T) {
modifier := NewResponseModifier(recorder)
modifier.Header().Set("H1", "V1")
modifier.Write([]byte("body"))
- require.False(t, modifier.Hijacked())
+ assert.Assert(t, !modifier.Hijacked())
modifier.WriteHeader(http.StatusInternalServerError)
- require.NotNil(t, modifier.RawBody())
+ assert.Assert(t, modifier.RawBody() != nil)
raw, err := modifier.RawHeaders()
- require.NotNil(t, raw)
- require.Nil(t, err)
+ assert.Assert(t, raw != nil)
+ assert.NilError(t, err)
headerData := strings.Split(strings.TrimSpace(string(raw)), ":")
- require.EqualValues(t, "H1", strings.TrimSpace(headerData[0]))
- require.EqualValues(t, "V1", strings.TrimSpace(headerData[1]))
+ assert.Equal(t, "H1", strings.TrimSpace(headerData[0]))
+ assert.Equal(t, "V1", strings.TrimSpace(headerData[1]))
modifier.Flush()
modifier.FlushAll()
diff --git a/pkg/authorization/middleware_unix_test.go b/pkg/authorization/middleware_unix_test.go
index 257832b338..ddfe9d958f 100644
--- a/pkg/authorization/middleware_unix_test.go
+++ b/pkg/authorization/middleware_unix_test.go
@@ -8,7 +8,8 @@ import (
"testing"
"github.com/docker/docker/pkg/plugingetter"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -30,7 +31,7 @@ func TestMiddlewareWrapHandler(t *testing.T) {
middleWare.SetPlugins([]string{"My Test Plugin"})
setAuthzPlugins(middleWare, authList)
mdHandler := middleWare.WrapHandler(handler)
- require.NotNil(t, mdHandler)
+ assert.Assert(t, mdHandler != nil)
addr := "www.example.com/auth"
req, _ := http.NewRequest("GET", addr, nil)
@@ -46,7 +47,7 @@ func TestMiddlewareWrapHandler(t *testing.T) {
Msg: "Server Auth Not Allowed",
}
if err := mdHandler(ctx, resp, req, map[string]string{}); err == nil {
- require.Error(t, err)
+ assert.Assert(t, is.ErrorContains(err, ""))
}
})
@@ -57,7 +58,7 @@ func TestMiddlewareWrapHandler(t *testing.T) {
Msg: "Server Auth Allowed",
}
if err := mdHandler(ctx, resp, req, map[string]string{}); err != nil {
- require.NoError(t, err)
+ assert.NilError(t, err)
}
})
diff --git a/pkg/fileutils/fileutils_test.go b/pkg/fileutils/fileutils_test.go
index 0a648d1466..b167538d5a 100644
--- a/pkg/fileutils/fileutils_test.go
+++ b/pkg/fileutils/fileutils_test.go
@@ -10,8 +10,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
// CopyFile with invalid src
@@ -384,9 +384,9 @@ func TestMatches(t *testing.T) {
for _, test := range tests {
desc := fmt.Sprintf("pattern=%q text=%q", test.pattern, test.text)
pm, err := NewPatternMatcher([]string{test.pattern})
- require.NoError(t, err, desc)
+ assert.NilError(t, err, desc)
res, _ := pm.Matches(test.text)
- assert.Equal(t, test.pass, res, desc)
+ assert.Check(t, is.Equal(test.pass, res), desc)
}
}
diff --git a/pkg/idtools/idtools_unix_test.go b/pkg/idtools/idtools_unix_test.go
index 931e332bb9..e493b9e8d5 100644
--- a/pkg/idtools/idtools_unix_test.go
+++ b/pkg/idtools/idtools_unix_test.go
@@ -10,9 +10,9 @@ import (
"path/filepath"
"testing"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/gotestyourself/gotestyourself/skip"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
"golang.org/x/sys/unix"
)
@@ -89,7 +89,7 @@ func TestMkdirAllAndChown(t *testing.T) {
func TestMkdirAllAndChownNew(t *testing.T) {
RequiresRoot(t)
dirName, err := ioutil.TempDir("", "mkdirnew")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dirName)
testTree := map[string]node{
@@ -99,32 +99,32 @@ func TestMkdirAllAndChownNew(t *testing.T) {
"lib/x86_64": {45, 45},
"lib/x86_64/share": {1, 1},
}
- require.NoError(t, buildTree(dirName, testTree))
+ assert.NilError(t, buildTree(dirName, testTree))
// test adding a directory to a pre-existing dir; only the new dir is owned by the uid/gid
err = MkdirAllAndChownNew(filepath.Join(dirName, "usr", "share"), 0755, IDPair{UID: 99, GID: 99})
- require.NoError(t, err)
+ assert.NilError(t, err)
testTree["usr/share"] = node{99, 99}
verifyTree, err := readTree(dirName, "")
- require.NoError(t, err)
- require.NoError(t, compareTrees(testTree, verifyTree))
+ assert.NilError(t, err)
+ assert.NilError(t, compareTrees(testTree, verifyTree))
// test 2-deep new directories--both should be owned by the uid/gid pair
err = MkdirAllAndChownNew(filepath.Join(dirName, "lib", "some", "other"), 0755, IDPair{UID: 101, GID: 101})
- require.NoError(t, err)
+ assert.NilError(t, err)
testTree["lib/some"] = node{101, 101}
testTree["lib/some/other"] = node{101, 101}
verifyTree, err = readTree(dirName, "")
- require.NoError(t, err)
- require.NoError(t, compareTrees(testTree, verifyTree))
+ assert.NilError(t, err)
+ assert.NilError(t, compareTrees(testTree, verifyTree))
// test a directory that already exists; should NOT be chowned
err = MkdirAllAndChownNew(filepath.Join(dirName, "usr"), 0755, IDPair{UID: 102, GID: 102})
- require.NoError(t, err)
+ assert.NilError(t, err)
verifyTree, err = readTree(dirName, "")
- require.NoError(t, err)
- require.NoError(t, compareTrees(testTree, verifyTree))
+ assert.NilError(t, err)
+ assert.NilError(t, compareTrees(testTree, verifyTree))
}
func TestMkdirAndChown(t *testing.T) {
@@ -235,7 +235,7 @@ func compareTrees(left, right map[string]node) error {
func delUser(t *testing.T, name string) {
_, err := execCmd("userdel", name)
- assert.NoError(t, err)
+ assert.Check(t, err)
}
func TestParseSubidFileWithNewlinesAndComments(t *testing.T) {
@@ -283,9 +283,9 @@ func TestGetRootUIDGID(t *testing.T) {
}
uid, gid, err := GetRootUIDGID(uidMap, gidMap)
- assert.NoError(t, err)
- assert.Equal(t, os.Getegid(), uid)
- assert.Equal(t, os.Getegid(), gid)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(os.Getegid(), uid))
+ assert.Check(t, is.Equal(os.Getegid(), gid))
uidMapError := []IDMap{
{
@@ -295,7 +295,7 @@ func TestGetRootUIDGID(t *testing.T) {
},
}
_, _, err = GetRootUIDGID(uidMapError, gidMap)
- assert.EqualError(t, err, "Container ID 0 cannot be mapped to a host ID")
+ assert.Check(t, is.Error(err, "Container ID 0 cannot be mapped to a host ID"))
}
func TestToContainer(t *testing.T) {
@@ -308,74 +308,74 @@ func TestToContainer(t *testing.T) {
}
containerID, err := toContainer(2, uidMap)
- assert.NoError(t, err)
- assert.Equal(t, uidMap[0].ContainerID, containerID)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(uidMap[0].ContainerID, containerID))
}
func TestNewIDMappings(t *testing.T) {
RequiresRoot(t)
_, _, err := AddNamespaceRangesUser(tempUser)
- assert.NoError(t, err)
+ assert.Check(t, err)
defer delUser(t, tempUser)
tempUser, err := user.Lookup(tempUser)
- assert.NoError(t, err)
+ assert.Check(t, err)
gids, err := tempUser.GroupIds()
- assert.NoError(t, err)
+ assert.Check(t, err)
group, err := user.LookupGroupId(string(gids[0]))
- assert.NoError(t, err)
+ assert.Check(t, err)
idMappings, err := NewIDMappings(tempUser.Username, group.Name)
- assert.NoError(t, err)
+ assert.Check(t, err)
rootUID, rootGID, err := GetRootUIDGID(idMappings.UIDs(), idMappings.GIDs())
- assert.NoError(t, err)
+ assert.Check(t, err)
dirName, err := ioutil.TempDir("", "mkdirall")
- assert.NoError(t, err, "Couldn't create temp directory")
+ assert.Check(t, err, "Couldn't create temp directory")
defer os.RemoveAll(dirName)
err = MkdirAllAndChown(dirName, 0700, IDPair{UID: rootUID, GID: rootGID})
- assert.NoError(t, err, "Couldn't change ownership of file path. Got error")
- assert.True(t, CanAccess(dirName, idMappings.RootPair()), fmt.Sprintf("Unable to access %s directory with user UID:%d and GID:%d", dirName, rootUID, rootGID))
+ assert.Check(t, err, "Couldn't change ownership of file path. Got error")
+ assert.Check(t, CanAccess(dirName, idMappings.RootPair()), fmt.Sprintf("Unable to access %s directory with user UID:%d and GID:%d", dirName, rootUID, rootGID))
}
func TestLookupUserAndGroup(t *testing.T) {
RequiresRoot(t)
uid, gid, err := AddNamespaceRangesUser(tempUser)
- assert.NoError(t, err)
+ assert.Check(t, err)
defer delUser(t, tempUser)
fetchedUser, err := LookupUser(tempUser)
- assert.NoError(t, err)
+ assert.Check(t, err)
fetchedUserByID, err := LookupUID(uid)
- assert.NoError(t, err)
- assert.Equal(t, fetchedUserByID, fetchedUser)
+ assert.Check(t, err)
+ assert.Check(t, is.DeepEqual(fetchedUserByID, fetchedUser))
fetchedGroup, err := LookupGroup(tempUser)
- assert.NoError(t, err)
+ assert.Check(t, err)
fetchedGroupByID, err := LookupGID(gid)
- assert.NoError(t, err)
- assert.Equal(t, fetchedGroupByID, fetchedGroup)
+ assert.Check(t, err)
+ assert.Check(t, is.DeepEqual(fetchedGroupByID, fetchedGroup))
}
func TestLookupUserAndGroupThatDoesNotExist(t *testing.T) {
fakeUser := "fakeuser"
_, err := LookupUser(fakeUser)
- assert.EqualError(t, err, "getent unable to find entry \""+fakeUser+"\" in passwd database")
+ assert.Check(t, is.Error(err, "getent unable to find entry \""+fakeUser+"\" in passwd database"))
_, err = LookupUID(-1)
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
fakeGroup := "fakegroup"
_, err = LookupGroup(fakeGroup)
- assert.EqualError(t, err, "getent unable to find entry \""+fakeGroup+"\" in group database")
+ assert.Check(t, is.Error(err, "getent unable to find entry \""+fakeGroup+"\" in group database"))
_, err = LookupGID(-1)
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
}
// TestMkdirIsNotDir checks that mkdirAs() function (used by MkdirAll...)
@@ -389,7 +389,7 @@ func TestMkdirIsNotDir(t *testing.T) {
defer os.Remove(file.Name())
err = mkdirAs(file.Name(), 0755, 0, 0, false, false)
- assert.EqualError(t, err, "mkdir "+file.Name()+": not a directory")
+ assert.Check(t, is.Error(err, "mkdir "+file.Name()+": not a directory"))
}
func RequiresRoot(t *testing.T) {
diff --git a/pkg/ioutils/readers_test.go b/pkg/ioutils/readers_test.go
index e322fdf840..e009ab26f6 100644
--- a/pkg/ioutils/readers_test.go
+++ b/pkg/ioutils/readers_test.go
@@ -7,7 +7,8 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@@ -36,7 +37,7 @@ func TestReaderErrWrapperReadOnError(t *testing.T) {
called = true
})
_, err := wrapper.Read([]byte{})
- assert.EqualError(t, err, "error reader always fail")
+ assert.Check(t, is.Error(err, "error reader always fail"))
if !called {
t.Fatalf("readErrWrapper should have call the anonymous function on failure")
}
diff --git a/pkg/jsonmessage/jsonmessage_test.go b/pkg/jsonmessage/jsonmessage_test.go
index 2bad8a2025..ab1d879c5a 100644
--- a/pkg/jsonmessage/jsonmessage_test.go
+++ b/pkg/jsonmessage/jsonmessage_test.go
@@ -9,7 +9,8 @@ import (
"time"
"github.com/docker/docker/pkg/term"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestError(t *testing.T) {
@@ -198,7 +199,7 @@ func TestJSONMessageDisplayWithJSONError(t *testing.T) {
jsonMessage = JSONMessage{Error: &JSONError{401, "Anything"}}
err = jsonMessage.Display(data, &noTermInfo{})
- assert.EqualError(t, err, "authentication is required")
+ assert.Check(t, is.Error(err, "authentication is required"))
}
func TestDisplayJSONMessagesStreamInvalidJSON(t *testing.T) {
diff --git a/pkg/plugins/client_test.go b/pkg/plugins/client_test.go
index 10c8d8fd56..d420010f1a 100644
--- a/pkg/plugins/client_test.go
+++ b/pkg/plugins/client_test.go
@@ -14,9 +14,9 @@ import (
"github.com/docker/docker/pkg/plugins/transport"
"github.com/docker/go-connections/tlsconfig"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
var (
@@ -88,7 +88,7 @@ func TestEchoInputOutput(t *testing.T) {
t.Fatal(err)
}
- assert.Equal(t, m, output)
+ assert.Check(t, is.DeepEqual(m, output))
err = c.Call("Test.Echo", nil, nil)
if err != nil {
t.Fatal(err)
@@ -205,7 +205,7 @@ func TestClientStream(t *testing.T) {
if err := json.NewDecoder(body).Decode(&output); err != nil {
t.Fatalf("Test.Echo: error reading plugin resp: %v", err)
}
- assert.Equal(t, m, output)
+ assert.Check(t, is.DeepEqual(m, output))
}
func TestClientSendFile(t *testing.T) {
@@ -233,7 +233,7 @@ func TestClientSendFile(t *testing.T) {
if err := c.SendFile("Test.Echo", &buf, &output); err != nil {
t.Fatal(err)
}
- assert.Equal(t, m, output)
+ assert.Check(t, is.DeepEqual(m, output))
}
func TestClientWithRequestTimeout(t *testing.T) {
@@ -248,7 +248,7 @@ func TestClientWithRequestTimeout(t *testing.T) {
client := &Client{http: srv.Client(), requestFactory: &testRequestWrapper{srv}}
_, err := client.callWithRetry("/Plugin.Hello", nil, false, WithRequestTimeout(timeout))
- require.Error(t, err, "expected error")
+ assert.Assert(t, is.ErrorContains(err, ""), "expected error")
err = errors.Cause(err)
@@ -256,7 +256,7 @@ func TestClientWithRequestTimeout(t *testing.T) {
case *url.Error:
err = e.Err
}
- require.Equal(t, context.DeadlineExceeded, err)
+ assert.DeepEqual(t, context.DeadlineExceeded, err)
}
type testRequestWrapper struct {
diff --git a/pkg/plugins/discovery_unix_test.go b/pkg/plugins/discovery_unix_test.go
index 9212946b2e..2c718d8bee 100644
--- a/pkg/plugins/discovery_unix_test.go
+++ b/pkg/plugins/discovery_unix_test.go
@@ -11,7 +11,7 @@ import (
"reflect"
"testing"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestLocalSocket(t *testing.T) {
@@ -91,7 +91,7 @@ func TestScan(t *testing.T) {
r := newLocalRegistry()
p, err := r.Plugin(name)
- require.NoError(t, err)
+ assert.NilError(t, err)
pluginNamesNotEmpty, err := Scan()
if err != nil {
diff --git a/pkg/plugins/plugin_test.go b/pkg/plugins/plugin_test.go
index 1540a19a64..0efd5e3aa0 100644
--- a/pkg/plugins/plugin_test.go
+++ b/pkg/plugins/plugin_test.go
@@ -14,8 +14,9 @@ import (
"github.com/docker/docker/pkg/plugins/transport"
"github.com/docker/go-connections/tlsconfig"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
"github.com/pkg/errors"
- "github.com/stretchr/testify/assert"
)
const (
@@ -78,11 +79,11 @@ func TestGet(t *testing.T) {
// check negative case where plugin fruit doesn't implement banana
_, err = Get("fruit", "banana")
- assert.Equal(t, errors.Cause(err), ErrNotImplements)
+ assert.Check(t, is.DeepEqual(errors.Cause(err), ErrNotImplements))
// check negative case where plugin vegetable doesn't exist
_, err = Get("vegetable", "potato")
- assert.Equal(t, errors.Cause(err), ErrNotFound)
+ assert.Check(t, is.DeepEqual(errors.Cause(err), ErrNotFound))
}
diff --git a/pkg/plugins/transport/http_test.go b/pkg/plugins/transport/http_test.go
index 2e48b0fe0a..081f60424d 100644
--- a/pkg/plugins/transport/http_test.go
+++ b/pkg/plugins/transport/http_test.go
@@ -5,7 +5,8 @@ import (
"net/http"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestHTTPTransport(t *testing.T) {
@@ -16,5 +17,5 @@ func TestHTTPTransport(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- assert.Equal(t, "POST", request.Method)
+ assert.Check(t, is.Equal("POST", request.Method))
}
diff --git a/pkg/pools/pools_test.go b/pkg/pools/pools_test.go
index 2dbea36ae0..76015169d4 100644
--- a/pkg/pools/pools_test.go
+++ b/pkg/pools/pools_test.go
@@ -7,8 +7,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestBufioReaderPoolGetWithNoReaderShouldCreateOne(t *testing.T) {
@@ -95,16 +95,16 @@ func TestBufioWriterPoolPutAndGet(t *testing.T) {
buf := new(bytes.Buffer)
bw := bufio.NewWriter(buf)
writer := BufioWriter32KPool.Get(bw)
- require.NotNil(t, writer)
+ assert.Assert(t, writer != nil)
written, err := writer.Write([]byte("foobar"))
- require.NoError(t, err)
- assert.Equal(t, 6, written)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(6, written))
// Make sure we Flush all the way ?
writer.Flush()
bw.Flush()
- assert.Len(t, buf.Bytes(), 6)
+ assert.Check(t, is.Len(buf.Bytes(), 6))
// Reset the buffer
buf.Reset()
BufioWriter32KPool.Put(writer)
diff --git a/pkg/reexec/reexec_test.go b/pkg/reexec/reexec_test.go
index e6bbe9f9a0..90aa01a390 100644
--- a/pkg/reexec/reexec_test.go
+++ b/pkg/reexec/reexec_test.go
@@ -5,8 +5,7 @@ import (
"os/exec"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func init() {
@@ -19,7 +18,7 @@ func init() {
func TestRegister(t *testing.T) {
defer func() {
if r := recover(); r != nil {
- require.Equal(t, `reexec func already registered under name "reexec"`, r)
+ assert.Equal(t, `reexec func already registered under name "reexec"`, r)
}
}()
Register("reexec", func() {})
@@ -28,13 +27,13 @@ func TestRegister(t *testing.T) {
func TestCommand(t *testing.T) {
cmd := Command("reexec")
w, err := cmd.StdinPipe()
- require.NoError(t, err, "Error on pipe creation: %v", err)
+ assert.NilError(t, err, "Error on pipe creation: %v", err)
defer w.Close()
err = cmd.Start()
- require.NoError(t, err, "Error on re-exec cmd: %v", err)
+ assert.NilError(t, err, "Error on re-exec cmd: %v", err)
err = cmd.Wait()
- require.EqualError(t, err, "exit status 2")
+ assert.Error(t, err, "exit status 2")
}
func TestNaiveSelf(t *testing.T) {
@@ -44,10 +43,10 @@ func TestNaiveSelf(t *testing.T) {
cmd := exec.Command(naiveSelf(), "-test.run=TestNaiveSelf")
cmd.Env = append(os.Environ(), "TEST_CHECK=1")
err := cmd.Start()
- require.NoError(t, err, "Unable to start command")
+ assert.NilError(t, err, "Unable to start command")
err = cmd.Wait()
- require.EqualError(t, err, "exit status 2")
+ assert.Error(t, err, "exit status 2")
os.Args[0] = "mkdir"
- assert.NotEqual(t, naiveSelf(), os.Args[0])
+ assert.Check(t, naiveSelf() != os.Args[0])
}
diff --git a/pkg/signal/signal_linux_test.go b/pkg/signal/signal_linux_test.go
index d7e8da2523..71c577ed64 100644
--- a/pkg/signal/signal_linux_test.go
+++ b/pkg/signal/signal_linux_test.go
@@ -8,7 +8,8 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestCatchAll(t *testing.T) {
@@ -34,7 +35,7 @@ func TestCatchAll(t *testing.T) {
}()
s := <-sigs
- assert.EqualValues(t, s.String(), signal.String())
+ assert.Check(t, is.Equal(s.String(), signal.String()))
}
}
@@ -50,9 +51,9 @@ func TestStopCatch(t *testing.T) {
syscall.Kill(syscall.Getpid(), signal)
}()
signalString := <-channel
- assert.EqualValues(t, signalString.String(), signal.String())
+ assert.Check(t, is.Equal(signalString.String(), signal.String()))
StopCatch(channel)
_, ok := <-channel
- assert.EqualValues(t, ok, false)
+ assert.Check(t, is.Equal(ok, false))
}
diff --git a/pkg/signal/signal_test.go b/pkg/signal/signal_test.go
index 1add526d16..bbf3736fc8 100644
--- a/pkg/signal/signal_test.go
+++ b/pkg/signal/signal_test.go
@@ -4,30 +4,31 @@ import (
"syscall"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestParseSignal(t *testing.T) {
_, checkAtoiError := ParseSignal("0")
- assert.EqualError(t, checkAtoiError, "Invalid signal: 0")
+ assert.Check(t, is.Error(checkAtoiError, "Invalid signal: 0"))
_, error := ParseSignal("SIG")
- assert.EqualError(t, error, "Invalid signal: SIG")
+ assert.Check(t, is.Error(error, "Invalid signal: SIG"))
for sigStr := range SignalMap {
responseSignal, error := ParseSignal(sigStr)
- assert.NoError(t, error)
+ assert.Check(t, error)
signal := SignalMap[sigStr]
- assert.EqualValues(t, signal, responseSignal)
+ assert.Check(t, is.DeepEqual(signal, responseSignal))
}
}
func TestValidSignalForPlatform(t *testing.T) {
isValidSignal := ValidSignalForPlatform(syscall.Signal(0))
- assert.EqualValues(t, false, isValidSignal)
+ assert.Check(t, is.Equal(false, isValidSignal))
for _, sigN := range SignalMap {
isValidSignal = ValidSignalForPlatform(syscall.Signal(sigN))
- assert.EqualValues(t, true, isValidSignal)
+ assert.Check(t, is.Equal(true, isValidSignal))
}
}
diff --git a/pkg/signal/trap_linux_test.go b/pkg/signal/trap_linux_test.go
index d32a4366f4..a3afe7a7b6 100644
--- a/pkg/signal/trap_linux_test.go
+++ b/pkg/signal/trap_linux_test.go
@@ -10,19 +10,19 @@ import (
"syscall"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func buildTestBinary(t *testing.T, tmpdir string, prefix string) (string, string) {
tmpDir, err := ioutil.TempDir(tmpdir, prefix)
- require.NoError(t, err)
+ assert.NilError(t, err)
exePath := tmpDir + "/" + prefix
wd, _ := os.Getwd()
testHelperCode := wd + "/testfiles/main.go"
cmd := exec.Command("go", "build", "-o", exePath, testHelperCode)
err = cmd.Run()
- require.NoError(t, err)
+ assert.NilError(t, err)
return exePath, tmpDir
}
@@ -48,14 +48,14 @@ func TestTrap(t *testing.T) {
cmd.Env = append(cmd.Env, "IF_MULTIPLE=1")
}
err := cmd.Start()
- require.NoError(t, err)
+ assert.NilError(t, err)
err = cmd.Wait()
if e, ok := err.(*exec.ExitError); ok {
code := e.Sys().(syscall.WaitStatus).ExitStatus()
if v.multiple {
- assert.Equal(t, 128+int(v.signal.(syscall.Signal)), code)
+ assert.Check(t, is.DeepEqual(128+int(v.signal.(syscall.Signal)), code))
} else {
- assert.Equal(t, 99, code)
+ assert.Check(t, is.Equal(99, code))
}
continue
}
@@ -66,17 +66,17 @@ func TestTrap(t *testing.T) {
func TestDumpStacks(t *testing.T) {
directory, err := ioutil.TempDir("", "test-dump-tasks")
- assert.NoError(t, err)
+ assert.Check(t, err)
defer os.RemoveAll(directory)
dumpPath, err := DumpStacks(directory)
- assert.NoError(t, err)
+ assert.Check(t, err)
readFile, _ := ioutil.ReadFile(dumpPath)
fileData := string(readFile)
- assert.Contains(t, fileData, "goroutine")
+ assert.Check(t, is.Contains(fileData, "goroutine"))
}
func TestDumpStacksWithEmptyInput(t *testing.T) {
path, err := DumpStacks("")
- assert.NoError(t, err)
- assert.Equal(t, os.Stderr.Name(), path)
+ assert.Check(t, err)
+ assert.Check(t, is.Equal(os.Stderr.Name(), path))
}
diff --git a/pkg/streamformatter/streamformatter_test.go b/pkg/streamformatter/streamformatter_test.go
index 7259c54df8..e655f9140a 100644
--- a/pkg/streamformatter/streamformatter_test.go
+++ b/pkg/streamformatter/streamformatter_test.go
@@ -8,14 +8,14 @@ import (
"testing"
"github.com/docker/docker/pkg/jsonmessage"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestRawProgressFormatterFormatStatus(t *testing.T) {
sf := rawProgressFormatter{}
res := sf.formatStatus("ID", "%s%d", "a", 1)
- assert.Equal(t, "a1\r\n", string(res))
+ assert.Check(t, is.Equal("a1\r\n", string(res)))
}
func TestRawProgressFormatterFormatProgress(t *testing.T) {
@@ -27,28 +27,28 @@ func TestRawProgressFormatterFormatProgress(t *testing.T) {
}
res := sf.formatProgress("id", "action", jsonProgress, nil)
out := string(res)
- assert.True(t, strings.HasPrefix(out, "action [===="))
- assert.Contains(t, out, "15B/30B")
- assert.True(t, strings.HasSuffix(out, "\r"))
+ assert.Check(t, strings.HasPrefix(out, "action [===="))
+ assert.Check(t, is.Contains(out, "15B/30B"))
+ assert.Check(t, strings.HasSuffix(out, "\r"))
}
func TestFormatStatus(t *testing.T) {
res := FormatStatus("ID", "%s%d", "a", 1)
expected := `{"status":"a1","id":"ID"}` + streamNewline
- assert.Equal(t, expected, string(res))
+ assert.Check(t, is.Equal(expected, string(res)))
}
func TestFormatError(t *testing.T) {
res := FormatError(errors.New("Error for formatter"))
expected := `{"errorDetail":{"message":"Error for formatter"},"error":"Error for formatter"}` + "\r\n"
- assert.Equal(t, expected, string(res))
+ assert.Check(t, is.Equal(expected, string(res)))
}
func TestFormatJSONError(t *testing.T) {
err := &jsonmessage.JSONError{Code: 50, Message: "Json error"}
res := FormatError(err)
expected := `{"errorDetail":{"code":50,"message":"Json error"},"error":"Json error"}` + streamNewline
- assert.Equal(t, expected, string(res))
+ assert.Check(t, is.Equal(expected, string(res)))
}
func TestJsonProgressFormatterFormatProgress(t *testing.T) {
@@ -61,9 +61,9 @@ func TestJsonProgressFormatterFormatProgress(t *testing.T) {
res := sf.formatProgress("id", "action", jsonProgress, &AuxFormatter{Writer: &bytes.Buffer{}})
msg := &jsonmessage.JSONMessage{}
- require.NoError(t, json.Unmarshal(res, msg))
- assert.Equal(t, "id", msg.ID)
- assert.Equal(t, "action", msg.Status)
+ assert.NilError(t, json.Unmarshal(res, msg))
+ assert.Check(t, is.Equal("id", msg.ID))
+ assert.Check(t, is.Equal("action", msg.Status))
// jsonProgress will always be in the format of:
// [=========================> ] 15B/30B 412910h51m30s
@@ -81,20 +81,20 @@ func TestJsonProgressFormatterFormatProgress(t *testing.T) {
expectedProgress, expectedProgressShort, msg.ProgressMessage)
}
- assert.Equal(t, jsonProgress, msg.Progress)
+ assert.Check(t, is.DeepEqual(jsonProgress, msg.Progress))
}
func TestJsonProgressFormatterFormatStatus(t *testing.T) {
sf := jsonProgressFormatter{}
res := sf.formatStatus("ID", "%s%d", "a", 1)
- assert.Equal(t, `{"status":"a1","id":"ID"}`+streamNewline, string(res))
+ assert.Check(t, is.Equal(`{"status":"a1","id":"ID"}`+streamNewline, string(res)))
}
func TestNewJSONProgressOutput(t *testing.T) {
b := bytes.Buffer{}
b.Write(FormatStatus("id", "Downloading"))
_ = NewJSONProgressOutput(&b, false)
- assert.Equal(t, `{"status":"Downloading","id":"id"}`+streamNewline, b.String())
+ assert.Check(t, is.Equal(`{"status":"Downloading","id":"id"}`+streamNewline, b.String()))
}
func TestAuxFormatterEmit(t *testing.T) {
@@ -104,6 +104,6 @@ func TestAuxFormatterEmit(t *testing.T) {
Data string
}{"Additional data"}
err := aux.Emit(sampleAux)
- require.NoError(t, err)
- assert.Equal(t, `{"aux":{"Data":"Additional data"}}`+streamNewline, b.String())
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(`{"aux":{"Data":"Additional data"}}`+streamNewline, b.String()))
}
diff --git a/pkg/streamformatter/streamwriter_test.go b/pkg/streamformatter/streamwriter_test.go
index 332d66414f..b74d6fb2d3 100644
--- a/pkg/streamformatter/streamwriter_test.go
+++ b/pkg/streamformatter/streamwriter_test.go
@@ -4,8 +4,8 @@ import (
"bytes"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestStreamWriterStdout(t *testing.T) {
@@ -14,11 +14,11 @@ func TestStreamWriterStdout(t *testing.T) {
sw := NewStdoutWriter(buffer)
size, err := sw.Write([]byte(content))
- require.NoError(t, err)
- assert.Equal(t, len(content), size)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(content), size))
expected := `{"stream":"content"}` + streamNewline
- assert.Equal(t, expected, buffer.String())
+ assert.Check(t, is.Equal(expected, buffer.String()))
}
func TestStreamWriterStderr(t *testing.T) {
@@ -27,9 +27,9 @@ func TestStreamWriterStderr(t *testing.T) {
sw := NewStderrWriter(buffer)
size, err := sw.Write([]byte(content))
- require.NoError(t, err)
- assert.Equal(t, len(content), size)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(len(content), size))
expected := `{"stream":"\u001b[91mcontent\u001b[0m"}` + streamNewline
- assert.Equal(t, expected, buffer.String())
+ assert.Check(t, is.Equal(expected, buffer.String()))
}
diff --git a/pkg/sysinfo/sysinfo_linux_test.go b/pkg/sysinfo/sysinfo_linux_test.go
index a798bf6e85..e8a12a35c9 100644
--- a/pkg/sysinfo/sysinfo_linux_test.go
+++ b/pkg/sysinfo/sysinfo_linux_test.go
@@ -7,18 +7,18 @@ import (
"path/filepath"
"testing"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
"golang.org/x/sys/unix"
)
func TestReadProcBool(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "test-sysinfo-proc")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmpDir)
procFile := filepath.Join(tmpDir, "read-proc-bool")
err = ioutil.WriteFile(procFile, []byte("1"), 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
if !readProcBool(procFile) {
t.Fatal("expected proc bool to be true, got false")
@@ -39,7 +39,7 @@ func TestReadProcBool(t *testing.T) {
func TestCgroupEnabled(t *testing.T) {
cgroupDir, err := ioutil.TempDir("", "cgroup-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(cgroupDir)
if cgroupEnabled(cgroupDir, "test") {
@@ -47,7 +47,7 @@ func TestCgroupEnabled(t *testing.T) {
}
err = ioutil.WriteFile(path.Join(cgroupDir, "test"), []byte{}, 0644)
- require.NoError(t, err)
+ assert.NilError(t, err)
if !cgroupEnabled(cgroupDir, "test") {
t.Fatal("cgroupEnabled should be true")
@@ -56,11 +56,11 @@ func TestCgroupEnabled(t *testing.T) {
func TestNew(t *testing.T) {
sysInfo := New(false)
- require.NotNil(t, sysInfo)
+ assert.Assert(t, sysInfo != nil)
checkSysInfo(t, sysInfo)
sysInfo = New(true)
- require.NotNil(t, sysInfo)
+ assert.Assert(t, sysInfo != nil)
checkSysInfo(t, sysInfo)
}
@@ -69,10 +69,10 @@ func checkSysInfo(t *testing.T, sysInfo *SysInfo) {
if err := unix.Prctl(unix.PR_GET_SECCOMP, 0, 0, 0, 0); err != unix.EINVAL {
// Make sure the kernel has CONFIG_SECCOMP_FILTER.
if err := unix.Prctl(unix.PR_SET_SECCOMP, unix.SECCOMP_MODE_FILTER, 0, 0, 0); err != unix.EINVAL {
- require.True(t, sysInfo.Seccomp)
+ assert.Assert(t, sysInfo.Seccomp)
}
} else {
- require.False(t, sysInfo.Seccomp)
+ assert.Assert(t, !sysInfo.Seccomp)
}
}
@@ -83,7 +83,7 @@ func TestNewAppArmorEnabled(t *testing.T) {
}
sysInfo := New(true)
- require.True(t, sysInfo.AppArmor)
+ assert.Assert(t, sysInfo.AppArmor)
}
func TestNewAppArmorDisabled(t *testing.T) {
@@ -93,7 +93,7 @@ func TestNewAppArmorDisabled(t *testing.T) {
}
sysInfo := New(true)
- require.False(t, sysInfo.AppArmor)
+ assert.Assert(t, !sysInfo.AppArmor)
}
func TestNumCPU(t *testing.T) {
diff --git a/pkg/system/stat_unix_test.go b/pkg/system/stat_unix_test.go
index 12687b33c1..fd68a96656 100644
--- a/pkg/system/stat_unix_test.go
+++ b/pkg/system/stat_unix_test.go
@@ -7,7 +7,7 @@ import (
"syscall"
"testing"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// TestFromStatT tests fromStatT for a tempfile
@@ -17,10 +17,10 @@ func TestFromStatT(t *testing.T) {
stat := &syscall.Stat_t{}
err := syscall.Lstat(file, stat)
- require.NoError(t, err)
+ assert.NilError(t, err)
s, err := fromStatT(stat)
- require.NoError(t, err)
+ assert.NilError(t, err)
if stat.Mode != s.Mode() {
t.Fatal("got invalid mode")
diff --git a/pkg/tarsum/tarsum_test.go b/pkg/tarsum/tarsum_test.go
index 466eda0aec..35f08ebce9 100644
--- a/pkg/tarsum/tarsum_test.go
+++ b/pkg/tarsum/tarsum_test.go
@@ -17,8 +17,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
type testLayer struct {
@@ -225,13 +225,13 @@ func TestNewTarSumForLabel(t *testing.T) {
func TestEmptyTar(t *testing.T) {
// Test without gzip.
ts, err := emptyTarSum(false)
- require.NoError(t, err)
+ assert.NilError(t, err)
zeroBlock := make([]byte, 1024)
buf := new(bytes.Buffer)
n, err := io.Copy(buf, ts)
- require.NoError(t, err)
+ assert.NilError(t, err)
if n != int64(len(zeroBlock)) || !bytes.Equal(buf.Bytes(), zeroBlock) {
t.Fatalf("tarSum did not write the correct number of zeroed bytes: %d", n)
@@ -246,16 +246,16 @@ func TestEmptyTar(t *testing.T) {
// Test with gzip.
ts, err = emptyTarSum(true)
- require.NoError(t, err)
+ assert.NilError(t, err)
buf.Reset()
_, err = io.Copy(buf, ts)
- require.NoError(t, err)
+ assert.NilError(t, err)
bufgz := new(bytes.Buffer)
gz := gzip.NewWriter(bufgz)
n, err = io.Copy(gz, bytes.NewBuffer(zeroBlock))
- require.NoError(t, err)
+ assert.NilError(t, err)
gz.Close()
gzBytes := bufgz.Bytes()
@@ -275,7 +275,7 @@ func TestEmptyTar(t *testing.T) {
}
resultSum = ts.Sum(nil)
- assert.Equal(t, expectedSum, resultSum)
+ assert.Check(t, is.Equal(expectedSum, resultSum))
}
var (
diff --git a/pkg/term/ascii_test.go b/pkg/term/ascii_test.go
index e426de35b4..321d1b87de 100644
--- a/pkg/term/ascii_test.go
+++ b/pkg/term/ascii_test.go
@@ -3,23 +3,23 @@ package term // import "github.com/docker/docker/pkg/term"
import (
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestToBytes(t *testing.T) {
codes, err := ToBytes("ctrl-a,a")
- require.NoError(t, err)
- assert.Equal(t, []byte{1, 97}, codes)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual([]byte{1, 97}, codes))
_, err = ToBytes("shift-z")
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
codes, err = ToBytes("ctrl-@,ctrl-[,~,ctrl-o")
- require.NoError(t, err)
- assert.Equal(t, []byte{0, 27, 126, 15}, codes)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual([]byte{0, 27, 126, 15}, codes))
codes, err = ToBytes("DEL,+")
- require.NoError(t, err)
- assert.Equal(t, []byte{127, 43}, codes)
+ assert.NilError(t, err)
+ assert.Check(t, is.DeepEqual([]byte{127, 43}, codes))
}
diff --git a/pkg/term/proxy_test.go b/pkg/term/proxy_test.go
index 01be1d55be..9a53e2bc71 100644
--- a/pkg/term/proxy_test.go
+++ b/pkg/term/proxy_test.go
@@ -5,8 +5,8 @@ import (
"fmt"
"testing"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestEscapeProxyRead(t *testing.T) {
@@ -15,75 +15,75 @@ func TestEscapeProxyRead(t *testing.T) {
reader := NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf := make([]byte, len(keys))
nr, err := reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys)))
- require.Equal(t, keys, buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, len(keys), fmt.Sprintf("nr %d should be equal to the number of %d", nr, len(keys)))
+ assert.Assert(t, is.DeepEqual(keys, buf), "keys & the read buffer should be equal")
keys, _ = ToBytes("")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf = make([]byte, len(keys))
nr, err = reader.Read(buf)
- require.Error(t, err, "Should throw error when no keys are to read")
- require.EqualValues(t, nr, 0, "nr should be zero")
- assert.Len(t, keys, 0)
- assert.Len(t, buf, 0)
+ assert.Assert(t, is.ErrorContains(err, ""), "Should throw error when no keys are to read")
+ assert.Equal(t, nr, 0, "nr should be zero")
+ assert.Check(t, is.Len(keys, 0))
+ assert.Check(t, is.Len(buf, 0))
escapeKeys, _ = ToBytes("ctrl-x,ctrl-@")
keys, _ = ToBytes("DEL")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf = make([]byte, len(keys))
nr, err = reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, 1, fmt.Sprintf("nr %d should be equal to the number of 1", nr))
- require.Equal(t, keys, buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, 1, fmt.Sprintf("nr %d should be equal to the number of 1", nr))
+ assert.Assert(t, is.DeepEqual(keys, buf), "keys & the read buffer should be equal")
escapeKeys, _ = ToBytes("ctrl-c")
keys, _ = ToBytes("ctrl-c")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf = make([]byte, len(keys))
nr, err = reader.Read(buf)
- require.EqualError(t, err, "read escape sequence")
- require.EqualValues(t, nr, 0, "nr should be equal to 0")
- require.Equal(t, keys, buf, "keys & the read buffer should be equal")
+ assert.Error(t, err, "read escape sequence")
+ assert.Equal(t, nr, 0, "nr should be equal to 0")
+ assert.Assert(t, is.DeepEqual(keys, buf), "keys & the read buffer should be equal")
escapeKeys, _ = ToBytes("ctrl-c,ctrl-z")
keys, _ = ToBytes("ctrl-c,ctrl-z")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf = make([]byte, 1)
nr, err = reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, 0, "nr should be equal to 0")
- require.Equal(t, keys[0:1], buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, 0, "nr should be equal to 0")
+ assert.Assert(t, is.DeepEqual(keys[0:1], buf), "keys & the read buffer should be equal")
nr, err = reader.Read(buf)
- require.EqualError(t, err, "read escape sequence")
- require.EqualValues(t, nr, 0, "nr should be equal to 0")
- require.Equal(t, keys[1:], buf, "keys & the read buffer should be equal")
+ assert.Error(t, err, "read escape sequence")
+ assert.Equal(t, nr, 0, "nr should be equal to 0")
+ assert.Assert(t, is.DeepEqual(keys[1:], buf), "keys & the read buffer should be equal")
escapeKeys, _ = ToBytes("ctrl-c,ctrl-z")
keys, _ = ToBytes("ctrl-c,DEL,+")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf = make([]byte, 1)
nr, err = reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, 0, "nr should be equal to 0")
- require.Equal(t, keys[0:1], buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, 0, "nr should be equal to 0")
+ assert.Assert(t, is.DeepEqual(keys[0:1], buf), "keys & the read buffer should be equal")
buf = make([]byte, len(keys))
nr, err = reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys)))
- require.Equal(t, keys, buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys)))
+ assert.Assert(t, is.DeepEqual(keys, buf), "keys & the read buffer should be equal")
escapeKeys, _ = ToBytes("ctrl-c,ctrl-z")
keys, _ = ToBytes("ctrl-c,DEL")
reader = NewEscapeProxy(bytes.NewReader(keys), escapeKeys)
buf = make([]byte, 1)
nr, err = reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, 0, "nr should be equal to 0")
- require.Equal(t, keys[0:1], buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, 0, "nr should be equal to 0")
+ assert.Assert(t, is.DeepEqual(keys[0:1], buf), "keys & the read buffer should be equal")
buf = make([]byte, len(keys))
nr, err = reader.Read(buf)
- require.NoError(t, err)
- require.EqualValues(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys)))
- require.Equal(t, keys, buf, "keys & the read buffer should be equal")
+ assert.NilError(t, err)
+ assert.Equal(t, nr, len(keys), fmt.Sprintf("nr should be equal to %d", len(keys)))
+ assert.Assert(t, is.DeepEqual(keys, buf), "keys & the read buffer should be equal")
}
diff --git a/pkg/term/term_linux_test.go b/pkg/term/term_linux_test.go
index 6e42d3edd7..98d2b1a3f2 100644
--- a/pkg/term/term_linux_test.go
+++ b/pkg/term/term_linux_test.go
@@ -7,7 +7,7 @@ import (
"os"
"testing"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
// RequiresRoot skips tests that require root, unless the test.root flag has
@@ -31,85 +31,85 @@ func newTempFile() (*os.File, error) {
func TestGetWinsize(t *testing.T) {
tty, err := newTtyForTest(t)
defer tty.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
winSize, err := GetWinsize(tty.Fd())
- require.NoError(t, err)
- require.NotNil(t, winSize)
- require.NotNil(t, winSize.Height)
- require.NotNil(t, winSize.Width)
+ assert.NilError(t, err)
+ assert.Assert(t, winSize != nil)
+ assert.Assert(t, winSize.Height != nil)
+ assert.Assert(t, winSize.Width != nil)
newSize := Winsize{Width: 200, Height: 200, x: winSize.x, y: winSize.y}
err = SetWinsize(tty.Fd(), &newSize)
- require.NoError(t, err)
+ assert.NilError(t, err)
winSize, err = GetWinsize(tty.Fd())
- require.NoError(t, err)
- require.Equal(t, *winSize, newSize)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, *winSize, newSize)
}
func TestSetWinsize(t *testing.T) {
tty, err := newTtyForTest(t)
defer tty.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
winSize, err := GetWinsize(tty.Fd())
- require.NoError(t, err)
- require.NotNil(t, winSize)
+ assert.NilError(t, err)
+ assert.Assert(t, winSize != nil)
newSize := Winsize{Width: 200, Height: 200, x: winSize.x, y: winSize.y}
err = SetWinsize(tty.Fd(), &newSize)
- require.NoError(t, err)
+ assert.NilError(t, err)
winSize, err = GetWinsize(tty.Fd())
- require.NoError(t, err)
- require.Equal(t, *winSize, newSize)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, *winSize, newSize)
}
func TestGetFdInfo(t *testing.T) {
tty, err := newTtyForTest(t)
defer tty.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
inFd, isTerminal := GetFdInfo(tty)
- require.Equal(t, inFd, tty.Fd())
- require.Equal(t, isTerminal, true)
+ assert.Equal(t, inFd, tty.Fd())
+ assert.Equal(t, isTerminal, true)
tmpFile, err := newTempFile()
- require.NoError(t, err)
+ assert.NilError(t, err)
defer tmpFile.Close()
inFd, isTerminal = GetFdInfo(tmpFile)
- require.Equal(t, inFd, tmpFile.Fd())
- require.Equal(t, isTerminal, false)
+ assert.Equal(t, inFd, tmpFile.Fd())
+ assert.Equal(t, isTerminal, false)
}
func TestIsTerminal(t *testing.T) {
tty, err := newTtyForTest(t)
defer tty.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
isTerminal := IsTerminal(tty.Fd())
- require.Equal(t, isTerminal, true)
+ assert.Equal(t, isTerminal, true)
tmpFile, err := newTempFile()
- require.NoError(t, err)
+ assert.NilError(t, err)
defer tmpFile.Close()
isTerminal = IsTerminal(tmpFile.Fd())
- require.Equal(t, isTerminal, false)
+ assert.Equal(t, isTerminal, false)
}
func TestSaveState(t *testing.T) {
tty, err := newTtyForTest(t)
defer tty.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
state, err := SaveState(tty.Fd())
- require.NoError(t, err)
- require.NotNil(t, state)
+ assert.NilError(t, err)
+ assert.Assert(t, state != nil)
tty, err = newTtyForTest(t)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer tty.Close()
err = RestoreTerminal(tty.Fd(), state)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestDisableEcho(t *testing.T) {
tty, err := newTtyForTest(t)
defer tty.Close()
- require.NoError(t, err)
+ assert.NilError(t, err)
state, err := SetRawTerminal(tty.Fd())
defer RestoreTerminal(tty.Fd(), state)
- require.NoError(t, err)
- require.NotNil(t, state)
+ assert.NilError(t, err)
+ assert.Assert(t, state != nil)
err = DisableEcho(tty.Fd(), state)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
diff --git a/reference/store_test.go b/reference/store_test.go
index e423f5db2e..24c0597a3e 100644
--- a/reference/store_test.go
+++ b/reference/store_test.go
@@ -9,9 +9,9 @@ import (
"testing"
"github.com/docker/distribution/reference"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
digest "github.com/opencontainers/go-digest"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
)
var (
@@ -64,10 +64,10 @@ func TestLoad(t *testing.T) {
func TestSave(t *testing.T) {
jsonFile, err := ioutil.TempFile("", "tag-store-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
_, err = jsonFile.Write([]byte(`{}`))
- require.NoError(t, err)
+ assert.NilError(t, err)
jsonFile.Close()
defer os.RemoveAll(jsonFile.Name())
@@ -328,23 +328,23 @@ func TestAddDeleteGet(t *testing.T) {
func TestInvalidTags(t *testing.T) {
tmpDir, err := ioutil.TempDir("", "tag-store-test")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(tmpDir)
store, err := NewReferenceStore(filepath.Join(tmpDir, "repositories.json"))
- require.NoError(t, err)
+ assert.NilError(t, err)
id := digest.Digest("sha256:470022b8af682154f57a2163d030eb369549549cba00edc69e1b99b46bb924d6")
// sha256 as repo name
ref, err := reference.ParseNormalizedNamed("sha256:abc")
- require.NoError(t, err)
+ assert.NilError(t, err)
err = store.AddTag(ref, id, true)
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
// setting digest as a tag
ref, err = reference.ParseNormalizedNamed("registry@sha256:367eb40fd0330a7e464777121e39d2f5b3e8e23a1e159342e53ab05c9e4d94e6")
- require.NoError(t, err)
+ assert.NilError(t, err)
err = store.AddTag(ref, id, true)
- assert.Error(t, err)
+ assert.Check(t, is.ErrorContains(err, ""))
}
diff --git a/registry/config_test.go b/registry/config_test.go
index 61b1c26d35..4df9cdb948 100644
--- a/registry/config_test.go
+++ b/registry/config_test.go
@@ -6,7 +6,8 @@ import (
"strings"
"testing"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestLoadAllowNondistributableArtifacts(t *testing.T) {
@@ -311,9 +312,9 @@ func TestNewServiceConfig(t *testing.T) {
for _, testCase := range testCases {
_, err := newServiceConfig(testCase.opts)
if testCase.errStr != "" {
- assert.EqualError(t, err, testCase.errStr)
+ assert.Check(t, is.Error(err, testCase.errStr))
} else {
- assert.Nil(t, err)
+ assert.Check(t, err)
}
}
}
@@ -347,8 +348,8 @@ func TestValidateIndexName(t *testing.T) {
for _, testCase := range valid {
result, err := ValidateIndexName(testCase.index)
- if assert.NoError(t, err) {
- assert.Equal(t, testCase.expect, result)
+ if assert.Check(t, err) {
+ assert.Check(t, is.Equal(testCase.expect, result))
}
}
@@ -375,6 +376,6 @@ func TestValidateIndexNameWithError(t *testing.T) {
}
for _, testCase := range invalid {
_, err := ValidateIndexName(testCase.index)
- assert.EqualError(t, err, testCase.err)
+ assert.Check(t, is.Error(err, testCase.err))
}
}
diff --git a/registry/registry_test.go b/registry/registry_test.go
index 6375301469..b4420d558c 100644
--- a/registry/registry_test.go
+++ b/registry/registry_test.go
@@ -12,7 +12,7 @@ import (
"github.com/docker/distribution/registry/client/transport"
"github.com/docker/docker/api/types"
registrytypes "github.com/docker/docker/api/types/registry"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
)
var (
@@ -757,12 +757,12 @@ func TestSearchRepositories(t *testing.T) {
func TestTrustedLocation(t *testing.T) {
for _, url := range []string{"http://example.com", "https://example.com:7777", "http://docker.io", "http://test.docker.com", "https://fakedocker.com"} {
req, _ := http.NewRequest("GET", url, nil)
- assert.False(t, trustedLocation(req))
+ assert.Check(t, !trustedLocation(req))
}
for _, url := range []string{"https://docker.io", "https://test.docker.com:80"} {
req, _ := http.NewRequest("GET", url, nil)
- assert.True(t, trustedLocation(req))
+ assert.Check(t, trustedLocation(req))
}
}
diff --git a/registry/resumable/resumablerequestreader_test.go b/registry/resumable/resumablerequestreader_test.go
index 9a08e3416e..bd3d55885f 100644
--- a/registry/resumable/resumablerequestreader_test.go
+++ b/registry/resumable/resumablerequestreader_test.go
@@ -10,8 +10,8 @@ import (
"testing"
"time"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestResumableRequestHeaderSimpleErrors(t *testing.T) {
@@ -24,11 +24,11 @@ func TestResumableRequestHeaderSimpleErrors(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", ts.URL, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
resreq := &requestReader{}
_, err = resreq.Read([]byte{})
- assert.EqualError(t, err, "client and request can't be nil")
+ assert.Check(t, is.Error(err, "client and request can't be nil"))
resreq = &requestReader{
client: client,
@@ -36,7 +36,7 @@ func TestResumableRequestHeaderSimpleErrors(t *testing.T) {
totalSize: -1,
}
_, err = resreq.Read([]byte{})
- assert.EqualError(t, err, "failed to auto detect content length")
+ assert.Check(t, is.Error(err, "failed to auto detect content length"))
}
// Not too much failures, bails out after some wait
@@ -45,7 +45,7 @@ func TestResumableRequestHeaderNotTooMuchFailures(t *testing.T) {
var badReq *http.Request
badReq, err := http.NewRequest("GET", "I'm not an url", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
resreq := &requestReader{
client: client,
@@ -55,8 +55,8 @@ func TestResumableRequestHeaderNotTooMuchFailures(t *testing.T) {
waitDuration: 10 * time.Millisecond,
}
read, err := resreq.Read([]byte{})
- require.NoError(t, err)
- assert.Equal(t, 0, read)
+ assert.NilError(t, err)
+ assert.Check(t, is.Equal(0, read))
}
// Too much failures, returns the error
@@ -65,7 +65,7 @@ func TestResumableRequestHeaderTooMuchFailures(t *testing.T) {
var badReq *http.Request
badReq, err := http.NewRequest("GET", "I'm not an url", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
resreq := &requestReader{
client: client,
@@ -77,8 +77,8 @@ func TestResumableRequestHeaderTooMuchFailures(t *testing.T) {
expectedError := `Get I%27m%20not%20an%20url: unsupported protocol scheme ""`
read, err := resreq.Read([]byte{})
- assert.EqualError(t, err, expectedError)
- assert.Equal(t, 0, read)
+ assert.Check(t, is.Error(err, expectedError))
+ assert.Check(t, is.Equal(0, read))
}
type errorReaderCloser struct{}
@@ -93,7 +93,7 @@ func (errorReaderCloser) Read(p []byte) (n int, err error) {
func TestResumableRequestReaderWithReadError(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", "", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &http.Client{}
@@ -116,15 +116,15 @@ func TestResumableRequestReaderWithReadError(t *testing.T) {
buf := make([]byte, 1)
read, err := resreq.Read(buf)
- require.NoError(t, err)
+ assert.NilError(t, err)
- assert.Equal(t, 0, read)
+ assert.Check(t, is.Equal(0, read))
}
func TestResumableRequestReaderWithEOFWith416Response(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", "", nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &http.Client{}
@@ -147,7 +147,7 @@ func TestResumableRequestReaderWithEOFWith416Response(t *testing.T) {
buf := make([]byte, 1)
_, err = resreq.Read(buf)
- assert.EqualError(t, err, io.EOF.Error())
+ assert.Check(t, is.Error(err, io.EOF.Error()))
}
func TestResumableRequestReaderWithServerDoesntSupportByteRanges(t *testing.T) {
@@ -160,7 +160,7 @@ func TestResumableRequestReaderWithServerDoesntSupportByteRanges(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", ts.URL, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &http.Client{}
@@ -173,7 +173,7 @@ func TestResumableRequestReaderWithServerDoesntSupportByteRanges(t *testing.T) {
buf := make([]byte, 2)
_, err = resreq.Read(buf)
- assert.EqualError(t, err, "the server doesn't support byte ranges")
+ assert.Check(t, is.Error(err, "the server doesn't support byte ranges"))
}
func TestResumableRequestReaderWithZeroTotalSize(t *testing.T) {
@@ -186,7 +186,7 @@ func TestResumableRequestReaderWithZeroTotalSize(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", ts.URL, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &http.Client{}
retries := uint32(5)
@@ -195,10 +195,10 @@ func TestResumableRequestReaderWithZeroTotalSize(t *testing.T) {
defer resreq.Close()
data, err := ioutil.ReadAll(resreq)
- require.NoError(t, err)
+ assert.NilError(t, err)
resstr := strings.TrimSuffix(string(data), "\n")
- assert.Equal(t, srvtxt, resstr)
+ assert.Check(t, is.Equal(srvtxt, resstr))
}
func TestResumableRequestReader(t *testing.T) {
@@ -211,7 +211,7 @@ func TestResumableRequestReader(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", ts.URL, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &http.Client{}
retries := uint32(5)
@@ -221,10 +221,10 @@ func TestResumableRequestReader(t *testing.T) {
defer resreq.Close()
data, err := ioutil.ReadAll(resreq)
- require.NoError(t, err)
+ assert.NilError(t, err)
resstr := strings.TrimSuffix(string(data), "\n")
- assert.Equal(t, srvtxt, resstr)
+ assert.Check(t, is.Equal(srvtxt, resstr))
}
func TestResumableRequestReaderWithInitialResponse(t *testing.T) {
@@ -237,21 +237,21 @@ func TestResumableRequestReaderWithInitialResponse(t *testing.T) {
var req *http.Request
req, err := http.NewRequest("GET", ts.URL, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
client := &http.Client{}
retries := uint32(5)
imgSize := int64(len(srvtxt))
res, err := client.Do(req)
- require.NoError(t, err)
+ assert.NilError(t, err)
resreq := NewRequestReaderWithInitialResponse(client, req, retries, imgSize, res)
defer resreq.Close()
data, err := ioutil.ReadAll(resreq)
- require.NoError(t, err)
+ assert.NilError(t, err)
resstr := strings.TrimSuffix(string(data), "\n")
- assert.Equal(t, srvtxt, resstr)
+ assert.Check(t, is.Equal(srvtxt, resstr))
}
diff --git a/runconfig/config_test.go b/runconfig/config_test.go
index 63619fe53f..58e3a9f788 100644
--- a/runconfig/config_test.go
+++ b/runconfig/config_test.go
@@ -12,8 +12,8 @@ import (
"github.com/docker/docker/api/types/container"
networktypes "github.com/docker/docker/api/types/network"
"github.com/docker/docker/api/types/strslice"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
type f struct {
@@ -149,21 +149,21 @@ func runDecodeContainerConfigTestCase(testcase decodeConfigTestcase) func(t *tes
raw := marshal(t, testcase.wrapper, testcase.doc)
config, hostConfig, _, err := decodeContainerConfig(bytes.NewReader(raw))
if testcase.expectedErr != "" {
- if !assert.Error(t, err) {
+ if !assert.Check(t, is.ErrorContains(err, "")) {
return
}
- assert.Contains(t, err.Error(), testcase.expectedErr)
+ assert.Check(t, is.Contains(err.Error(), testcase.expectedErr))
return
}
- assert.NoError(t, err)
- assert.Equal(t, testcase.expectedConfig, config)
- assert.Equal(t, testcase.expectedHostConfig, hostConfig)
+ assert.Check(t, err)
+ assert.Check(t, is.DeepEqual(testcase.expectedConfig, config))
+ assert.Check(t, is.DeepEqual(testcase.expectedHostConfig, hostConfig))
}
}
func marshal(t *testing.T, w ContainerConfigWrapper, doc string) []byte {
b, err := json.Marshal(w)
- require.NoError(t, err, "%s: failed to encode config wrapper", doc)
+ assert.NilError(t, err, "%s: failed to encode config wrapper", doc)
return b
}
diff --git a/runconfig/hostconfig_test.go b/runconfig/hostconfig_test.go
index 48d902d4d7..d2482fbe7b 100644
--- a/runconfig/hostconfig_test.go
+++ b/runconfig/hostconfig_test.go
@@ -10,7 +10,8 @@ import (
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/pkg/sysinfo"
- "github.com/stretchr/testify/assert"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
// TODO Windows: This will need addressing for a Windows daemon.
@@ -83,12 +84,12 @@ func TestIpcModeTest(t *testing.T) {
}
for ipcMode, state := range ipcModes {
- assert.Equal(t, state.private, ipcMode.IsPrivate(), "IpcMode.IsPrivate() parsing failed for %q", ipcMode)
- assert.Equal(t, state.host, ipcMode.IsHost(), "IpcMode.IsHost() parsing failed for %q", ipcMode)
- assert.Equal(t, state.container, ipcMode.IsContainer(), "IpcMode.IsContainer() parsing failed for %q", ipcMode)
- assert.Equal(t, state.shareable, ipcMode.IsShareable(), "IpcMode.IsShareable() parsing failed for %q", ipcMode)
- assert.Equal(t, state.valid, ipcMode.Valid(), "IpcMode.Valid() parsing failed for %q", ipcMode)
- assert.Equal(t, state.ctrName, ipcMode.Container(), "IpcMode.Container() parsing failed for %q", ipcMode)
+ assert.Check(t, is.Equal(state.private, ipcMode.IsPrivate()), "IpcMode.IsPrivate() parsing failed for %q", ipcMode)
+ assert.Check(t, is.Equal(state.host, ipcMode.IsHost()), "IpcMode.IsHost() parsing failed for %q", ipcMode)
+ assert.Check(t, is.Equal(state.container, ipcMode.IsContainer()), "IpcMode.IsContainer() parsing failed for %q", ipcMode)
+ assert.Check(t, is.Equal(state.shareable, ipcMode.IsShareable()), "IpcMode.IsShareable() parsing failed for %q", ipcMode)
+ assert.Check(t, is.Equal(state.valid, ipcMode.Valid()), "IpcMode.Valid() parsing failed for %q", ipcMode)
+ assert.Check(t, is.Equal(state.ctrName, ipcMode.Container()), "IpcMode.Container() parsing failed for %q", ipcMode)
}
}
@@ -195,7 +196,7 @@ func TestDecodeHostConfig(t *testing.T) {
t.Fatal(fmt.Errorf("Error parsing %s: %v", f, err))
}
- assert.False(t, c.Privileged)
+ assert.Check(t, !c.Privileged)
if l := len(c.Binds); l != 1 {
t.Fatalf("Expected 1 bind, found %d\n", l)
diff --git a/volume/store/db_test.go b/volume/store/db_test.go
index 9c45cd13ba..0a2727e749 100644
--- a/volume/store/db_test.go
+++ b/volume/store/db_test.go
@@ -8,33 +8,34 @@ import (
"time"
"github.com/boltdb/bolt"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestSetGetMeta(t *testing.T) {
t.Parallel()
dir, err := ioutil.TempDir("", "test-set-get")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dir)
db, err := bolt.Open(filepath.Join(dir, "db"), 0600, &bolt.Options{Timeout: 1 * time.Second})
- require.NoError(t, err)
+ assert.NilError(t, err)
store := &VolumeStore{db: db}
_, err = store.getMeta("test")
- require.Error(t, err)
+ assert.Assert(t, is.ErrorContains(err, ""))
err = db.Update(func(tx *bolt.Tx) error {
_, err := tx.CreateBucket(volumeBucketName)
return err
})
- require.NoError(t, err)
+ assert.NilError(t, err)
meta, err := store.getMeta("test")
- require.NoError(t, err)
- require.Equal(t, volumeMetadata{}, meta)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, volumeMetadata{}, meta)
testMeta := volumeMetadata{
Name: "test",
@@ -43,9 +44,9 @@ func TestSetGetMeta(t *testing.T) {
Options: map[string]string{"foo": "bar"},
}
err = store.setMeta("test", testMeta)
- require.NoError(t, err)
+ assert.NilError(t, err)
meta, err = store.getMeta("test")
- require.NoError(t, err)
- require.Equal(t, testMeta, meta)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, testMeta, meta)
}
diff --git a/volume/store/restore_test.go b/volume/store/restore_test.go
index 83efd36b63..680735a384 100644
--- a/volume/store/restore_test.go
+++ b/volume/store/restore_test.go
@@ -8,14 +8,14 @@ import (
"github.com/docker/docker/volume"
volumedrivers "github.com/docker/docker/volume/drivers"
volumetestutils "github.com/docker/docker/volume/testutils"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
)
func TestRestore(t *testing.T) {
t.Parallel()
dir, err := ioutil.TempDir("", "test-restore")
- require.NoError(t, err)
+ assert.NilError(t, err)
defer os.RemoveAll(dir)
driverName := "test-restore"
@@ -23,33 +23,33 @@ func TestRestore(t *testing.T) {
defer volumedrivers.Unregister("test-restore")
s, err := New(dir)
- require.NoError(t, err)
+ assert.NilError(t, err)
defer s.Shutdown()
_, err = s.Create("test1", driverName, nil, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
testLabels := map[string]string{"a": "1"}
testOpts := map[string]string{"foo": "bar"}
_, err = s.Create("test2", driverName, testOpts, testLabels)
- require.NoError(t, err)
+ assert.NilError(t, err)
s.Shutdown()
s, err = New(dir)
- require.NoError(t, err)
+ assert.NilError(t, err)
v, err := s.Get("test1")
- require.NoError(t, err)
+ assert.NilError(t, err)
dv := v.(volume.DetailedVolume)
var nilMap map[string]string
- require.Equal(t, nilMap, dv.Options())
- require.Equal(t, nilMap, dv.Labels())
+ assert.DeepEqual(t, nilMap, dv.Options())
+ assert.DeepEqual(t, nilMap, dv.Labels())
v, err = s.Get("test2")
- require.NoError(t, err)
+ assert.NilError(t, err)
dv = v.(volume.DetailedVolume)
- require.Equal(t, testOpts, dv.Options())
- require.Equal(t, testLabels, dv.Labels())
+ assert.DeepEqual(t, testOpts, dv.Options())
+ assert.DeepEqual(t, testLabels, dv.Labels())
}
diff --git a/volume/store/store_test.go b/volume/store/store_test.go
index e53c728dd0..c6d31364ac 100644
--- a/volume/store/store_test.go
+++ b/volume/store/store_test.go
@@ -12,8 +12,8 @@ import (
"github.com/docker/docker/volume"
"github.com/docker/docker/volume/drivers"
volumetestutils "github.com/docker/docker/volume/testutils"
- "github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/require"
+ "github.com/gotestyourself/gotestyourself/assert"
+ is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestCreate(t *testing.T) {
@@ -332,15 +332,15 @@ func TestRefDerefRemove(t *testing.T) {
defer cleanup(t)
v, err := s.CreateWithRef("test", driverName, "test-ref", nil, nil)
- require.NoError(t, err)
+ assert.NilError(t, err)
err = s.Remove(v)
- require.Error(t, err)
- require.Equal(t, errVolumeInUse, err.(*OpErr).Err)
+ assert.Assert(t, is.ErrorContains(err, ""))
+ assert.Equal(t, errVolumeInUse, err.(*OpErr).Err)
s.Dereference(v, "test-ref")
err = s.Remove(v)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestGet(t *testing.T) {
@@ -351,21 +351,21 @@ func TestGet(t *testing.T) {
defer cleanup(t)
_, err := s.Get("not-exist")
- require.Error(t, err)
- require.Equal(t, errNoSuchVolume, err.(*OpErr).Err)
+ assert.Assert(t, is.ErrorContains(err, ""))
+ assert.Equal(t, errNoSuchVolume, err.(*OpErr).Err)
v1, err := s.Create("test", driverName, nil, map[string]string{"a": "1"})
- require.NoError(t, err)
+ assert.NilError(t, err)
v2, err := s.Get("test")
- require.NoError(t, err)
- require.Equal(t, v1, v2)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, v1, v2)
dv := v2.(volume.DetailedVolume)
- require.Equal(t, "1", dv.Labels()["a"])
+ assert.Equal(t, "1", dv.Labels()["a"])
err = s.Remove(v1)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func TestGetWithRef(t *testing.T) {
@@ -376,22 +376,22 @@ func TestGetWithRef(t *testing.T) {
defer cleanup(t)
_, err := s.GetWithRef("not-exist", driverName, "test-ref")
- require.Error(t, err)
+ assert.Assert(t, is.ErrorContains(err, ""))
v1, err := s.Create("test", driverName, nil, map[string]string{"a": "1"})
- require.NoError(t, err)
+ assert.NilError(t, err)
v2, err := s.GetWithRef("test", driverName, "test-ref")
- require.NoError(t, err)
- require.Equal(t, v1, v2)
+ assert.NilError(t, err)
+ assert.DeepEqual(t, v1, v2)
err = s.Remove(v2)
- require.Error(t, err)
- require.Equal(t, errVolumeInUse, err.(*OpErr).Err)
+ assert.Assert(t, is.ErrorContains(err, ""))
+ assert.Equal(t, errVolumeInUse, err.(*OpErr).Err)
s.Dereference(v2, "test-ref")
err = s.Remove(v2)
- require.NoError(t, err)
+ assert.NilError(t, err)
}
func setupTest(t *testing.T, name string) (*VolumeStore, func(*testing.T)) {
@@ -409,15 +409,15 @@ func newTestStore(t *testing.T) (*VolumeStore, func(*testing.T)) {
t.Helper()
dir, err := ioutil.TempDir("", "store-root")
- require.NoError(t, err)
+ assert.NilError(t, err)
cleanup := func(t *testing.T) {
err := os.RemoveAll(dir)
- assert.NoError(t, err)
+ assert.Check(t, err)
}
s, err := New(dir)
- assert.NoError(t, err)
+ assert.Check(t, err)
return s, func(t *testing.T) {
s.Shutdown()
cleanup(t)