diff options
183 files changed, 2257 insertions, 2203 deletions
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.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.NilError(t, err) + assert.Assert(t, loadedConfig != nil) + + 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.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.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.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.NilError(t, err) + + 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.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.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) |