diff --git a/builder/dockerfile/buildargs_test.go b/builder/dockerfile/buildargs_test.go index 03df19b2a1a2c27c69ae16b750ec170877e336d1..625a02b1549831972893706fc981cb468aea33c0 100644 --- a/builder/dockerfile/buildargs_test.go +++ b/builder/dockerfile/buildargs_test.go @@ -1,8 +1,9 @@ package dockerfile import ( - "github.com/docker/docker/pkg/testutil/assert" "testing" + + "github.com/stretchr/testify/assert" ) func strPtr(source string) *string { @@ -37,7 +38,7 @@ func TestGetAllAllowed(t *testing.T) { "ArgFromMeta": "frommeta1", "ArgFromMetaOverriden": "fromdockerfile3", } - assert.DeepEqual(t, all, expected) + assert.Equal(t, expected, all) } func TestGetAllMeta(t *testing.T) { @@ -59,5 +60,5 @@ func TestGetAllMeta(t *testing.T) { "ArgOverriddenByOptions": "fromopt2", "ArgNoDefaultInMetaFromOptions": "fromopt3", } - assert.DeepEqual(t, all, expected) + assert.Equal(t, expected, all) } diff --git a/builder/dockerfile/builder_test.go b/builder/dockerfile/builder_test.go index 5c2fc326febb1f4a730e35f862da7ef76d411b42..5fedca0fdd14b52e6aae77aac1f96eddf451f4ec 100644 --- a/builder/dockerfile/builder_test.go +++ b/builder/dockerfile/builder_test.go @@ -5,13 +5,13 @@ import ( "testing" "github.com/docker/docker/builder/dockerfile/parser" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestAddNodesForLabelOption(t *testing.T) { dockerfile := "FROM scratch" result, err := parser.Parse(strings.NewReader(dockerfile)) - assert.NilError(t, err) + assert.NoError(t, err) labels := map[string]string{ "org.e": "cli-e", @@ -27,8 +27,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.Equal(t, len(nodes.Children), 2) + assert.Len(t, nodes.Children, 2) for i, v := range nodes.Children { - assert.Equal(t, v.Original, expected[i]) + assert.Equal(t, expected[i], v.Original) } } diff --git a/builder/dockerfile/dispatchers_test.go b/builder/dockerfile/dispatchers_test.go index 644b6108254911220232d2c58ac41ef164fba94d..a504540e3d773ae6dd0f042a55c3b885a49a9139 100644 --- a/builder/dockerfile/dispatchers_test.go +++ b/builder/dockerfile/dispatchers_test.go @@ -10,8 +10,8 @@ import ( "github.com/docker/docker/api/types/container" "github.com/docker/docker/api/types/strslice" "github.com/docker/docker/builder" - "github.com/docker/docker/pkg/testutil/assert" "github.com/docker/go-connections/nat" + "github.com/stretchr/testify/assert" ) type commandWithFunction struct { @@ -137,13 +137,13 @@ func TestEnv2Variables(t *testing.T) { args := []string{"var1", "val1", "var2", "val2"} err := env(b, args, nil, "") - assert.NilError(t, err) + assert.NoError(t, err) expected := []string{ fmt.Sprintf("%s=%s", args[0], args[1]), fmt.Sprintf("%s=%s", args[2], args[3]), } - assert.DeepEqual(t, b.runConfig.Env, expected) + assert.Equal(t, expected, b.runConfig.Env) } func TestEnvValueWithExistingRunConfigEnv(t *testing.T) { @@ -153,13 +153,13 @@ func TestEnvValueWithExistingRunConfigEnv(t *testing.T) { args := []string{"var1", "val1"} err := env(b, args, nil, "") - assert.NilError(t, err) + assert.NoError(t, err) expected := []string{ fmt.Sprintf("%s=%s", args[0], args[1]), "var2=fromenv", } - assert.DeepEqual(t, b.runConfig.Env, expected) + assert.Equal(t, expected, b.runConfig.Env) } func TestMaintainer(t *testing.T) { @@ -215,40 +215,40 @@ func TestFromScratch(t *testing.T) { err := from(b, []string{"scratch"}, nil, "") if runtime.GOOS == "windows" { - assert.Error(t, err, "Windows does not support FROM scratch") + assert.EqualError(t, err, "Windows does not support FROM scratch") return } - assert.NilError(t, err) - assert.Equal(t, b.image, "") - assert.Equal(t, b.noBaseImage, true) + assert.NoError(t, err) + assert.Equal(t, "", b.image) + assert.Equal(t, true, b.noBaseImage) } func TestFromWithArg(t *testing.T) { tag, expected := ":sometag", "expectedthisid" getImage := func(name string) (builder.Image, error) { - assert.Equal(t, name, "alpine"+tag) + assert.Equal(t, "alpine"+tag, name) return &mockImage{id: "expectedthisid"}, nil } b := newBuilderWithMockBackend() b.docker.(*MockBackend).getImageOnBuildFunc = getImage - assert.NilError(t, arg(b, []string{"THETAG=" + tag}, nil, "")) + assert.NoError(t, arg(b, []string{"THETAG=" + tag}, nil, "")) err := from(b, []string{"alpine${THETAG}"}, nil, "") - assert.NilError(t, err) - assert.Equal(t, b.image, expected) - assert.Equal(t, b.from.ImageID(), expected) - assert.Equal(t, len(b.buildArgs.GetAllAllowed()), 0) - assert.Equal(t, len(b.buildArgs.GetAllMeta()), 1) + assert.NoError(t, err) + assert.Equal(t, expected, b.image) + assert.Equal(t, expected, b.from.ImageID()) + assert.Len(t, b.buildArgs.GetAllAllowed(), 0) + assert.Len(t, b.buildArgs.GetAllMeta(), 1) } func TestFromWithUndefinedArg(t *testing.T) { tag, expected := "sometag", "expectedthisid" getImage := func(name string) (builder.Image, error) { - assert.Equal(t, name, "alpine") + assert.Equal(t, "alpine", name) return &mockImage{id: "expectedthisid"}, nil } b := newBuilderWithMockBackend() @@ -256,8 +256,8 @@ func TestFromWithUndefinedArg(t *testing.T) { b.options.BuildArgs = map[string]*string{"THETAG": &tag} err := from(b, []string{"alpine${THETAG}"}, nil, "") - assert.NilError(t, err) - assert.Equal(t, b.image, expected) + assert.NoError(t, err) + assert.Equal(t, expected, b.image) } func TestOnbuildIllegalTriggers(t *testing.T) { @@ -508,11 +508,11 @@ func TestArg(t *testing.T) { argDef := fmt.Sprintf("%s=%s", argName, argVal) err := arg(b, []string{argDef}, nil, "") - assert.NilError(t, err) + assert.NoError(t, err) expected := map[string]string{argName: argVal} allowed := b.buildArgs.GetAllAllowed() - assert.DeepEqual(t, allowed, expected) + assert.Equal(t, expected, allowed) } func TestShell(t *testing.T) { diff --git a/builder/dockerfile/internals_test.go b/builder/dockerfile/internals_test.go index 1bffecfa750a59ae2e1016f0728e3f2fccefb354..b97940146708c2fc46d0739f5249e034f48c862c 100644 --- a/builder/dockerfile/internals_test.go +++ b/builder/dockerfile/internals_test.go @@ -7,7 +7,8 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/builder" "github.com/docker/docker/pkg/archive" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestEmptyDockerfile(t *testing.T) { @@ -38,7 +39,7 @@ func TestDockerfileOutsideTheBuildContext(t *testing.T) { contextDir, cleanup := createTestTempDir(t, "", "builder-dockerfile-test") defer cleanup() - expectedError := "Forbidden path outside the build context" + expectedError := "Forbidden path outside the build context: ../../Dockerfile ()" readAndCheckDockerfile(t, "DockerfileOutsideTheBuildContext", contextDir, "../../Dockerfile", expectedError) } @@ -54,7 +55,7 @@ func TestNonExistingDockerfile(t *testing.T) { func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath, expectedError string) { tarStream, err := archive.Tar(contextDir, archive.Uncompressed) - assert.NilError(t, err) + require.NoError(t, err) defer func() { if err = tarStream.Close(); err != nil { @@ -63,7 +64,7 @@ func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath, }() context, err := builder.MakeTarSumContext(tarStream) - assert.NilError(t, err) + require.NoError(t, err) defer func() { if err = context.Close(); err != nil { @@ -78,5 +79,5 @@ func readAndCheckDockerfile(t *testing.T, testName, contextDir, dockerfilePath, b := &Builder{options: options, context: context} _, err = b.readAndParseDockerfile() - assert.Error(t, err, expectedError) + assert.EqualError(t, err, expectedError) } diff --git a/builder/dockerfile/parser/line_parsers_test.go b/builder/dockerfile/parser/line_parsers_test.go index 30b6bdd8249a9de9017447421189df20e8b364b8..cd6d57af3a9008741647f73440c29e260edbd16a 100644 --- a/builder/dockerfile/parser/line_parsers_test.go +++ b/builder/dockerfile/parser/line_parsers_test.go @@ -1,26 +1,27 @@ package parser import ( - "github.com/docker/docker/pkg/testutil/assert" "testing" + + "github.com/stretchr/testify/assert" ) func TestParseNameValOldFormat(t *testing.T) { directive := Directive{} node, err := parseNameVal("foo bar", "LABEL", &directive) - assert.NilError(t, err) + assert.NoError(t, err) expected := &Node{ Value: "foo", Next: &Node{Value: "bar"}, } - assert.DeepEqual(t, node, expected) + assert.Equal(t, expected, node) } func TestParseNameValNewFormat(t *testing.T) { directive := Directive{} node, err := parseNameVal("foo=bar thing=star", "LABEL", &directive) - assert.NilError(t, err) + assert.NoError(t, err) expected := &Node{ Value: "foo", @@ -34,7 +35,7 @@ func TestParseNameValNewFormat(t *testing.T) { }, }, } - assert.DeepEqual(t, node, expected) + assert.Equal(t, expected, node) } func TestNodeFromLabels(t *testing.T) { @@ -60,6 +61,6 @@ func TestNodeFromLabels(t *testing.T) { } node := NodeFromLabels(labels) - assert.DeepEqual(t, node, expected) + assert.Equal(t, expected, node) } diff --git a/builder/dockerfile/parser/parser_test.go b/builder/dockerfile/parser/parser_test.go index 7f273002c734fecb1d5ea441cff99998dce3035d..99b614ba9f7960343481a6e7f8e1b60c85e22b0a 100644 --- a/builder/dockerfile/parser/parser_test.go +++ b/builder/dockerfile/parser/parser_test.go @@ -9,7 +9,8 @@ import ( "runtime" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) const testDir = "testfiles" @@ -18,11 +19,11 @@ const testFileLineInfo = "testfile-line/Dockerfile" func getDirs(t *testing.T, dir string) []string { f, err := os.Open(dir) - assert.NilError(t, err) + require.NoError(t, err) defer f.Close() dirs, err := f.Readdirnames(0) - assert.NilError(t, err) + require.NoError(t, err) return dirs } @@ -31,11 +32,11 @@ func TestTestNegative(t *testing.T) { dockerfile := filepath.Join(negativeTestDir, dir, "Dockerfile") df, err := os.Open(dockerfile) - assert.NilError(t, err) + require.NoError(t, err) defer df.Close() _, err = Parse(df) - assert.Error(t, err, "") + assert.Error(t, err) } } @@ -45,21 +46,21 @@ func TestTestData(t *testing.T) { resultfile := filepath.Join(testDir, dir, "result") df, err := os.Open(dockerfile) - assert.NilError(t, err) + require.NoError(t, err) defer df.Close() result, err := Parse(df) - assert.NilError(t, err) + require.NoError(t, err) content, err := ioutil.ReadFile(resultfile) - assert.NilError(t, err) + require.NoError(t, err) 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.Contains(t, result.AST.Dump()+"\n", string(content), "In "+dockerfile) } } @@ -101,24 +102,24 @@ func TestParseWords(t *testing.T) { for _, test := range tests { words := parseWords(test["input"][0], NewDefaultDirective()) - assert.DeepEqual(t, words, test["expect"]) + assert.Equal(t, test["expect"], words) } } func TestLineInformation(t *testing.T) { df, err := os.Open(testFileLineInfo) - assert.NilError(t, err) + require.NoError(t, err) defer df.Close() result, err := Parse(df) - assert.NilError(t, err) + require.NoError(t, err) ast := result.AST if ast.StartLine != 5 || ast.endLine != 31 { fmt.Fprintf(os.Stderr, "Wrong root line information: expected(%d-%d), actual(%d-%d)\n", 5, 31, ast.StartLine, ast.endLine) t.Fatal("Root line information doesn't match result.") } - assert.Equal(t, len(ast.Children), 3) + assert.Len(t, ast.Children, 3) expected := [][]int{ {5, 5}, {11, 12}, diff --git a/builder/dockerfile/shell_parser_test.go b/builder/dockerfile/shell_parser_test.go index 67e3e2e2fd1c837732079da854d9112a3dd44e32..da4125488b16eaff6b12cad812d703b3e7ade1b7 100644 --- a/builder/dockerfile/shell_parser_test.go +++ b/builder/dockerfile/shell_parser_test.go @@ -7,7 +7,7 @@ import ( "strings" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestShellParser4EnvVars(t *testing.T) { @@ -15,7 +15,7 @@ func TestShellParser4EnvVars(t *testing.T) { lineCount := 0 file, err := os.Open(fn) - assert.NilError(t, err) + assert.NoError(t, err) defer file.Close() scanner := bufio.NewScanner(file) @@ -36,7 +36,7 @@ func TestShellParser4EnvVars(t *testing.T) { } words := strings.Split(line, "|") - assert.Equal(t, len(words), 3) + assert.Len(t, words, 3) platform := strings.TrimSpace(words[0]) source := strings.TrimSpace(words[1]) @@ -51,9 +51,9 @@ func TestShellParser4EnvVars(t *testing.T) { ((platform == "U" || platform == "A") && runtime.GOOS != "windows") { newWord, err := ProcessWord(source, envs, '\\') if expected == "error" { - assert.Error(t, err, "") + assert.Error(t, err) } else { - assert.NilError(t, err) + assert.NoError(t, err) assert.Equal(t, newWord, expected) } } diff --git a/cli/command/bundlefile/bundlefile_test.go b/cli/command/bundlefile/bundlefile_test.go index c343410df304d38145a6a92b1297e73578a2dd16..bd059c4dca9188c396065abcdcbbfb7166f7e847 100644 --- a/cli/command/bundlefile/bundlefile_test.go +++ b/cli/command/bundlefile/bundlefile_test.go @@ -5,7 +5,7 @@ import ( "strings" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestLoadFileV01Success(t *testing.T) { @@ -25,9 +25,9 @@ func TestLoadFileV01Success(t *testing.T) { }`) bundle, err := LoadFile(reader) - assert.NilError(t, err) - assert.Equal(t, bundle.Version, "0.1") - assert.Equal(t, len(bundle.Services), 2) + assert.NoError(t, err) + assert.Equal(t, "0.1", bundle.Version) + assert.Len(t, bundle.Services, 2) } func TestLoadFileSyntaxError(t *testing.T) { @@ -37,7 +37,7 @@ func TestLoadFileSyntaxError(t *testing.T) { }`) _, err := LoadFile(reader) - assert.Error(t, err, "syntax error at byte 37: invalid character 'u'") + assert.EqualError(t, err, "JSON syntax error at byte 37: invalid character 'u' looking for beginning of value") } func TestLoadFileTypeError(t *testing.T) { @@ -52,7 +52,7 @@ func TestLoadFileTypeError(t *testing.T) { }`) _, err := LoadFile(reader) - assert.Error(t, err, "Unexpected type at byte 94. Expected []string but received string") + assert.EqualError(t, err, "Unexpected type at byte 94. Expected []string but received string.") } func TestPrint(t *testing.T) { @@ -66,7 +66,7 @@ func TestPrint(t *testing.T) { }, }, } - assert.NilError(t, Print(&buffer, bundle)) + assert.NoError(t, Print(&buffer, bundle)) output := buffer.String() assert.Contains(t, output, "\"Image\": \"image\"") assert.Contains(t, output, diff --git a/cli/command/container/opts_test.go b/cli/command/container/opts_test.go index 575b214edc5f96d9fc6bb014752e1f6c85e45e4b..2d0049768a3d54e916044779234bb998b8639637 100644 --- a/cli/command/container/opts_test.go +++ b/cli/command/container/opts_test.go @@ -13,11 +13,12 @@ import ( "github.com/docker/docker/api/types/container" networktypes "github.com/docker/docker/api/types/network" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/runconfig" "github.com/docker/go-connections/nat" "github.com/pkg/errors" "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" ) func TestValidateAttach(t *testing.T) { @@ -243,23 +244,23 @@ func TestParseWithMacAddress(t *testing.T) { func TestParseWithMemory(t *testing.T) { invalidMemory := "--memory=invalid" _, _, _, err := parseRun([]string{invalidMemory, "img", "cmd"}) - assert.Error(t, err, invalidMemory) + testutil.ErrorContains(t, err, invalidMemory) _, hostconfig := mustParse(t, "--memory=1G") - assert.Equal(t, hostconfig.Memory, int64(1073741824)) + assert.Equal(t, int64(1073741824), hostconfig.Memory) } func TestParseWithMemorySwap(t *testing.T) { invalidMemory := "--memory-swap=invalid" _, _, _, err := parseRun([]string{invalidMemory, "img", "cmd"}) - assert.Error(t, err, invalidMemory) + testutil.ErrorContains(t, err, invalidMemory) _, hostconfig := mustParse(t, "--memory-swap=1G") - assert.Equal(t, hostconfig.MemorySwap, int64(1073741824)) + assert.Equal(t, int64(1073741824), hostconfig.MemorySwap) _, hostconfig = mustParse(t, "--memory-swap=-1") - assert.Equal(t, hostconfig.MemorySwap, int64(-1)) + assert.Equal(t, int64(-1), hostconfig.MemorySwap) } func TestParseHostname(t *testing.T) { diff --git a/cli/command/container/ps_test.go b/cli/command/container/ps_test.go index 62b054527478a09901e5421b304afb8400fe33a9..47665b0e2ca63aa90aef321944d9605f92b619e2 100644 --- a/cli/command/container/ps_test.go +++ b/cli/command/container/ps_test.go @@ -4,13 +4,13 @@ import ( "testing" "github.com/docker/docker/opts" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestBuildContainerListOptions(t *testing.T) { filters := opts.NewFilterOpt() - assert.NilError(t, filters.Set("foo=bar")) - assert.NilError(t, filters.Set("baz=foo")) + assert.NoError(t, filters.Set("foo=bar")) + assert.NoError(t, filters.Set("baz=foo")) contexts := []struct { psOpts *psOptions @@ -101,12 +101,12 @@ func TestBuildContainerListOptions(t *testing.T) { for _, c := range contexts { options, err := buildContainerListOptions(c.psOpts) - assert.NilError(t, err) + assert.NoError(t, err) assert.Equal(t, c.expectedAll, options.All) assert.Equal(t, c.expectedSize, options.Size) assert.Equal(t, c.expectedLimit, options.Limit) - assert.Equal(t, options.Filters.Len(), len(c.expectedFilters)) + assert.Equal(t, len(c.expectedFilters), options.Filters.Len()) for k, v := range c.expectedFilters { f := options.Filters diff --git a/cli/command/formatter/container_test.go b/cli/command/formatter/container_test.go index a5615d176844392d4554d5b61a5474fcba5c5a26..8d23cc781ce68b619d1dc02d67769359d39549ca 100644 --- a/cli/command/formatter/container_test.go +++ b/cli/command/formatter/container_test.go @@ -10,7 +10,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestContainerPsContext(t *testing.T) { @@ -245,9 +245,9 @@ conta "ubuntu" 24 hours ago//.FOOBAR_BAR testcase.context.Output = out err := ContainerWrite(testcase.context, containers) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -334,7 +334,7 @@ func TestContainerContextWriteJSON(t *testing.T) { if err := json.Unmarshal([]byte(line), &m); err != nil { t.Fatal(err) } - assert.DeepEqual(t, m, expectedJSONs[i]) + assert.Equal(t, expectedJSONs[i], m) } } @@ -354,7 +354,7 @@ func TestContainerContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, containers[i].ID) + assert.Equal(t, containers[i].ID, s) } } diff --git a/cli/command/formatter/diff_test.go b/cli/command/formatter/diff_test.go index 52080354f5137839f019e51aa938ef3078973e5d..1aa7b53056a35fca93ef82a449fa01498ed4ff2b 100644 --- a/cli/command/formatter/diff_test.go +++ b/cli/command/formatter/diff_test.go @@ -6,7 +6,7 @@ import ( "github.com/docker/docker/api/types/container" "github.com/docker/docker/pkg/archive" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestDiffContextFormatWrite(t *testing.T) { @@ -51,9 +51,9 @@ D: /usr/app/old_app.js testcase.context.Output = out err := DiffWrite(testcase.context, diffs) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } diff --git a/cli/command/formatter/disk_usage_test.go b/cli/command/formatter/disk_usage_test.go index 7093cfe85a7cc87c7700f9ce15a4ce85b2b6f3cd..302eb2c8f76728c6a2f81da21d48eed5701b5ccc 100644 --- a/cli/command/formatter/disk_usage_test.go +++ b/cli/command/formatter/disk_usage_test.go @@ -4,7 +4,7 @@ import ( "bytes" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestDiskUsageContextFormatWrite(t *testing.T) { @@ -117,9 +117,9 @@ reclaimable: 0B out := bytes.NewBufferString("") testcase.context.Output = out if err := testcase.context.Write(); err != nil { - assert.Equal(t, err.Error(), testcase.expected) + assert.Equal(t, testcase.expected, err.Error()) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } diff --git a/cli/command/formatter/image_test.go b/cli/command/formatter/image_test.go index e7c15dbf5a950ef9698b4a13bf0ede73e0260758..b3c4cc8094b974895e2d4af179909b476641de26 100644 --- a/cli/command/formatter/image_test.go +++ b/cli/command/formatter/image_test.go @@ -9,7 +9,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestImageContext(t *testing.T) { @@ -265,9 +265,9 @@ image_id: imageID3 testcase.context.Output = out err := ImageWrite(testcase.context, images) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -320,7 +320,7 @@ func TestImageContextWriteWithNoImage(t *testing.T) { for _, context := range contexts { ImageWrite(context.context, images) - assert.Equal(t, out.String(), context.expected) + assert.Equal(t, context.expected, out.String()) // Clean buffer out.Reset() } diff --git a/cli/command/formatter/network_test.go b/cli/command/formatter/network_test.go index 24bf46d256597a872e2d353b965141201e4a7dc1..b8cab078e7faa8f10c41d24bb270bccaa85a41f7 100644 --- a/cli/command/formatter/network_test.go +++ b/cli/command/formatter/network_test.go @@ -9,7 +9,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestNetworkContext(t *testing.T) { @@ -160,9 +160,9 @@ foobar_bar 2017-01-01 00:00:00 +0000 UTC testcase.context.Output = out err := NetworkWrite(testcase.context, networks) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -188,7 +188,7 @@ func TestNetworkContextWriteJSON(t *testing.T) { if err := json.Unmarshal([]byte(line), &m); err != nil { t.Fatal(err) } - assert.DeepEqual(t, m, expectedJSONs[i]) + assert.Equal(t, expectedJSONs[i], m) } } @@ -208,6 +208,6 @@ func TestNetworkContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, networks[i].ID) + assert.Equal(t, networks[i].ID, s) } } diff --git a/cli/command/formatter/node_test.go b/cli/command/formatter/node_test.go index 86f4979d3f1ef39a430539da8c96e1d372b3049a..ea2f4ce4d5e4ef4afc9464cd66a561a6ffb35bf9 100644 --- a/cli/command/formatter/node_test.go +++ b/cli/command/formatter/node_test.go @@ -9,7 +9,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestNodeContext(t *testing.T) { @@ -135,9 +135,9 @@ foobar_bar testcase.context.Output = out err := NodeWrite(testcase.context, nodes, types.Info{}) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -163,7 +163,7 @@ func TestNodeContextWriteJSON(t *testing.T) { if err := json.Unmarshal([]byte(line), &m); err != nil { t.Fatal(err) } - assert.DeepEqual(t, m, expectedJSONs[i]) + assert.Equal(t, expectedJSONs[i], m) } } @@ -183,6 +183,6 @@ func TestNodeContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, nodes[i].ID) + assert.Equal(t, nodes[i].ID, s) } } diff --git a/cli/command/formatter/plugin_test.go b/cli/command/formatter/plugin_test.go index 3cc0af8a3ef8ffd9d678b23d2342f322b800b26b..607262dcc9003d41efad197328d8e9167e6d03f3 100644 --- a/cli/command/formatter/plugin_test.go +++ b/cli/command/formatter/plugin_test.go @@ -8,7 +8,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestPluginContext(t *testing.T) { @@ -131,9 +131,9 @@ foobar_bar testcase.context.Output = out err := PluginWrite(testcase.context, plugins) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -158,7 +158,7 @@ func TestPluginContextWriteJSON(t *testing.T) { if err := json.Unmarshal([]byte(line), &m); err != nil { t.Fatal(err) } - assert.DeepEqual(t, m, expectedJSONs[i]) + assert.Equal(t, expectedJSONs[i], m) } } @@ -177,6 +177,6 @@ func TestPluginContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, plugins[i].ID) + assert.Equal(t, plugins[i].ID, s) } } diff --git a/cli/command/formatter/secret_test.go b/cli/command/formatter/secret_test.go index 722b6505656b749d6269d5314630a2743477e251..98fe61315f49cd67999a83a90f176de5fd2e17b8 100644 --- a/cli/command/formatter/secret_test.go +++ b/cli/command/formatter/secret_test.go @@ -6,7 +6,7 @@ import ( "time" "github.com/docker/docker/api/types/swarm" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestSecretContextFormatWrite(t *testing.T) { @@ -55,9 +55,9 @@ id_rsa out := bytes.NewBufferString("") testcase.context.Output = out if err := SecretWrite(testcase.context, secrets); err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } diff --git a/cli/command/formatter/service_test.go b/cli/command/formatter/service_test.go index 93ffc92a3b2d6006cc3ff3aeb9bb7edc16e55f6b..629f853930add277cfb6b7f19718528e65dd661d 100644 --- a/cli/command/formatter/service_test.go +++ b/cli/command/formatter/service_test.go @@ -7,7 +7,7 @@ import ( "testing" "github.com/docker/docker/api/types/swarm" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestServiceContextWrite(t *testing.T) { @@ -137,9 +137,9 @@ bar testcase.context.Output = out err := ServiceListWrite(testcase.context, services, info) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -205,7 +205,7 @@ func TestServiceContextWriteJSON(t *testing.T) { if err := json.Unmarshal([]byte(line), &m); err != nil { t.Fatal(err) } - assert.DeepEqual(t, m, expectedJSONs[i]) + assert.Equal(t, expectedJSONs[i], m) } } func TestServiceContextWriteJSONField(t *testing.T) { @@ -234,6 +234,6 @@ func TestServiceContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, services[i].Spec.Name) + assert.Equal(t, services[i].Spec.Name, s) } } diff --git a/cli/command/formatter/stats_test.go b/cli/command/formatter/stats_test.go index 5d6a91e7c9fc50466a386fb0481bbb76e32da464..078e8db32adf003541ba7a7b9db905740060ea88 100644 --- a/cli/command/formatter/stats_test.go +++ b/cli/command/formatter/stats_test.go @@ -5,7 +5,7 @@ import ( "testing" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestContainerStatsContext(t *testing.T) { @@ -116,9 +116,9 @@ container2 -- te.context.Output = &out err := ContainerStatsWrite(te.context, stats, "linux") if err != nil { - assert.Error(t, err, te.expected) + assert.EqualError(t, err, te.expected) } else { - assert.Equal(t, out.String(), te.expected) + assert.Equal(t, te.expected, out.String()) } } } @@ -182,9 +182,9 @@ container2 -- -- te.context.Output = &out err := ContainerStatsWrite(te.context, stats, "windows") if err != nil { - assert.Error(t, err, te.expected) + assert.EqualError(t, err, te.expected) } else { - assert.Equal(t, out.String(), te.expected) + assert.Equal(t, te.expected, out.String()) } } } @@ -259,7 +259,7 @@ func TestContainerStatsContextWriteWithNoStatsWindows(t *testing.T) { for _, context := range contexts { ContainerStatsWrite(context.context, []StatsEntry{}, "windows") - assert.Equal(t, out.String(), context.expected) + assert.Equal(t, context.expected, out.String()) // Clean buffer out.Reset() } diff --git a/cli/command/formatter/task_test.go b/cli/command/formatter/task_test.go index 8de9d66f57cdea78960e9b8e1b74d49a39d79a7a..d2843c70d42d34293230f7e8cabe0ef9c4c1a747 100644 --- a/cli/command/formatter/task_test.go +++ b/cli/command/formatter/task_test.go @@ -7,7 +7,7 @@ import ( "testing" "github.com/docker/docker/api/types/swarm" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestTaskContextWrite(t *testing.T) { @@ -76,9 +76,9 @@ foobar_bar foo2 testcase.context.Output = out err := TaskWrite(testcase.context, tasks, names, nodes) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -102,6 +102,6 @@ func TestTaskContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, tasks[i].ID) + assert.Equal(t, tasks[i].ID, s) } } diff --git a/cli/command/formatter/volume_test.go b/cli/command/formatter/volume_test.go index 9c23ae447d20a7d14d95ce3d5ce3676d50e270d7..bf1100893f5d642901bc630e945f9f916d0d433d 100644 --- a/cli/command/formatter/volume_test.go +++ b/cli/command/formatter/volume_test.go @@ -8,7 +8,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/pkg/stringid" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestVolumeContext(t *testing.T) { @@ -131,9 +131,9 @@ foobar_bar testcase.context.Output = out err := VolumeWrite(testcase.context, volumes) if err != nil { - assert.Error(t, err, testcase.expected) + assert.EqualError(t, err, testcase.expected) } else { - assert.Equal(t, out.String(), testcase.expected) + assert.Equal(t, testcase.expected, out.String()) } } } @@ -158,7 +158,7 @@ func TestVolumeContextWriteJSON(t *testing.T) { if err := json.Unmarshal([]byte(line), &m); err != nil { t.Fatal(err) } - assert.DeepEqual(t, m, expectedJSONs[i]) + assert.Equal(t, expectedJSONs[i], m) } } @@ -178,6 +178,6 @@ func TestVolumeContextWriteJSONField(t *testing.T) { if err := json.Unmarshal([]byte(line), &s); err != nil { t.Fatal(err) } - assert.Equal(t, s, volumes[i].Name) + assert.Equal(t, volumes[i].Name, s) } } diff --git a/cli/command/idresolver/idresolver_test.go b/cli/command/idresolver/idresolver_test.go index 720667daa19b0d69482f27ed12a45f2f2a30be47..1aca09ce96b627be679a8b8769c4f03d88b292e4 100644 --- a/cli/command/idresolver/idresolver_test.go +++ b/cli/command/idresolver/idresolver_test.go @@ -6,8 +6,8 @@ import ( "github.com/docker/docker/api/types/swarm" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" "golang.org/x/net/context" ) @@ -21,7 +21,7 @@ func TestResolveError(t *testing.T) { idResolver := New(cli, false) _, err := idResolver.Resolve(context.Background(), struct{}{}, "nodeID") - assert.Error(t, err, "unsupported type") + assert.EqualError(t, err, "unsupported type") } func TestResolveWithNoResolveOption(t *testing.T) { @@ -40,9 +40,9 @@ func TestResolveWithNoResolveOption(t *testing.T) { idResolver := New(cli, true) id, err := idResolver.Resolve(context.Background(), swarm.Node{}, "nodeID") - assert.NilError(t, err) - assert.Equal(t, id, "nodeID") - assert.Equal(t, resolved, false) + assert.NoError(t, err) + assert.Equal(t, "nodeID", id) + assert.False(t, resolved) } func TestResolveWithCache(t *testing.T) { @@ -59,11 +59,11 @@ func TestResolveWithCache(t *testing.T) { ctx := context.Background() for i := 0; i < 2; i++ { id, err := idResolver.Resolve(ctx, swarm.Node{}, "nodeID") - assert.NilError(t, err) - assert.Equal(t, id, "node-foo") + assert.NoError(t, err) + assert.Equal(t, "node-foo", id) } - assert.Equal(t, inspectCounter, 1) + assert.Equal(t, 1, inspectCounter) } func TestResolveNode(t *testing.T) { @@ -103,8 +103,8 @@ func TestResolveNode(t *testing.T) { idResolver := New(cli, false) id, err := idResolver.Resolve(ctx, swarm.Node{}, tc.nodeID) - assert.NilError(t, err) - assert.Equal(t, id, tc.expectedID) + assert.NoError(t, err) + assert.Equal(t, tc.expectedID, id) } } @@ -138,7 +138,7 @@ func TestResolveService(t *testing.T) { idResolver := New(cli, false) id, err := idResolver.Resolve(ctx, swarm.Service{}, tc.serviceID) - assert.NilError(t, err) - assert.Equal(t, id, tc.expectedID) + assert.NoError(t, err) + assert.Equal(t, tc.expectedID, id) } } diff --git a/cli/command/node/demote_test.go b/cli/command/node/demote_test.go index 710455ff56dec73020cd1703644f28e81e0d5234..803b9c229beb9de643bf5cc8ff7ef0c82a101635 100644 --- a/cli/command/node/demote_test.go +++ b/cli/command/node/demote_test.go @@ -10,7 +10,8 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/assert" ) func TestNodeDemoteErrors(t *testing.T) { @@ -47,7 +48,7 @@ func TestNodeDemoteErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -66,7 +67,7 @@ func TestNodeDemoteNoChange(t *testing.T) { }, }, buf)) cmd.SetArgs([]string{"nodeID"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } func TestNodeDemoteMultipleNode(t *testing.T) { @@ -84,5 +85,5 @@ func TestNodeDemoteMultipleNode(t *testing.T) { }, }, buf)) cmd.SetArgs([]string{"nodeID1", "nodeID2"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } diff --git a/cli/command/node/inspect_test.go b/cli/command/node/inspect_test.go index 9b6a04f11a05f4941291a5e198e30405b65ca376..95b45d51e9c8842bc7687bd005630907b05e7ed8 100644 --- a/cli/command/node/inspect_test.go +++ b/cli/command/node/inspect_test.go @@ -12,8 +12,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestNodeInspectErrors(t *testing.T) { @@ -77,7 +78,7 @@ func TestNodeInspectErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -115,9 +116,9 @@ func TestNodeInspectPretty(t *testing.T) { }, buf)) cmd.SetArgs([]string{"nodeID"}) cmd.Flags().Set("pretty", "true") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("node-inspect-pretty.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/node/list_test.go b/cli/command/node/list_test.go index 4b8d906c3ac7c11e43aa6aafdba1ae83b7f13693..af2d6be15633adfe91afcf50e39b2d7643454949 100644 --- a/cli/command/node/list_test.go +++ b/cli/command/node/list_test.go @@ -12,7 +12,7 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestNodeListErrorOnAPIFailure(t *testing.T) { @@ -50,7 +50,7 @@ func TestNodeListErrorOnAPIFailure(t *testing.T) { cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newListCommand(cli) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + assert.EqualError(t, cmd.Execute(), tc.expectedError) } } @@ -74,7 +74,7 @@ func TestNodeList(t *testing.T) { }, buf) cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newListCommand(cli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Contains(t, buf.String(), `nodeID1 * nodeHostname1 Ready Active Leader`) assert.Contains(t, buf.String(), `nodeID2 nodeHostname2 Ready Active Reachable`) assert.Contains(t, buf.String(), `nodeID3 nodeHostname3 Ready Active`) @@ -92,7 +92,7 @@ func TestNodeListQuietShouldOnlyPrintIDs(t *testing.T) { cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newListCommand(cli) cmd.Flags().Set("quiet", "true") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Contains(t, buf.String(), "nodeID") } @@ -102,7 +102,7 @@ func TestNodeListContainsHostname(t *testing.T) { cli := test.NewFakeCli(&fakeClient{}, buf) cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newListCommand(cli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Contains(t, buf.String(), "HOSTNAME") } @@ -128,7 +128,7 @@ func TestNodeListDefaultFormat(t *testing.T) { NodesFormat: "{{.ID}}: {{.Hostname}} {{.Status}}/{{.ManagerStatus}}", }) cmd := newListCommand(cli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Contains(t, buf.String(), `nodeID1: nodeHostname1 Ready/Leader`) assert.Contains(t, buf.String(), `nodeID2: nodeHostname2 Ready/Reachable`) assert.Contains(t, buf.String(), `nodeID3: nodeHostname3 Ready`) @@ -156,7 +156,7 @@ func TestNodeListFormat(t *testing.T) { }) cmd := newListCommand(cli) cmd.Flags().Set("format", "{{.Hostname}}: {{.ManagerStatus}}") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Contains(t, buf.String(), `nodeHostname1: Leader`) assert.Contains(t, buf.String(), `nodeHostname2: Reachable`) } diff --git a/cli/command/node/promote_test.go b/cli/command/node/promote_test.go index 9b646724d1afdb5434269eb566fe91cf434bd33d..ce2fb13dcafe460bf5d6c96c32048f621e7e8d03 100644 --- a/cli/command/node/promote_test.go +++ b/cli/command/node/promote_test.go @@ -10,7 +10,8 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/assert" ) func TestNodePromoteErrors(t *testing.T) { @@ -47,7 +48,7 @@ func TestNodePromoteErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -66,7 +67,7 @@ func TestNodePromoteNoChange(t *testing.T) { }, }, buf)) cmd.SetArgs([]string{"nodeID"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } func TestNodePromoteMultipleNode(t *testing.T) { @@ -84,5 +85,5 @@ func TestNodePromoteMultipleNode(t *testing.T) { }, }, buf)) cmd.SetArgs([]string{"nodeID1", "nodeID2"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } diff --git a/cli/command/node/ps_test.go b/cli/command/node/ps_test.go index de6ff7d5789cd1c35c2a5704ea6cd5ba3ca05dda..f604628991591a146faf78f202c70681920cc890 100644 --- a/cli/command/node/ps_test.go +++ b/cli/command/node/ps_test.go @@ -13,8 +13,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestNodePsErrors(t *testing.T) { @@ -62,7 +63,7 @@ func TestNodePsErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + assert.EqualError(t, cmd.Execute(), tc.expectedError) } } @@ -125,9 +126,9 @@ func TestNodePs(t *testing.T) { for key, value := range tc.flags { cmd.Flags().Set(key, value) } - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("node-ps.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/node/remove_test.go b/cli/command/node/remove_test.go index d7e742aa4c8890275d8ce544ac756181fea7d1e5..b53431dfa7bccf191f38a21f00d21a9a1801703f 100644 --- a/cli/command/node/remove_test.go +++ b/cli/command/node/remove_test.go @@ -6,8 +6,9 @@ import ( "testing" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestNodeRemoveErrors(t *testing.T) { @@ -35,7 +36,7 @@ func TestNodeRemoveErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -43,5 +44,5 @@ func TestNodeRemoveMultiple(t *testing.T) { buf := new(bytes.Buffer) cmd := newRemoveCommand(test.NewFakeCli(&fakeClient{}, buf)) cmd.SetArgs([]string{"nodeID1", "nodeID2"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } diff --git a/cli/command/node/update_test.go b/cli/command/node/update_test.go index 493a386270b44ad56fd6216fdc7e61bfd6952479..a5e2d20e9a06c26d8a051d6a0ca7ed956ac0d354 100644 --- a/cli/command/node/update_test.go +++ b/cli/command/node/update_test.go @@ -10,7 +10,8 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/assert" ) func TestNodeUpdateErrors(t *testing.T) { @@ -67,7 +68,7 @@ func TestNodeUpdateErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -167,6 +168,6 @@ func TestNodeUpdate(t *testing.T) { for key, value := range tc.flags { cmd.Flags().Set(key, value) } - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } } diff --git a/cli/command/secret/create_test.go b/cli/command/secret/create_test.go index cbdfd633383ad6d5f0fe98a6ee877c96e87222c1..0e9c1cd4af5f06b3e478718b1d0c7623c4f1b3e5 100644 --- a/cli/command/secret/create_test.go +++ b/cli/command/secret/create_test.go @@ -10,9 +10,10 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) const secretDataFile = "secret-create-with-name.golden" @@ -47,7 +48,7 @@ func TestSecretCreateErrors(t *testing.T) { ) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -71,10 +72,10 @@ func TestSecretCreateWithName(t *testing.T) { cmd := newSecretCreateCommand(cli) cmd.SetArgs([]string{name, filepath.Join("testdata", secretDataFile)}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) expected := golden.Get(t, actual, secretDataFile) - assert.Equal(t, string(actual), string(expected)) - assert.Equal(t, strings.TrimSpace(buf.String()), "ID-"+name) + assert.Equal(t, expected, actual) + assert.Equal(t, "ID-"+name, strings.TrimSpace(buf.String())) } func TestSecretCreateWithLabels(t *testing.T) { @@ -105,8 +106,8 @@ func TestSecretCreateWithLabels(t *testing.T) { cmd.SetArgs([]string{name, filepath.Join("testdata", secretDataFile)}) cmd.Flags().Set("label", "lbl1=Label-foo") cmd.Flags().Set("label", "lbl2=Label-bar") - assert.NilError(t, cmd.Execute()) - assert.Equal(t, strings.TrimSpace(buf.String()), "ID-"+name) + assert.NoError(t, cmd.Execute()) + assert.Equal(t, "ID-"+name, strings.TrimSpace(buf.String())) } func compareMap(actual map[string]string, expected map[string]string) bool { diff --git a/cli/command/secret/inspect_test.go b/cli/command/secret/inspect_test.go index 558e23d7c729c49b89ff125a472245be6a2b1892..52b9a1cef0371b4945129f886dc36339eb623ac6 100644 --- a/cli/command/secret/inspect_test.go +++ b/cli/command/secret/inspect_test.go @@ -11,8 +11,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestSecretInspectErrors(t *testing.T) { @@ -62,7 +63,7 @@ func TestSecretInspectErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -100,10 +101,10 @@ func TestSecretInspectWithoutFormat(t *testing.T) { }, buf), ) cmd.SetArgs(tc.args) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("secret-inspect-without-format.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } @@ -141,9 +142,9 @@ func TestSecretInspectWithFormat(t *testing.T) { ) cmd.SetArgs(tc.args) cmd.Flags().Set("format", tc.format) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("secret-inspect-with-format.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/secret/ls_test.go b/cli/command/secret/ls_test.go index d9a4324b75d0714c9f6bc2779adc4a74f39c9eef..cb0510adffe54c46e1c9df29729f6a268cad34b8 100644 --- a/cli/command/secret/ls_test.go +++ b/cli/command/secret/ls_test.go @@ -13,8 +13,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestSecretListErrors(t *testing.T) { @@ -43,7 +44,7 @@ func TestSecretListErrors(t *testing.T) { ) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -70,10 +71,10 @@ func TestSecretList(t *testing.T) { cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newSecretListCommand(cli) cmd.SetOutput(buf) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "secret-list.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } func TestSecretListWithQuietOption(t *testing.T) { @@ -91,10 +92,10 @@ func TestSecretListWithQuietOption(t *testing.T) { cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newSecretListCommand(cli) cmd.Flags().Set("quiet", "true") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "secret-list-with-quiet-option.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } func TestSecretListWithConfigFormat(t *testing.T) { @@ -113,10 +114,10 @@ func TestSecretListWithConfigFormat(t *testing.T) { SecretFormat: "{{ .Name }} {{ .Labels }}", }) cmd := newSecretListCommand(cli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "secret-list-with-config-format.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } func TestSecretListWithFormat(t *testing.T) { @@ -133,18 +134,18 @@ func TestSecretListWithFormat(t *testing.T) { }, buf) cmd := newSecretListCommand(cli) cmd.Flags().Set("format", "{{ .Name }} {{ .Labels }}") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "secret-list-with-format.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } func TestSecretListWithFilter(t *testing.T) { buf := new(bytes.Buffer) cli := test.NewFakeCli(&fakeClient{ secretListFunc: func(options types.SecretListOptions) ([]swarm.Secret, error) { - assert.Equal(t, options.Filters.Get("name")[0], "foo") - assert.Equal(t, options.Filters.Get("label")[0], "lbl1=Label-bar") + assert.Equal(t, "foo", options.Filters.Get("name")[0], "foo") + assert.Equal(t, "lbl1=Label-bar", options.Filters.Get("label")[0]) return []swarm.Secret{ *Secret(SecretID("ID-foo"), SecretName("foo"), @@ -165,8 +166,8 @@ func TestSecretListWithFilter(t *testing.T) { cmd := newSecretListCommand(cli) cmd.Flags().Set("filter", "name=foo") cmd.Flags().Set("filter", "label=lbl1=Label-bar") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "secret-list-with-filter.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } diff --git a/cli/command/secret/remove_test.go b/cli/command/secret/remove_test.go index 92ca9b9b9d116661434812a9cae7b8efbb0eea4b..b8bbb5e6f5caedc09818e40410661b785c3ddd3b 100644 --- a/cli/command/secret/remove_test.go +++ b/cli/command/secret/remove_test.go @@ -7,8 +7,9 @@ import ( "testing" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestSecretRemoveErrors(t *testing.T) { @@ -38,7 +39,7 @@ func TestSecretRemoveErrors(t *testing.T) { ) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -54,9 +55,9 @@ func TestSecretRemoveWithName(t *testing.T) { }, buf) cmd := newSecretRemoveCommand(cli) cmd.SetArgs(names) - assert.NilError(t, cmd.Execute()) - assert.EqualStringSlice(t, strings.Split(strings.TrimSpace(buf.String()), "\n"), names) - assert.EqualStringSlice(t, removedSecrets, names) + assert.NoError(t, cmd.Execute()) + assert.Equal(t, names, strings.Split(strings.TrimSpace(buf.String()), "\n")) + assert.Equal(t, names, removedSecrets) } func TestSecretRemoveContinueAfterError(t *testing.T) { @@ -76,6 +77,6 @@ func TestSecretRemoveContinueAfterError(t *testing.T) { cmd := newSecretRemoveCommand(cli) cmd.SetArgs(names) - assert.Error(t, cmd.Execute(), "error removing secret: foo") - assert.EqualStringSlice(t, removedSecrets, names) + assert.EqualError(t, cmd.Execute(), "error removing secret: foo") + assert.Equal(t, names, removedSecrets) } diff --git a/cli/command/service/inspect_test.go b/cli/command/service/inspect_test.go index 44d9df9176f39a4287e4ff950e19734e04fbcd99..c5bda7dcd908d4bb114ed9c63c408b54d426c889 100644 --- a/cli/command/service/inspect_test.go +++ b/cli/command/service/inspect_test.go @@ -10,7 +10,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/cli/command/formatter" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func formatServiceInspect(t *testing.T, format formatter.Format, now time.Time) string { @@ -136,5 +136,5 @@ func TestJSONFormatWithNoUpdateConfig(t *testing.T) { t.Fatal(err) } t.Logf("m2=%+v", m2) - assert.DeepEqual(t, m2, m1) + assert.Equal(t, m1, m2) } diff --git a/cli/command/service/opts_test.go b/cli/command/service/opts_test.go index 46db5fc8386cfa16d1bfaa920fd8fbe32fd7493c..675fbe4b9949aec6ee5c09c67aeb173fb70714ea 100644 --- a/cli/command/service/opts_test.go +++ b/cli/command/service/opts_test.go @@ -1,71 +1,70 @@ package service import ( - "reflect" "testing" "time" "github.com/docker/docker/api/types/container" "github.com/docker/docker/opts" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestMemBytesString(t *testing.T) { var mem opts.MemBytes = 1048576 - assert.Equal(t, mem.String(), "1MiB") + assert.Equal(t, "1MiB", mem.String()) } func TestMemBytesSetAndValue(t *testing.T) { var mem opts.MemBytes - assert.NilError(t, mem.Set("5kb")) - assert.Equal(t, mem.Value(), int64(5120)) + assert.NoError(t, mem.Set("5kb")) + assert.Equal(t, int64(5120), mem.Value()) } func TestNanoCPUsString(t *testing.T) { var cpus opts.NanoCPUs = 6100000000 - assert.Equal(t, cpus.String(), "6.100") + assert.Equal(t, "6.100", cpus.String()) } func TestNanoCPUsSetAndValue(t *testing.T) { var cpus opts.NanoCPUs - assert.NilError(t, cpus.Set("0.35")) - assert.Equal(t, cpus.Value(), int64(350000000)) + assert.NoError(t, cpus.Set("0.35")) + assert.Equal(t, int64(350000000), cpus.Value()) } func TestDurationOptString(t *testing.T) { dur := time.Duration(300 * 10e8) duration := DurationOpt{value: &dur} - assert.Equal(t, duration.String(), "5m0s") + assert.Equal(t, "5m0s", duration.String()) } func TestDurationOptSetAndValue(t *testing.T) { var duration DurationOpt - assert.NilError(t, duration.Set("300s")) - assert.Equal(t, *duration.Value(), time.Duration(300*10e8)) - assert.NilError(t, duration.Set("-300s")) - assert.Equal(t, *duration.Value(), time.Duration(-300*10e8)) + assert.NoError(t, duration.Set("300s")) + assert.Equal(t, time.Duration(300*10e8), *duration.Value()) + assert.NoError(t, duration.Set("-300s")) + assert.Equal(t, time.Duration(-300*10e8), *duration.Value()) } func TestPositiveDurationOptSetAndValue(t *testing.T) { var duration PositiveDurationOpt - assert.NilError(t, duration.Set("300s")) - assert.Equal(t, *duration.Value(), time.Duration(300*10e8)) - assert.Error(t, duration.Set("-300s"), "cannot be negative") + assert.NoError(t, duration.Set("300s")) + assert.Equal(t, time.Duration(300*10e8), *duration.Value()) + assert.EqualError(t, duration.Set("-300s"), "duration cannot be negative") } func TestUint64OptString(t *testing.T) { value := uint64(2345678) opt := Uint64Opt{value: &value} - assert.Equal(t, opt.String(), "2345678") + assert.Equal(t, "2345678", opt.String()) opt = Uint64Opt{} - assert.Equal(t, opt.String(), "") + assert.Equal(t, "", opt.String()) } func TestUint64OptSetAndValue(t *testing.T) { var opt Uint64Opt - assert.NilError(t, opt.Set("14445")) - assert.Equal(t, *opt.Value(), uint64(14445)) + assert.NoError(t, opt.Set("14445")) + assert.Equal(t, uint64(14445), *opt.Value()) } func TestHealthCheckOptionsToHealthConfig(t *testing.T) { @@ -78,14 +77,14 @@ func TestHealthCheckOptionsToHealthConfig(t *testing.T) { retries: 10, } config, err := opt.toHealthConfig() - assert.NilError(t, err) - assert.Equal(t, reflect.DeepEqual(config, &container.HealthConfig{ + assert.NoError(t, err) + assert.Equal(t, &container.HealthConfig{ Test: []string{"CMD-SHELL", "curl"}, Interval: time.Second, Timeout: time.Second, StartPeriod: time.Second, Retries: 10, - }), true) + }, config) } func TestHealthCheckOptionsToHealthConfigNoHealthcheck(t *testing.T) { @@ -93,10 +92,10 @@ func TestHealthCheckOptionsToHealthConfigNoHealthcheck(t *testing.T) { noHealthcheck: true, } config, err := opt.toHealthConfig() - assert.NilError(t, err) - assert.Equal(t, reflect.DeepEqual(config, &container.HealthConfig{ + assert.NoError(t, err) + assert.Equal(t, &container.HealthConfig{ Test: []string{"NONE"}, - }), true) + }, config) } func TestHealthCheckOptionsToHealthConfigConflict(t *testing.T) { @@ -105,5 +104,5 @@ func TestHealthCheckOptionsToHealthConfigConflict(t *testing.T) { noHealthcheck: true, } _, err := opt.toHealthConfig() - assert.Error(t, err, "--no-healthcheck conflicts with --health-* options") + assert.EqualError(t, err, "--no-healthcheck conflicts with --health-* options") } diff --git a/cli/command/service/update_test.go b/cli/command/service/update_test.go index 090372fb78bef214fd9aaabbcd5eecefba1bebf0..8f49d52ab8b6e97e18fb155852fcf10895552ea6 100644 --- a/cli/command/service/update_test.go +++ b/cli/command/service/update_test.go @@ -10,7 +10,8 @@ import ( "github.com/docker/docker/api/types/container" mounttypes "github.com/docker/docker/api/types/mount" "github.com/docker/docker/api/types/swarm" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" "golang.org/x/net/context" ) @@ -23,7 +24,7 @@ func TestUpdateServiceArgs(t *testing.T) { cspec.Args = []string{"old", "args"} updateService(nil, nil, flags, spec) - assert.EqualStringSlice(t, cspec.Args, []string{"the", "new args"}) + assert.Equal(t, []string{"the", "new args"}, cspec.Args) } func TestUpdateLabels(t *testing.T) { @@ -37,9 +38,9 @@ func TestUpdateLabels(t *testing.T) { } updateLabels(flags, &labels) - assert.Equal(t, len(labels), 2) - assert.Equal(t, labels["tokeep"], "value") - assert.Equal(t, labels["toadd"], "newlabel") + assert.Len(t, labels, 2) + assert.Equal(t, "value", labels["tokeep"]) + assert.Equal(t, "newlabel", labels["toadd"]) } func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) { @@ -48,7 +49,7 @@ func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) { labels := map[string]string{"foo": "theoldlabel"} updateLabels(flags, &labels) - assert.Equal(t, len(labels), 1) + assert.Len(t, labels, 1) } func TestUpdatePlacementConstraints(t *testing.T) { @@ -61,9 +62,9 @@ func TestUpdatePlacementConstraints(t *testing.T) { } updatePlacementConstraints(flags, placement) - assert.Equal(t, len(placement.Constraints), 2) - assert.Equal(t, placement.Constraints[0], "container=tokeep") - assert.Equal(t, placement.Constraints[1], "node=toadd") + require.Len(t, placement.Constraints, 2) + assert.Equal(t, "container=tokeep", placement.Constraints[0]) + assert.Equal(t, "node=toadd", placement.Constraints[1]) } func TestUpdatePlacementPrefs(t *testing.T) { @@ -87,9 +88,9 @@ func TestUpdatePlacementPrefs(t *testing.T) { } updatePlacementPreferences(flags, placement) - assert.Equal(t, len(placement.Preferences), 2) - assert.Equal(t, placement.Preferences[0].Spread.SpreadDescriptor, "node.labels.row") - assert.Equal(t, placement.Preferences[1].Spread.SpreadDescriptor, "node.labels.dc") + require.Len(t, placement.Preferences, 2) + assert.Equal(t, "node.labels.row", placement.Preferences[0].Spread.SpreadDescriptor) + assert.Equal(t, "node.labels.dc", placement.Preferences[1].Spread.SpreadDescriptor) } func TestUpdateEnvironment(t *testing.T) { @@ -100,11 +101,11 @@ func TestUpdateEnvironment(t *testing.T) { envs := []string{"toremove=theenvtoremove", "tokeep=value"} updateEnvironment(flags, &envs) - assert.Equal(t, len(envs), 2) + require.Len(t, envs, 2) // Order has been removed in updateEnvironment (map) sort.Strings(envs) - assert.Equal(t, envs[0], "toadd=newenv") - assert.Equal(t, envs[1], "tokeep=value") + assert.Equal(t, "toadd=newenv", envs[0]) + assert.Equal(t, "tokeep=value", envs[1]) } func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) { @@ -116,7 +117,7 @@ func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) { envs := []string{"foo=value"} updateEnvironment(flags, &envs) - assert.Equal(t, len(envs), 0) + assert.Len(t, envs, 0) } func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) { @@ -127,8 +128,8 @@ func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) { envs := []string{"A=c"} updateEnvironment(flags, &envs) - assert.Equal(t, len(envs), 1) - assert.Equal(t, envs[0], "A=b") + require.Len(t, envs, 1) + assert.Equal(t, "A=b", envs[0]) } func TestUpdateGroups(t *testing.T) { @@ -142,10 +143,10 @@ func TestUpdateGroups(t *testing.T) { groups := []string{"bar", "root"} updateGroups(flags, &groups) - assert.Equal(t, len(groups), 3) - assert.Equal(t, groups[0], "bar") - assert.Equal(t, groups[1], "foo") - assert.Equal(t, groups[2], "wheel") + require.Len(t, groups, 3) + assert.Equal(t, "bar", groups[0]) + assert.Equal(t, "foo", groups[1]) + assert.Equal(t, "wheel", groups[2]) } func TestUpdateDNSConfig(t *testing.T) { @@ -160,7 +161,7 @@ func TestUpdateDNSConfig(t *testing.T) { // IPv6 flags.Set("dns-add", "2001:db8:abc8::1") // Invalid dns record - assert.Error(t, flags.Set("dns-add", "x.y.z.w"), "x.y.z.w is not an ip address") + assert.EqualError(t, flags.Set("dns-add", "x.y.z.w"), "x.y.z.w is not an ip address") // domains with duplicates flags.Set("dns-search-add", "example.com") @@ -168,7 +169,7 @@ func TestUpdateDNSConfig(t *testing.T) { flags.Set("dns-search-add", "example.org") flags.Set("dns-search-rm", "example.org") // Invalid dns search domain - assert.Error(t, flags.Set("dns-search-add", "example$com"), "example$com is not a valid domain") + assert.EqualError(t, flags.Set("dns-search-add", "example$com"), "example$com is not a valid domain") flags.Set("dns-option-add", "ndots:9") flags.Set("dns-option-rm", "timeout:3") @@ -181,16 +182,16 @@ func TestUpdateDNSConfig(t *testing.T) { updateDNSConfig(flags, &config) - assert.Equal(t, len(config.Nameservers), 3) - assert.Equal(t, config.Nameservers[0], "1.1.1.1") - assert.Equal(t, config.Nameservers[1], "2001:db8:abc8::1") - assert.Equal(t, config.Nameservers[2], "5.5.5.5") + require.Len(t, config.Nameservers, 3) + assert.Equal(t, "1.1.1.1", config.Nameservers[0]) + assert.Equal(t, "2001:db8:abc8::1", config.Nameservers[1]) + assert.Equal(t, "5.5.5.5", config.Nameservers[2]) - assert.Equal(t, len(config.Search), 2) - assert.Equal(t, config.Search[0], "example.com") - assert.Equal(t, config.Search[1], "localdomain") + require.Len(t, config.Search, 2) + assert.Equal(t, "example.com", config.Search[0]) + assert.Equal(t, "localdomain", config.Search[1]) - assert.Equal(t, len(config.Options), 1) + require.Len(t, config.Options, 1) assert.Equal(t, config.Options[0], "ndots:9") } @@ -205,10 +206,9 @@ func TestUpdateMounts(t *testing.T) { } updateMounts(flags, &mounts) - assert.Equal(t, len(mounts), 2) - assert.Equal(t, mounts[0].Target, "/toadd") - assert.Equal(t, mounts[1].Target, "/tokeep") - + require.Len(t, mounts, 2) + assert.Equal(t, "/toadd", mounts[0].Target) + assert.Equal(t, "/tokeep", mounts[1].Target) } func TestUpdateMountsWithDuplicateMounts(t *testing.T) { @@ -222,10 +222,10 @@ func TestUpdateMountsWithDuplicateMounts(t *testing.T) { } updateMounts(flags, &mounts) - assert.Equal(t, len(mounts), 3) - assert.Equal(t, mounts[0].Target, "/tokeep1") - assert.Equal(t, mounts[1].Target, "/tokeep2") - assert.Equal(t, mounts[2].Target, "/toadd") + require.Len(t, mounts, 3) + assert.Equal(t, "/tokeep1", mounts[0].Target) + assert.Equal(t, "/tokeep2", mounts[1].Target) + assert.Equal(t, "/toadd", mounts[2].Target) } func TestUpdatePorts(t *testing.T) { @@ -239,13 +239,13 @@ func TestUpdatePorts(t *testing.T) { } err := updatePorts(flags, &portConfigs) - assert.Equal(t, err, nil) - assert.Equal(t, len(portConfigs), 2) + assert.NoError(t, err) + require.Len(t, portConfigs, 2) // Do a sort to have the order (might have changed by map) targetPorts := []int{int(portConfigs[0].TargetPort), int(portConfigs[1].TargetPort)} sort.Ints(targetPorts) - assert.Equal(t, targetPorts[0], 555) - assert.Equal(t, targetPorts[1], 1000) + assert.Equal(t, 555, targetPorts[0]) + assert.Equal(t, 1000, targetPorts[1]) } func TestUpdatePortsDuplicate(t *testing.T) { @@ -263,9 +263,9 @@ func TestUpdatePortsDuplicate(t *testing.T) { } err := updatePorts(flags, &portConfigs) - assert.Equal(t, err, nil) - assert.Equal(t, len(portConfigs), 1) - assert.Equal(t, portConfigs[0].TargetPort, uint32(80)) + assert.NoError(t, err) + require.Len(t, portConfigs, 1) + assert.Equal(t, uint32(80), portConfigs[0].TargetPort) } func TestUpdateHealthcheckTable(t *testing.T) { @@ -339,9 +339,9 @@ func TestUpdateHealthcheckTable(t *testing.T) { } err := updateHealthcheck(flags, cspec) if c.err != "" { - assert.Error(t, err, c.err) + assert.EqualError(t, err, c.err) } else { - assert.NilError(t, err) + assert.NoError(t, err) if !reflect.DeepEqual(cspec.Healthcheck, c.expected) { t.Errorf("incorrect result for test %d, expected health config:\n\t%#v\ngot:\n\t%#v", i, c.expected, cspec.Healthcheck) } @@ -358,15 +358,15 @@ func TestUpdateHosts(t *testing.T) { // just hostname should work as well flags.Set("host-rm", "example.net") // bad format error - assert.Error(t, flags.Set("host-add", "$example.com$"), "bad format for add-host:") + assert.EqualError(t, flags.Set("host-add", "$example.com$"), `bad format for add-host: "$example.com$"`) hosts := []string{"1.2.3.4 example.com", "4.3.2.1 example.org", "2001:db8:abc8::1 example.net"} updateHosts(flags, &hosts) - assert.Equal(t, len(hosts), 3) - assert.Equal(t, hosts[0], "1.2.3.4 example.com") - assert.Equal(t, hosts[1], "2001:db8:abc8::1 ipv6.net") - assert.Equal(t, hosts[2], "4.3.2.1 example.org") + require.Len(t, hosts, 3) + assert.Equal(t, "1.2.3.4 example.com", hosts[0]) + assert.Equal(t, "2001:db8:abc8::1 ipv6.net", hosts[1]) + assert.Equal(t, "4.3.2.1 example.org", hosts[2]) } func TestUpdatePortsRmWithProtocol(t *testing.T) { @@ -387,10 +387,10 @@ func TestUpdatePortsRmWithProtocol(t *testing.T) { } err := updatePorts(flags, &portConfigs) - assert.Equal(t, err, nil) - assert.Equal(t, len(portConfigs), 2) - assert.Equal(t, portConfigs[0].TargetPort, uint32(81)) - assert.Equal(t, portConfigs[1].TargetPort, uint32(82)) + assert.NoError(t, err) + require.Len(t, portConfigs, 2) + assert.Equal(t, uint32(81), portConfigs[0].TargetPort) + assert.Equal(t, uint32(82), portConfigs[1].TargetPort) } type secretAPIClientMock struct { @@ -444,11 +444,11 @@ func TestUpdateSecretUpdateInPlace(t *testing.T) { updatedSecrets, err := getUpdatedSecrets(apiClient, flags, secrets) - assert.Equal(t, err, nil) - assert.Equal(t, len(updatedSecrets), 1) - assert.Equal(t, updatedSecrets[0].SecretID, "tn9qiblgnuuut11eufquw5dev") - assert.Equal(t, updatedSecrets[0].SecretName, "foo") - assert.Equal(t, updatedSecrets[0].File.Name, "foo2") + assert.NoError(t, err) + require.Len(t, updatedSecrets, 1) + assert.Equal(t, "tn9qiblgnuuut11eufquw5dev", updatedSecrets[0].SecretID) + assert.Equal(t, "foo", updatedSecrets[0].SecretName) + assert.Equal(t, "foo2", updatedSecrets[0].File.Name) } func TestUpdateReadOnly(t *testing.T) { @@ -459,18 +459,18 @@ func TestUpdateReadOnly(t *testing.T) { flags := newUpdateCommand(nil).Flags() flags.Set("read-only", "true") updateService(nil, nil, flags, spec) - assert.Equal(t, cspec.ReadOnly, true) + assert.True(t, cspec.ReadOnly) // Update without --read-only, no change flags = newUpdateCommand(nil).Flags() updateService(nil, nil, flags, spec) - assert.Equal(t, cspec.ReadOnly, true) + assert.True(t, cspec.ReadOnly) // Update with --read-only=false, changed to false flags = newUpdateCommand(nil).Flags() flags.Set("read-only", "false") updateService(nil, nil, flags, spec) - assert.Equal(t, cspec.ReadOnly, false) + assert.False(t, cspec.ReadOnly) } func TestUpdateStopSignal(t *testing.T) { @@ -481,16 +481,16 @@ func TestUpdateStopSignal(t *testing.T) { flags := newUpdateCommand(nil).Flags() flags.Set("stop-signal", "SIGUSR1") updateService(nil, nil, flags, spec) - assert.Equal(t, cspec.StopSignal, "SIGUSR1") + assert.Equal(t, "SIGUSR1", cspec.StopSignal) // Update without --stop-signal, no change flags = newUpdateCommand(nil).Flags() updateService(nil, nil, flags, spec) - assert.Equal(t, cspec.StopSignal, "SIGUSR1") + assert.Equal(t, "SIGUSR1", cspec.StopSignal) // Update with --stop-signal=SIGWINCH flags = newUpdateCommand(nil).Flags() flags.Set("stop-signal", "SIGWINCH") updateService(nil, nil, flags, spec) - assert.Equal(t, cspec.StopSignal, "SIGWINCH") + assert.Equal(t, "SIGWINCH", cspec.StopSignal) } diff --git a/cli/command/stack/deploy_test.go b/cli/command/stack/deploy_test.go index 328222af5351406e98559eb96ce48d7dcdba128e..817c06dd049deb13a5ddcbfd75916e4d9b36bbf3 100644 --- a/cli/command/stack/deploy_test.go +++ b/cli/command/stack/deploy_test.go @@ -6,7 +6,7 @@ import ( "github.com/docker/docker/cli/compose/convert" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" "golang.org/x/net/context" ) @@ -23,5 +23,5 @@ func TestPruneServices(t *testing.T) { pruneServices(ctx, dockerCli, namespace, services) - assert.DeepEqual(t, client.removedServices, buildObjectIDs([]string{objectName("foo", "remove")})) + assert.Equal(t, buildObjectIDs([]string{objectName("foo", "remove")}), client.removedServices) } diff --git a/cli/command/stack/remove_test.go b/cli/command/stack/remove_test.go index 7f64fb5505830cc90b11de7bdd81888f1e5cf94f..17a334db1ed8347e92eee1cde6fd869e7f74e94e 100644 --- a/cli/command/stack/remove_test.go +++ b/cli/command/stack/remove_test.go @@ -7,7 +7,7 @@ import ( "testing" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestRemoveStack(t *testing.T) { @@ -17,20 +17,20 @@ func TestRemoveStack(t *testing.T) { objectName("bar", "service1"), objectName("bar", "service2"), } - allServicesIDs := buildObjectIDs(allServices) + allServiceIDs := buildObjectIDs(allServices) allNetworks := []string{ objectName("foo", "network1"), objectName("bar", "network1"), } - allNetworksIDs := buildObjectIDs(allNetworks) + allNetworkIDs := buildObjectIDs(allNetworks) allSecrets := []string{ objectName("foo", "secret1"), objectName("foo", "secret2"), objectName("bar", "secret1"), } - allSecretsIDs := buildObjectIDs(allSecrets) + allSecretIDs := buildObjectIDs(allSecrets) cli := &fakeClient{ services: allServices, @@ -40,22 +40,22 @@ func TestRemoveStack(t *testing.T) { cmd := newRemoveCommand(test.NewFakeCli(cli, &bytes.Buffer{})) cmd.SetArgs([]string{"foo", "bar"}) - assert.NilError(t, cmd.Execute()) - assert.DeepEqual(t, cli.removedServices, allServicesIDs) - assert.DeepEqual(t, cli.removedNetworks, allNetworksIDs) - assert.DeepEqual(t, cli.removedSecrets, allSecretsIDs) + assert.NoError(t, cmd.Execute()) + assert.Equal(t, allServiceIDs, cli.removedServices) + assert.Equal(t, allNetworkIDs, cli.removedNetworks) + assert.Equal(t, allSecretIDs, cli.removedSecrets) } func TestSkipEmptyStack(t *testing.T) { buf := new(bytes.Buffer) allServices := []string{objectName("bar", "service1"), objectName("bar", "service2")} - allServicesIDs := buildObjectIDs(allServices) + allServiceIDs := buildObjectIDs(allServices) allNetworks := []string{objectName("bar", "network1")} - allNetworksIDs := buildObjectIDs(allNetworks) + allNetworkIDs := buildObjectIDs(allNetworks) allSecrets := []string{objectName("bar", "secret1")} - allSecretsIDs := buildObjectIDs(allSecrets) + allSecretIDs := buildObjectIDs(allSecrets) cli := &fakeClient{ services: allServices, @@ -65,22 +65,22 @@ func TestSkipEmptyStack(t *testing.T) { cmd := newRemoveCommand(test.NewFakeCli(cli, buf)) cmd.SetArgs([]string{"foo", "bar"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Contains(t, buf.String(), "Nothing found in stack: foo") - assert.DeepEqual(t, cli.removedServices, allServicesIDs) - assert.DeepEqual(t, cli.removedNetworks, allNetworksIDs) - assert.DeepEqual(t, cli.removedSecrets, allSecretsIDs) + assert.Equal(t, allServiceIDs, cli.removedServices) + assert.Equal(t, allNetworkIDs, cli.removedNetworks) + assert.Equal(t, allSecretIDs, cli.removedSecrets) } func TestContinueAfterError(t *testing.T) { allServices := []string{objectName("foo", "service1"), objectName("bar", "service1")} - allServicesIDs := buildObjectIDs(allServices) + allServiceIDs := buildObjectIDs(allServices) allNetworks := []string{objectName("foo", "network1"), objectName("bar", "network1")} - allNetworksIDs := buildObjectIDs(allNetworks) + allNetworkIDs := buildObjectIDs(allNetworks) allSecrets := []string{objectName("foo", "secret1"), objectName("bar", "secret1")} - allSecretsIDs := buildObjectIDs(allSecrets) + allSecretIDs := buildObjectIDs(allSecrets) removedServices := []string{} cli := &fakeClient{ @@ -100,8 +100,8 @@ func TestContinueAfterError(t *testing.T) { cmd := newRemoveCommand(test.NewFakeCli(cli, &bytes.Buffer{})) cmd.SetArgs([]string{"foo", "bar"}) - assert.Error(t, cmd.Execute(), "Failed to remove some resources from stack: foo") - assert.DeepEqual(t, removedServices, allServicesIDs) - assert.DeepEqual(t, cli.removedNetworks, allNetworksIDs) - assert.DeepEqual(t, cli.removedSecrets, allSecretsIDs) + assert.EqualError(t, cmd.Execute(), "Failed to remove some resources from stack: foo") + assert.Equal(t, allServiceIDs, removedServices) + assert.Equal(t, allNetworkIDs, cli.removedNetworks) + assert.Equal(t, allSecretIDs, cli.removedSecrets) } diff --git a/cli/command/swarm/init_test.go b/cli/command/swarm/init_test.go index c21433bdb97b36f930915e443d49691190506a9c..39cb73888c716dda72c490240418a7ea0ceced46 100644 --- a/cli/command/swarm/init_test.go +++ b/cli/command/swarm/init_test.go @@ -9,9 +9,10 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestSwarmInitErrorOnAPIFailure(t *testing.T) { @@ -76,7 +77,7 @@ func TestSwarmInitErrorOnAPIFailure(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + assert.EqualError(t, cmd.Execute(), tc.expectedError) } } @@ -122,9 +123,9 @@ func TestSwarmInit(t *testing.T) { for key, value := range tc.flags { cmd.Flags().Set(key, value) } - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("init-%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/swarm/join_test.go b/cli/command/swarm/join_test.go index 6d92f0c4fa9dfc5c2fed7c51974d744d7f5f6b8d..6893f68e1d64393268d8336d27118665a35b280c 100644 --- a/cli/command/swarm/join_test.go +++ b/cli/command/swarm/join_test.go @@ -9,8 +9,9 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestSwarmJoinErrors(t *testing.T) { @@ -56,7 +57,7 @@ func TestSwarmJoinErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -96,7 +97,7 @@ func TestSwarmJoin(t *testing.T) { infoFunc: tc.infoFunc, }, buf)) cmd.SetArgs([]string{"remote"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) assert.Equal(t, strings.TrimSpace(buf.String()), tc.expected) } } diff --git a/cli/command/swarm/join_token_test.go b/cli/command/swarm/join_token_test.go index 9b10369ad08c14d16874d9e790b08d94a5f84f65..928918900983a0a17c24fb8c5b5fed03874202b6 100644 --- a/cli/command/swarm/join_token_test.go +++ b/cli/command/swarm/join_token_test.go @@ -12,8 +12,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestSwarmJoinTokenErrors(t *testing.T) { @@ -102,7 +103,7 @@ func TestSwarmJoinTokenErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -208,9 +209,9 @@ func TestSwarmJoinToken(t *testing.T) { for key, value := range tc.flags { cmd.Flags().Set(key, value) } - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("jointoken-%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/swarm/leave_test.go b/cli/command/swarm/leave_test.go index 93a58887a7ec60613f37eea2474364db66be19d1..030f18039a1c21dd2bf9f7039ecc4f3956046ab0 100644 --- a/cli/command/swarm/leave_test.go +++ b/cli/command/swarm/leave_test.go @@ -7,8 +7,9 @@ import ( "testing" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestSwarmLeaveErrors(t *testing.T) { @@ -39,7 +40,7 @@ func TestSwarmLeaveErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -47,6 +48,6 @@ func TestSwarmLeave(t *testing.T) { buf := new(bytes.Buffer) cmd := newLeaveCommand( test.NewFakeCli(&fakeClient{}, buf)) - assert.NilError(t, cmd.Execute()) - assert.Equal(t, strings.TrimSpace(buf.String()), "Node left the swarm.") + assert.NoError(t, cmd.Execute()) + assert.Equal(t, "Node left the swarm.", strings.TrimSpace(buf.String())) } diff --git a/cli/command/swarm/opts_test.go b/cli/command/swarm/opts_test.go index 9a97e8bd2c6dad3e285f0eda6b6e051a93764546..c694cc1bdd0bebb93ae20136be27649f050eed5f 100644 --- a/cli/command/swarm/opts_test.go +++ b/cli/command/swarm/opts_test.go @@ -3,37 +3,37 @@ package swarm import ( "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestNodeAddrOptionSetHostAndPort(t *testing.T) { opt := NewNodeAddrOption("old:123") addr := "newhost:5555" - assert.NilError(t, opt.Set(addr)) - assert.Equal(t, opt.Value(), addr) + assert.NoError(t, opt.Set(addr)) + assert.Equal(t, addr, opt.Value()) } func TestNodeAddrOptionSetHostOnly(t *testing.T) { opt := NewListenAddrOption() - assert.NilError(t, opt.Set("newhost")) - assert.Equal(t, opt.Value(), "newhost:2377") + assert.NoError(t, opt.Set("newhost")) + assert.Equal(t, "newhost:2377", opt.Value()) } func TestNodeAddrOptionSetHostOnlyIPv6(t *testing.T) { opt := NewListenAddrOption() - assert.NilError(t, opt.Set("::1")) - assert.Equal(t, opt.Value(), "[::1]:2377") + assert.NoError(t, opt.Set("::1")) + assert.Equal(t, "[::1]:2377", opt.Value()) } func TestNodeAddrOptionSetPortOnly(t *testing.T) { opt := NewListenAddrOption() - assert.NilError(t, opt.Set(":4545")) - assert.Equal(t, opt.Value(), "0.0.0.0:4545") + assert.NoError(t, opt.Set(":4545")) + assert.Equal(t, "0.0.0.0:4545", opt.Value()) } func TestNodeAddrOptionSetInvalidFormat(t *testing.T) { opt := NewListenAddrOption() - assert.Error(t, opt.Set("http://localhost:4545"), "Invalid") + assert.EqualError(t, opt.Set("http://localhost:4545"), "Invalid proto, expected tcp: http://localhost:4545") } func TestExternalCAOptionErrors(t *testing.T) { @@ -64,7 +64,7 @@ func TestExternalCAOptionErrors(t *testing.T) { } for _, tc := range testCases { opt := &ExternalCAOption{} - assert.Error(t, opt.Set(tc.externalCA), tc.expectedError) + assert.EqualError(t, opt.Set(tc.externalCA), tc.expectedError) } } @@ -96,15 +96,15 @@ func TestExternalCAOption(t *testing.T) { } for _, tc := range testCases { opt := &ExternalCAOption{} - assert.NilError(t, opt.Set(tc.externalCA)) - assert.Equal(t, opt.String(), tc.expected) + assert.NoError(t, opt.Set(tc.externalCA)) + assert.Equal(t, tc.expected, opt.String()) } } func TestExternalCAOptionMultiple(t *testing.T) { opt := &ExternalCAOption{} - assert.NilError(t, opt.Set("protocol=cfssl,url=https://example.com")) - assert.NilError(t, opt.Set("protocol=CFSSL,url=anything")) - assert.Equal(t, len(opt.Value()), 2) - assert.Equal(t, opt.String(), "cfssl: https://example.com, cfssl: anything") + assert.NoError(t, opt.Set("protocol=cfssl,url=https://example.com")) + assert.NoError(t, opt.Set("protocol=CFSSL,url=anything")) + assert.Len(t, opt.Value(), 2) + assert.Equal(t, "cfssl: https://example.com, cfssl: anything", opt.String()) } diff --git a/cli/command/swarm/unlock_key_test.go b/cli/command/swarm/unlock_key_test.go index 7b644f70e9fec88dc11b401e93e317116f98e985..23752104aaafda39b0a8c9301ebde3a7f174b5f6 100644 --- a/cli/command/swarm/unlock_key_test.go +++ b/cli/command/swarm/unlock_key_test.go @@ -12,8 +12,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestSwarmUnlockKeyErrors(t *testing.T) { @@ -94,7 +95,7 @@ func TestSwarmUnlockKeyErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -168,9 +169,9 @@ func TestSwarmUnlockKey(t *testing.T) { for key, value := range tc.flags { cmd.Flags().Set(key, value) } - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("unlockkeys-%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/swarm/unlock_test.go b/cli/command/swarm/unlock_test.go index 620fecafed3a72a90bbabd486b96d50a97d6be13..e1a2bb4cc51eec54200d605bad0ab43b18dfbd50 100644 --- a/cli/command/swarm/unlock_test.go +++ b/cli/command/swarm/unlock_test.go @@ -9,8 +9,9 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/swarm" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestSwarmUnlockErrors(t *testing.T) { @@ -73,7 +74,7 @@ func TestSwarmUnlockErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -97,5 +98,5 @@ func TestSwarmUnlock(t *testing.T) { }, buf) dockerCli.SetIn(ioutil.NopCloser(strings.NewReader(input))) cmd := newUnlockCommand(dockerCli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } diff --git a/cli/command/swarm/update_test.go b/cli/command/swarm/update_test.go index 0450c02979e6e433175cedfea1c5bb1bb386e5f9..65366ddd205dc7096682c019f733d705ba94c83e 100644 --- a/cli/command/swarm/update_test.go +++ b/cli/command/swarm/update_test.go @@ -13,8 +13,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestSwarmUpdateErrors(t *testing.T) { @@ -79,7 +80,7 @@ func TestSwarmUpdateErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -175,9 +176,9 @@ func TestSwarmUpdate(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(buf) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("update-%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/volume/create_test.go b/cli/command/volume/create_test.go index ccb7ac75bfc0c04db9d6da21af0e64310b008408..45cf63113479ecc2610a0516d46354f6e86e0cee 100644 --- a/cli/command/volume/create_test.go +++ b/cli/command/volume/create_test.go @@ -9,8 +9,9 @@ import ( "github.com/docker/docker/api/types" volumetypes "github.com/docker/docker/api/types/volume" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestVolumeCreateErrors(t *testing.T) { @@ -50,7 +51,7 @@ func TestVolumeCreateErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -71,15 +72,15 @@ func TestVolumeCreateWithName(t *testing.T) { // Test by flags cmd := newCreateCommand(cli) cmd.Flags().Set("name", name) - assert.NilError(t, cmd.Execute()) - assert.Equal(t, strings.TrimSpace(buf.String()), name) + assert.NoError(t, cmd.Execute()) + assert.Equal(t, name, strings.TrimSpace(buf.String())) // Then by args buf.Reset() cmd = newCreateCommand(cli) cmd.SetArgs([]string{name}) - assert.NilError(t, cmd.Execute()) - assert.Equal(t, strings.TrimSpace(buf.String()), name) + assert.NoError(t, cmd.Execute()) + assert.Equal(t, name, strings.TrimSpace(buf.String())) } func TestVolumeCreateWithFlags(t *testing.T) { @@ -121,8 +122,8 @@ func TestVolumeCreateWithFlags(t *testing.T) { cmd.Flags().Set("opt", "baz=baz") cmd.Flags().Set("label", "lbl1=v1") cmd.Flags().Set("label", "lbl2=v2") - assert.NilError(t, cmd.Execute()) - assert.Equal(t, strings.TrimSpace(buf.String()), name) + assert.NoError(t, cmd.Execute()) + assert.Equal(t, name, strings.TrimSpace(buf.String())) } func compareMap(actual map[string]string, expected map[string]string) bool { diff --git a/cli/command/volume/inspect_test.go b/cli/command/volume/inspect_test.go index 7c4cce39dbb876d796b3c662165691310d7681ce..bc1b52644094ff84df9c6c54567daac211a724db 100644 --- a/cli/command/volume/inspect_test.go +++ b/cli/command/volume/inspect_test.go @@ -11,8 +11,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestVolumeInspectErrors(t *testing.T) { @@ -64,7 +65,7 @@ func TestVolumeInspectErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -102,10 +103,10 @@ func TestVolumeInspectWithoutFormat(t *testing.T) { }, buf), ) cmd.SetArgs(tc.args) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("volume-inspect-without-format.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } @@ -143,9 +144,9 @@ func TestVolumeInspectWithFormat(t *testing.T) { ) cmd.SetArgs(tc.args) cmd.Flags().Set("format", tc.format) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("volume-inspect-with-format.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/volume/list_test.go b/cli/command/volume/list_test.go index b2306a5d8eda284c0d22f16de6d9f0b7abf62b33..4f5e99389ff985431f6c4348cd13861594b331cd 100644 --- a/cli/command/volume/list_test.go +++ b/cli/command/volume/list_test.go @@ -13,8 +13,9 @@ import ( "github.com/pkg/errors" // Import builders to get the builder function as package function . "github.com/docker/docker/cli/internal/test/builders" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" + "github.com/stretchr/testify/assert" ) func TestVolumeListErrors(t *testing.T) { @@ -47,7 +48,7 @@ func TestVolumeListErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -68,10 +69,10 @@ func TestVolumeListWithoutFormat(t *testing.T) { }, buf) cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newListCommand(cli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "volume-list-without-format.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } func TestVolumeListWithConfigFormat(t *testing.T) { @@ -93,10 +94,10 @@ func TestVolumeListWithConfigFormat(t *testing.T) { VolumesFormat: "{{ .Name }} {{ .Driver }} {{ .Labels }}", }) cmd := newListCommand(cli) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "volume-list-with-config-format.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } func TestVolumeListWithFormat(t *testing.T) { @@ -117,8 +118,8 @@ func TestVolumeListWithFormat(t *testing.T) { cli.SetConfigfile(&configfile.ConfigFile{}) cmd := newListCommand(cli) cmd.Flags().Set("format", "{{ .Name }} {{ .Driver }} {{ .Labels }}") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "volume-list-with-format.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } diff --git a/cli/command/volume/prune_test.go b/cli/command/volume/prune_test.go index dab997f625cc2b84d2aa6b15fe2fe86d670e227a..05da9bdded1c65c7601d03384186a23d33afbf96 100644 --- a/cli/command/volume/prune_test.go +++ b/cli/command/volume/prune_test.go @@ -11,9 +11,10 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/golden" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestVolumePruneErrors(t *testing.T) { @@ -48,7 +49,7 @@ func TestVolumePruneErrors(t *testing.T) { cmd.Flags().Set(key, value) } cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -73,10 +74,10 @@ func TestVolumePruneForce(t *testing.T) { }, buf), ) cmd.Flags().Set("force", "true") - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), fmt.Sprintf("volume-prune.%s.golden", tc.name)) - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } func TestVolumePrunePromptYes(t *testing.T) { @@ -94,10 +95,10 @@ func TestVolumePrunePromptYes(t *testing.T) { cmd := NewPruneCommand( cli, ) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "volume-prune-yes.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } @@ -116,10 +117,10 @@ func TestVolumePrunePromptNo(t *testing.T) { cmd := NewPruneCommand( cli, ) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) actual := buf.String() expected := golden.Get(t, []byte(actual), "volume-prune-no.golden") - assert.EqualNormalizedString(t, assert.RemoveSpace, actual, string(expected)) + testutil.EqualNormalizedString(t, testutil.RemoveSpace, actual, string(expected)) } } diff --git a/cli/command/volume/remove_test.go b/cli/command/volume/remove_test.go index 0154a5d55110efdf2dc76171d0a1738b66641245..5a4dc1f4b724d15f5fa67c02915ef49cd6c1378d 100644 --- a/cli/command/volume/remove_test.go +++ b/cli/command/volume/remove_test.go @@ -6,8 +6,9 @@ import ( "testing" "github.com/docker/docker/cli/internal/test" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/pkg/errors" + "github.com/stretchr/testify/assert" ) func TestVolumeRemoveErrors(t *testing.T) { @@ -35,7 +36,7 @@ func TestVolumeRemoveErrors(t *testing.T) { }, buf)) cmd.SetArgs(tc.args) cmd.SetOutput(ioutil.Discard) - assert.Error(t, cmd.Execute(), tc.expectedError) + testutil.ErrorContains(t, cmd.Execute(), tc.expectedError) } } @@ -43,5 +44,5 @@ func TestNodeRemoveMultiple(t *testing.T) { buf := new(bytes.Buffer) cmd := newRemoveCommand(test.NewFakeCli(&fakeClient{}, buf)) cmd.SetArgs([]string{"volume1", "volume2"}) - assert.NilError(t, cmd.Execute()) + assert.NoError(t, cmd.Execute()) } diff --git a/cli/compose/convert/compose_test.go b/cli/compose/convert/compose_test.go index c267820956fd91e4f09f6554196d0d1615d06b18..a76d5ecd4fa15600feb0c15aa45d1dc11a653776 100644 --- a/cli/compose/convert/compose_test.go +++ b/cli/compose/convert/compose_test.go @@ -6,13 +6,14 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/network" composetypes "github.com/docker/docker/cli/compose/types" - "github.com/docker/docker/pkg/testutil/assert" "github.com/docker/docker/pkg/testutil/tempfile" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestNamespaceScope(t *testing.T) { scoped := Namespace{name: "foo"}.Scope("bar") - assert.Equal(t, scoped, "foo_bar") + assert.Equal(t, "foo_bar", scoped) } func TestAddStackLabel(t *testing.T) { @@ -24,7 +25,7 @@ func TestAddStackLabel(t *testing.T) { "something": "labeled", LabelNamespace: "foo", } - assert.DeepEqual(t, actual, expected) + assert.Equal(t, expected, actual) } func TestNetworks(t *testing.T) { @@ -98,8 +99,8 @@ func TestNetworks(t *testing.T) { } networks, externals := Networks(namespace, source, serviceNetworks) - assert.DeepEqual(t, networks, expected) - assert.DeepEqual(t, externals, []string{"special"}) + assert.Equal(t, expected, networks) + assert.Equal(t, []string{"special"}, externals) } func TestSecrets(t *testing.T) { @@ -122,13 +123,13 @@ func TestSecrets(t *testing.T) { } specs, err := Secrets(namespace, source) - assert.NilError(t, err) - assert.Equal(t, len(specs), 1) + assert.NoError(t, err) + require.Len(t, specs, 1) secret := specs[0] - assert.Equal(t, secret.Name, "foo_one") - assert.DeepEqual(t, secret.Labels, map[string]string{ + assert.Equal(t, "foo_one", secret.Name) + assert.Equal(t, map[string]string{ "monster": "mash", LabelNamespace: "foo", - }) - assert.DeepEqual(t, secret.Data, []byte(secretText)) + }, secret.Labels) + assert.Equal(t, []byte(secretText), secret.Data) } diff --git a/cli/compose/convert/service_test.go b/cli/compose/convert/service_test.go index 91af572994fa793e1f04e16af80fd109267c51e4..b08ecf36367dae425a4c18b268efcf5d9fe3709b 100644 --- a/cli/compose/convert/service_test.go +++ b/cli/compose/convert/service_test.go @@ -9,18 +9,18 @@ import ( "github.com/docker/docker/api/types/container" "github.com/docker/docker/api/types/swarm" composetypes "github.com/docker/docker/cli/compose/types" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestConvertRestartPolicyFromNone(t *testing.T) { policy, err := convertRestartPolicy("no", nil) - assert.NilError(t, err) - assert.Equal(t, policy, (*swarm.RestartPolicy)(nil)) + assert.NoError(t, err) + assert.Equal(t, (*swarm.RestartPolicy)(nil), policy) } func TestConvertRestartPolicyFromUnknown(t *testing.T) { _, err := convertRestartPolicy("unknown", nil) - assert.Error(t, err, "unknown restart policy: unknown") + assert.EqualError(t, err, "unknown restart policy: unknown") } func TestConvertRestartPolicyFromAlways(t *testing.T) { @@ -28,8 +28,8 @@ func TestConvertRestartPolicyFromAlways(t *testing.T) { expected := &swarm.RestartPolicy{ Condition: swarm.RestartPolicyConditionAny, } - assert.NilError(t, err) - assert.DeepEqual(t, policy, expected) + assert.NoError(t, err) + assert.Equal(t, expected, policy) } func TestConvertRestartPolicyFromFailure(t *testing.T) { @@ -39,8 +39,8 @@ func TestConvertRestartPolicyFromFailure(t *testing.T) { Condition: swarm.RestartPolicyConditionOnFailure, MaxAttempts: &attempts, } - assert.NilError(t, err) - assert.DeepEqual(t, policy, expected) + assert.NoError(t, err) + assert.Equal(t, expected, policy) } func strPtr(val string) *string { @@ -54,7 +54,7 @@ func TestConvertEnvironment(t *testing.T) { } env := convertEnvironment(source) sort.Strings(env) - assert.DeepEqual(t, env, []string{"foo=bar", "key=value"}) + assert.Equal(t, []string{"foo=bar", "key=value"}, env) } func TestConvertResourcesFull(t *testing.T) { @@ -69,7 +69,7 @@ func TestConvertResourcesFull(t *testing.T) { }, } resources, err := convertResources(source) - assert.NilError(t, err) + assert.NoError(t, err) expected := &swarm.ResourceRequirements{ Limits: &swarm.Resources{ @@ -81,7 +81,7 @@ func TestConvertResourcesFull(t *testing.T) { MemoryBytes: 200000000, }, } - assert.DeepEqual(t, resources, expected) + assert.Equal(t, expected, resources) } func TestConvertResourcesOnlyMemory(t *testing.T) { @@ -94,7 +94,7 @@ func TestConvertResourcesOnlyMemory(t *testing.T) { }, } resources, err := convertResources(source) - assert.NilError(t, err) + assert.NoError(t, err) expected := &swarm.ResourceRequirements{ Limits: &swarm.Resources{ @@ -104,7 +104,7 @@ func TestConvertResourcesOnlyMemory(t *testing.T) { MemoryBytes: 200000000, }, } - assert.DeepEqual(t, resources, expected) + assert.Equal(t, expected, resources) } func TestConvertHealthcheck(t *testing.T) { @@ -123,8 +123,8 @@ func TestConvertHealthcheck(t *testing.T) { } healthcheck, err := convertHealthcheck(source) - assert.NilError(t, err) - assert.DeepEqual(t, healthcheck, expected) + assert.NoError(t, err) + assert.Equal(t, expected, healthcheck) } func TestConvertHealthcheckDisable(t *testing.T) { @@ -134,8 +134,8 @@ func TestConvertHealthcheckDisable(t *testing.T) { } healthcheck, err := convertHealthcheck(source) - assert.NilError(t, err) - assert.DeepEqual(t, healthcheck, expected) + assert.NoError(t, err) + assert.Equal(t, expected, healthcheck) } func TestConvertHealthcheckDisableWithTest(t *testing.T) { @@ -144,7 +144,7 @@ func TestConvertHealthcheckDisableWithTest(t *testing.T) { Test: []string{"EXEC", "touch"}, } _, err := convertHealthcheck(source) - assert.Error(t, err, "test and disable can't be set") + assert.EqualError(t, err, "test and disable can't be set at the same time") } func TestConvertEndpointSpec(t *testing.T) { @@ -178,8 +178,8 @@ func TestConvertEndpointSpec(t *testing.T) { }, } - assert.NilError(t, err) - assert.DeepEqual(t, *endpoint, expected) + assert.NoError(t, err) + assert.Equal(t, expected, *endpoint) } func TestConvertServiceNetworksOnlyDefault(t *testing.T) { @@ -195,8 +195,8 @@ func TestConvertServiceNetworksOnlyDefault(t *testing.T) { }, } - assert.NilError(t, err) - assert.DeepEqual(t, configs, expected) + assert.NoError(t, err) + assert.Equal(t, expected, configs) } func TestConvertServiceNetworks(t *testing.T) { @@ -235,8 +235,8 @@ func TestConvertServiceNetworks(t *testing.T) { sortedConfigs := byTargetSort(configs) sort.Sort(&sortedConfigs) - assert.NilError(t, err) - assert.DeepEqual(t, []swarm.NetworkAttachmentConfig(sortedConfigs), expected) + assert.NoError(t, err) + assert.Equal(t, expected, []swarm.NetworkAttachmentConfig(sortedConfigs)) } func TestConvertServiceNetworksCustomDefault(t *testing.T) { @@ -260,8 +260,8 @@ func TestConvertServiceNetworksCustomDefault(t *testing.T) { }, } - assert.NilError(t, err) - assert.DeepEqual(t, []swarm.NetworkAttachmentConfig(configs), expected) + assert.NoError(t, err) + assert.Equal(t, expected, []swarm.NetworkAttachmentConfig(configs)) } type byTargetSort []swarm.NetworkAttachmentConfig @@ -281,8 +281,8 @@ func (s byTargetSort) Swap(i, j int) { func TestConvertDNSConfigEmpty(t *testing.T) { dnsConfig, err := convertDNSConfig(nil, nil) - assert.NilError(t, err) - assert.Equal(t, dnsConfig, (*swarm.DNSConfig)(nil)) + assert.NoError(t, err) + assert.Equal(t, (*swarm.DNSConfig)(nil), dnsConfig) } var ( @@ -292,27 +292,27 @@ var ( func TestConvertDNSConfigAll(t *testing.T) { dnsConfig, err := convertDNSConfig(nameservers, search) - assert.NilError(t, err) - assert.DeepEqual(t, dnsConfig, &swarm.DNSConfig{ + assert.NoError(t, err) + assert.Equal(t, &swarm.DNSConfig{ Nameservers: nameservers, Search: search, - }) + }, dnsConfig) } func TestConvertDNSConfigNameservers(t *testing.T) { dnsConfig, err := convertDNSConfig(nameservers, nil) - assert.NilError(t, err) - assert.DeepEqual(t, dnsConfig, &swarm.DNSConfig{ + assert.NoError(t, err) + assert.Equal(t, &swarm.DNSConfig{ Nameservers: nameservers, Search: nil, - }) + }, dnsConfig) } func TestConvertDNSConfigSearch(t *testing.T) { dnsConfig, err := convertDNSConfig(nil, search) - assert.NilError(t, err) - assert.DeepEqual(t, dnsConfig, &swarm.DNSConfig{ + assert.NoError(t, err) + assert.Equal(t, &swarm.DNSConfig{ Nameservers: nil, Search: search, - }) + }, dnsConfig) } diff --git a/cli/compose/convert/volume_test.go b/cli/compose/convert/volume_test.go index 73d642e5fe7923e939aae2207d2ba3afcd612720..a7502d17376ff85b460ec917b73a9938d4ce5da3 100644 --- a/cli/compose/convert/volume_test.go +++ b/cli/compose/convert/volume_test.go @@ -5,7 +5,7 @@ import ( "github.com/docker/docker/api/types/mount" composetypes "github.com/docker/docker/cli/compose/types" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestConvertVolumeToMountAnonymousVolume(t *testing.T) { @@ -18,8 +18,8 @@ func TestConvertVolumeToMountAnonymousVolume(t *testing.T) { Target: "/foo/bar", } mount, err := convertVolumeToMount(config, volumes{}, NewNamespace("foo")) - assert.NilError(t, err) - assert.DeepEqual(t, mount, expected) + assert.NoError(t, err) + assert.Equal(t, expected, mount) } func TestConvertVolumeToMountConflictingOptionsBind(t *testing.T) { @@ -34,7 +34,7 @@ func TestConvertVolumeToMountConflictingOptionsBind(t *testing.T) { }, } _, err := convertVolumeToMount(config, volumes{}, namespace) - assert.Error(t, err, "bind options are incompatible") + assert.EqualError(t, err, "bind options are incompatible with type volume") } func TestConvertVolumeToMountConflictingOptionsVolume(t *testing.T) { @@ -49,7 +49,7 @@ func TestConvertVolumeToMountConflictingOptionsVolume(t *testing.T) { }, } _, err := convertVolumeToMount(config, volumes{}, namespace) - assert.Error(t, err, "volume options are incompatible") + assert.EqualError(t, err, "volume options are incompatible with type bind") } func TestConvertVolumeToMountNamedVolume(t *testing.T) { @@ -94,8 +94,8 @@ func TestConvertVolumeToMountNamedVolume(t *testing.T) { }, } mount, err := convertVolumeToMount(config, stackVolumes, namespace) - assert.NilError(t, err) - assert.DeepEqual(t, mount, expected) + assert.NoError(t, err) + assert.Equal(t, expected, mount) } func TestConvertVolumeToMountNamedVolumeExternal(t *testing.T) { @@ -122,8 +122,8 @@ func TestConvertVolumeToMountNamedVolumeExternal(t *testing.T) { Target: "/foo", } mount, err := convertVolumeToMount(config, stackVolumes, namespace) - assert.NilError(t, err) - assert.DeepEqual(t, mount, expected) + assert.NoError(t, err) + assert.Equal(t, expected, mount) } func TestConvertVolumeToMountNamedVolumeExternalNoCopy(t *testing.T) { @@ -153,8 +153,8 @@ func TestConvertVolumeToMountNamedVolumeExternalNoCopy(t *testing.T) { }, } mount, err := convertVolumeToMount(config, stackVolumes, namespace) - assert.NilError(t, err) - assert.DeepEqual(t, mount, expected) + assert.NoError(t, err) + assert.Equal(t, expected, mount) } func TestConvertVolumeToMountBind(t *testing.T) { @@ -175,8 +175,8 @@ func TestConvertVolumeToMountBind(t *testing.T) { Bind: &composetypes.ServiceVolumeBind{Propagation: "shared"}, } mount, err := convertVolumeToMount(config, stackVolumes, namespace) - assert.NilError(t, err) - assert.DeepEqual(t, mount, expected) + assert.NoError(t, err) + assert.Equal(t, expected, mount) } func TestConvertVolumeToMountVolumeDoesNotExist(t *testing.T) { @@ -188,5 +188,5 @@ func TestConvertVolumeToMountVolumeDoesNotExist(t *testing.T) { ReadOnly: true, } _, err := convertVolumeToMount(config, volumes{}, namespace) - assert.Error(t, err, "undefined volume \"unknown\"") + assert.EqualError(t, err, "undefined volume \"unknown\"") } diff --git a/cli/compose/loader/volume_test.go b/cli/compose/loader/volume_test.go index 19d19f23060bf32c82870ffc0d3f1519a980e36f..9b09c13534afce550b0c067068bbe59c1121f331 100644 --- a/cli/compose/loader/volume_test.go +++ b/cli/compose/loader/volume_test.go @@ -4,15 +4,16 @@ import ( "testing" "github.com/docker/docker/cli/compose/types" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/assert" ) func TestParseVolumeAnonymousVolume(t *testing.T) { for _, path := range []string{"/path", "/path/foo"} { volume, err := parseVolume(path) expected := types.ServiceVolumeConfig{Type: "volume", Target: path} - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } @@ -20,29 +21,29 @@ func TestParseVolumeAnonymousVolumeWindows(t *testing.T) { for _, path := range []string{"C:\\path", "Z:\\path\\foo"} { volume, err := parseVolume(path) expected := types.ServiceVolumeConfig{Type: "volume", Target: path} - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } func TestParseVolumeTooManyColons(t *testing.T) { _, err := parseVolume("/foo:/foo:ro:foo") - assert.Error(t, err, "too many colons") + assert.EqualError(t, err, "invalid spec: /foo:/foo:ro:foo: too many colons") } func TestParseVolumeShortVolumes(t *testing.T) { for _, path := range []string{".", "/a"} { volume, err := parseVolume(path) expected := types.ServiceVolumeConfig{Type: "volume", Target: path} - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } func TestParseVolumeMissingSource(t *testing.T) { for _, spec := range []string{":foo", "/foo::ro"} { _, err := parseVolume(spec) - assert.Error(t, err, "empty section between colons") + testutil.ErrorContains(t, err, "empty section between colons") } } @@ -54,8 +55,8 @@ func TestParseVolumeBindMount(t *testing.T) { Source: path, Target: "/target", } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } @@ -72,8 +73,8 @@ func TestParseVolumeRelativeBindMountWindows(t *testing.T) { Source: path, Target: "d:\\target", } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } @@ -85,8 +86,8 @@ func TestParseVolumeWithBindOptions(t *testing.T) { Target: "/target", Bind: &types.ServiceVolumeBind{Propagation: "slave"}, } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } func TestParseVolumeWithBindOptionsWindows(t *testing.T) { @@ -98,13 +99,13 @@ func TestParseVolumeWithBindOptionsWindows(t *testing.T) { ReadOnly: true, Bind: &types.ServiceVolumeBind{Propagation: "rprivate"}, } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } func TestParseVolumeWithInvalidVolumeOptions(t *testing.T) { _, err := parseVolume("name:/target:bogus") - assert.Error(t, err, "invalid spec: name:/target:bogus: unknown option: bogus") + assert.EqualError(t, err, "invalid spec: name:/target:bogus: unknown option: bogus") } func TestParseVolumeWithVolumeOptions(t *testing.T) { @@ -115,8 +116,8 @@ func TestParseVolumeWithVolumeOptions(t *testing.T) { Target: "/target", Volume: &types.ServiceVolumeVolume{NoCopy: true}, } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } func TestParseVolumeWithReadOnly(t *testing.T) { @@ -128,8 +129,8 @@ func TestParseVolumeWithReadOnly(t *testing.T) { Target: "/target", ReadOnly: true, } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } @@ -142,7 +143,7 @@ func TestParseVolumeWithRW(t *testing.T) { Target: "/target", ReadOnly: false, } - assert.NilError(t, err) - assert.DeepEqual(t, volume, expected) + assert.NoError(t, err) + assert.Equal(t, expected, volume) } } diff --git a/cli/compose/template/template_test.go b/cli/compose/template/template_test.go index 6b81bf0a39c8250b2edf7a3d0af7dd38e63664c7..4ad3f252ac71ca343db276f81fb49d2d458245b4 100644 --- a/cli/compose/template/template_test.go +++ b/cli/compose/template/template_test.go @@ -18,7 +18,7 @@ func defaultMapping(name string) (string, bool) { func TestEscaped(t *testing.T) { result, err := Substitute("$${foo}", defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "${foo}", result) } @@ -43,7 +43,7 @@ func TestInvalid(t *testing.T) { func TestNoValueNoDefault(t *testing.T) { for _, template := range []string{"This ${missing} var", "This ${BAR} var"} { result, err := Substitute(template, defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "This var", result) } } @@ -51,7 +51,7 @@ func TestNoValueNoDefault(t *testing.T) { func TestValueNoDefault(t *testing.T) { for _, template := range []string{"This $FOO var", "This ${FOO} var"} { result, err := Substitute(template, defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "This first var", result) } } @@ -59,25 +59,25 @@ func TestValueNoDefault(t *testing.T) { func TestNoValueWithDefault(t *testing.T) { for _, template := range []string{"ok ${missing:-def}", "ok ${missing-def}"} { result, err := Substitute(template, defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "ok def", result) } } func TestEmptyValueWithSoftDefault(t *testing.T) { result, err := Substitute("ok ${BAR:-def}", defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "ok def", result) } func TestEmptyValueWithHardDefault(t *testing.T) { result, err := Substitute("ok ${BAR-def}", defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "ok ", result) } func TestNonAlphanumericDefault(t *testing.T) { result, err := Substitute("ok ${BAR:-/non:-alphanumeric}", defaultMapping) - assert.NoError(t, err) + assert.Nil(t, err) assert.Equal(t, "ok /non:-alphanumeric", result) } diff --git a/cli/flags/common_test.go b/cli/flags/common_test.go index 616d577f0b80b81fc1460d7186c302dc5307ce06..cf0bf22e26c25657c5705b155b7d14dcd256dbdc 100644 --- a/cli/flags/common_test.go +++ b/cli/flags/common_test.go @@ -5,8 +5,8 @@ import ( "testing" cliconfig "github.com/docker/docker/cli/config" - "github.com/docker/docker/pkg/testutil/assert" "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" ) func TestCommonOptionsInstallFlags(t *testing.T) { @@ -19,9 +19,9 @@ func TestCommonOptionsInstallFlags(t *testing.T) { "--tlscert=\"/foo/cert\"", "--tlskey=\"/foo/key\"", }) - assert.NilError(t, err) - assert.Equal(t, opts.TLSOptions.CAFile, "/foo/cafile") - assert.Equal(t, opts.TLSOptions.CertFile, "/foo/cert") + 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") } @@ -35,8 +35,8 @@ func TestCommonOptionsInstallFlagsWithDefaults(t *testing.T) { opts.InstallFlags(flags) err := flags.Parse([]string{}) - assert.NilError(t, err) - assert.Equal(t, opts.TLSOptions.CAFile, defaultPath("ca.pem")) - assert.Equal(t, opts.TLSOptions.CertFile, defaultPath("cert.pem")) - assert.Equal(t, opts.TLSOptions.KeyFile, defaultPath("key.pem")) + 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) } diff --git a/client/container_prune_test.go b/client/container_prune_test.go index 55e551bb4b1db33dacd07c5885c9309ba9da81ba..8a1c63897bc87ab20b7e93ff8d436cb0ea7b143a 100644 --- a/client/container_prune_test.go +++ b/client/container_prune_test.go @@ -11,7 +11,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" "golang.org/x/net/context" ) @@ -24,7 +24,7 @@ func TestContainersPruneError(t *testing.T) { filters := filters.NewArgs() _, err := client.ContainersPrune(context.Background(), filters) - assert.Error(t, err, "Error response from daemon: Server error") + assert.EqualError(t, err, "Error response from daemon: Server error") } func TestContainersPrune(t *testing.T) { @@ -99,7 +99,7 @@ func TestContainersPrune(t *testing.T) { query := req.URL.Query() for key, expected := range listCase.expectedQueryParams { actual := query.Get(key) - assert.Equal(t, actual, expected) + assert.Equal(t, expected, actual) } content, err := json.Marshal(types.ContainersPruneReport{ ContainersDeleted: []string{"container_id1", "container_id2"}, @@ -117,8 +117,8 @@ func TestContainersPrune(t *testing.T) { } report, err := client.ContainersPrune(context.Background(), listCase.filters) - assert.NilError(t, err) - assert.Equal(t, len(report.ContainersDeleted), 2) - assert.Equal(t, report.SpaceReclaimed, uint64(9999)) + assert.NoError(t, err) + assert.Len(t, report.ContainersDeleted, 2) + assert.Equal(t, uint64(9999), report.SpaceReclaimed) } } diff --git a/client/image_prune_test.go b/client/image_prune_test.go index 5dfb173acc1f01838dbaf1ca62af143c80649fd1..453f84adee8f21a876f1e76c868b5156b5b62773 100644 --- a/client/image_prune_test.go +++ b/client/image_prune_test.go @@ -11,7 +11,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" "golang.org/x/net/context" ) @@ -24,7 +24,7 @@ func TestImagesPruneError(t *testing.T) { filters := filters.NewArgs() _, err := client.ImagesPrune(context.Background(), filters) - assert.Error(t, err, "Error response from daemon: Server error") + assert.EqualError(t, err, "Error response from daemon: Server error") } func TestImagesPrune(t *testing.T) { @@ -87,7 +87,7 @@ func TestImagesPrune(t *testing.T) { query := req.URL.Query() for key, expected := range listCase.expectedQueryParams { actual := query.Get(key) - assert.Equal(t, actual, expected) + assert.Equal(t, expected, actual) } content, err := json.Marshal(types.ImagesPruneReport{ ImagesDeleted: []types.ImageDeleteResponseItem{ @@ -112,8 +112,8 @@ func TestImagesPrune(t *testing.T) { } report, err := client.ImagesPrune(context.Background(), listCase.filters) - assert.NilError(t, err) - assert.Equal(t, len(report.ImagesDeleted), 2) - assert.Equal(t, report.SpaceReclaimed, uint64(9999)) + assert.NoError(t, err) + assert.Len(t, report.ImagesDeleted, 2) + assert.Equal(t, uint64(9999), report.SpaceReclaimed) } } diff --git a/client/network_prune_test.go b/client/network_prune_test.go index 2bf4af4716d51bdd5cc969a247adae56a8a21cc2..3e4f5d0415d95b49b810884c1699b56f8b66469c 100644 --- a/client/network_prune_test.go +++ b/client/network_prune_test.go @@ -11,7 +11,7 @@ import ( "github.com/docker/docker/api/types" "github.com/docker/docker/api/types/filters" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" "golang.org/x/net/context" ) @@ -89,7 +89,7 @@ func TestNetworksPrune(t *testing.T) { query := req.URL.Query() for key, expected := range listCase.expectedQueryParams { actual := query.Get(key) - assert.Equal(t, actual, expected) + assert.Equal(t, expected, actual) } content, err := json.Marshal(types.NetworksPruneReport{ NetworksDeleted: []string{"network_id1", "network_id2"}, @@ -106,7 +106,7 @@ func TestNetworksPrune(t *testing.T) { } report, err := client.NetworksPrune(context.Background(), listCase.filters) - assert.NilError(t, err) - assert.Equal(t, len(report.NetworksDeleted), 2) + assert.NoError(t, err) + assert.Len(t, report.NetworksDeleted, 2) } } diff --git a/cmd/docker/daemon_none_test.go b/cmd/docker/daemon_none_test.go index bd42add98696cdb3aa0c94ac9ac6f9ab2271006d..af0fcfd670ffe145afb30d1522ad6c31ea940883 100644 --- a/cmd/docker/daemon_none_test.go +++ b/cmd/docker/daemon_none_test.go @@ -5,7 +5,7 @@ package main import ( "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestDaemonCommand(t *testing.T) { @@ -13,5 +13,5 @@ func TestDaemonCommand(t *testing.T) { cmd.SetArgs([]string{"--version"}) err := cmd.Execute() - assert.Error(t, err, "Please run `dockerd`") + assert.EqualError(t, err, "Please run `dockerd`") } diff --git a/cmd/docker/daemon_unit_test.go b/cmd/docker/daemon_unit_test.go index 26348a88435f8d7bd696cab74e113f197e28aa6e..ffd8a5e2f58102d972b89765938f66dd721b8920 100644 --- a/cmd/docker/daemon_unit_test.go +++ b/cmd/docker/daemon_unit_test.go @@ -5,8 +5,8 @@ package main import ( "testing" - "github.com/docker/docker/pkg/testutil/assert" "github.com/spf13/cobra" + "github.com/stretchr/testify/assert" ) func stubRun(cmd *cobra.Command, args []string) error { @@ -18,7 +18,7 @@ func TestDaemonCommandHelp(t *testing.T) { cmd.RunE = stubRun cmd.SetArgs([]string{"--help"}) err := cmd.Execute() - assert.NilError(t, err) + assert.NoError(t, err) } func TestDaemonCommand(t *testing.T) { @@ -26,5 +26,5 @@ func TestDaemonCommand(t *testing.T) { cmd.RunE = stubRun cmd.SetArgs([]string{"--containerd", "/foo"}) err := cmd.Execute() - assert.NilError(t, err) + assert.NoError(t, err) } diff --git a/cmd/docker/docker_test.go b/cmd/docker/docker_test.go index f8a5297ed468c3c72da6521098135ba0a1e9edc9..88afb41e9ebe0658cd6003f92091c12493e58915 100644 --- a/cmd/docker/docker_test.go +++ b/cmd/docker/docker_test.go @@ -8,7 +8,7 @@ import ( "github.com/Sirupsen/logrus" "github.com/docker/docker/cli/command" "github.com/docker/docker/cli/debug" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestClientDebugEnabled(t *testing.T) { @@ -18,9 +18,9 @@ func TestClientDebugEnabled(t *testing.T) { cmd.Flags().Set("debug", "true") err := cmd.PersistentPreRunE(cmd, []string{}) - assert.NilError(t, err) - assert.Equal(t, os.Getenv("DEBUG"), "1") - assert.Equal(t, logrus.GetLevel(), logrus.DebugLevel) + assert.NoError(t, err) + assert.Equal(t, "1", os.Getenv("DEBUG")) + assert.Equal(t, logrus.DebugLevel, logrus.GetLevel()) } func TestExitStatusForInvalidSubcommandWithHelpFlag(t *testing.T) { @@ -28,5 +28,5 @@ func TestExitStatusForInvalidSubcommandWithHelpFlag(t *testing.T) { cmd := newDockerCommand(command.NewDockerCli(os.Stdin, discard, discard)) cmd.SetArgs([]string{"help", "invalid"}) err := cmd.Execute() - assert.Error(t, err, "unknown help topic: invalid") + assert.EqualError(t, err, "unknown help topic: invalid") } diff --git a/cmd/dockerd/config_unix_test.go b/cmd/dockerd/config_unix_test.go index 595b07263bdd19a900a124ad5d08ca14ad6fd7d2..99b2f90b400f3d1c829243a80c12205b07ba2d27 100644 --- a/cmd/dockerd/config_unix_test.go +++ b/cmd/dockerd/config_unix_test.go @@ -7,8 +7,8 @@ import ( "testing" "github.com/docker/docker/daemon/config" - "github.com/docker/docker/pkg/testutil/assert" "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" ) func TestDaemonParseShmSize(t *testing.T) { @@ -20,13 +20,7 @@ func TestDaemonParseShmSize(t *testing.T) { conf := &config.Config{} installConfigFlags(conf, flags) // By default `--default-shm-size=64M` - expectedValue := 64 * 1024 * 1024 - if conf.ShmSize.Value() != int64(expectedValue) { - t.Fatalf("expected default shm size %d, got %d", expectedValue, conf.ShmSize.Value()) - } - assert.NilError(t, flags.Set("default-shm-size", "128M")) - expectedValue = 128 * 1024 * 1024 - if conf.ShmSize.Value() != int64(expectedValue) { - t.Fatalf("expected default shm size %d, got %d", expectedValue, conf.ShmSize.Value()) - } + 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()) } diff --git a/cmd/dockerd/daemon_test.go b/cmd/dockerd/daemon_test.go index dade9c7806fed8f289d23eb213b90063848e0f53..5e60ef55f6599f7d3d1dd3eac01559b83aa1fdf2 100644 --- a/cmd/dockerd/daemon_test.go +++ b/cmd/dockerd/daemon_test.go @@ -6,9 +6,11 @@ import ( "github.com/Sirupsen/logrus" cliflags "github.com/docker/docker/cli/flags" "github.com/docker/docker/daemon/config" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/docker/docker/pkg/testutil/tempfile" "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func defaultOptions(configFile string) daemonOptions { @@ -29,8 +31,8 @@ func TestLoadDaemonCliConfigWithoutOverriding(t *testing.T) { opts.common.Debug = true loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) + require.NoError(t, err) + require.NotNil(t, loadedConfig) if !loadedConfig.Debug { t.Fatalf("expected debug to be copied from the common flags, got false") } @@ -42,9 +44,9 @@ func TestLoadDaemonCliConfigWithTLS(t *testing.T) { opts.common.TLS = true loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.CommonTLSOptions.CAFile, "/tmp/ca.pem") + require.NoError(t, err) + require.NotNil(t, loadedConfig) + assert.Equal(t, "/tmp/ca.pem", loadedConfig.CommonTLSOptions.CAFile) } func TestLoadDaemonCliConfigWithConflicts(t *testing.T) { @@ -55,12 +57,12 @@ func TestLoadDaemonCliConfigWithConflicts(t *testing.T) { opts := defaultOptions(configFile) flags := opts.flags - assert.NilError(t, flags.Set("config-file", configFile)) - assert.NilError(t, flags.Set("label", "l1=bar")) - assert.NilError(t, flags.Set("label", "l2=baz")) + assert.NoError(t, flags.Set("config-file", configFile)) + assert.NoError(t, flags.Set("label", "l1=bar")) + assert.NoError(t, flags.Set("label", "l2=baz")) _, err := loadDaemonCliConfig(opts) - assert.Error(t, err, "as a flag and in the configuration file: labels") + testutil.ErrorContains(t, err, "as a flag and in the configuration file: labels") } func TestLoadDaemonCliConfigWithTLSVerify(t *testing.T) { @@ -71,8 +73,8 @@ func TestLoadDaemonCliConfigWithTLSVerify(t *testing.T) { opts.common.TLSOptions.CAFile = "/tmp/ca.pem" loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) + require.NoError(t, err) + require.NotNil(t, loadedConfig) assert.Equal(t, loadedConfig.TLS, true) } @@ -84,9 +86,9 @@ func TestLoadDaemonCliConfigWithExplicitTLSVerifyFalse(t *testing.T) { opts.common.TLSOptions.CAFile = "/tmp/ca.pem" loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.TLS, true) + require.NoError(t, err) + require.NotNil(t, loadedConfig) + assert.True(t, loadedConfig.TLS) } func TestLoadDaemonCliConfigWithoutTLSVerify(t *testing.T) { @@ -97,9 +99,9 @@ func TestLoadDaemonCliConfigWithoutTLSVerify(t *testing.T) { opts.common.TLSOptions.CAFile = "/tmp/ca.pem" loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.TLS, false) + require.NoError(t, err) + require.NotNil(t, loadedConfig) + assert.False(t, loadedConfig.TLS) } func TestLoadDaemonCliConfigWithLogLevel(t *testing.T) { @@ -108,10 +110,10 @@ func TestLoadDaemonCliConfigWithLogLevel(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.LogLevel, "warn") - assert.Equal(t, logrus.GetLevel(), logrus.WarnLevel) + require.NoError(t, err) + require.NotNil(t, loadedConfig) + assert.Equal(t, "warn", loadedConfig.LogLevel) + assert.Equal(t, logrus.WarnLevel, logrus.GetLevel()) } func TestLoadDaemonConfigWithEmbeddedOptions(t *testing.T) { @@ -121,10 +123,10 @@ func TestLoadDaemonConfigWithEmbeddedOptions(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.CommonTLSOptions.CAFile, "/etc/certs/ca.pem") - assert.Equal(t, loadedConfig.LogConfig.Type, "syslog") + 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) } func TestLoadDaemonConfigWithRegistryOptions(t *testing.T) { @@ -137,9 +139,9 @@ func TestLoadDaemonConfigWithRegistryOptions(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) + require.NoError(t, err) + require.NotNil(t, loadedConfig) - assert.Equal(t, len(loadedConfig.Mirrors), 1) - assert.Equal(t, len(loadedConfig.InsecureRegistries), 1) + assert.Len(t, loadedConfig.Mirrors, 1) + assert.Len(t, loadedConfig.InsecureRegistries, 1) } diff --git a/cmd/dockerd/daemon_unix_test.go b/cmd/dockerd/daemon_unix_test.go index f757c52e24727f263a3e1cfdcefe2cbc945638bb..4aaa758d538513fdbd5e1242b3e2b8e7ea34357e 100644 --- a/cmd/dockerd/daemon_unix_test.go +++ b/cmd/dockerd/daemon_unix_test.go @@ -9,8 +9,9 @@ import ( "testing" "github.com/docker/docker/daemon/config" - "github.com/docker/docker/pkg/testutil/assert" "github.com/docker/docker/pkg/testutil/tempfile" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) { @@ -21,17 +22,17 @@ func TestLoadDaemonCliConfigWithDaemonFlags(t *testing.T) { opts := defaultOptions(tempFile.Name()) opts.common.Debug = true opts.common.LogLevel = "info" - assert.NilError(t, opts.flags.Set("selinux-enabled", "true")) + assert.NoError(t, opts.flags.Set("selinux-enabled", "true")) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - - assert.Equal(t, loadedConfig.Debug, true) - assert.Equal(t, loadedConfig.LogLevel, "info") - assert.Equal(t, loadedConfig.EnableSelinuxSupport, true) - assert.Equal(t, loadedConfig.LogConfig.Type, "json-file") - assert.Equal(t, loadedConfig.LogConfig.Config["max-size"], "1k") + 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"]) } func TestLoadDaemonConfigWithNetwork(t *testing.T) { @@ -41,11 +42,11 @@ func TestLoadDaemonConfigWithNetwork(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) + require.NoError(t, err) + require.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.IP, "127.0.0.2") - assert.Equal(t, loadedConfig.DefaultIP.String(), "127.0.0.1") + assert.Equal(t, "127.0.0.2", loadedConfig.IP) + assert.Equal(t, "127.0.0.1", loadedConfig.DefaultIP.String()) } func TestLoadDaemonConfigWithMapOptions(t *testing.T) { @@ -58,14 +59,14 @@ func TestLoadDaemonConfigWithMapOptions(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) + require.NoError(t, err) + require.NotNil(t, loadedConfig) assert.NotNil(t, loadedConfig.ClusterOpts) expectedPath := "/var/lib/docker/discovery_certs/ca.pem" - assert.Equal(t, loadedConfig.ClusterOpts["kv.cacertfile"], expectedPath) + assert.Equal(t, expectedPath, loadedConfig.ClusterOpts["kv.cacertfile"]) assert.NotNil(t, loadedConfig.LogConfig.Config) - assert.Equal(t, loadedConfig.LogConfig.Config["tag"], "test") + assert.Equal(t, "test", loadedConfig.LogConfig.Config["tag"]) } func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) { @@ -75,18 +76,17 @@ func TestLoadDaemonConfigWithTrueDefaultValues(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.NotNil(t, loadedConfig.ClusterOpts) + require.NoError(t, err) + require.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.EnableUserlandProxy, false) + assert.False(t, loadedConfig.EnableUserlandProxy) // make sure reloading doesn't generate configuration // conflicts after normalizing boolean values. reload := func(reloadedConfig *config.Config) { - assert.Equal(t, reloadedConfig.EnableUserlandProxy, false) + assert.False(t, reloadedConfig.EnableUserlandProxy) } - assert.NilError(t, config.Reload(opts.configFile, opts.flags, reload)) + assert.NoError(t, config.Reload(opts.configFile, opts.flags, reload)) } func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) { @@ -95,11 +95,10 @@ func TestLoadDaemonConfigWithTrueDefaultValuesLeaveDefaults(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.NotNil(t, loadedConfig.ClusterOpts) + require.NoError(t, err) + require.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.EnableUserlandProxy, true) + assert.True(t, loadedConfig.EnableUserlandProxy) } func TestLoadDaemonConfigWithLegacyRegistryOptions(t *testing.T) { @@ -109,7 +108,7 @@ func TestLoadDaemonConfigWithLegacyRegistryOptions(t *testing.T) { opts := defaultOptions(tempFile.Name()) loadedConfig, err := loadDaemonCliConfig(opts) - assert.NilError(t, err) - assert.NotNil(t, loadedConfig) - assert.Equal(t, loadedConfig.V2Only, true) + require.NoError(t, err) + require.NotNil(t, loadedConfig) + assert.True(t, loadedConfig.V2Only) } diff --git a/daemon/config/config_test.go b/daemon/config/config_test.go index 7508c213c48177288eb02bd3586bc7f6f137acd6..cc5f01063c2ccc587d201262cb5886e26353ea7d 100644 --- a/daemon/config/config_test.go +++ b/daemon/config/config_test.go @@ -9,8 +9,9 @@ import ( "github.com/docker/docker/daemon/discovery" "github.com/docker/docker/opts" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/spf13/pflag" + "github.com/stretchr/testify/assert" ) func TestDaemonConfigurationNotFound(t *testing.T) { @@ -61,9 +62,9 @@ func TestFindConfigurationConflicts(t *testing.T) { flags := pflag.NewFlagSet("test", pflag.ContinueOnError) flags.String("authorization-plugins", "", "") - assert.NilError(t, flags.Set("authorization-plugins", "asdf")) + assert.NoError(t, flags.Set("authorization-plugins", "asdf")) - assert.Error(t, + testutil.ErrorContains(t, findConfigurationConflicts(config, flags), "authorization-plugins: (from flag: asdf, from file: foobar)") } @@ -74,10 +75,10 @@ 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.NilError(t, flags.Set("host", "tcp://127.0.0.1:4444")) - assert.NilError(t, flags.Set("host", "unix:///var/run/docker.sock")) + assert.NoError(t, flags.Set("host", "tcp://127.0.0.1:4444")) + assert.NoError(t, flags.Set("host", "unix:///var/run/docker.sock")) - assert.Error(t, findConfigurationConflicts(config, flags), "hosts") + testutil.ErrorContains(t, findConfigurationConflicts(config, flags), "hosts") } func TestDaemonConfigurationMergeConflicts(t *testing.T) { diff --git a/daemon/delete_test.go b/daemon/delete_test.go index 21b4696a6d6c00909e5211f15591bd9ed89d9649..3113d77aee8eb092c6b0f50fcc073dcc85427731 100644 --- a/daemon/delete_test.go +++ b/daemon/delete_test.go @@ -9,12 +9,13 @@ import ( "github.com/docker/docker/api/types" containertypes "github.com/docker/docker/api/types/container" "github.com/docker/docker/container" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/require" ) func newDaemonWithTmpRoot(t *testing.T) (*Daemon, func()) { tmp, err := ioutil.TempDir("", "docker-daemon-unix-test-") - assert.NilError(t, err) + require.NoError(t, err) d := &Daemon{ repository: tmp, root: tmp, @@ -40,8 +41,8 @@ func TestContainerDeletePaused(t *testing.T) { err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: false}) - assert.Error(t, err, "cannot remove a paused container") - assert.Error(t, err, "Unpause and then stop the container before attempting removal or force remove") + testutil.ErrorContains(t, err, "cannot remove a paused container") + testutil.ErrorContains(t, err, "Unpause and then stop the container before attempting removal or force remove") } // TestContainerDeleteRestarting tests that a useful error message and instructions is given when attempting @@ -63,8 +64,8 @@ func TestContainerDeleteRestarting(t *testing.T) { d.containers.Add(c.ID, c) err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: false}) - assert.Error(t, err, "cannot remove a restarting container") - assert.Error(t, err, "Stop the container before attempting removal or force remove") + testutil.ErrorContains(t, err, "cannot remove a restarting container") + testutil.ErrorContains(t, err, "Stop the container before attempting removal or force remove") } // TestContainerDeleteRunning tests that a useful error message and instructions is given when attempting @@ -83,8 +84,7 @@ func TestContainerDeleteRunning(t *testing.T) { d.containers.Add(c.ID, c) err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: false}) - assert.Error(t, err, "cannot remove a running container") - assert.Error(t, err, "Stop the container before attempting removal or force remove") + testutil.ErrorContains(t, err, "cannot remove a running container") } func TestContainerDoubleDelete(t *testing.T) { @@ -106,5 +106,5 @@ func TestContainerDoubleDelete(t *testing.T) { // Try to remove the container when its state is removalInProgress. // It should return an error indicating it is under removal progress. err := d.ContainerRm(c.ID, &types.ContainerRmConfig{ForceRemove: true}) - assert.Error(t, err, fmt.Sprintf("removal of container %s is already in progress", c.ID)) + testutil.ErrorContains(t, err, fmt.Sprintf("removal of container %s is already in progress", c.ID)) } diff --git a/image/fs_test.go b/image/fs_test.go index 76abbdcc42d5e89c45ca4f921a803ef0195f635d..5f2437cadd42c1684f54941b7e428c85595f7700 100644 --- a/image/fs_test.go +++ b/image/fs_test.go @@ -11,16 +11,17 @@ import ( "path/filepath" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "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.NilError(t, err) + assert.NoError(t, err) fsBackend, err := NewFSStoreBackend(tmpdir) - assert.NilError(t, err) + assert.NoError(t, err) return fsBackend, func() { os.RemoveAll(tmpdir) } } @@ -30,15 +31,15 @@ func TestFSGetInvalidData(t *testing.T) { defer cleanup() id, err := store.Set([]byte("foobar")) - assert.NilError(t, err) + assert.NoError(t, err) dgst := digest.Digest(id) err = ioutil.WriteFile(filepath.Join(store.(*fs).root, contentDirName, string(dgst.Algorithm()), dgst.Hex()), []byte("foobar2"), 0600) - assert.NilError(t, err) + assert.NoError(t, err) _, err = store.Get(id) - assert.Error(t, err, "failed to verify") + testutil.ErrorContains(t, err, "failed to verify") } func TestFSInvalidSet(t *testing.T) { @@ -47,15 +48,15 @@ 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.NilError(t, err) + assert.NoError(t, err) _, err = store.Set([]byte("foobar")) - assert.Error(t, err, "failed to write digest data") + testutil.ErrorContains(t, err, "failed to write digest data") } func TestFSInvalidRoot(t *testing.T) { tmpdir, err := ioutil.TempDir("", "images-fs-store") - assert.NilError(t, err) + assert.NoError(t, err) defer os.RemoveAll(tmpdir) tcases := []struct { @@ -70,14 +71,14 @@ 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.NilError(t, err) + assert.NoError(t, err) f, err := os.Create(filePath) - assert.NilError(t, err) + assert.NoError(t, err) f.Close() _, err = NewFSStoreBackend(root) - assert.Error(t, err, "failed to create storage backend") + testutil.ErrorContains(t, err, "failed to create storage backend") os.RemoveAll(root) } @@ -89,10 +90,10 @@ func TestFSMetadataGetSet(t *testing.T) { defer cleanup() id, err := store.Set([]byte("foo")) - assert.NilError(t, err) + assert.NoError(t, err) id2, err := store.Set([]byte("bar")) - assert.NilError(t, err) + assert.NoError(t, err) tcases := []struct { id digest.Digest @@ -106,10 +107,10 @@ func TestFSMetadataGetSet(t *testing.T) { for _, tc := range tcases { err = store.SetMetadata(tc.id, tc.key, tc.value) - assert.NilError(t, err) + assert.NoError(t, err) actual, err := store.GetMetadata(tc.id, tc.key) - assert.NilError(t, err) + assert.NoError(t, err) if bytes.Compare(actual, tc.value) != 0 { t.Fatalf("Metadata expected %q, got %q", tc.value, actual) @@ -117,14 +118,14 @@ func TestFSMetadataGetSet(t *testing.T) { } _, err = store.GetMetadata(id2, "tkey2") - assert.Error(t, err, "failed to read metadata") + testutil.ErrorContains(t, err, "failed to read metadata") id3 := digest.FromBytes([]byte("baz")) err = store.SetMetadata(id3, "tkey", []byte("tval")) - assert.Error(t, err, "failed to get digest") + testutil.ErrorContains(t, err, "failed to get digest") _, err = store.GetMetadata(id3, "tkey") - assert.Error(t, err, "failed to get digest") + testutil.ErrorContains(t, err, "failed to get digest") } func TestFSInvalidWalker(t *testing.T) { @@ -132,19 +133,19 @@ func TestFSInvalidWalker(t *testing.T) { defer cleanup() fooID, err := store.Set([]byte("foo")) - assert.NilError(t, err) + assert.NoError(t, err) err = ioutil.WriteFile(filepath.Join(store.(*fs).root, contentDirName, "sha256/foobar"), []byte("foobar"), 0600) - assert.NilError(t, err) + assert.NoError(t, err) n := 0 err = store.Walk(func(id digest.Digest) error { - assert.Equal(t, id, fooID) + assert.Equal(t, fooID, id) n++ return nil }) - assert.NilError(t, err) - assert.Equal(t, n, 1) + assert.NoError(t, err) + assert.Equal(t, 1, n) } func TestFSGetSet(t *testing.T) { @@ -161,12 +162,12 @@ func TestFSGetSet(t *testing.T) { randomInput := make([]byte, 8*1024) _, err := rand.Read(randomInput) - assert.NilError(t, err) + assert.NoError(t, err) // skipping use of digest pkg because it is used by the implementation h := sha256.New() _, err = h.Write(randomInput) - assert.NilError(t, err) + assert.NoError(t, err) tcases = append(tcases, tcase{ input: randomInput, @@ -175,13 +176,13 @@ func TestFSGetSet(t *testing.T) { for _, tc := range tcases { id, err := store.Set([]byte(tc.input)) - assert.NilError(t, err) - assert.Equal(t, id, tc.expected) + assert.NoError(t, err) + assert.Equal(t, tc.expected, id) } for _, tc := range tcases { data, err := store.Get(tc.expected) - assert.NilError(t, err) + assert.NoError(t, err) if bytes.Compare(data, tc.input) != 0 { t.Fatalf("expected data %q, got %q", tc.input, data) } @@ -194,7 +195,7 @@ func TestFSGetUnsetKey(t *testing.T) { for _, key := range []digest.Digest{"foobar:abc", "sha256:abc", "sha256:c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2a"} { _, err := store.Get(key) - assert.Error(t, err, "failed to get digest") + testutil.ErrorContains(t, err, "failed to get digest") } } @@ -204,7 +205,7 @@ func TestFSGetEmptyData(t *testing.T) { for _, emptyData := range [][]byte{nil, {}} { _, err := store.Set(emptyData) - assert.Error(t, err, "invalid empty data") + testutil.ErrorContains(t, err, "invalid empty data") } } @@ -213,25 +214,25 @@ func TestFSDelete(t *testing.T) { defer cleanup() id, err := store.Set([]byte("foo")) - assert.NilError(t, err) + assert.NoError(t, err) id2, err := store.Set([]byte("bar")) - assert.NilError(t, err) + assert.NoError(t, err) err = store.Delete(id) - assert.NilError(t, err) + assert.NoError(t, err) _, err = store.Get(id) - assert.Error(t, err, "failed to get digest") + testutil.ErrorContains(t, err, "failed to get digest") _, err = store.Get(id2) - assert.NilError(t, err) + assert.NoError(t, err) err = store.Delete(id2) - assert.NilError(t, err) + assert.NoError(t, err) _, err = store.Get(id2) - assert.Error(t, err, "failed to get digest") + testutil.ErrorContains(t, err, "failed to get digest") } func TestFSWalker(t *testing.T) { @@ -239,10 +240,10 @@ func TestFSWalker(t *testing.T) { defer cleanup() id, err := store.Set([]byte("foo")) - assert.NilError(t, err) + assert.NoError(t, err) id2, err := store.Set([]byte("bar")) - assert.NilError(t, err) + assert.NoError(t, err) tcases := make(map[digest.Digest]struct{}) tcases[id] = struct{}{} @@ -253,9 +254,9 @@ func TestFSWalker(t *testing.T) { n++ return nil }) - assert.NilError(t, err) - assert.Equal(t, n, 2) - assert.Equal(t, len(tcases), 0) + assert.NoError(t, err) + assert.Equal(t, 2, n) + assert.Len(t, tcases, 0) } func TestFSWalkerStopOnError(t *testing.T) { @@ -263,12 +264,12 @@ func TestFSWalkerStopOnError(t *testing.T) { defer cleanup() id, err := store.Set([]byte("foo")) - assert.NilError(t, err) + assert.NoError(t, err) tcases := make(map[digest.Digest]struct{}) tcases[id] = struct{}{} err = store.Walk(func(id digest.Digest) error { return errors.New("what") }) - assert.Error(t, err, "what") + testutil.ErrorContains(t, err, "what") } diff --git a/image/image_test.go b/image/image_test.go index b0561536d3cc5de6e9ff0a158e6c714c5ea7542e..1455947df262be77a0095dda2ac0a5ab3b4f088b 100644 --- a/image/image_test.go +++ b/image/image_test.go @@ -6,7 +6,8 @@ import ( "strings" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) const sampleImageJSON = `{ @@ -21,13 +22,13 @@ const sampleImageJSON = `{ func TestNewFromJSON(t *testing.T) { img, err := NewFromJSON([]byte(sampleImageJSON)) - assert.NilError(t, err) - assert.Equal(t, string(img.RawJSON()), sampleImageJSON) + require.NoError(t, err) + assert.Equal(t, sampleImageJSON, string(img.RawJSON())) } func TestNewFromJSONWithInvalidJSON(t *testing.T) { _, err := NewFromJSON([]byte("{}")) - assert.Error(t, err, "invalid image JSON, no RootFS key") + assert.EqualError(t, err, "invalid image JSON, no RootFS key") } func TestMarshalKeyOrder(t *testing.T) { @@ -38,7 +39,7 @@ func TestMarshalKeyOrder(t *testing.T) { Architecture: "c", }, }) - assert.NilError(t, err) + assert.NoError(t, err) expectedOrder := []string{"architecture", "author", "comment"} var indexes []int diff --git a/image/store_test.go b/image/store_test.go index bc0148b03ebcaf20a9cfb2d4b0c0ff922f541d48..21a9b0b41b009187810a9b3a193bb906aa8a46eb 100644 --- a/image/store_test.go +++ b/image/store_test.go @@ -4,8 +4,9 @@ import ( "testing" "github.com/docker/docker/layer" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" "github.com/opencontainers/go-digest" + "github.com/stretchr/testify/assert" ) func TestRestore(t *testing.T) { @@ -13,55 +14,55 @@ func TestRestore(t *testing.T) { defer cleanup() id1, err := fs.Set([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`)) - assert.NilError(t, err) + assert.NoError(t, err) _, err = fs.Set([]byte(`invalid`)) - assert.NilError(t, err) + assert.NoError(t, err) id2, err := fs.Set([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`)) - assert.NilError(t, err) + assert.NoError(t, err) err = fs.SetMetadata(id2, "parent", []byte(id1)) - assert.NilError(t, err) + assert.NoError(t, err) is, err := NewImageStore(fs, &mockLayerGetReleaser{}) - assert.NilError(t, err) + assert.NoError(t, err) - assert.Equal(t, len(is.Map()), 2) + assert.Len(t, is.Map(), 2) img1, err := is.Get(ID(id1)) - assert.NilError(t, err) - assert.Equal(t, img1.computedID, ID(id1)) - assert.Equal(t, img1.computedID.String(), string(id1)) + assert.NoError(t, err) + assert.Equal(t, ID(id1), img1.computedID) + assert.Equal(t, string(id1), img1.computedID.String()) img2, err := is.Get(ID(id2)) - assert.NilError(t, err) - assert.Equal(t, img1.Comment, "abc") - assert.Equal(t, img2.Comment, "def") + assert.NoError(t, err) + assert.Equal(t, "abc", img1.Comment) + assert.Equal(t, "def", img2.Comment) p, err := is.GetParent(ID(id1)) - assert.Error(t, err, "failed to read metadata") + testutil.ErrorContains(t, err, "failed to read metadata") p, err = is.GetParent(ID(id2)) - assert.NilError(t, err) - assert.Equal(t, p, ID(id1)) + assert.NoError(t, err) + assert.Equal(t, ID(id1), p) children := is.Children(ID(id1)) - assert.Equal(t, len(children), 1) - assert.Equal(t, children[0], ID(id2)) - assert.Equal(t, len(is.Heads()), 1) + assert.Len(t, children, 1) + assert.Equal(t, ID(id2), children[0]) + assert.Len(t, is.Heads(), 1) sid1, err := is.Search(string(id1)[:10]) - assert.NilError(t, err) - assert.Equal(t, sid1, ID(id1)) + assert.NoError(t, err) + assert.Equal(t, ID(id1), sid1) sid1, err = is.Search(digest.Digest(id1).Hex()[:6]) - assert.NilError(t, err) - assert.Equal(t, sid1, ID(id1)) + assert.NoError(t, err) + assert.Equal(t, ID(id1), sid1) invalidPattern := digest.Digest(id1).Hex()[1:6] _, err = is.Search(invalidPattern) - assert.Error(t, err, "No such image") + testutil.ErrorContains(t, err, "No such image") } func TestAddDelete(t *testing.T) { @@ -69,34 +70,34 @@ func TestAddDelete(t *testing.T) { defer cleanup() id1, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`)) - assert.NilError(t, err) - assert.Equal(t, id1, ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993")) + assert.NoError(t, err) + assert.Equal(t, ID("sha256:8d25a9c45df515f9d0fe8e4a6b1c64dd3b965a84790ddbcc7954bb9bc89eb993"), id1) img, err := is.Get(id1) - assert.NilError(t, err) - assert.Equal(t, img.Comment, "abc") + assert.NoError(t, err) + assert.Equal(t, "abc", img.Comment) id2, err := is.Create([]byte(`{"comment": "def", "rootfs": {"type": "layers", "diff_ids": ["2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae"]}}`)) - assert.NilError(t, err) + assert.NoError(t, err) err = is.SetParent(id2, id1) - assert.NilError(t, err) + assert.NoError(t, err) pid1, err := is.GetParent(id2) - assert.NilError(t, err) + assert.NoError(t, err) assert.Equal(t, pid1, id1) _, err = is.Delete(id1) - assert.NilError(t, err) + assert.NoError(t, err) _, err = is.Get(id1) - assert.Error(t, err, "failed to get digest") + testutil.ErrorContains(t, err, "failed to get digest") _, err = is.Get(id2) - assert.NilError(t, err) + assert.NoError(t, err) _, err = is.GetParent(id2) - assert.Error(t, err, "failed to read metadata") + testutil.ErrorContains(t, err, "failed to read metadata") } func TestSearchAfterDelete(t *testing.T) { @@ -104,17 +105,17 @@ func TestSearchAfterDelete(t *testing.T) { defer cleanup() id, err := is.Create([]byte(`{"comment": "abc", "rootfs": {"type": "layers"}}`)) - assert.NilError(t, err) + assert.NoError(t, err) id1, err := is.Search(string(id)[:15]) - assert.NilError(t, err) + assert.NoError(t, err) assert.Equal(t, id1, id) _, err = is.Delete(id) - assert.NilError(t, err) + assert.NoError(t, err) _, err = is.Search(string(id)[:15]) - assert.Error(t, err, "No such image") + testutil.ErrorContains(t, err, "No such image") } func TestParentReset(t *testing.T) { @@ -122,27 +123,27 @@ func TestParentReset(t *testing.T) { defer cleanup() id, err := is.Create([]byte(`{"comment": "abc1", "rootfs": {"type": "layers"}}`)) - assert.NilError(t, err) + assert.NoError(t, err) id2, err := is.Create([]byte(`{"comment": "abc2", "rootfs": {"type": "layers"}}`)) - assert.NilError(t, err) + assert.NoError(t, err) id3, err := is.Create([]byte(`{"comment": "abc3", "rootfs": {"type": "layers"}}`)) - assert.NilError(t, err) + assert.NoError(t, err) - assert.NilError(t, is.SetParent(id, id2)) - assert.Equal(t, len(is.Children(id2)), 1) + assert.NoError(t, is.SetParent(id, id2)) + assert.Len(t, is.Children(id2), 1) - assert.NilError(t, is.SetParent(id, id3)) - assert.Equal(t, len(is.Children(id2)), 0) - assert.Equal(t, len(is.Children(id3)), 1) + assert.NoError(t, is.SetParent(id, id3)) + assert.Len(t, is.Children(id2), 0) + assert.Len(t, is.Children(id3), 1) } func defaultImageStore(t *testing.T) (Store, func()) { fsBackend, cleanup := defaultFSStoreBackend(t) store, err := NewImageStore(fsBackend, &mockLayerGetReleaser{}) - assert.NilError(t, err) + assert.NoError(t, err) return store, cleanup } diff --git a/opts/mount_test.go b/opts/mount_test.go index 59606c38e2c33e27f28c6f18de2726aa9097faf3..72aaa6258e03ed936802ace3ce0504b968ebe7a1 100644 --- a/opts/mount_test.go +++ b/opts/mount_test.go @@ -5,7 +5,9 @@ import ( "testing" mounttypes "github.com/docker/docker/api/types/mount" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestMountOptString(t *testing.T) { @@ -24,7 +26,7 @@ func TestMountOptString(t *testing.T) { }, } expected := "bind /home/path /target, volume foo /target/foo" - assert.Equal(t, mount.String(), expected) + assert.Equal(t, expected, mount.String()) } func TestMountOptSetBindNoErrorBind(t *testing.T) { @@ -37,15 +39,15 @@ func TestMountOptSetBindNoErrorBind(t *testing.T) { } { var mount MountOpt - assert.NilError(t, mount.Set(testcase)) + assert.NoError(t, mount.Set(testcase)) mounts := mount.Value() - assert.Equal(t, len(mounts), 1) - assert.Equal(t, mounts[0], mounttypes.Mount{ + require.Len(t, mounts, 1) + assert.Equal(t, mounttypes.Mount{ Type: mounttypes.TypeBind, Source: "/source", Target: "/target", - }) + }, mounts[0]) } } @@ -59,15 +61,15 @@ func TestMountOptSetVolumeNoError(t *testing.T) { } { var mount MountOpt - assert.NilError(t, mount.Set(testcase)) + assert.NoError(t, mount.Set(testcase)) mounts := mount.Value() - assert.Equal(t, len(mounts), 1) - assert.Equal(t, mounts[0], mounttypes.Mount{ + require.Len(t, mounts, 1) + assert.Equal(t, mounttypes.Mount{ Type: mounttypes.TypeVolume, Source: "/source", Target: "/target", - }) + }, mounts[0]) } } @@ -75,82 +77,82 @@ func TestMountOptSetVolumeNoError(t *testing.T) { // volume mount. func TestMountOptDefaultType(t *testing.T) { var mount MountOpt - assert.NilError(t, mount.Set("target=/target,source=/foo")) - assert.Equal(t, mount.values[0].Type, mounttypes.TypeVolume) + assert.NoError(t, mount.Set("target=/target,source=/foo")) + assert.Equal(t, mounttypes.TypeVolume, mount.values[0].Type) } func TestMountOptSetErrorNoTarget(t *testing.T) { var mount MountOpt - assert.Error(t, mount.Set("type=volume,source=/foo"), "target is required") + assert.EqualError(t, mount.Set("type=volume,source=/foo"), "target is required") } func TestMountOptSetErrorInvalidKey(t *testing.T) { var mount MountOpt - assert.Error(t, mount.Set("type=volume,bogus=foo"), "unexpected key 'bogus'") + assert.EqualError(t, mount.Set("type=volume,bogus=foo"), "unexpected key 'bogus' in 'bogus=foo'") } func TestMountOptSetErrorInvalidField(t *testing.T) { var mount MountOpt - assert.Error(t, mount.Set("type=volume,bogus"), "invalid field 'bogus'") + assert.EqualError(t, mount.Set("type=volume,bogus"), "invalid field 'bogus' must be a key=value pair") } func TestMountOptSetErrorInvalidReadOnly(t *testing.T) { var mount MountOpt - assert.Error(t, mount.Set("type=volume,readonly=no"), "invalid value for readonly: no") - assert.Error(t, mount.Set("type=volume,readonly=invalid"), "invalid value for readonly: invalid") + assert.EqualError(t, mount.Set("type=volume,readonly=no"), "invalid value for readonly: no") + assert.EqualError(t, mount.Set("type=volume,readonly=invalid"), "invalid value for readonly: invalid") } func TestMountOptDefaultEnableReadOnly(t *testing.T) { var m MountOpt - assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo")) - assert.Equal(t, m.values[0].ReadOnly, false) + assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo")) + assert.False(t, m.values[0].ReadOnly) m = MountOpt{} - assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly")) - assert.Equal(t, m.values[0].ReadOnly, true) + assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly")) + assert.True(t, m.values[0].ReadOnly) m = MountOpt{} - assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=1")) - assert.Equal(t, m.values[0].ReadOnly, true) + assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=1")) + assert.True(t, m.values[0].ReadOnly) m = MountOpt{} - assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=true")) - assert.Equal(t, m.values[0].ReadOnly, true) + assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=true")) + assert.True(t, m.values[0].ReadOnly) m = MountOpt{} - assert.NilError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=0")) - assert.Equal(t, m.values[0].ReadOnly, false) + assert.NoError(t, m.Set("type=bind,target=/foo,source=/foo,readonly=0")) + assert.False(t, m.values[0].ReadOnly) } func TestMountOptVolumeNoCopy(t *testing.T) { var m MountOpt - assert.NilError(t, m.Set("type=volume,target=/foo,volume-nocopy")) - assert.Equal(t, m.values[0].Source, "") + assert.NoError(t, m.Set("type=volume,target=/foo,volume-nocopy")) + assert.Equal(t, "", m.values[0].Source) m = MountOpt{} - assert.NilError(t, m.Set("type=volume,target=/foo,source=foo")) - assert.Equal(t, m.values[0].VolumeOptions == nil, true) + assert.NoError(t, m.Set("type=volume,target=/foo,source=foo")) + assert.True(t, m.values[0].VolumeOptions == nil) m = MountOpt{} - assert.NilError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=true")) - assert.Equal(t, m.values[0].VolumeOptions != nil, true) - assert.Equal(t, m.values[0].VolumeOptions.NoCopy, true) + assert.NoError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=true")) + assert.True(t, m.values[0].VolumeOptions != nil) + assert.True(t, m.values[0].VolumeOptions.NoCopy) m = MountOpt{} - assert.NilError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy")) - assert.Equal(t, m.values[0].VolumeOptions != nil, true) - assert.Equal(t, m.values[0].VolumeOptions.NoCopy, true) + assert.NoError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy")) + assert.True(t, m.values[0].VolumeOptions != nil) + assert.True(t, m.values[0].VolumeOptions.NoCopy) m = MountOpt{} - assert.NilError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=1")) - assert.Equal(t, m.values[0].VolumeOptions != nil, true) - assert.Equal(t, m.values[0].VolumeOptions.NoCopy, true) + assert.NoError(t, m.Set("type=volume,target=/foo,source=foo,volume-nocopy=1")) + assert.True(t, m.values[0].VolumeOptions != nil) + assert.True(t, m.values[0].VolumeOptions.NoCopy) } func TestMountOptTypeConflict(t *testing.T) { var m MountOpt - assert.Error(t, m.Set("type=bind,target=/foo,source=/foo,volume-nocopy=true"), "cannot mix") - assert.Error(t, m.Set("type=volume,target=/foo,source=/foo,bind-propagation=rprivate"), "cannot mix") + testutil.ErrorContains(t, m.Set("type=bind,target=/foo,source=/foo,volume-nocopy=true"), "cannot mix") + testutil.ErrorContains(t, m.Set("type=volume,target=/foo,source=/foo,bind-propagation=rprivate"), "cannot mix") } func TestMountOptSetTmpfsNoError(t *testing.T) { @@ -161,24 +163,24 @@ func TestMountOptSetTmpfsNoError(t *testing.T) { } { var mount MountOpt - assert.NilError(t, mount.Set(testcase)) + assert.NoError(t, mount.Set(testcase)) mounts := mount.Value() - assert.Equal(t, len(mounts), 1) - assert.DeepEqual(t, mounts[0], mounttypes.Mount{ + require.Len(t, mounts, 1) + assert.Equal(t, mounttypes.Mount{ Type: mounttypes.TypeTmpfs, Target: "/target", TmpfsOptions: &mounttypes.TmpfsOptions{ SizeBytes: 1024 * 1024, // not 1000 * 1000 Mode: os.FileMode(0700), }, - }) + }, mounts[0]) } } func TestMountOptSetTmpfsError(t *testing.T) { var m MountOpt - assert.Error(t, m.Set("type=tmpfs,target=/foo,tmpfs-size=foo"), "invalid value for tmpfs-size") - assert.Error(t, m.Set("type=tmpfs,target=/foo,tmpfs-mode=foo"), "invalid value for tmpfs-mode") - assert.Error(t, m.Set("type=tmpfs"), "target is required") + testutil.ErrorContains(t, m.Set("type=tmpfs,target=/foo,tmpfs-size=foo"), "invalid value for tmpfs-size") + testutil.ErrorContains(t, m.Set("type=tmpfs,target=/foo,tmpfs-mode=foo"), "invalid value for tmpfs-mode") + testutil.ErrorContains(t, m.Set("type=tmpfs"), "target is required") } diff --git a/opts/port_test.go b/opts/port_test.go index a483d269aad5bdf68a21c7e1a0f20c0de4c48dff..9315b7218c69be2191356a276f13b6919fa5067d 100644 --- a/opts/port_test.go +++ b/opts/port_test.go @@ -4,7 +4,8 @@ import ( "testing" "github.com/docker/docker/api/types/swarm" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/docker/docker/pkg/testutil" + "github.com/stretchr/testify/assert" ) func TestPortOptValidSimpleSyntax(t *testing.T) { @@ -98,8 +99,8 @@ func TestPortOptValidSimpleSyntax(t *testing.T) { } for _, tc := range testCases { var port PortOpt - assert.NilError(t, port.Set(tc.value)) - assert.Equal(t, len(port.Value()), len(tc.expected)) + assert.NoError(t, port.Set(tc.value)) + assert.Len(t, port.Value(), len(tc.expected)) for _, expectedPortConfig := range tc.expected { assertContains(t, port.Value(), expectedPortConfig) } @@ -189,8 +190,8 @@ func TestPortOptValidComplexSyntax(t *testing.T) { } for _, tc := range testCases { var port PortOpt - assert.NilError(t, port.Set(tc.value)) - assert.Equal(t, len(port.Value()), len(tc.expected)) + assert.NoError(t, port.Set(tc.value)) + assert.Len(t, port.Value(), len(tc.expected)) for _, expectedPortConfig := range tc.expected { assertContains(t, port.Value(), expectedPortConfig) } @@ -241,7 +242,7 @@ func TestPortOptInvalidComplexSyntax(t *testing.T) { } for _, tc := range testCases { var port PortOpt - assert.Error(t, port.Set(tc.value), tc.expectedError) + testutil.ErrorContains(t, port.Set(tc.value), tc.expectedError) } } @@ -268,16 +269,16 @@ func TestPortOptInvalidSimpleSyntax(t *testing.T) { }, { value: "", - expectedError: "No port specified", + expectedError: "No port specified: ", }, { value: "1.1.1.1:80:80", - expectedError: "HostIP is not supported", + expectedError: "HostIP is not supported.", }, } for _, tc := range testCases { var port PortOpt - assert.Error(t, port.Set(tc.value), tc.expectedError) + assert.EqualError(t, port.Set(tc.value), tc.expectedError) } } diff --git a/opts/quotedstring_test.go b/opts/quotedstring_test.go index 0ebf04bbe044ba5906b41387e1fccc4a5c048e81..54dcbc19bc7aa6238b6c356a9276cee8e2debb81 100644 --- a/opts/quotedstring_test.go +++ b/opts/quotedstring_test.go @@ -1,28 +1,29 @@ package opts import ( - "github.com/docker/docker/pkg/testutil/assert" "testing" + + "github.com/stretchr/testify/assert" ) func TestQuotedStringSetWithQuotes(t *testing.T) { value := "" qs := NewQuotedString(&value) - assert.NilError(t, qs.Set("\"something\"")) - assert.Equal(t, qs.String(), "something") - assert.Equal(t, value, "something") + assert.NoError(t, qs.Set(`"something"`)) + assert.Equal(t, "something", qs.String()) + assert.Equal(t, "something", value) } func TestQuotedStringSetWithMismatchedQuotes(t *testing.T) { value := "" qs := NewQuotedString(&value) - assert.NilError(t, qs.Set("\"something'")) - assert.Equal(t, qs.String(), "\"something'") + assert.NoError(t, qs.Set(`"something'`)) + assert.Equal(t, `"something'`, qs.String()) } func TestQuotedStringSetWithNoQuotes(t *testing.T) { value := "" qs := NewQuotedString(&value) - assert.NilError(t, qs.Set("something")) - assert.Equal(t, qs.String(), "something") + assert.NoError(t, qs.Set("something")) + assert.Equal(t, "something", qs.String()) } diff --git a/opts/secret_test.go b/opts/secret_test.go index 5654c79f1f5a15276aa3b990a4c9bb67dd001021..ad0005e4ad75cf083a4850cef085355dbc35d6b1 100644 --- a/opts/secret_test.go +++ b/opts/secret_test.go @@ -4,76 +4,77 @@ import ( "os" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) func TestSecretOptionsSimple(t *testing.T) { var opt SecretOpt testCase := "app-secret" - assert.NilError(t, opt.Set(testCase)) + assert.NoError(t, opt.Set(testCase)) reqs := opt.Value() - assert.Equal(t, len(reqs), 1) + require.Len(t, reqs, 1) req := reqs[0] - assert.Equal(t, req.SecretName, "app-secret") - assert.Equal(t, req.File.Name, "app-secret") - assert.Equal(t, req.File.UID, "0") - assert.Equal(t, req.File.GID, "0") + assert.Equal(t, "app-secret", req.SecretName) + assert.Equal(t, "app-secret", req.File.Name) + assert.Equal(t, "0", req.File.UID) + assert.Equal(t, "0", req.File.GID) } func TestSecretOptionsSourceTarget(t *testing.T) { var opt SecretOpt testCase := "source=foo,target=testing" - assert.NilError(t, opt.Set(testCase)) + assert.NoError(t, opt.Set(testCase)) reqs := opt.Value() - assert.Equal(t, len(reqs), 1) + require.Len(t, reqs, 1) req := reqs[0] - assert.Equal(t, req.SecretName, "foo") - assert.Equal(t, req.File.Name, "testing") + assert.Equal(t, "foo", req.SecretName) + assert.Equal(t, "testing", req.File.Name) } func TestSecretOptionsShorthand(t *testing.T) { var opt SecretOpt testCase := "src=foo,target=testing" - assert.NilError(t, opt.Set(testCase)) + assert.NoError(t, opt.Set(testCase)) reqs := opt.Value() - assert.Equal(t, len(reqs), 1) + require.Len(t, reqs, 1) req := reqs[0] - assert.Equal(t, req.SecretName, "foo") + assert.Equal(t, "foo", req.SecretName) } func TestSecretOptionsCustomUidGid(t *testing.T) { var opt SecretOpt testCase := "source=foo,target=testing,uid=1000,gid=1001" - assert.NilError(t, opt.Set(testCase)) + assert.NoError(t, opt.Set(testCase)) reqs := opt.Value() - assert.Equal(t, len(reqs), 1) + require.Len(t, reqs, 1) req := reqs[0] - assert.Equal(t, req.SecretName, "foo") - assert.Equal(t, req.File.Name, "testing") - assert.Equal(t, req.File.UID, "1000") - assert.Equal(t, req.File.GID, "1001") + assert.Equal(t, "foo", req.SecretName) + assert.Equal(t, "testing", req.File.Name) + assert.Equal(t, "1000", req.File.UID) + assert.Equal(t, "1001", req.File.GID) } func TestSecretOptionsCustomMode(t *testing.T) { var opt SecretOpt testCase := "source=foo,target=testing,uid=1000,gid=1001,mode=0444" - assert.NilError(t, opt.Set(testCase)) + assert.NoError(t, opt.Set(testCase)) reqs := opt.Value() - assert.Equal(t, len(reqs), 1) + require.Len(t, reqs, 1) req := reqs[0] - assert.Equal(t, req.SecretName, "foo") - assert.Equal(t, req.File.Name, "testing") - assert.Equal(t, req.File.UID, "1000") - assert.Equal(t, req.File.GID, "1001") - assert.Equal(t, req.File.Mode, os.FileMode(0444)) + assert.Equal(t, "foo", req.SecretName) + assert.Equal(t, "testing", req.File.Name) + assert.Equal(t, "1000", req.File.UID) + assert.Equal(t, "1001", req.File.GID) + assert.Equal(t, os.FileMode(0444), req.File.Mode) } diff --git a/pkg/archive/archive_test.go b/pkg/archive/archive_test.go index 481369da7327c1aded88e725021d0dd950735b23..e351a0455baa34000378486ba0f843761ae3f6b1 100644 --- a/pkg/archive/archive_test.go +++ b/pkg/archive/archive_test.go @@ -14,7 +14,8 @@ import ( "testing" "time" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" ) var tmp string @@ -1211,19 +1212,19 @@ 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, actual, testcase.expected, testcase.doc) + assert.Equal(t, testcase.expected, actual, testcase.doc) } } func buildSourceArchive(t *testing.T, numberOfFiles int) (io.ReadCloser, func()) { srcDir, err := ioutil.TempDir("", "docker-test-srcDir") - assert.NilError(t, err) + require.NoError(t, err) _, err = prepareUntarSourceDirectory(numberOfFiles, srcDir, false) - assert.NilError(t, err) + require.NoError(t, err) sourceArchive, err := TarWithOptions(srcDir, &TarOptions{}) - assert.NilError(t, err) + require.NoError(t, err) return sourceArchive, func() { os.RemoveAll(srcDir) sourceArchive.Close() @@ -1257,16 +1258,16 @@ 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") - assert.NilError(t, err) + require.NoError(t, err) defer os.RemoveAll(destDir) err = Untar(archive, destDir, nil) - assert.NilError(t, err) + require.NoError(t, err) files, _ := ioutil.ReadDir(destDir) - assert.Equal(t, len(files), expectedCount, doc) + assert.Len(t, files, expectedCount, doc) content, err := ioutil.ReadFile(filepath.Join(destDir, name)) - assert.NilError(t, err) + assert.NoError(t, err) return string(content) } diff --git a/pkg/templates/templates_test.go b/pkg/templates/templates_test.go index 7fa1df64ee7fd32e24da0baad15d70b34e839161..f97257191237d7b60acd7186a4486cffc59439b0 100644 --- a/pkg/templates/templates_test.go +++ b/pkg/templates/templates_test.go @@ -4,27 +4,27 @@ import ( "bytes" "testing" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestParseStringFunctions(t *testing.T) { tm, err := Parse(`{{join (split . ":") "/"}}`) - assert.NilError(t, err) + assert.NoError(t, err) var b bytes.Buffer - assert.NilError(t, tm.Execute(&b, "text:with:colon")) + assert.NoError(t, tm.Execute(&b, "text:with:colon")) want := "text/with/colon" - assert.Equal(t, b.String(), want) + assert.Equal(t, want, b.String()) } func TestNewParse(t *testing.T) { tm, err := NewParse("foo", "this is a {{ . }}") - assert.NilError(t, err) + assert.NoError(t, err) var b bytes.Buffer - assert.NilError(t, tm.Execute(&b, "string")) + assert.NoError(t, tm.Execute(&b, "string")) want := "this is a string" - assert.Equal(t, b.String(), want) + assert.Equal(t, want, b.String()) } func TestParseTruncateFunction(t *testing.T) { @@ -50,10 +50,10 @@ func TestParseTruncateFunction(t *testing.T) { for _, testCase := range testCases { tm, err := Parse(testCase.template) - assert.NilError(t, err) + assert.NoError(t, err) var b bytes.Buffer - assert.NilError(t, tm.Execute(&b, source)) - assert.Equal(t, b.String(), testCase.expected) + assert.NoError(t, tm.Execute(&b, source)) + assert.Equal(t, testCase.expected, b.String()) } } diff --git a/pkg/testutil/assert/assert.go b/pkg/testutil/assert/assert.go deleted file mode 100644 index fdc0fab5d8b4b15e3fce53f13ae0779e0a5e8ff0..0000000000000000000000000000000000000000 --- a/pkg/testutil/assert/assert.go +++ /dev/null @@ -1,132 +0,0 @@ -// Package assert contains functions for making assertions in unit tests -package assert - -import ( - "fmt" - "path/filepath" - "reflect" - "runtime" - "strings" - "unicode" - - "github.com/davecgh/go-spew/spew" -) - -// TestingT is an interface which defines the methods of testing.T that are -// required by this package -type TestingT interface { - Fatalf(string, ...interface{}) -} - -// Equal compare the actual value to the expected value and fails the test if -// they are not equal. -func Equal(t TestingT, actual, expected interface{}, extra ...string) { - if expected != actual { - fatalWithExtra(t, extra, "Expected '%v' (%T) got '%v' (%T)", expected, expected, actual, actual) - } -} - -// EqualNormalizedString compare the actual value to the expected value after applying the specified -// transform function. It fails the test if these two transformed string are not equal. -// For example `EqualNormalizedString(t, RemoveSpace, "foo\n", "foo")` wouldn't fail the test as -// spaces (and thus '\n') are removed before comparing the string. -func EqualNormalizedString(t TestingT, transformFun func(rune) rune, actual, expected string) { - if strings.Map(transformFun, actual) != strings.Map(transformFun, expected) { - fatal(t, "Expected '%v' got '%v'", expected, expected, actual, actual) - } -} - -// RemoveSpace returns -1 if the specified runes is considered as a space (unicode) -// and the rune itself otherwise. -func RemoveSpace(r rune) rune { - if unicode.IsSpace(r) { - return -1 - } - return r -} - -//EqualStringSlice compares two slices and fails the test if they do not contain -// the same items. -func EqualStringSlice(t TestingT, actual, expected []string) { - if len(actual) != len(expected) { - fatal(t, "Expected (length %d): %q\nActual (length %d): %q", - len(expected), expected, len(actual), actual) - } - for i, item := range actual { - if item != expected[i] { - fatal(t, "Slices differ at element %d, expected %q got %q", - i, expected[i], item) - } - } -} - -// NilError asserts that the error is nil, otherwise it fails the test. -func NilError(t TestingT, err error) { - if err != nil { - fatal(t, "Expected no error, got: %s", err.Error()) - } -} - -// DeepEqual compare the actual value to the expected value and fails the test if -// they are not "deeply equal". -func DeepEqual(t TestingT, actual, expected interface{}) { - if !reflect.DeepEqual(actual, expected) { - fatal(t, "Expected (%T):\n%v\n\ngot (%T):\n%s\n", - expected, spew.Sdump(expected), actual, spew.Sdump(actual)) - } -} - -// Error asserts that error is not nil, and contains the expected text, -// otherwise it fails the test. -func Error(t TestingT, err error, contains string) { - if err == nil { - fatal(t, "Expected an error, but error was nil") - } - - if !strings.Contains(err.Error(), contains) { - fatal(t, "Expected error to contain '%s', got '%s'", contains, err.Error()) - } -} - -// Contains asserts that the string contains a substring, otherwise it fails the -// test. -func Contains(t TestingT, actual, contains string) { - if !strings.Contains(actual, contains) { - fatal(t, "Expected '%s' to contain '%s'", actual, contains) - } -} - -// NotNil fails the test if the object is nil -func NotNil(t TestingT, obj interface{}) { - if obj == nil { - fatal(t, "Expected non-nil value.") - } -} - -// Nil fails the test if the object is not nil -func Nil(t TestingT, obj interface{}) { - if obj != nil { - fatal(t, "Expected nil value, got (%T) %s", obj, obj) - } -} - -func fatal(t TestingT, format string, args ...interface{}) { - t.Fatalf(errorSource()+format, args...) -} - -func fatalWithExtra(t TestingT, extra []string, format string, args ...interface{}) { - msg := fmt.Sprintf(errorSource()+format, args...) - if len(extra) > 0 { - msg += ": " + strings.Join(extra, ", ") - } - t.Fatalf(msg) -} - -// See testing.decorate() -func errorSource() string { - _, filename, line, ok := runtime.Caller(3) - if !ok { - return "" - } - return fmt.Sprintf("%s:%d: ", filepath.Base(filename), line) -} diff --git a/pkg/testutil/cmd/command_test.go b/pkg/testutil/cmd/command_test.go index df234420794fd2c33a500cf82d4830ea52894822..d24b42b72681cf69ca63584a1a080b8f96d2e35e 100644 --- a/pkg/testutil/cmd/command_test.go +++ b/pkg/testutil/cmd/command_test.go @@ -6,7 +6,7 @@ import ( "testing" "time" - "github.com/docker/docker/pkg/testutil/assert" + "github.com/stretchr/testify/assert" ) func TestRunCommand(t *testing.T) { @@ -74,7 +74,7 @@ func TestRunCommandWithTimeoutKilled(t *testing.T) { result.Assert(t, Expected{Timeout: true}) ones := strings.Split(result.Stdout(), "\n") - assert.Equal(t, len(ones), 4) + assert.Len(t, ones, 4) } func TestRunCommandWithErrors(t *testing.T) { diff --git a/pkg/testutil/helpers.go b/pkg/testutil/helpers.go new file mode 100644 index 0000000000000000000000000000000000000000..c2911487122450d891b5c1007a5c9027e03986e6 --- /dev/null +++ b/pkg/testutil/helpers.go @@ -0,0 +1,33 @@ +package testutil + +import ( + "strings" + "unicode" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// ErrorContains checks that the error is not nil, and contains the expected +// substring. +func ErrorContains(t require.TestingT, err error, expectedError string) { + require.Error(t, err) + assert.Contains(t, err.Error(), expectedError) +} + +// EqualNormalizedString compare the actual value to the expected value after applying the specified +// transform function. It fails the test if these two transformed string are not equal. +// For example `EqualNormalizedString(t, RemoveSpace, "foo\n", "foo")` wouldn't fail the test as +// spaces (and thus '\n') are removed before comparing the string. +func EqualNormalizedString(t require.TestingT, transformFun func(rune) rune, actual, expected string) { + require.Equal(t, strings.Map(transformFun, expected), strings.Map(transformFun, actual)) +} + +// RemoveSpace returns -1 if the specified runes is considered as a space (unicode) +// and the rune itself otherwise. +func RemoveSpace(r rune) rune { + if unicode.IsSpace(r) { + return -1 + } + return r +} diff --git a/pkg/testutil/tempfile/tempfile.go b/pkg/testutil/tempfile/tempfile.go index 48c654d1f43c8a4e1173c13d24125ced72e15d74..b375cb9561ab3a02a75aed4c424dba30a935e3be 100644 --- a/pkg/testutil/tempfile/tempfile.go +++ b/pkg/testutil/tempfile/tempfile.go @@ -1,9 +1,10 @@ package tempfile import ( - "github.com/docker/docker/pkg/testutil/assert" "io/ioutil" "os" + + "github.com/stretchr/testify/require" ) // TempFile is a temporary file that can be used with unit tests. TempFile @@ -14,12 +15,12 @@ type TempFile struct { } // NewTempFile returns a new temp file with contents -func NewTempFile(t assert.TestingT, prefix string, content string) *TempFile { +func NewTempFile(t require.TestingT, prefix string, content string) *TempFile { file, err := ioutil.TempFile("", prefix+"-") - assert.NilError(t, err) + require.NoError(t, err) _, err = file.Write([]byte(content)) - assert.NilError(t, err) + require.NoError(t, err) file.Close() return &TempFile{File: file} } diff --git a/vendor.conf b/vendor.conf index c302b9398d8aed79ed603fdb7a938c14bbb04426..75e68008fb21324aa52c6fc67591b3b1637e0ae3 100644 --- a/vendor.conf +++ b/vendor.conf @@ -4,7 +4,7 @@ github.com/Microsoft/hcsshim v0.5.13 # TODO: get rid of this fork once PR https://github.com/Microsoft/go-winio/pull/43 is merged github.com/Microsoft/go-winio 7c7d6b461cb10872c1138a0d7f3acf9a41b5c353 https://github.com/dgageot/go-winio.git github.com/Sirupsen/logrus v0.11.0 -github.com/davecgh/go-spew 6d212800a42e8ab5c146b8ace3490ee17e5225f9 +github.com/davecgh/go-spew 346938d642f2ec3594ed81d874461961cd0faa76 github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a github.com/go-check/check 4ed411733c5785b40214c70bce814c3a3a689609 https://github.com/cpuguy83/check.git github.com/gorilla/context v1.1 @@ -19,6 +19,7 @@ golang.org/x/sys 8f0908ab3b2457e2e15403d3697c9ef5cb4b57a9 github.com/docker/go-units 9e638d38cf6977a37a8ea0078f3ee75a7cdb2dd1 github.com/docker/go-connections e15c02316c12de00874640cd76311849de2aeed5 golang.org/x/text f72d8390a633d5dfb0cc84043294db9f6c935756 +github.com/stretchr/testify 4d4bfba8f1d1027c4fdbe371823030df51419987 github.com/RackSec/srslog 456df3a81436d29ba874f3590eeeee25d666f8a5 github.com/imdario/mergo 0.2.1 diff --git a/vendor/github.com/davecgh/go-spew/LICENSE b/vendor/github.com/davecgh/go-spew/LICENSE index bb67332310b9709d35e92ebcd75f36d7e9c45684..c836416192da3691281691dfb0d16e177dfd068b 100644 --- a/vendor/github.com/davecgh/go-spew/LICENSE +++ b/vendor/github.com/davecgh/go-spew/LICENSE @@ -1,6 +1,6 @@ ISC License -Copyright (c) 2012-2013 Dave Collins +Copyright (c) 2012-2016 Dave Collins Permission to use, copy, modify, and distribute this software for any purpose with or without fee is hereby granted, provided that the above diff --git a/vendor/github.com/davecgh/go-spew/README.md b/vendor/github.com/davecgh/go-spew/README.md index 556170ae6338197005b3515b195af27036591a27..262430449b272933b04efbb02731997a6772d31a 100644 --- a/vendor/github.com/davecgh/go-spew/README.md +++ b/vendor/github.com/davecgh/go-spew/README.md @@ -1,11 +1,13 @@ go-spew ======= -[![Build Status](https://travis-ci.org/davecgh/go-spew.png?branch=master)] -(https://travis-ci.org/davecgh/go-spew) [![Coverage Status] -(https://coveralls.io/repos/davecgh/go-spew/badge.png?branch=master)] +[![Build Status](https://img.shields.io/travis/davecgh/go-spew.svg)] +(https://travis-ci.org/davecgh/go-spew) [![ISC License] +(http://img.shields.io/badge/license-ISC-blue.svg)](http://copyfree.org) [![Coverage Status] +(https://img.shields.io/coveralls/davecgh/go-spew.svg)] (https://coveralls.io/r/davecgh/go-spew?branch=master) + Go-spew implements a deep pretty printer for Go data structures to aid in debugging. A comprehensive suite of tests with 100% test coverage is provided to ensure proper functionality. See `test_coverage.txt` for the gocov coverage @@ -19,7 +21,7 @@ post about it ## Documentation -[![GoDoc](https://godoc.org/github.com/davecgh/go-spew/spew?status.png)] +[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)] (http://godoc.org/github.com/davecgh/go-spew/spew) Full `go doc` style documentation for the project can be viewed online without @@ -160,6 +162,15 @@ options. See the ConfigState documentation for more details. App Engine or with the "safe" build tag specified. Pointer method invocation is enabled by default. +* DisablePointerAddresses + DisablePointerAddresses specifies whether to disable the printing of + pointer addresses. This is useful when diffing data structures in tests. + +* DisableCapacities + DisableCapacities specifies whether to disable the printing of capacities + for arrays, slices, maps and channels. This is useful when diffing data + structures in tests. + * ContinueOnMethod Enables recursion into types after invoking error and Stringer interface methods. Recursion after method invocation is disabled by default. @@ -191,4 +202,4 @@ using the unsafe package. ## License -Go-spew is licensed under the liberal ISC License. +Go-spew is licensed under the [copyfree](http://copyfree.org) ISC License. diff --git a/vendor/github.com/davecgh/go-spew/spew/bypass.go b/vendor/github.com/davecgh/go-spew/spew/bypass.go index d42a0bc4afcca5d5113e4fd6e5f33110b920da61..8a4a6589a2d42ca8efa4a2dc8477f602d8dff328 100644 --- a/vendor/github.com/davecgh/go-spew/spew/bypass.go +++ b/vendor/github.com/davecgh/go-spew/spew/bypass.go @@ -1,4 +1,4 @@ -// Copyright (c) 2015 Dave Collins +// Copyright (c) 2015-2016 Dave Collins // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above diff --git a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go index e47a4e795138b537ec06b8bdb068157b6a6a6514..1fe3cf3d5d10ef9e2d4145186c691ccce698195c 100644 --- a/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go +++ b/vendor/github.com/davecgh/go-spew/spew/bypasssafe.go @@ -1,4 +1,4 @@ -// Copyright (c) 2015 Dave Collins +// Copyright (c) 2015-2016 Dave Collins // // Permission to use, copy, modify, and distribute this software for any // purpose with or without fee is hereby granted, provided that the above diff --git a/vendor/github.com/davecgh/go-spew/spew/common.go b/vendor/github.com/davecgh/go-spew/spew/common.go index 14f02dc15b7dd70886b25b055fe9db99bc0941ff..7c519ff47ac3cb8f39fa775e031dd9c5f27db58b 100644 --- a/vendor/github.com/davecgh/go-spew/spew/common.go +++ b/vendor/github.com/davecgh/go-spew/spew/common.go @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013 Dave Collins + * Copyright (c) 2013-2016 Dave Collins * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above diff --git a/vendor/github.com/davecgh/go-spew/spew/config.go b/vendor/github.com/davecgh/go-spew/spew/config.go index 5552827238cc11ae2cb1c7040c46e0315fad6bca..2e3d22f312026ff2c863bbffcbc88b7f6fb942f5 100644 --- a/vendor/github.com/davecgh/go-spew/spew/config.go +++ b/vendor/github.com/davecgh/go-spew/spew/config.go @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013 Dave Collins + * Copyright (c) 2013-2016 Dave Collins * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -67,6 +67,15 @@ type ConfigState struct { // Google App Engine or with the "safe" build tag specified. DisablePointerMethods bool + // DisablePointerAddresses specifies whether to disable the printing of + // pointer addresses. This is useful when diffing data structures in tests. + DisablePointerAddresses bool + + // DisableCapacities specifies whether to disable the printing of capacities + // for arrays, slices, maps and channels. This is useful when diffing + // data structures in tests. + DisableCapacities bool + // ContinueOnMethod specifies whether or not recursion should continue once // a custom error or Stringer interface is invoked. The default, false, // means it will print the results of invoking the custom error or Stringer diff --git a/vendor/github.com/davecgh/go-spew/spew/doc.go b/vendor/github.com/davecgh/go-spew/spew/doc.go index 5be0c4060908e349051ee5c61194db883938b157..aacaac6f1e1e936ee0022c00e139756c9bdc2b3e 100644 --- a/vendor/github.com/davecgh/go-spew/spew/doc.go +++ b/vendor/github.com/davecgh/go-spew/spew/doc.go @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013 Dave Collins + * Copyright (c) 2013-2016 Dave Collins * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -91,6 +91,15 @@ The following configuration options are available: which only accept pointer receivers from non-pointer variables. Pointer method invocation is enabled by default. + * DisablePointerAddresses + DisablePointerAddresses specifies whether to disable the printing of + pointer addresses. This is useful when diffing data structures in tests. + + * DisableCapacities + DisableCapacities specifies whether to disable the printing of + capacities for arrays, slices, maps and channels. This is useful when + diffing data structures in tests. + * ContinueOnMethod Enables recursion into types after invoking error and Stringer interface methods. Recursion after method invocation is disabled by default. diff --git a/vendor/github.com/davecgh/go-spew/spew/dump.go b/vendor/github.com/davecgh/go-spew/spew/dump.go index a0ff95e27e524b488f1b5d9f51ecfef5d64b7981..df1d582a728aec65edfe02b828f75d8a7def892b 100644 --- a/vendor/github.com/davecgh/go-spew/spew/dump.go +++ b/vendor/github.com/davecgh/go-spew/spew/dump.go @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013 Dave Collins + * Copyright (c) 2013-2016 Dave Collins * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -129,7 +129,7 @@ func (d *dumpState) dumpPtr(v reflect.Value) { d.w.Write(closeParenBytes) // Display pointer information. - if len(pointerChain) > 0 { + if !d.cs.DisablePointerAddresses && len(pointerChain) > 0 { d.w.Write(openParenBytes) for i, addr := range pointerChain { if i > 0 { @@ -282,13 +282,13 @@ func (d *dumpState) dump(v reflect.Value) { case reflect.Map, reflect.String: valueLen = v.Len() } - if valueLen != 0 || valueCap != 0 { + if valueLen != 0 || !d.cs.DisableCapacities && valueCap != 0 { d.w.Write(openParenBytes) if valueLen != 0 { d.w.Write(lenEqualsBytes) printInt(d.w, int64(valueLen), 10) } - if valueCap != 0 { + if !d.cs.DisableCapacities && valueCap != 0 { if valueLen != 0 { d.w.Write(spaceBytes) } diff --git a/vendor/github.com/davecgh/go-spew/spew/format.go b/vendor/github.com/davecgh/go-spew/spew/format.go index ecf3b80e24bc054808efe0d5b5f14cf7d3502bbb..c49875bacbb88a2252d942c1ee9b84381305fa29 100644 --- a/vendor/github.com/davecgh/go-spew/spew/format.go +++ b/vendor/github.com/davecgh/go-spew/spew/format.go @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013 Dave Collins + * Copyright (c) 2013-2016 Dave Collins * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above diff --git a/vendor/github.com/davecgh/go-spew/spew/spew.go b/vendor/github.com/davecgh/go-spew/spew/spew.go index d8233f542e126f9a76a6fad0826e48c9b8bd8d86..32c0e338825308f6b9b4d0407aa5682a23e2dc9c 100644 --- a/vendor/github.com/davecgh/go-spew/spew/spew.go +++ b/vendor/github.com/davecgh/go-spew/spew/spew.go @@ -1,5 +1,5 @@ /* - * Copyright (c) 2013 Dave Collins + * Copyright (c) 2013-2016 Dave Collins * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above diff --git a/vendor/github.com/stretchr/testify/README.md b/vendor/github.com/stretchr/testify/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e57b1811f0a16bec61062088be655b994c58e7b2 --- /dev/null +++ b/vendor/github.com/stretchr/testify/README.md @@ -0,0 +1,332 @@ +Testify - Thou Shalt Write Tests +================================ + +[![Build Status](https://travis-ci.org/stretchr/testify.svg)](https://travis-ci.org/stretchr/testify) [![Go Report Card](https://goreportcard.com/badge/github.com/stretchr/testify)](https://goreportcard.com/report/github.com/stretchr/testify) [![GoDoc](https://godoc.org/github.com/stretchr/testify?status.svg)](https://godoc.org/github.com/stretchr/testify) + +Go code (golang) set of packages that provide many tools for testifying that your code will behave as you intend. + +Features include: + + * [Easy assertions](#assert-package) + * [Mocking](#mock-package) + * [HTTP response trapping](#http-package) + * [Testing suite interfaces and functions](#suite-package) + +Get started: + + * Install testify with [one line of code](#installation), or [update it with another](#staying-up-to-date) + * For an introduction to writing test code in Go, see http://golang.org/doc/code.html#Testing + * Check out the API Documentation http://godoc.org/github.com/stretchr/testify + * To make your testing life easier, check out our other project, [gorc](http://github.com/stretchr/gorc) + * A little about [Test-Driven Development (TDD)](http://en.wikipedia.org/wiki/Test-driven_development) + + + +[`assert`](http://godoc.org/github.com/stretchr/testify/assert "API documentation") package +------------------------------------------------------------------------------------------- + +The `assert` package provides some helpful methods that allow you to write better test code in Go. + + * Prints friendly, easy to read failure descriptions + * Allows for very readable code + * Optionally annotate each assertion with a message + +See it in action: + +```go +package yours + +import ( + "testing" + "github.com/stretchr/testify/assert" +) + +func TestSomething(t *testing.T) { + + // assert equality + assert.Equal(t, 123, 123, "they should be equal") + + // assert inequality + assert.NotEqual(t, 123, 456, "they should not be equal") + + // assert for nil (good for errors) + assert.Nil(t, object) + + // assert for not nil (good when you expect something) + if assert.NotNil(t, object) { + + // now we know that object isn't nil, we are safe to make + // further assertions without causing any errors + assert.Equal(t, "Something", object.Value) + + } + +} +``` + + * Every assert func takes the `testing.T` object as the first argument. This is how it writes the errors out through the normal `go test` capabilities. + * Every assert func returns a bool indicating whether the assertion was successful or not, this is useful for if you want to go on making further assertions under certain conditions. + +if you assert many times, use the below: + +```go +package yours + +import ( + "testing" + "github.com/stretchr/testify/assert" +) + +func TestSomething(t *testing.T) { + assert := assert.New(t) + + // assert equality + assert.Equal(123, 123, "they should be equal") + + // assert inequality + assert.NotEqual(123, 456, "they should not be equal") + + // assert for nil (good for errors) + assert.Nil(object) + + // assert for not nil (good when you expect something) + if assert.NotNil(object) { + + // now we know that object isn't nil, we are safe to make + // further assertions without causing any errors + assert.Equal("Something", object.Value) + } +} +``` + +[`require`](http://godoc.org/github.com/stretchr/testify/require "API documentation") package +--------------------------------------------------------------------------------------------- + +The `require` package provides same global functions as the `assert` package, but instead of returning a boolean result they terminate current test. + +See [t.FailNow](http://golang.org/pkg/testing/#T.FailNow) for details. + + +[`http`](http://godoc.org/github.com/stretchr/testify/http "API documentation") package +--------------------------------------------------------------------------------------- + +The `http` package contains test objects useful for testing code that relies on the `net/http` package. Check out the [(deprecated) API documentation for the `http` package](http://godoc.org/github.com/stretchr/testify/http). + +We recommend you use [httptest](http://golang.org/pkg/net/http/httptest) instead. + +[`mock`](http://godoc.org/github.com/stretchr/testify/mock "API documentation") package +---------------------------------------------------------------------------------------- + +The `mock` package provides a mechanism for easily writing mock objects that can be used in place of real objects when writing test code. + +An example test function that tests a piece of code that relies on an external object `testObj`, can setup expectations (testify) and assert that they indeed happened: + +```go +package yours + +import ( + "testing" + "github.com/stretchr/testify/mock" +) + +/* + Test objects +*/ + +// MyMockedObject is a mocked object that implements an interface +// that describes an object that the code I am testing relies on. +type MyMockedObject struct{ + mock.Mock +} + +// DoSomething is a method on MyMockedObject that implements some interface +// and just records the activity, and returns what the Mock object tells it to. +// +// In the real object, this method would do something useful, but since this +// is a mocked object - we're just going to stub it out. +// +// NOTE: This method is not being tested here, code that uses this object is. +func (m *MyMockedObject) DoSomething(number int) (bool, error) { + + args := m.Called(number) + return args.Bool(0), args.Error(1) + +} + +/* + Actual test functions +*/ + +// TestSomething is an example of how to use our test object to +// make assertions about some target code we are testing. +func TestSomething(t *testing.T) { + + // create an instance of our test object + testObj := new(MyMockedObject) + + // setup expectations + testObj.On("DoSomething", 123).Return(true, nil) + + // call the code we are testing + targetFuncThatDoesSomethingWithObj(testObj) + + // assert that the expectations were met + testObj.AssertExpectations(t) + +} +``` + +For more information on how to write mock code, check out the [API documentation for the `mock` package](http://godoc.org/github.com/stretchr/testify/mock). + +You can use the [mockery tool](http://github.com/vektra/mockery) to autogenerate the mock code against an interface as well, making using mocks much quicker. + +[`suite`](http://godoc.org/github.com/stretchr/testify/suite "API documentation") package +----------------------------------------------------------------------------------------- + +The `suite` package provides functionality that you might be used to from more common object oriented languages. With it, you can build a testing suite as a struct, build setup/teardown methods and testing methods on your struct, and run them with 'go test' as per normal. + +An example suite is shown below: + +```go +// Basic imports +import ( + "testing" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" +) + +// Define the suite, and absorb the built-in basic suite +// functionality from testify - including a T() method which +// returns the current testing context +type ExampleTestSuite struct { + suite.Suite + VariableThatShouldStartAtFive int +} + +// Make sure that VariableThatShouldStartAtFive is set to five +// before each test +func (suite *ExampleTestSuite) SetupTest() { + suite.VariableThatShouldStartAtFive = 5 +} + +// All methods that begin with "Test" are run as tests within a +// suite. +func (suite *ExampleTestSuite) TestExample() { + assert.Equal(suite.T(), 5, suite.VariableThatShouldStartAtFive) +} + +// In order for 'go test' to run this suite, we need to create +// a normal test function and pass our suite to suite.Run +func TestExampleTestSuite(t *testing.T) { + suite.Run(t, new(ExampleTestSuite)) +} +``` + +For a more complete example, using all of the functionality provided by the suite package, look at our [example testing suite](https://github.com/stretchr/testify/blob/master/suite/suite_test.go) + +For more information on writing suites, check out the [API documentation for the `suite` package](http://godoc.org/github.com/stretchr/testify/suite). + +`Suite` object has assertion methods: + +```go +// Basic imports +import ( + "testing" + "github.com/stretchr/testify/suite" +) + +// Define the suite, and absorb the built-in basic suite +// functionality from testify - including assertion methods. +type ExampleTestSuite struct { + suite.Suite + VariableThatShouldStartAtFive int +} + +// Make sure that VariableThatShouldStartAtFive is set to five +// before each test +func (suite *ExampleTestSuite) SetupTest() { + suite.VariableThatShouldStartAtFive = 5 +} + +// All methods that begin with "Test" are run as tests within a +// suite. +func (suite *ExampleTestSuite) TestExample() { + suite.Equal(suite.VariableThatShouldStartAtFive, 5) +} + +// In order for 'go test' to run this suite, we need to create +// a normal test function and pass our suite to suite.Run +func TestExampleTestSuite(t *testing.T) { + suite.Run(t, new(ExampleTestSuite)) +} +``` + +------ + +Installation +============ + +To install Testify, use `go get`: + + * Latest version: go get github.com/stretchr/testify + * Specific version: go get gopkg.in/stretchr/testify.v1 + +This will then make the following packages available to you: + + github.com/stretchr/testify/assert + github.com/stretchr/testify/mock + github.com/stretchr/testify/http + +Import the `testify/assert` package into your code using this template: + +```go +package yours + +import ( + "testing" + "github.com/stretchr/testify/assert" +) + +func TestSomething(t *testing.T) { + + assert.True(t, true, "True is true!") + +} +``` + +------ + +Staying up to date +================== + +To update Testify to the latest version, use `go get -u github.com/stretchr/testify`. + +------ + +Version History +=============== + + * 1.0 - New package versioning strategy adopted. + +------ + +Contributing +============ + +Please feel free to submit issues, fork the repository and send pull requests! + +When submitting an issue, we ask that you please include a complete test function that demonstrates the issue. Extra credit for those using Testify to write the test code that demonstrates it. + +------ + +Licence +======= +Copyright (c) 2012 - 2013 Mat Ryer and Tyler Bunnell + +Please consider promoting this project if you find it useful. + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go index e6a796046cfd768ec1f0795e11f569cdd8522da4..aa4311ff84615e7afde16d5cbb92ecaf565e3f11 100644 --- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go +++ b/vendor/github.com/stretchr/testify/assert/assertion_forward.go @@ -1,386 +1,351 @@ /* * CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen * THIS FILE MUST NOT BE EDITED BY HAND -*/ + */ package assert import ( - http "net/http" url "net/url" time "time" ) - // Condition uses a Comparison to assert a complex condition. func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool { return Condition(a.t, comp, msgAndArgs...) } - // Contains asserts that the specified string, list(array, slice...) or map contains the // specified substring or element. -// +// // a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'") // a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'") // a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { return Contains(a.t, s, contains, msgAndArgs...) } - // Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either // a slice or a channel with len == 0. -// +// // a.Empty(obj) -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { return Empty(a.t, object, msgAndArgs...) } - // Equal asserts that two objects are equal. -// +// // a.Equal(123, 123, "123 and 123 should be equal") -// +// // Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { return Equal(a.t, expected, actual, msgAndArgs...) } - // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. -// +// // actualObj, err := SomeFunction() -// if assert.Error(t, err, "An error was expected") { -// assert.Equal(t, err, expectedError) -// } -// +// a.EqualError(err, expectedErrorString, "An error was expected") +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool { return EqualError(a.t, theError, errString, msgAndArgs...) } - // EqualValues asserts that two objects are equal or convertable to the same types // and equal. -// +// // a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { return EqualValues(a.t, expected, actual, msgAndArgs...) } - // Error asserts that a function returned an error (i.e. not `nil`). -// +// // actualObj, err := SomeFunction() // if a.Error(err, "An error was expected") { // assert.Equal(t, err, expectedError) // } -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { return Error(a.t, err, msgAndArgs...) } - // Exactly asserts that two objects are equal is value and type. -// +// // a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { return Exactly(a.t, expected, actual, msgAndArgs...) } - // Fail reports a failure through func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool { return Fail(a.t, failureMessage, msgAndArgs...) } - // FailNow fails test func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool { return FailNow(a.t, failureMessage, msgAndArgs...) } - // False asserts that the specified value is false. -// +// // a.False(myBool, "myBool should be false") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { return False(a.t, value, msgAndArgs...) } - // HTTPBodyContains asserts that a specified handler returns a // body that contains a string. -// +// // a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { return HTTPBodyContains(a.t, handler, method, url, values, str) } - // HTTPBodyNotContains asserts that a specified handler returns a // body that does not contain a string. -// +// // a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) bool { return HTTPBodyNotContains(a.t, handler, method, url, values, str) } - // HTTPError asserts that a specified handler returns an error status code. -// +// // a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) bool { return HTTPError(a.t, handler, method, url, values) } - // HTTPRedirect asserts that a specified handler returns a redirect status code. -// +// // a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) bool { return HTTPRedirect(a.t, handler, method, url, values) } - // HTTPSuccess asserts that a specified handler returns a success status code. -// +// // a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) bool { return HTTPSuccess(a.t, handler, method, url, values) } - // Implements asserts that an object is implemented by the specified interface. -// +// // a.Implements((*MyInterface)(nil), new(MyObject), "MyObject") func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { return Implements(a.t, interfaceObject, object, msgAndArgs...) } - // InDelta asserts that the two numerals are within delta of each other. -// +// // a.InDelta(math.Pi, (22 / 7.0), 0.01) -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { return InDelta(a.t, expected, actual, delta, msgAndArgs...) } - // InDeltaSlice is the same as InDelta, except it compares two slices. func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) } - // InEpsilon asserts that expected and actual have a relative error less than epsilon -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) } - -// InEpsilonSlice is the same as InEpsilon, except it compares two slices. -func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - return InEpsilonSlice(a.t, expected, actual, delta, msgAndArgs...) +// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. +func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { + return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) } - // IsType asserts that the specified objects are of the same type. func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { return IsType(a.t, expectedType, object, msgAndArgs...) } - // JSONEq asserts that two JSON strings are equivalent. -// +// // a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool { return JSONEq(a.t, expected, actual, msgAndArgs...) } - // Len asserts that the specified object has specific length. // Len also fails if the object has a type that len() not accept. -// +// // a.Len(mySlice, 3, "The size of slice is not 3") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool { return Len(a.t, object, length, msgAndArgs...) } - // Nil asserts that the specified object is nil. -// +// // a.Nil(err, "err should be nothing") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { return Nil(a.t, object, msgAndArgs...) } - // NoError asserts that a function returned no error (i.e. `nil`). -// +// // actualObj, err := SomeFunction() // if a.NoError(err) { // assert.Equal(t, actualObj, expectedObj) // } -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { return NoError(a.t, err, msgAndArgs...) } - // NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the // specified substring or element. -// +// // a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'") // a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'") // a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { return NotContains(a.t, s, contains, msgAndArgs...) } - // NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either // a slice or a channel with len == 0. -// +// // if a.NotEmpty(obj) { // assert.Equal(t, "two", obj[1]) // } -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool { return NotEmpty(a.t, object, msgAndArgs...) } - // NotEqual asserts that the specified values are NOT equal. -// +// // a.NotEqual(obj1, obj2, "two objects shouldn't be equal") -// +// // Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { return NotEqual(a.t, expected, actual, msgAndArgs...) } - // NotNil asserts that the specified object is not nil. -// +// // a.NotNil(err, "err should be something") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool { return NotNil(a.t, object, msgAndArgs...) } - // NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. -// +// // a.NotPanics(func(){ // RemainCalm() // }, "Calling RemainCalm() should NOT panic") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool { return NotPanics(a.t, f, msgAndArgs...) } - // NotRegexp asserts that a specified regexp does not match a string. -// +// // a.NotRegexp(regexp.MustCompile("starts"), "it's starting") // a.NotRegexp("^start", "it's not starting") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { return NotRegexp(a.t, rx, str, msgAndArgs...) } - // NotZero asserts that i is not the zero value for its type and returns the truth. func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool { return NotZero(a.t, i, msgAndArgs...) } - // Panics asserts that the code inside the specified PanicTestFunc panics. -// +// // a.Panics(func(){ // GoCrazy() // }, "Calling GoCrazy() should panic") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { return Panics(a.t, f, msgAndArgs...) } - // Regexp asserts that a specified regexp matches a string. -// +// // a.Regexp(regexp.MustCompile("start"), "it's starting") // a.Regexp("start...$", "it's not starting") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { return Regexp(a.t, rx, str, msgAndArgs...) } - // True asserts that the specified value is true. -// +// // a.True(myBool, "myBool should be true") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { return True(a.t, value, msgAndArgs...) } - // WithinDuration asserts that the two times are within duration delta of each other. -// +// // a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s") -// +// // Returns whether the assertion was successful (true) or not (false). func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { return WithinDuration(a.t, expected, actual, delta, msgAndArgs...) } - // Zero asserts that i is the zero value for its type and returns the truth. func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool { return Zero(a.t, i, msgAndArgs...) diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go index d7c16c5903a573dfe3b705325fb267bdf0e6e675..d1552e5e3f8349c18d83c4283839be2bd0a6a751 100644 --- a/vendor/github.com/stretchr/testify/assert/assertions.go +++ b/vendor/github.com/stretchr/testify/assert/assertions.go @@ -65,7 +65,7 @@ func ObjectsAreEqualValues(expected, actual interface{}) bool { /* CallerInfo is necessary because the assert functions use the testing object internally, causing it to print the file:line of the assert method, rather than where -the problem actually occured in calling code.*/ +the problem actually occurred in calling code.*/ // CallerInfo returns an array of strings containing the file and line number // of each stack frame leading from the current test to the assert call that @@ -82,7 +82,9 @@ func CallerInfo() []string { for i := 0; ; i++ { pc, file, line, ok = runtime.Caller(i) if !ok { - return nil + // The breaks below failed to terminate the loop, and we ran off the + // end of the call stack. + break } // This is a huge edge case, but it will panic if this is the case, see #180 @@ -90,6 +92,21 @@ func CallerInfo() []string { break } + f := runtime.FuncForPC(pc) + if f == nil { + break + } + name = f.Name() + + // testing.tRunner is the standard library function that calls + // tests. Subtests are called directly by tRunner, without going through + // the Test/Benchmark/Example function that contains the t.Run calls, so + // with subtests we should break when we hit tRunner, without adding it + // to the list of callers. + if name == "testing.tRunner" { + break + } + parts := strings.Split(file, "/") dir := parts[len(parts)-2] file = parts[len(parts)-1] @@ -97,11 +114,6 @@ func CallerInfo() []string { callers = append(callers, fmt.Sprintf("%s:%d", file, line)) } - f := runtime.FuncForPC(pc) - if f == nil { - break - } - name = f.Name() // Drop the package segments := strings.Split(name, ".") name = segments[len(segments)-1] @@ -141,7 +153,7 @@ func getWhitespaceString() string { parts := strings.Split(file, "/") file = parts[len(parts)-1] - return strings.Repeat(" ", len(fmt.Sprintf("%s:%d: ", file, line))) + return strings.Repeat(" ", len(fmt.Sprintf("%s:%d: ", file, line))) } @@ -158,22 +170,18 @@ func messageFromMsgAndArgs(msgAndArgs ...interface{}) string { return "" } -// Indents all lines of the message by appending a number of tabs to each line, in an output format compatible with Go's -// test printing (see inner comment for specifics) -func indentMessageLines(message string, tabs int) string { +// Aligns the provided message so that all lines after the first line start at the same location as the first line. +// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab). +// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the +// basis on which the alignment occurs). +func indentMessageLines(message string, longestLabelLen int) string { outBuf := new(bytes.Buffer) for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ { + // no need to align first line because it starts at the correct location (after the label) if i != 0 { - outBuf.WriteRune('\n') - } - for ii := 0; ii < tabs; ii++ { - outBuf.WriteRune('\t') - // Bizarrely, all lines except the first need one fewer tabs prepended, so deliberately advance the counter - // by 1 prematurely. - if ii == 0 && i > 0 { - ii++ - } + // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab + outBuf.WriteString("\n\r\t" + strings.Repeat(" ", longestLabelLen +1) + "\t") } outBuf.WriteString(scanner.Text()) } @@ -205,29 +213,49 @@ func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool // Fail reports a failure through func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { + content := []labeledContent{ + {"Error Trace", strings.Join(CallerInfo(), "\n\r\t\t\t")}, + {"Error", failureMessage}, + } message := messageFromMsgAndArgs(msgAndArgs...) - - errorTrace := strings.Join(CallerInfo(), "\n\r\t\t\t") if len(message) > 0 { - t.Errorf("\r%s\r\tError Trace:\t%s\n"+ - "\r\tError:%s\n"+ - "\r\tMessages:\t%s\n\r", - getWhitespaceString(), - errorTrace, - indentMessageLines(failureMessage, 2), - message) - } else { - t.Errorf("\r%s\r\tError Trace:\t%s\n"+ - "\r\tError:%s\n\r", - getWhitespaceString(), - errorTrace, - indentMessageLines(failureMessage, 2)) + content = append(content, labeledContent{"Messages", message}) } + t.Errorf("\r" + getWhitespaceString() + labeledOutput(content...)) + return false } +type labeledContent struct { + label string + content string +} + +// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner: +// +// \r\t{{label}}:{{align_spaces}}\t{{content}}\n +// +// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label. +// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this +// alignment is achieved, "\t{{content}}\n" is added for the output. +// +// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line. +func labeledOutput(content ...labeledContent) string { + longestLabel := 0 + for _, v := range content { + if len(v.label) > longestLabel { + longestLabel = len(v.label) + } + } + var output string + for _, v := range content { + output += "\r\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n" + } + return output +} + // Implements asserts that an object is implemented by the specified interface. // // assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject") @@ -258,18 +286,39 @@ func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs // assert.Equal(t, 123, 123, "123 and 123 should be equal") // // Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if !ObjectsAreEqual(expected, actual) { diff := diff(expected, actual) - return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+ - " != %#v (actual)%s", expected, actual, diff), msgAndArgs...) + expected, actual = formatUnequalValues(expected, actual) + return Fail(t, fmt.Sprintf("Not equal: \n"+ + "expected: %s\n"+ + "received: %s%s", expected, actual, diff), msgAndArgs...) } return true } +// formatUnequalValues takes two values of arbitrary types and returns string +// representations appropriate to be presented to the user. +// +// If the values are not of like type, the returned strings will be prefixed +// with the type name, and the value will be enclosed in parenthesis similar +// to a type conversion in the Go grammar. +func formatUnequalValues(expected, actual interface{}) (e string, a string) { + if reflect.TypeOf(expected) != reflect.TypeOf(actual) { + return fmt.Sprintf("%T(%#v)", expected, expected), + fmt.Sprintf("%T(%#v)", actual, actual) + } + + return fmt.Sprintf("%#v", expected), + fmt.Sprintf("%#v", actual) +} + // EqualValues asserts that two objects are equal or convertable to the same types // and equal. // @@ -279,8 +328,11 @@ func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if !ObjectsAreEqualValues(expected, actual) { - return Fail(t, fmt.Sprintf("Not equal: %#v (expected)\n"+ - " != %#v (actual)", expected, actual), msgAndArgs...) + diff := diff(expected, actual) + expected, actual = formatUnequalValues(expected, actual) + return Fail(t, fmt.Sprintf("Not equal: \n"+ + "expected: %s\n"+ + "received: %s%s", expected, actual, diff), msgAndArgs...) } return true @@ -507,6 +559,9 @@ func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { // assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal") // // Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { if ObjectsAreEqual(expected, actual) { @@ -832,11 +887,11 @@ func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, m // // Returns whether the assertion was successful (true) or not (false). func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { - if isNil(err) { - return true + if err != nil { + return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...) } - return Fail(t, fmt.Sprintf("Received unexpected error %q", err), msgAndArgs...) + return true } // Error asserts that a function returned an error (i.e. not `nil`). @@ -849,29 +904,33 @@ func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { // Returns whether the assertion was successful (true) or not (false). func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { - message := messageFromMsgAndArgs(msgAndArgs...) - return NotNil(t, err, "An error is expected but got nil. %s", message) + if err == nil { + return Fail(t, "An error is expected but got nil.", msgAndArgs...) + } + return true } // EqualError asserts that a function returned an error (i.e. not `nil`) // and that it is equal to the provided error. // // actualObj, err := SomeFunction() -// if assert.Error(t, err, "An error was expected") { -// assert.Equal(t, err, expectedError) -// } +// assert.EqualError(t, err, expectedErrorString, "An error was expected") // // Returns whether the assertion was successful (true) or not (false). func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { - - message := messageFromMsgAndArgs(msgAndArgs...) - if !NotNil(t, theError, "An error is expected but got nil. %s", message) { + if !Error(t, theError, msgAndArgs...) { return false } - s := "An error with value \"%s\" is expected but got \"%s\". %s" - return Equal(t, errString, theError.Error(), - s, errString, theError.Error(), message) + expected := errString + actual := theError.Error() + // don't need to use deep equals here, we know they are both strings + if expected != actual { + return Fail(t, fmt.Sprintf("Error message not equal:\n"+ + "expected: %q\n"+ + "received: %q", expected, actual), msgAndArgs...) + } + return true } // matchRegexp return true if a specified regexp matches a string. @@ -986,9 +1045,8 @@ func diff(expected interface{}, actual interface{}) string { return "" } - spew.Config.SortKeys = true - e := spew.Sdump(expected) - a := spew.Sdump(actual) + e := spewConfig.Sdump(expected) + a := spewConfig.Sdump(actual) diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ A: difflib.SplitLines(e), @@ -1002,3 +1060,10 @@ func diff(expected interface{}, actual interface{}) string { return "\n\nDiff:\n" + diff } + +var spewConfig = spew.ConfigState{ + Indent: " ", + DisablePointerAddresses: true, + DisableCapacities: true, + SortKeys: true, +} diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go index e1b9442b5abf23f71b89c6f3b2b6ce6caa4e7948..fa7ab89b1808e0cbbff9bd72b866b719005076b4 100644 --- a/vendor/github.com/stretchr/testify/assert/http_assertions.go +++ b/vendor/github.com/stretchr/testify/assert/http_assertions.go @@ -99,7 +99,7 @@ func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url strin contains := strings.Contains(body, fmt.Sprint(str)) if contains { - Fail(t, "Expected response body for %s to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body) + Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) } return !contains diff --git a/vendor/github.com/stretchr/testify/require/doc.go b/vendor/github.com/stretchr/testify/require/doc.go new file mode 100644 index 0000000000000000000000000000000000000000..169de39221c73123409330785477fdee95131445 --- /dev/null +++ b/vendor/github.com/stretchr/testify/require/doc.go @@ -0,0 +1,28 @@ +// Package require implements the same assertions as the `assert` package but +// stops test execution when a test fails. +// +// Example Usage +// +// The following is a complete example using require in a standard test function: +// import ( +// "testing" +// "github.com/stretchr/testify/require" +// ) +// +// func TestSomething(t *testing.T) { +// +// var a string = "Hello" +// var b string = "Hello" +// +// require.Equal(t, a, b, "The two words should be the same.") +// +// } +// +// Assertions +// +// The `require` package have same global functions as in the `assert` package, +// but instead of returning a boolean result they call `t.FailNow()`. +// +// Every assertion function also takes an optional string message as the final argument, +// allowing custom error messages to be appended to the message the assertion method outputs. +package require diff --git a/vendor/github.com/stretchr/testify/require/forward_requirements.go b/vendor/github.com/stretchr/testify/require/forward_requirements.go new file mode 100644 index 0000000000000000000000000000000000000000..d3c2ab9bc7eb882805727b432baab076059c4112 --- /dev/null +++ b/vendor/github.com/stretchr/testify/require/forward_requirements.go @@ -0,0 +1,16 @@ +package require + +// Assertions provides assertion methods around the +// TestingT interface. +type Assertions struct { + t TestingT +} + +// New makes a new Assertions object for the specified TestingT. +func New(t TestingT) *Assertions { + return &Assertions{ + t: t, + } +} + +//go:generate go run ../_codegen/main.go -output-package=require -template=require_forward.go.tmpl diff --git a/vendor/github.com/stretchr/testify/require/require.go b/vendor/github.com/stretchr/testify/require/require.go new file mode 100644 index 0000000000000000000000000000000000000000..fc567f140a20bb37ff0532a7ac542dc02831a54f --- /dev/null +++ b/vendor/github.com/stretchr/testify/require/require.go @@ -0,0 +1,429 @@ +/* +* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +* THIS FILE MUST NOT BE EDITED BY HAND + */ + +package require + +import ( + assert "github.com/stretchr/testify/assert" + http "net/http" + url "net/url" + time "time" +) + +// Condition uses a Comparison to assert a complex condition. +func Condition(t TestingT, comp assert.Comparison, msgAndArgs ...interface{}) { + if !assert.Condition(t, comp, msgAndArgs...) { + t.FailNow() + } +} + +// Contains asserts that the specified string, list(array, slice...) or map contains the +// specified substring or element. +// +// assert.Contains(t, "Hello World", "World", "But 'Hello World' does contain 'World'") +// assert.Contains(t, ["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'") +// assert.Contains(t, {"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'") +// +// Returns whether the assertion was successful (true) or not (false). +func Contains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { + if !assert.Contains(t, s, contains, msgAndArgs...) { + t.FailNow() + } +} + +// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// assert.Empty(t, obj) +// +// Returns whether the assertion was successful (true) or not (false). +func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) { + if !assert.Empty(t, object, msgAndArgs...) { + t.FailNow() + } +} + +// Equal asserts that two objects are equal. +// +// assert.Equal(t, 123, 123, "123 and 123 should be equal") +// +// Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func Equal(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + if !assert.Equal(t, expected, actual, msgAndArgs...) { + t.FailNow() + } +} + +// EqualError asserts that a function returned an error (i.e. not `nil`) +// and that it is equal to the provided error. +// +// actualObj, err := SomeFunction() +// assert.EqualError(t, err, expectedErrorString, "An error was expected") +// +// Returns whether the assertion was successful (true) or not (false). +func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) { + if !assert.EqualError(t, theError, errString, msgAndArgs...) { + t.FailNow() + } +} + +// EqualValues asserts that two objects are equal or convertable to the same types +// and equal. +// +// assert.EqualValues(t, uint32(123), int32(123), "123 and 123 should be equal") +// +// Returns whether the assertion was successful (true) or not (false). +func EqualValues(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + if !assert.EqualValues(t, expected, actual, msgAndArgs...) { + t.FailNow() + } +} + +// Error asserts that a function returned an error (i.e. not `nil`). +// +// actualObj, err := SomeFunction() +// if assert.Error(t, err, "An error was expected") { +// assert.Equal(t, err, expectedError) +// } +// +// Returns whether the assertion was successful (true) or not (false). +func Error(t TestingT, err error, msgAndArgs ...interface{}) { + if !assert.Error(t, err, msgAndArgs...) { + t.FailNow() + } +} + +// Exactly asserts that two objects are equal is value and type. +// +// assert.Exactly(t, int32(123), int64(123), "123 and 123 should NOT be equal") +// +// Returns whether the assertion was successful (true) or not (false). +func Exactly(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + if !assert.Exactly(t, expected, actual, msgAndArgs...) { + t.FailNow() + } +} + +// Fail reports a failure through +func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) { + if !assert.Fail(t, failureMessage, msgAndArgs...) { + t.FailNow() + } +} + +// FailNow fails test +func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) { + if !assert.FailNow(t, failureMessage, msgAndArgs...) { + t.FailNow() + } +} + +// False asserts that the specified value is false. +// +// assert.False(t, myBool, "myBool should be false") +// +// Returns whether the assertion was successful (true) or not (false). +func False(t TestingT, value bool, msgAndArgs ...interface{}) { + if !assert.False(t, value, msgAndArgs...) { + t.FailNow() + } +} + +// HTTPBodyContains asserts that a specified handler returns a +// body that contains a string. +// +// assert.HTTPBodyContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { + if !assert.HTTPBodyContains(t, handler, method, url, values, str) { + t.FailNow() + } +} + +// HTTPBodyNotContains asserts that a specified handler returns a +// body that does not contain a string. +// +// assert.HTTPBodyNotContains(t, myHandler, "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { + if !assert.HTTPBodyNotContains(t, handler, method, url, values, str) { + t.FailNow() + } +} + +// HTTPError asserts that a specified handler returns an error status code. +// +// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPError(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) { + if !assert.HTTPError(t, handler, method, url, values) { + t.FailNow() + } +} + +// HTTPRedirect asserts that a specified handler returns a redirect status code. +// +// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPRedirect(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) { + if !assert.HTTPRedirect(t, handler, method, url, values) { + t.FailNow() + } +} + +// HTTPSuccess asserts that a specified handler returns a success status code. +// +// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) +// +// Returns whether the assertion was successful (true) or not (false). +func HTTPSuccess(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values) { + if !assert.HTTPSuccess(t, handler, method, url, values) { + t.FailNow() + } +} + +// Implements asserts that an object is implemented by the specified interface. +// +// assert.Implements(t, (*MyInterface)(nil), new(MyObject), "MyObject") +func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { + if !assert.Implements(t, interfaceObject, object, msgAndArgs...) { + t.FailNow() + } +} + +// InDelta asserts that the two numerals are within delta of each other. +// +// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) +// +// Returns whether the assertion was successful (true) or not (false). +func InDelta(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { + if !assert.InDelta(t, expected, actual, delta, msgAndArgs...) { + t.FailNow() + } +} + +// InDeltaSlice is the same as InDelta, except it compares two slices. +func InDeltaSlice(t TestingT, expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { + if !assert.InDeltaSlice(t, expected, actual, delta, msgAndArgs...) { + t.FailNow() + } +} + +// InEpsilon asserts that expected and actual have a relative error less than epsilon +// +// Returns whether the assertion was successful (true) or not (false). +func InEpsilon(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { + if !assert.InEpsilon(t, expected, actual, epsilon, msgAndArgs...) { + t.FailNow() + } +} + +// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. +func InEpsilonSlice(t TestingT, expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { + if !assert.InEpsilonSlice(t, expected, actual, epsilon, msgAndArgs...) { + t.FailNow() + } +} + +// IsType asserts that the specified objects are of the same type. +func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { + if !assert.IsType(t, expectedType, object, msgAndArgs...) { + t.FailNow() + } +} + +// JSONEq asserts that two JSON strings are equivalent. +// +// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) +// +// Returns whether the assertion was successful (true) or not (false). +func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) { + if !assert.JSONEq(t, expected, actual, msgAndArgs...) { + t.FailNow() + } +} + +// Len asserts that the specified object has specific length. +// Len also fails if the object has a type that len() not accept. +// +// assert.Len(t, mySlice, 3, "The size of slice is not 3") +// +// Returns whether the assertion was successful (true) or not (false). +func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) { + if !assert.Len(t, object, length, msgAndArgs...) { + t.FailNow() + } +} + +// Nil asserts that the specified object is nil. +// +// assert.Nil(t, err, "err should be nothing") +// +// Returns whether the assertion was successful (true) or not (false). +func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) { + if !assert.Nil(t, object, msgAndArgs...) { + t.FailNow() + } +} + +// NoError asserts that a function returned no error (i.e. `nil`). +// +// actualObj, err := SomeFunction() +// if assert.NoError(t, err) { +// assert.Equal(t, actualObj, expectedObj) +// } +// +// Returns whether the assertion was successful (true) or not (false). +func NoError(t TestingT, err error, msgAndArgs ...interface{}) { + if !assert.NoError(t, err, msgAndArgs...) { + t.FailNow() + } +} + +// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the +// specified substring or element. +// +// assert.NotContains(t, "Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'") +// assert.NotContains(t, ["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'") +// assert.NotContains(t, {"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'") +// +// Returns whether the assertion was successful (true) or not (false). +func NotContains(t TestingT, s interface{}, contains interface{}, msgAndArgs ...interface{}) { + if !assert.NotContains(t, s, contains, msgAndArgs...) { + t.FailNow() + } +} + +// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// if assert.NotEmpty(t, obj) { +// assert.Equal(t, "two", obj[1]) +// } +// +// Returns whether the assertion was successful (true) or not (false). +func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) { + if !assert.NotEmpty(t, object, msgAndArgs...) { + t.FailNow() + } +} + +// NotEqual asserts that the specified values are NOT equal. +// +// assert.NotEqual(t, obj1, obj2, "two objects shouldn't be equal") +// +// Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func NotEqual(t TestingT, expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + if !assert.NotEqual(t, expected, actual, msgAndArgs...) { + t.FailNow() + } +} + +// NotNil asserts that the specified object is not nil. +// +// assert.NotNil(t, err, "err should be something") +// +// Returns whether the assertion was successful (true) or not (false). +func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) { + if !assert.NotNil(t, object, msgAndArgs...) { + t.FailNow() + } +} + +// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. +// +// assert.NotPanics(t, func(){ +// RemainCalm() +// }, "Calling RemainCalm() should NOT panic") +// +// Returns whether the assertion was successful (true) or not (false). +func NotPanics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { + if !assert.NotPanics(t, f, msgAndArgs...) { + t.FailNow() + } +} + +// NotRegexp asserts that a specified regexp does not match a string. +// +// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") +// assert.NotRegexp(t, "^start", "it's not starting") +// +// Returns whether the assertion was successful (true) or not (false). +func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { + if !assert.NotRegexp(t, rx, str, msgAndArgs...) { + t.FailNow() + } +} + +// NotZero asserts that i is not the zero value for its type and returns the truth. +func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) { + if !assert.NotZero(t, i, msgAndArgs...) { + t.FailNow() + } +} + +// Panics asserts that the code inside the specified PanicTestFunc panics. +// +// assert.Panics(t, func(){ +// GoCrazy() +// }, "Calling GoCrazy() should panic") +// +// Returns whether the assertion was successful (true) or not (false). +func Panics(t TestingT, f assert.PanicTestFunc, msgAndArgs ...interface{}) { + if !assert.Panics(t, f, msgAndArgs...) { + t.FailNow() + } +} + +// Regexp asserts that a specified regexp matches a string. +// +// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") +// assert.Regexp(t, "start...$", "it's not starting") +// +// Returns whether the assertion was successful (true) or not (false). +func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) { + if !assert.Regexp(t, rx, str, msgAndArgs...) { + t.FailNow() + } +} + +// True asserts that the specified value is true. +// +// assert.True(t, myBool, "myBool should be true") +// +// Returns whether the assertion was successful (true) or not (false). +func True(t TestingT, value bool, msgAndArgs ...interface{}) { + if !assert.True(t, value, msgAndArgs...) { + t.FailNow() + } +} + +// WithinDuration asserts that the two times are within duration delta of each other. +// +// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s") +// +// Returns whether the assertion was successful (true) or not (false). +func WithinDuration(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { + if !assert.WithinDuration(t, expected, actual, delta, msgAndArgs...) { + t.FailNow() + } +} + +// Zero asserts that i is the zero value for its type and returns the truth. +func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) { + if !assert.Zero(t, i, msgAndArgs...) { + t.FailNow() + } +} diff --git a/vendor/github.com/stretchr/testify/require/require_forward.go b/vendor/github.com/stretchr/testify/require/require_forward.go new file mode 100644 index 0000000000000000000000000000000000000000..caa18793dfa243722e945a749f9287edc63921ff --- /dev/null +++ b/vendor/github.com/stretchr/testify/require/require_forward.go @@ -0,0 +1,353 @@ +/* +* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen +* THIS FILE MUST NOT BE EDITED BY HAND + */ + +package require + +import ( + assert "github.com/stretchr/testify/assert" + http "net/http" + url "net/url" + time "time" +) + +// Condition uses a Comparison to assert a complex condition. +func (a *Assertions) Condition(comp assert.Comparison, msgAndArgs ...interface{}) { + Condition(a.t, comp, msgAndArgs...) +} + +// Contains asserts that the specified string, list(array, slice...) or map contains the +// specified substring or element. +// +// a.Contains("Hello World", "World", "But 'Hello World' does contain 'World'") +// a.Contains(["Hello", "World"], "World", "But ["Hello", "World"] does contain 'World'") +// a.Contains({"Hello": "World"}, "Hello", "But {'Hello': 'World'} does contain 'Hello'") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { + Contains(a.t, s, contains, msgAndArgs...) +} + +// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// a.Empty(obj) +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) { + Empty(a.t, object, msgAndArgs...) +} + +// Equal asserts that two objects are equal. +// +// a.Equal(123, 123, "123 and 123 should be equal") +// +// Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + Equal(a.t, expected, actual, msgAndArgs...) +} + +// EqualError asserts that a function returned an error (i.e. not `nil`) +// and that it is equal to the provided error. +// +// actualObj, err := SomeFunction() +// a.EqualError(err, expectedErrorString, "An error was expected") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) { + EqualError(a.t, theError, errString, msgAndArgs...) +} + +// EqualValues asserts that two objects are equal or convertable to the same types +// and equal. +// +// a.EqualValues(uint32(123), int32(123), "123 and 123 should be equal") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + EqualValues(a.t, expected, actual, msgAndArgs...) +} + +// Error asserts that a function returned an error (i.e. not `nil`). +// +// actualObj, err := SomeFunction() +// if a.Error(err, "An error was expected") { +// assert.Equal(t, err, expectedError) +// } +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Error(err error, msgAndArgs ...interface{}) { + Error(a.t, err, msgAndArgs...) +} + +// Exactly asserts that two objects are equal is value and type. +// +// a.Exactly(int32(123), int64(123), "123 and 123 should NOT be equal") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + Exactly(a.t, expected, actual, msgAndArgs...) +} + +// Fail reports a failure through +func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) { + Fail(a.t, failureMessage, msgAndArgs...) +} + +// FailNow fails test +func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) { + FailNow(a.t, failureMessage, msgAndArgs...) +} + +// False asserts that the specified value is false. +// +// a.False(myBool, "myBool should be false") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) False(value bool, msgAndArgs ...interface{}) { + False(a.t, value, msgAndArgs...) +} + +// HTTPBodyContains asserts that a specified handler returns a +// body that contains a string. +// +// a.HTTPBodyContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { + HTTPBodyContains(a.t, handler, method, url, values, str) +} + +// HTTPBodyNotContains asserts that a specified handler returns a +// body that does not contain a string. +// +// a.HTTPBodyNotContains(myHandler, "www.google.com", nil, "I'm Feeling Lucky") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}) { + HTTPBodyNotContains(a.t, handler, method, url, values, str) +} + +// HTTPError asserts that a specified handler returns an error status code. +// +// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values) { + HTTPError(a.t, handler, method, url, values) +} + +// HTTPRedirect asserts that a specified handler returns a redirect status code. +// +// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values) { + HTTPRedirect(a.t, handler, method, url, values) +} + +// HTTPSuccess asserts that a specified handler returns a success status code. +// +// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values) { + HTTPSuccess(a.t, handler, method, url, values) +} + +// Implements asserts that an object is implemented by the specified interface. +// +// a.Implements((*MyInterface)(nil), new(MyObject), "MyObject") +func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) { + Implements(a.t, interfaceObject, object, msgAndArgs...) +} + +// InDelta asserts that the two numerals are within delta of each other. +// +// a.InDelta(math.Pi, (22 / 7.0), 0.01) +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { + InDelta(a.t, expected, actual, delta, msgAndArgs...) +} + +// InDeltaSlice is the same as InDelta, except it compares two slices. +func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) { + InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) +} + +// InEpsilon asserts that expected and actual have a relative error less than epsilon +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { + InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) +} + +// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. +func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) { + InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) +} + +// IsType asserts that the specified objects are of the same type. +func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) { + IsType(a.t, expectedType, object, msgAndArgs...) +} + +// JSONEq asserts that two JSON strings are equivalent. +// +// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) { + JSONEq(a.t, expected, actual, msgAndArgs...) +} + +// Len asserts that the specified object has specific length. +// Len also fails if the object has a type that len() not accept. +// +// a.Len(mySlice, 3, "The size of slice is not 3") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) { + Len(a.t, object, length, msgAndArgs...) +} + +// Nil asserts that the specified object is nil. +// +// a.Nil(err, "err should be nothing") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) { + Nil(a.t, object, msgAndArgs...) +} + +// NoError asserts that a function returned no error (i.e. `nil`). +// +// actualObj, err := SomeFunction() +// if a.NoError(err) { +// assert.Equal(t, actualObj, expectedObj) +// } +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) { + NoError(a.t, err, msgAndArgs...) +} + +// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the +// specified substring or element. +// +// a.NotContains("Hello World", "Earth", "But 'Hello World' does NOT contain 'Earth'") +// a.NotContains(["Hello", "World"], "Earth", "But ['Hello', 'World'] does NOT contain 'Earth'") +// a.NotContains({"Hello": "World"}, "Earth", "But {'Hello': 'World'} does NOT contain 'Earth'") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) { + NotContains(a.t, s, contains, msgAndArgs...) +} + +// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either +// a slice or a channel with len == 0. +// +// if a.NotEmpty(obj) { +// assert.Equal(t, "two", obj[1]) +// } +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) { + NotEmpty(a.t, object, msgAndArgs...) +} + +// NotEqual asserts that the specified values are NOT equal. +// +// a.NotEqual(obj1, obj2, "two objects shouldn't be equal") +// +// Returns whether the assertion was successful (true) or not (false). +// +// Pointer variable equality is determined based on the equality of the +// referenced values (as opposed to the memory addresses). +func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) { + NotEqual(a.t, expected, actual, msgAndArgs...) +} + +// NotNil asserts that the specified object is not nil. +// +// a.NotNil(err, "err should be something") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) { + NotNil(a.t, object, msgAndArgs...) +} + +// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. +// +// a.NotPanics(func(){ +// RemainCalm() +// }, "Calling RemainCalm() should NOT panic") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) NotPanics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { + NotPanics(a.t, f, msgAndArgs...) +} + +// NotRegexp asserts that a specified regexp does not match a string. +// +// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") +// a.NotRegexp("^start", "it's not starting") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { + NotRegexp(a.t, rx, str, msgAndArgs...) +} + +// NotZero asserts that i is not the zero value for its type and returns the truth. +func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) { + NotZero(a.t, i, msgAndArgs...) +} + +// Panics asserts that the code inside the specified PanicTestFunc panics. +// +// a.Panics(func(){ +// GoCrazy() +// }, "Calling GoCrazy() should panic") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Panics(f assert.PanicTestFunc, msgAndArgs ...interface{}) { + Panics(a.t, f, msgAndArgs...) +} + +// Regexp asserts that a specified regexp matches a string. +// +// a.Regexp(regexp.MustCompile("start"), "it's starting") +// a.Regexp("start...$", "it's not starting") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) { + Regexp(a.t, rx, str, msgAndArgs...) +} + +// True asserts that the specified value is true. +// +// a.True(myBool, "myBool should be true") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) True(value bool, msgAndArgs ...interface{}) { + True(a.t, value, msgAndArgs...) +} + +// WithinDuration asserts that the two times are within duration delta of each other. +// +// a.WithinDuration(time.Now(), time.Now(), 10*time.Second, "The difference should not be more than 10s") +// +// Returns whether the assertion was successful (true) or not (false). +func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) { + WithinDuration(a.t, expected, actual, delta, msgAndArgs...) +} + +// Zero asserts that i is the zero value for its type and returns the truth. +func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) { + Zero(a.t, i, msgAndArgs...) +} diff --git a/vendor/github.com/stretchr/testify/require/requirements.go b/vendor/github.com/stretchr/testify/require/requirements.go new file mode 100644 index 0000000000000000000000000000000000000000..41147562d86209afe62e81140760950840e453c8 --- /dev/null +++ b/vendor/github.com/stretchr/testify/require/requirements.go @@ -0,0 +1,9 @@ +package require + +// TestingT is an interface wrapper around *testing.T +type TestingT interface { + Errorf(format string, args ...interface{}) + FailNow() +} + +//go:generate go run ../_codegen/main.go -output-package=require -template=require.go.tmpl