InTheForest/moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2026-01-11 02:31:44 +00:00
Code Issues Packages Projects Releases Wiki Activity

client: use t.Context in tests

Browse Source 
Signed-off-by: Sebastiaan van Stijn <github@gone.nl>
This commit is contained in:
Sebastiaan van Stijn
2025-11-10 23:23:23 +01:00
parent d105562bef
commit c950796596
64 changed files with 244 additions and 289 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
client/config_create_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -17,7 +16,7 @@ func TestConfigCreateError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigCreate(context.Background(), ConfigCreateOptions{Spec: swarm.ConfigSpec{}})
_, err = client.ConfigCreate(t.Context(), ConfigCreateOptions{Spec: swarm.ConfigSpec{}})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -35,7 +34,7 @@ func TestConfigCreate(t *testing.T) {
)
assert.NilError(t, err)
r, err := client.ConfigCreate(context.Background(), ConfigCreateOptions{Spec: swarm.ConfigSpec{}})
r, err := client.ConfigCreate(t.Context(), ConfigCreateOptions{Spec: swarm.ConfigSpec{}})
assert.NilError(t, err)
assert.Check(t, is.Equal(r.ID, "test_config"))
}

13
client/config_inspect_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"errors"
"net/http"
"testing"
@@ -18,7 +17,7 @@ func TestConfigInspectNotFound(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigInspect(context.Background(), "unknown", ConfigInspectOptions{})
_, err = client.ConfigInspect(t.Context(), "unknown", ConfigInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -29,11 +28,11 @@ func TestConfigInspectWithEmptyID(t *testing.T) {
}),
)
assert.NilError(t, err)
_, err = client.ConfigInspect(context.Background(), "", ConfigInspectOptions{})
_, err = client.ConfigInspect(t.Context(), "", ConfigInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ConfigInspect(context.Background(), " ", ConfigInspectOptions{})
_, err = client.ConfigInspect(t.Context(), " ", ConfigInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -44,7 +43,7 @@ func TestConfigInspectError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigInspect(context.Background(), "nothing", ConfigInspectOptions{})
_, err = client.ConfigInspect(t.Context(), "nothing", ConfigInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -54,7 +53,7 @@ func TestConfigInspectConfigNotFound(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigInspect(context.Background(), "unknown", ConfigInspectOptions{})
_, err = client.ConfigInspect(t.Context(), "unknown", ConfigInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -72,7 +71,7 @@ func TestConfigInspect(t *testing.T) {
)
assert.NilError(t, err)
result, err := client.ConfigInspect(context.Background(), "config_id", ConfigInspectOptions{})
result, err := client.ConfigInspect(t.Context(), "config_id", ConfigInspectOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(result.Config.ID, "config_id"))
}

5
client/config_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -18,7 +17,7 @@ func TestConfigListError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigList(context.Background(), ConfigListOptions{})
_, err = client.ConfigList(t.Context(), ConfigListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -67,7 +66,7 @@ func TestConfigList(t *testing.T) {
)
assert.NilError(t, err)
result, err := client.ConfigList(context.Background(), listCase.options)
result, err := client.ConfigList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(result.Items, 2))
}

9
client/config_remove_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -16,14 +15,14 @@ func TestConfigRemoveError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigRemove(context.Background(), "config_id", ConfigRemoveOptions{})
_, err = client.ConfigRemove(t.Context(), "config_id", ConfigRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ConfigRemove(context.Background(), "", ConfigRemoveOptions{})
_, err = client.ConfigRemove(t.Context(), "", ConfigRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ConfigRemove(context.Background(), " ", ConfigRemoveOptions{})
_, err = client.ConfigRemove(t.Context(), " ", ConfigRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -41,6 +40,6 @@ func TestConfigRemove(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigRemove(context.Background(), "config_id", ConfigRemoveOptions{})
_, err = client.ConfigRemove(t.Context(), "config_id", ConfigRemoveOptions{})
assert.NilError(t, err)
}

9
client/config_update_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -16,14 +15,14 @@ func TestConfigUpdateError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigUpdate(context.Background(), "config_id", ConfigUpdateOptions{})
_, err = client.ConfigUpdate(t.Context(), "config_id", ConfigUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ConfigUpdate(context.Background(), "", ConfigUpdateOptions{})
_, err = client.ConfigUpdate(t.Context(), "", ConfigUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ConfigUpdate(context.Background(), " ", ConfigUpdateOptions{})
_, err = client.ConfigUpdate(t.Context(), " ", ConfigUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -41,6 +40,6 @@ func TestConfigUpdate(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ConfigUpdate(context.Background(), "config_id", ConfigUpdateOptions{})
_, err = client.ConfigUpdate(t.Context(), "config_id", ConfigUpdateOptions{})
assert.NilError(t, err)
}

8
client/container_commit_test.go
View File

@@ -18,14 +18,14 @@ func TestContainerCommitError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerCommit(context.Background(), "nothing", ContainerCommitOptions{})
_, err = client.ContainerCommit(t.Context(), "nothing", ContainerCommitOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ContainerCommit(context.Background(), "", ContainerCommitOptions{})
_, err = client.ContainerCommit(t.Context(), "", ContainerCommitOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ContainerCommit(context.Background(), " ", ContainerCommitOptions{})
_, err = client.ContainerCommit(t.Context(), " ", ContainerCommitOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -83,7 +83,7 @@ func TestContainerCommit(t *testing.T) {
)
assert.NilError(t, err)
r, err := client.ContainerCommit(context.Background(), expectedContainerID, ContainerCommitOptions{
r, err := client.ContainerCommit(t.Context(), expectedContainerID, ContainerCommitOptions{
Reference: specifiedReference,
Comment: expectedComment,
Author: expectedAuthor,

39
client/container_copy_test.go
View File

@@ -2,7 +2,6 @@ package client
import (
"bytes"
"context"
"encoding/base64"
"encoding/json"
"errors"
@@ -24,14 +23,14 @@ func TestContainerStatPathError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerStatPath(context.Background(), "container_id", ContainerStatPathOptions{Path: "path"})
_, err = client.ContainerStatPath(t.Context(), "container_id", ContainerStatPathOptions{Path: "path"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ContainerStatPath(context.Background(), "", ContainerStatPathOptions{Path: "path"})
_, err = client.ContainerStatPath(t.Context(), "", ContainerStatPathOptions{Path: "path"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ContainerStatPath(context.Background(), " ", ContainerStatPathOptions{Path: "path"})
_, err = client.ContainerStatPath(t.Context(), " ", ContainerStatPathOptions{Path: "path"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -42,7 +41,7 @@ func TestContainerStatPathNotFoundError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerStatPath(context.Background(), "container_id", ContainerStatPathOptions{Path: "path"})
_, err = client.ContainerStatPath(t.Context(), "container_id", ContainerStatPathOptions{Path: "path"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -52,7 +51,7 @@ func TestContainerStatPathNoHeaderError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerStatPath(context.Background(), "container_id", ContainerStatPathOptions{Path: "path/to/file"})
_, err = client.ContainerStatPath(t.Context(), "container_id", ContainerStatPathOptions{Path: "path/to/file"})
assert.Check(t, err != nil, "expected an error, got nothing")
}
@@ -86,7 +85,7 @@ func TestContainerStatPath(t *testing.T) {
}),
)
assert.NilError(t, err)
res, err := client.ContainerStatPath(context.Background(), "container_id", ContainerStatPathOptions{Path: expectedPath})
res, err := client.ContainerStatPath(t.Context(), "container_id", ContainerStatPathOptions{Path: expectedPath})
assert.NilError(t, err)
assert.Check(t, is.Equal(res.Stat.Name, "name"))
assert.Check(t, is.Equal(res.Stat.Mode, os.FileMode(0o700)))
@@ -98,20 +97,20 @@ func TestCopyToContainerError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyToContainer(context.Background(), "container_id", CopyToContainerOptions{
_, err = client.CopyToContainer(t.Context(), "container_id", CopyToContainerOptions{
DestinationPath: "path/to/file",
Content: bytes.NewReader([]byte("")),
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.CopyToContainer(context.Background(), "", CopyToContainerOptions{
_, err = client.CopyToContainer(t.Context(), "", CopyToContainerOptions{
DestinationPath: "path/to/file",
Content: bytes.NewReader([]byte("")),
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.CopyToContainer(context.Background(), " ", CopyToContainerOptions{
_, err = client.CopyToContainer(t.Context(), " ", CopyToContainerOptions{
DestinationPath: "path/to/file",
Content: bytes.NewReader([]byte("")),
})
@@ -125,7 +124,7 @@ func TestCopyToContainerNotFoundError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyToContainer(context.Background(), "container_id", CopyToContainerOptions{
_, err = client.CopyToContainer(t.Context(), "container_id", CopyToContainerOptions{
DestinationPath: "path/to/file",
Content: bytes.NewReader([]byte("")),
})
@@ -140,7 +139,7 @@ func TestCopyToContainerEmptyResponse(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyToContainer(context.Background(), "container_id", CopyToContainerOptions{
_, err = client.CopyToContainer(t.Context(), "container_id", CopyToContainerOptions{
DestinationPath: "path/to/file",
Content: bytes.NewReader([]byte("")),
})
@@ -183,7 +182,7 @@ func TestCopyToContainer(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyToContainer(context.Background(), "container_id", CopyToContainerOptions{
_, err = client.CopyToContainer(t.Context(), "container_id", CopyToContainerOptions{
DestinationPath: expectedPath,
Content: bytes.NewReader([]byte("content")),
AllowOverwriteDirWithFile: false,
@@ -197,14 +196,14 @@ func TestCopyFromContainerError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyFromContainer(context.Background(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
_, err = client.CopyFromContainer(t.Context(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.CopyFromContainer(context.Background(), "", CopyFromContainerOptions{SourcePath: "path/to/file"})
_, err = client.CopyFromContainer(t.Context(), "", CopyFromContainerOptions{SourcePath: "path/to/file"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.CopyFromContainer(context.Background(), " ", CopyFromContainerOptions{SourcePath: "path/to/file"})
_, err = client.CopyFromContainer(t.Context(), " ", CopyFromContainerOptions{SourcePath: "path/to/file"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -215,7 +214,7 @@ func TestCopyFromContainerNotFoundError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyFromContainer(context.Background(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
_, err = client.CopyFromContainer(t.Context(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -240,7 +239,7 @@ func TestCopyFromContainerEmptyResponse(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyFromContainer(context.Background(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
_, err = client.CopyFromContainer(t.Context(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
assert.NilError(t, err)
}
@@ -250,7 +249,7 @@ func TestCopyFromContainerNoHeaderError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.CopyFromContainer(context.Background(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
_, err = client.CopyFromContainer(t.Context(), "container_id", CopyFromContainerOptions{SourcePath: "path/to/file"})
assert.Check(t, err != nil, "expected an error, got nothing")
}
@@ -285,7 +284,7 @@ func TestCopyFromContainer(t *testing.T) {
}),
)
assert.NilError(t, err)
res2, err := client.CopyFromContainer(context.Background(), "container_id", CopyFromContainerOptions{SourcePath: expectedPath})
res2, err := client.CopyFromContainer(t.Context(), "container_id", CopyFromContainerOptions{SourcePath: expectedPath})
assert.NilError(t, err)
assert.Check(t, is.Equal(res2.Stat.Name, "name"))
assert.Check(t, is.Equal(res2.Stat.Mode, os.FileMode(0o700)))

15
client/container_create_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"encoding/json"
"errors"
"fmt"
@@ -20,11 +19,11 @@ func TestContainerCreateError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: nil, Name: "nothing"})
_, err = client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: nil, Name: "nothing"})
assert.Error(t, err, "config.Image or Image is required")
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{}, Name: "nothing"})
_, err = client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: &container.Config{}, Name: "nothing"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
}
@@ -34,7 +33,7 @@ func TestContainerCreateImageNotFound(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{Image: "unknown_image"}, Name: "unknown"})
_, err = client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: &container.Config{Image: "unknown_image"}, Name: "unknown"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -56,7 +55,7 @@ func TestContainerCreateWithName(t *testing.T) {
)
assert.NilError(t, err)
r, err := client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{Image: "test"}, Name: "container_name"})
r, err := client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: &container.Config{Image: "test"}, Name: "container_name"})
assert.NilError(t, err)
assert.Check(t, is.Equal(r.ID, "container_id"))
}
@@ -78,7 +77,7 @@ func TestContainerCreateAutoRemove(t *testing.T) {
)
assert.NilError(t, err)
resp, err := client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{Image: "test"}, HostConfig: &container.HostConfig{AutoRemove: true}})
resp, err := client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: &container.Config{Image: "test"}, HostConfig: &container.HostConfig{AutoRemove: true}})
assert.NilError(t, err)
assert.Check(t, is.Equal(resp.ID, "container_id"))
}
@@ -91,7 +90,7 @@ func TestContainerCreateConnectionError(t *testing.T) {
client, err := New(WithAPIVersionNegotiation(), WithHost("tcp://no-such-host.invalid"))
assert.NilError(t, err)
_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{Image: "test"}})
_, err = client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: &container.Config{Image: "test"}})
assert.Check(t, is.ErrorType(err, IsErrConnectionFailed))
}
@@ -133,6 +132,6 @@ func TestContainerCreateCapabilities(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerCreate(context.Background(), ContainerCreateOptions{Config: &container.Config{Image: "test"}, HostConfig: &container.HostConfig{CapAdd: inputCaps, CapDrop: inputCaps}})
_, err = client.ContainerCreate(t.Context(), ContainerCreateOptions{Config: &container.Config{Image: "test"}, HostConfig: &container.HostConfig{CapAdd: inputCaps, CapDrop: inputCaps}})
assert.NilError(t, err)
}

9
client/container_diff_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -17,14 +16,14 @@ func TestContainerDiffError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerDiff(context.Background(), "nothing", ContainerDiffOptions{})
_, err = client.ContainerDiff(t.Context(), "nothing", ContainerDiffOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ContainerDiff(context.Background(), "", ContainerDiffOptions{})
_, err = client.ContainerDiff(t.Context(), "", ContainerDiffOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ContainerDiff(context.Background(), " ", ContainerDiffOptions{})
_, err = client.ContainerDiff(t.Context(), " ", ContainerDiffOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -57,7 +56,7 @@ func TestContainerDiff(t *testing.T) {
)
assert.NilError(t, err)
result, err := client.ContainerDiff(context.Background(), "container_id", ContainerDiffOptions{})
result, err := client.ContainerDiff(t.Context(), "container_id", ContainerDiffOptions{})
assert.NilError(t, err)
assert.Check(t, is.DeepEqual(result.Changes, expected))
}

5
client/container_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -18,7 +17,7 @@ func TestContainerListError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.ContainerList(context.Background(), ContainerListOptions{})
_, err = client.ContainerList(t.Context(), ContainerListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -65,7 +64,7 @@ func TestContainerList(t *testing.T) {
)
assert.NilError(t, err)
list, err := client.ContainerList(context.Background(), ContainerListOptions{
list, err := client.ContainerList(t.Context(), ContainerListOptions{
Size: true,
All: true,
Since: "container",

5
client/container_prune_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -15,7 +14,7 @@ func TestContainerPruneError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ContainerPrune(context.Background(), ContainerPruneOptions{})
_, err = client.ContainerPrune(t.Context(), ContainerPruneOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -89,7 +88,7 @@ func TestContainerPrune(t *testing.T) {
}))
assert.NilError(t, err)
req, err := client.ContainerPrune(context.Background(), ContainerPruneOptions{Filters: listCase.filters})
req, err := client.ContainerPrune(t.Context(), ContainerPruneOptions{Filters: listCase.filters})
assert.NilError(t, err)
assert.Check(t, is.Len(req.Report.ContainersDeleted, 2))
assert.Check(t, is.Equal(uint64(9999), req.Report.SpaceReclaimed))

9
client/container_rename_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -14,14 +13,14 @@ import (
func TestContainerRenameError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ContainerRename(context.Background(), "nothing", ContainerRenameOptions{NewName: "newNothing"})
_, err = client.ContainerRename(t.Context(), "nothing", ContainerRenameOptions{NewName: "newNothing"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ContainerRename(context.Background(), "", ContainerRenameOptions{NewName: "newNothing"})
_, err = client.ContainerRename(t.Context(), "", ContainerRenameOptions{NewName: "newNothing"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ContainerRename(context.Background(), " ", ContainerRenameOptions{NewName: "newNothing"})
_, err = client.ContainerRename(t.Context(), " ", ContainerRenameOptions{NewName: "newNothing"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -40,6 +39,6 @@ func TestContainerRename(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.ContainerRename(context.Background(), "container_id", ContainerRenameOptions{NewName: "newName"})
_, err = client.ContainerRename(t.Context(), "container_id", ContainerRenameOptions{NewName: "newName"})
assert.NilError(t, err)
}

9
client/container_top_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -15,14 +14,14 @@ import (
func TestContainerTopError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ContainerTop(context.Background(), "nothing", ContainerTopOptions{})
_, err = client.ContainerTop(t.Context(), "nothing", ContainerTopOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ContainerTop(context.Background(), "", ContainerTopOptions{})
_, err = client.ContainerTop(t.Context(), "", ContainerTopOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ContainerTop(context.Background(), " ", ContainerTopOptions{})
_, err = client.ContainerTop(t.Context(), " ", ContainerTopOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -54,7 +53,7 @@ func TestContainerTop(t *testing.T) {
}))
assert.NilError(t, err)
processList, err := client.ContainerTop(context.Background(), "container_id", ContainerTopOptions{
processList, err := client.ContainerTop(t.Context(), "container_id", ContainerTopOptions{
Arguments: []string{"arg1", "arg2"},
})
assert.NilError(t, err)

9
client/container_update_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ import (
func TestContainerUpdateError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ContainerUpdate(context.Background(), "nothing", ContainerUpdateOptions{})
_, err = client.ContainerUpdate(t.Context(), "nothing", ContainerUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ContainerUpdate(context.Background(), "", ContainerUpdateOptions{})
_, err = client.ContainerUpdate(t.Context(), "", ContainerUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ContainerUpdate(context.Background(), " ", ContainerUpdateOptions{})
_, err = client.ContainerUpdate(t.Context(), " ", ContainerUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,7 +36,7 @@ func TestContainerUpdate(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.ContainerUpdate(context.Background(), "container_id", ContainerUpdateOptions{
_, err = client.ContainerUpdate(t.Context(), "container_id", ContainerUpdateOptions{
Resources: &container.Resources{
CPUPeriod: 1,
},

3
client/distribution_inspect_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"errors"
"net/http"
"testing"
@@ -16,6 +15,6 @@ func TestDistributionInspectWithEmptyID(t *testing.T) {
return nil, errors.New("should not make request")
}))
assert.NilError(t, err)
_, err = client.DistributionInspect(context.Background(), "", DistributionInspectOptions{})
_, err = client.DistributionInspect(t.Context(), "", DistributionInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}

3
client/hijack_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"io"
"net"
@@ -89,7 +88,7 @@ func TestTLSCloseWriter(t *testing.T) {
client, err := New(WithHost("tcp://"+serverURL.Host), WithHTTPClient(ts.Client()))
assert.NilError(t, err)
resp, err := client.postHijacked(context.Background(), "/asdf", url.Values{}, nil, map[string][]string{"Content-Type": {"text/plain"}})
resp, err := client.postHijacked(t.Context(), "/asdf", url.Values{}, nil, map[string][]string{"Content-Type": {"text/plain"}})
assert.NilError(t, err)
defer resp.Close()

5
client/image_build_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"io"
"net/http"
@@ -18,7 +17,7 @@ import (
func TestImageBuildError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageBuild(context.Background(), nil, ImageBuildOptions{})
_, err = client.ImageBuild(t.Context(), nil, ImageBuildOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -188,7 +187,7 @@ func TestImageBuild(t *testing.T) {
return mockResponse(http.StatusOK, nil, "body")(req)
}))
assert.NilError(t, err)
buildResponse, err := client.ImageBuild(context.Background(), nil, buildCase.buildOptions)
buildResponse, err := client.ImageBuild(t.Context(), nil, buildCase.buildOptions)
assert.NilError(t, err)
response, err := io.ReadAll(buildResponse.Body)
assert.NilError(t, err)

5
client/image_history_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -15,7 +14,7 @@ import (
func TestImageHistoryError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageHistory(context.Background(), "nothing")
_, err = client.ImageHistory(t.Context(), "nothing")
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -44,7 +43,7 @@ func TestImageHistory(t *testing.T) {
},
}
imageHistories, err := client.ImageHistory(context.Background(), "image_id", ImageHistoryWithPlatform(ocispec.Platform{
imageHistories, err := client.ImageHistory(t.Context(), "image_id", ImageHistoryWithPlatform(ocispec.Platform{
Architecture: "arm64",
OS: "linux",
Variant: "v8",

5
client/image_import_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"io"
"net/http"
"net/url"
@@ -17,7 +16,7 @@ import (
func TestImageImportError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageImport(context.Background(), ImageImportSource{}, "image:tag", ImageImportOptions{})
_, err = client.ImageImport(t.Context(), ImageImportSource{}, "image:tag", ImageImportOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -77,7 +76,7 @@ func TestImageImport(t *testing.T) {
return mockResponse(http.StatusOK, nil, expectedOutput)(req)
}))
assert.NilError(t, err)
result, err := client.ImageImport(context.Background(), ImageImportSource{
result, err := client.ImageImport(t.Context(), ImageImportSource{
Source: strings.NewReader("source"),
SourceName: "image_source",
}, "repository_name:imported", tc.options)

11
client/image_inspect_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"errors"
"fmt"
"net/http"
@@ -18,7 +17,7 @@ func TestImageInspectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageInspect(context.Background(), "nothing")
_, err = client.ImageInspect(t.Context(), "nothing")
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -26,7 +25,7 @@ func TestImageInspectImageNotFound(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusNotFound, "Server error")))
assert.NilError(t, err)
_, err = client.ImageInspect(context.Background(), "unknown")
_, err = client.ImageInspect(t.Context(), "unknown")
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -35,7 +34,7 @@ func TestImageInspectWithEmptyID(t *testing.T) {
return nil, errors.New("should not make request")
}))
assert.NilError(t, err)
_, err = client.ImageInspect(context.Background(), "")
_, err = client.ImageInspect(t.Context(), "")
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -53,7 +52,7 @@ func TestImageInspect(t *testing.T) {
}))
assert.NilError(t, err)
imageInspect, err := client.ImageInspect(context.Background(), "image_id")
imageInspect, err := client.ImageInspect(t.Context(), "image_id")
assert.NilError(t, err)
assert.Check(t, is.Equal(imageInspect.ID, "image_id"))
assert.Check(t, is.DeepEqual(imageInspect.RepoTags, expectedTags))
@@ -88,7 +87,7 @@ func TestImageInspectWithPlatform(t *testing.T) {
}))
assert.NilError(t, err)
imageInspect, err := client.ImageInspect(context.Background(), "image_id", ImageInspectWithPlatform(requestedPlatform))
imageInspect, err := client.ImageInspect(t.Context(), "image_id", ImageInspectWithPlatform(requestedPlatform))
assert.NilError(t, err)
assert.Check(t, is.Equal(imageInspect.ID, "image_id"))
assert.Check(t, is.Equal(imageInspect.Architecture, "arm64"))

9
client/image_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"net/url"
@@ -17,7 +16,7 @@ func TestImageListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageList(context.Background(), ImageListOptions{})
_, err = client.ImageList(t.Context(), ImageListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -29,7 +28,7 @@ func TestImageListConnectionError(t *testing.T) {
client, err := New(WithAPIVersionNegotiation(), WithHost("tcp://no-such-host.invalid"))
assert.NilError(t, err)
_, err = client.ImageList(context.Background(), ImageListOptions{})
_, err = client.ImageList(t.Context(), ImageListOptions{})
assert.Check(t, is.ErrorType(err, IsErrConnectionFailed))
}
@@ -91,7 +90,7 @@ func TestImageList(t *testing.T) {
}))
assert.NilError(t, err)
images, err := client.ImageList(context.Background(), listCase.options)
images, err := client.ImageList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(images.Items, 2))
}
@@ -119,7 +118,7 @@ func TestImageListWithSharedSize(t *testing.T) {
return mockResponse(http.StatusOK, nil, "[]")(req)
}), WithVersion(tc.version))
assert.NilError(t, err)
_, err = client.ImageList(context.Background(), tc.options)
_, err = client.ImageList(t.Context(), tc.options)
assert.NilError(t, err)
expectedSet := tc.sharedSize != ""
assert.Check(t, is.Equal(query.Has(sharedSize), expectedSet))

5
client/image_load_test.go
View File

@@ -2,7 +2,6 @@ package client
import (
"bytes"
"context"
"encoding/json"
"io"
"net/http"
@@ -19,7 +18,7 @@ func TestImageLoadError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageLoad(context.Background(), nil, ImageLoadWithQuiet(true))
_, err = client.ImageLoad(t.Context(), nil, ImageLoadWithQuiet(true))
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -81,7 +80,7 @@ func TestImageLoad(t *testing.T) {
assert.NilError(t, err)
input := bytes.NewReader([]byte(expectedInput))
imageLoadResponse, err := client.ImageLoad(context.Background(), input,
imageLoadResponse, err := client.ImageLoad(t.Context(), input,
ImageLoadWithQuiet(tc.quiet),
ImageLoadWithPlatforms(tc.platforms...),
)

4
client/image_prune_test.go
View File

@@ -16,7 +16,7 @@ func TestImagePruneError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImagePrune(context.Background(), ImagePruneOptions{})
_, err = client.ImagePrune(t.Context(), ImagePruneOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -83,7 +83,7 @@ func TestImagePrune(t *testing.T) {
}))
assert.NilError(t, err)
res, err := client.ImagePrune(context.Background(), ImagePruneOptions{Filters: listCase.filters})
res, err := client.ImagePrune(t.Context(), ImagePruneOptions{Filters: listCase.filters})
assert.NilError(t, err)
assert.Check(t, is.Len(res.Report.ImagesDeleted, 2))
assert.Check(t, is.Equal(uint64(9999), res.Report.SpaceReclaimed))

14
client/image_pull_test.go
View File

@@ -23,28 +23,28 @@ func TestImagePullReferenceParseError(t *testing.T) {
}))
assert.NilError(t, err)
// An empty reference is an invalid reference
_, err = client.ImagePull(context.Background(), "", ImagePullOptions{})
_, err = client.ImagePull(t.Context(), "", ImagePullOptions{})
assert.Check(t, is.ErrorContains(err, "invalid reference format"))
}
func TestImagePullAnyError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{})
_, err = client.ImagePull(t.Context(), "myimage", ImagePullOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
func TestImagePullStatusUnauthorizedError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
assert.NilError(t, err)
_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{})
_, err = client.ImagePull(t.Context(), "myimage", ImagePullOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
}
func TestImagePullWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
assert.NilError(t, err)
_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{
_, err = client.ImagePull(t.Context(), "myimage", ImagePullOptions{
PrivilegeFunc: func(_ context.Context) (string, error) {
return "", errors.New("error requesting privilege")
},
@@ -55,7 +55,7 @@ func TestImagePullWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
func TestImagePullWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
assert.NilError(t, err)
_, err = client.ImagePull(context.Background(), "myimage", ImagePullOptions{
_, err = client.ImagePull(t.Context(), "myimage", ImagePullOptions{
PrivilegeFunc: staticAuth("a-auth-header"),
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
@@ -88,7 +88,7 @@ func TestImagePullWithPrivilegedFuncNoError(t *testing.T) {
return mockResponse(http.StatusOK, nil, "hello world")(req)
}))
assert.NilError(t, err)
resp, err := client.ImagePull(context.Background(), "myimage", ImagePullOptions{
resp, err := client.ImagePull(t.Context(), "myimage", ImagePullOptions{
RegistryAuth: invalidAuth,
PrivilegeFunc: staticAuth(validAuth),
})
@@ -177,7 +177,7 @@ func TestImagePullWithoutErrors(t *testing.T) {
return mockResponse(http.StatusOK, nil, expectedOutput)(req)
}))
assert.NilError(t, err)
resp, err := client.ImagePull(context.Background(), pullCase.reference, ImagePullOptions{
resp, err := client.ImagePull(t.Context(), pullCase.reference, ImagePullOptions{
All: pullCase.all,
})
assert.NilError(t, err)

16
client/image_push_test.go
View File

@@ -20,24 +20,24 @@ func TestImagePushReferenceError(t *testing.T) {
}))
assert.NilError(t, err)
// An empty reference is an invalid reference
_, err = client.ImagePush(context.Background(), "", ImagePushOptions{})
_, err = client.ImagePush(t.Context(), "", ImagePushOptions{})
assert.Check(t, is.ErrorContains(err, "invalid reference format"))
// A canonical reference cannot be pushed
_, err = client.ImagePush(context.Background(), "repo@sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", ImagePushOptions{})
_, err = client.ImagePush(t.Context(), "repo@sha256:ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff", ImagePushOptions{})
assert.Check(t, is.Error(err, "cannot push a digest reference"))
}
func TestImagePushAnyError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{})
_, err = client.ImagePush(t.Context(), "myimage", ImagePushOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
func TestImagePushStatusUnauthorizedError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
assert.NilError(t, err)
_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{})
_, err = client.ImagePush(t.Context(), "myimage", ImagePushOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
}
@@ -47,7 +47,7 @@ func TestImagePushWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
privilegeFunc := func(_ context.Context) (string, error) {
return "", errors.New("error requesting privilege")
}
_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{
_, err = client.ImagePush(t.Context(), "myimage", ImagePushOptions{
PrivilegeFunc: privilegeFunc,
})
assert.Check(t, is.Error(err, "error requesting privilege"))
@@ -59,7 +59,7 @@ func TestImagePushWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.T)
privilegeFunc := func(_ context.Context) (string, error) {
return "a-auth-header", nil
}
_, err = client.ImagePush(context.Background(), "myimage", ImagePushOptions{
_, err = client.ImagePush(t.Context(), "myimage", ImagePushOptions{
PrivilegeFunc: privilegeFunc,
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
@@ -88,7 +88,7 @@ func TestImagePushWithPrivilegedFuncNoError(t *testing.T) {
return mockResponse(http.StatusOK, nil, "hello world")(req)
}))
assert.NilError(t, err)
resp, err := client.ImagePush(context.Background(), "myname/myimage:tag", ImagePushOptions{
resp, err := client.ImagePush(t.Context(), "myname/myimage:tag", ImagePushOptions{
RegistryAuth: invalidAuth,
PrivilegeFunc: staticAuth(validAuth),
})
@@ -174,7 +174,7 @@ func TestImagePushWithoutErrors(t *testing.T) {
return mockResponse(http.StatusOK, nil, expectedOutput)(req)
}))
assert.NilError(t, err)
resp, err := client.ImagePush(context.Background(), tc.reference, ImagePushOptions{
resp, err := client.ImagePush(t.Context(), tc.reference, ImagePushOptions{
All: tc.all,
})
assert.NilError(t, err)

7
client/image_remove_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -17,7 +16,7 @@ func TestImageRemoveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageRemove(context.Background(), "image_id", ImageRemoveOptions{})
_, err = client.ImageRemove(t.Context(), "image_id", ImageRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -25,7 +24,7 @@ func TestImageRemoveImageNotFound(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusNotFound, "no such image: unknown")))
assert.NilError(t, err)
_, err = client.ImageRemove(context.Background(), "unknown", ImageRemoveOptions{})
_, err = client.ImageRemove(t.Context(), "unknown", ImageRemoveOptions{})
assert.Check(t, is.ErrorContains(err, "no such image: unknown"))
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -91,7 +90,7 @@ func TestImageRemove(t *testing.T) {
opts.Platforms = []ocispec.Platform{*removeCase.platform}
}
res, err := client.ImageRemove(context.Background(), "image_id", opts)
res, err := client.ImageRemove(t.Context(), "image_id", opts)
assert.NilError(t, err)
assert.Check(t, is.Len(res.Items, 2))
}

12
client/image_search_test.go
View File

@@ -16,14 +16,14 @@ import (
func TestImageSearchAnyError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{})
_, err = client.ImageSearch(t.Context(), "some-image", ImageSearchOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
func TestImageSearchStatusUnauthorizedError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusUnauthorized, "Unauthorized error")))
assert.NilError(t, err)
_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{})
_, err = client.ImageSearch(t.Context(), "some-image", ImageSearchOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
}
@@ -33,7 +33,7 @@ func TestImageSearchWithUnauthorizedErrorAndPrivilegeFuncError(t *testing.T) {
privilegeFunc := func(_ context.Context) (string, error) {
return "", errors.New("Error requesting privilege")
}
_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
_, err = client.ImageSearch(t.Context(), "some-image", ImageSearchOptions{
PrivilegeFunc: privilegeFunc,
})
assert.Check(t, is.Error(err, "Error requesting privilege"))
@@ -45,7 +45,7 @@ func TestImageSearchWithUnauthorizedErrorAndAnotherUnauthorizedError(t *testing.
privilegeFunc := func(_ context.Context) (string, error) {
return "a-auth-header", nil
}
_, err = client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
_, err = client.ImageSearch(t.Context(), "some-image", ImageSearchOptions{
PrivilegeFunc: privilegeFunc,
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsUnauthorized))
@@ -77,7 +77,7 @@ func TestImageSearchWithPrivilegedFuncNoError(t *testing.T) {
privilegeFunc := func(_ context.Context) (string, error) {
return "IAmValid", nil
}
results, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
results, err := client.ImageSearch(t.Context(), "some-image", ImageSearchOptions{
RegistryAuth: "NotValid",
PrivilegeFunc: privilegeFunc,
})
@@ -107,7 +107,7 @@ func TestImageSearchWithoutErrors(t *testing.T) {
})(req)
}))
assert.NilError(t, err)
results, err := client.ImageSearch(context.Background(), "some-image", ImageSearchOptions{
results, err := client.ImageSearch(t.Context(), "some-image", ImageSearchOptions{
Filters: make(Filters).Add("is-automated", "true").Add("stars", "3"),
})
assert.NilError(t, err)

11
client/image_tag_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"math/rand"
"net/http"
@@ -16,7 +15,7 @@ func TestImageTagError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageTag(context.Background(), ImageTagOptions{Source: "image_id", Target: "repo:tag"})
_, err = client.ImageTag(t.Context(), ImageTagOptions{Source: "image_id", Target: "repo:tag"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -26,13 +25,13 @@ func TestImageTagInvalidReference(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ImageTag(context.Background(), ImageTagOptions{Source: "image_id", Target: "aa/asdf$$^/aa"})
_, err = client.ImageTag(t.Context(), ImageTagOptions{Source: "image_id", Target: "aa/asdf$$^/aa"})
assert.Check(t, is.Error(err, `error parsing reference: "aa/asdf$$^/aa" is not a valid repository/tag: invalid reference format`))
}
// Ensure we don't allow the use of invalid repository names or tags; these tag operations should fail.
func TestImageTagInvalidSourceImageName(t *testing.T) {
ctx := context.Background()
ctx := t.Context()
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "client should not have made an API call")))
assert.NilError(t, err)
@@ -89,7 +88,7 @@ func TestImageTagHexSource(t *testing.T) {
client, err := New(WithMockClient(mockResponse(http.StatusOK, nil, "OK")))
assert.NilError(t, err)
_, err = client.ImageTag(context.Background(), ImageTagOptions{Source: "0d409d33b27e47423b049f7f863faa08655a8c901749c2b25b93ca67d01a470d", Target: "repo:tag"})
_, err = client.ImageTag(t.Context(), ImageTagOptions{Source: "0d409d33b27e47423b049f7f863faa08655a8c901749c2b25b93ca67d01a470d", Target: "repo:tag"})
assert.NilError(t, err)
}
@@ -164,7 +163,7 @@ func TestImageTag(t *testing.T) {
return mockResponse(http.StatusOK, nil, "")(req)
}))
assert.NilError(t, err)
_, err = client.ImageTag(context.Background(), ImageTagOptions{Source: "image_id", Target: tagCase.reference})
_, err = client.ImageTag(t.Context(), ImageTagOptions{Source: "image_id", Target: tagCase.reference})
assert.NilError(t, err)
}
}

10
client/network_connect_test.go
View File

@@ -17,19 +17,19 @@ func TestNetworkConnectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{
_, err = client.NetworkConnect(t.Context(), "network_id", NetworkConnectOptions{
Container: "container_id",
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
// Empty network ID or container ID
_, err = client.NetworkConnect(context.Background(), "", NetworkConnectOptions{
_, err = client.NetworkConnect(t.Context(), "", NetworkConnectOptions{
Container: "container_id",
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{})
_, err = client.NetworkConnect(t.Context(), "network_id", NetworkConnectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -59,7 +59,7 @@ func TestNetworkConnectEmptyNilEndpointSettings(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{
_, err = client.NetworkConnect(t.Context(), "network_id", NetworkConnectOptions{
Container: "container_id",
})
assert.NilError(t, err)
@@ -94,7 +94,7 @@ func TestNetworkConnect(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.NetworkConnect(context.Background(), "network_id", NetworkConnectOptions{
_, err = client.NetworkConnect(t.Context(), "network_id", NetworkConnectOptions{
Container: "container_id",
EndpointConfig: &network.EndpointSettings{
NetworkID: "NetworkID",

6
client/network_create_test.go
View File

@@ -15,7 +15,7 @@ func TestNetworkCreateError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NetworkCreate(context.Background(), "mynetwork", NetworkCreateOptions{})
_, err = client.NetworkCreate(t.Context(), "mynetwork", NetworkCreateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -27,7 +27,7 @@ func TestNetworkCreateConnectionError(t *testing.T) {
client, err := New(WithAPIVersionNegotiation(), WithHost("tcp://no-such-host.invalid"))
assert.NilError(t, err)
_, err = client.NetworkCreate(context.Background(), "mynetwork", NetworkCreateOptions{})
_, err = client.NetworkCreate(t.Context(), "mynetwork", NetworkCreateOptions{})
assert.Check(t, is.ErrorType(err, IsErrConnectionFailed))
}
@@ -46,7 +46,7 @@ func TestNetworkCreate(t *testing.T) {
assert.NilError(t, err)
enableIPv6 := true
networkResponse, err := client.NetworkCreate(context.Background(), "mynetwork", NetworkCreateOptions{
networkResponse, err := client.NetworkCreate(t.Context(), "mynetwork", NetworkCreateOptions{
Driver: "mydriver",
EnableIPv6: &enableIPv6,
Internal: true,

8
client/network_disconnect_test.go
View File

@@ -17,19 +17,19 @@ func TestNetworkDisconnectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NetworkDisconnect(context.Background(), "network_id", NetworkDisconnectOptions{
_, err = client.NetworkDisconnect(t.Context(), "network_id", NetworkDisconnectOptions{
Container: "container_id",
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
// Empty network ID or container ID
_, err = client.NetworkDisconnect(context.Background(), "", NetworkDisconnectOptions{
_, err = client.NetworkDisconnect(t.Context(), "", NetworkDisconnectOptions{
Container: "container_id",
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NetworkDisconnect(context.Background(), "network_id", NetworkDisconnectOptions{})
_, err = client.NetworkDisconnect(t.Context(), "network_id", NetworkDisconnectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -59,6 +59,6 @@ func TestNetworkDisconnect(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.NetworkDisconnect(context.Background(), "network_id", NetworkDisconnectOptions{Container: "container_id", Force: true})
_, err = client.NetworkDisconnect(t.Context(), "network_id", NetworkDisconnectOptions{Container: "container_id", Force: true})
assert.NilError(t, err)
}

14
client/network_inspect_test.go
View File

@@ -52,39 +52,39 @@ func TestNetworkInspect(t *testing.T) {
t.Run("empty ID", func(t *testing.T) {
// verify that the client does not create a request if the network-ID/name is empty.
_, err := client.NetworkInspect(context.Background(), "", NetworkInspectOptions{})
_, err := client.NetworkInspect(t.Context(), "", NetworkInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NetworkInspect(context.Background(), " ", NetworkInspectOptions{})
_, err = client.NetworkInspect(t.Context(), " ", NetworkInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
})
t.Run("no options", func(t *testing.T) {
r, err := client.NetworkInspect(context.Background(), "network_id", NetworkInspectOptions{})
r, err := client.NetworkInspect(t.Context(), "network_id", NetworkInspectOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(r.Network.Name, "mynetwork"))
})
t.Run("verbose", func(t *testing.T) {
r, err := client.NetworkInspect(context.Background(), "network_id", NetworkInspectOptions{Verbose: true})
r, err := client.NetworkInspect(t.Context(), "network_id", NetworkInspectOptions{Verbose: true})
assert.NilError(t, err)
assert.Check(t, is.Equal(r.Network.Name, "mynetwork"))
_, ok := r.Network.Services["web"]
assert.Check(t, ok, "expected service `web` missing in the verbose output")
})
t.Run("global scope", func(t *testing.T) {
_, err := client.NetworkInspect(context.Background(), "network_id", NetworkInspectOptions{Scope: "global"})
_, err := client.NetworkInspect(t.Context(), "network_id", NetworkInspectOptions{Scope: "global"})
assert.Check(t, is.ErrorContains(err, "Error: No such network: network_id"))
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
})
t.Run("unknown network", func(t *testing.T) {
_, err := client.NetworkInspect(context.Background(), "unknown", NetworkInspectOptions{})
_, err := client.NetworkInspect(t.Context(), "unknown", NetworkInspectOptions{})
assert.Check(t, is.ErrorContains(err, "Error: No such network: unknown"))
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
})
t.Run("server error", func(t *testing.T) {
// Just testing that an internal server error is converted correctly by the client
_, err := client.NetworkInspect(context.Background(), "test-500-response", NetworkInspectOptions{})
_, err := client.NetworkInspect(t.Context(), "test-500-response", NetworkInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
})
}

5
client/network_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestNetworkListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NetworkList(context.Background(), NetworkListOptions{})
_, err = client.NetworkList(t.Context(), NetworkListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -74,7 +73,7 @@ func TestNetworkList(t *testing.T) {
}))
assert.NilError(t, err)
res, err := client.NetworkList(context.Background(), listCase.options)
res, err := client.NetworkList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(res.Items, 1))
}

5
client/network_prune_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -17,7 +16,7 @@ func TestNetworkPruneError(t *testing.T) {
)
assert.NilError(t, err)
_, err = client.NetworkPrune(context.Background(), NetworkPruneOptions{})
_, err = client.NetworkPrune(t.Context(), NetworkPruneOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -82,7 +81,7 @@ func TestNetworkPrune(t *testing.T) {
)
assert.NilError(t, err)
res, err := client.NetworkPrune(context.Background(), NetworkPruneOptions{Filters: listCase.filters})
res, err := client.NetworkPrune(t.Context(), NetworkPruneOptions{Filters: listCase.filters})
assert.NilError(t, err)
assert.Check(t, is.Len(res.Report.NetworksDeleted, 2))
}

9
client/network_remove_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ func TestNetworkRemoveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NetworkRemove(context.Background(), "network_id", NetworkRemoveOptions{})
_, err = client.NetworkRemove(t.Context(), "network_id", NetworkRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.NetworkRemove(context.Background(), "", NetworkRemoveOptions{})
_, err = client.NetworkRemove(t.Context(), "", NetworkRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NetworkRemove(context.Background(), " ", NetworkRemoveOptions{})
_, err = client.NetworkRemove(t.Context(), " ", NetworkRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +36,6 @@ func TestNetworkRemove(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.NetworkRemove(context.Background(), "network_id", NetworkRemoveOptions{})
_, err = client.NetworkRemove(t.Context(), "network_id", NetworkRemoveOptions{})
assert.NilError(t, err)
}

11
client/node_inspect_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"errors"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestNodeInspectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NodeInspect(context.Background(), "nothing", NodeInspectOptions{})
_, err = client.NodeInspect(t.Context(), "nothing", NodeInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -24,7 +23,7 @@ func TestNodeInspectNodeNotFound(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusNotFound, "Server error")))
assert.NilError(t, err)
_, err = client.NodeInspect(context.Background(), "unknown", NodeInspectOptions{})
_, err = client.NodeInspect(t.Context(), "unknown", NodeInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -33,11 +32,11 @@ func TestNodeInspectWithEmptyID(t *testing.T) {
return nil, errors.New("should not make request")
}))
assert.NilError(t, err)
_, err = client.NodeInspect(context.Background(), "", NodeInspectOptions{})
_, err = client.NodeInspect(t.Context(), "", NodeInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NodeInspect(context.Background(), " ", NodeInspectOptions{})
_, err = client.NodeInspect(t.Context(), " ", NodeInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -54,7 +53,7 @@ func TestNodeInspect(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.NodeInspect(context.Background(), "node_id", NodeInspectOptions{})
result, err := client.NodeInspect(t.Context(), "node_id", NodeInspectOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(result.Node.ID, "node_id"))
}

5
client/node_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestNodeListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NodeList(context.Background(), NodeListOptions{})
_, err = client.NodeList(t.Context(), NodeListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -62,7 +61,7 @@ func TestNodeList(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.NodeList(context.Background(), listCase.options)
result, err := client.NodeList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(result.Items, 2))
}

8
client/node_remove_test.go
View File

@@ -15,14 +15,14 @@ func TestNodeRemoveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NodeRemove(context.Background(), "node_id", NodeRemoveOptions{Force: false})
_, err = client.NodeRemove(t.Context(), "node_id", NodeRemoveOptions{Force: false})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.NodeRemove(context.Background(), "", NodeRemoveOptions{Force: false})
_, err = client.NodeRemove(t.Context(), "", NodeRemoveOptions{Force: false})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NodeRemove(context.Background(), " ", NodeRemoveOptions{Force: false})
_, err = client.NodeRemove(t.Context(), " ", NodeRemoveOptions{Force: false})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -57,7 +57,7 @@ func TestNodeRemove(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.NodeRemove(context.Background(), "node_id", NodeRemoveOptions{Force: removeCase.force})
_, err = client.NodeRemove(t.Context(), "node_id", NodeRemoveOptions{Force: removeCase.force})
assert.NilError(t, err)
}
}

8
client/node_update_test.go
View File

@@ -15,20 +15,20 @@ func TestNodeUpdateError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.NodeUpdate(context.Background(), "node_id", NodeUpdateOptions{
_, err = client.NodeUpdate(t.Context(), "node_id", NodeUpdateOptions{
Version: swarm.Version{},
Spec: swarm.NodeSpec{},
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.NodeUpdate(context.Background(), "", NodeUpdateOptions{
_, err = client.NodeUpdate(t.Context(), "", NodeUpdateOptions{
Version: swarm.Version{},
Spec: swarm.NodeSpec{},
})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.NodeUpdate(context.Background(), " ", NodeUpdateOptions{
_, err = client.NodeUpdate(t.Context(), " ", NodeUpdateOptions{
Version: swarm.Version{},
Spec: swarm.NodeSpec{},
})
@@ -47,7 +47,7 @@ func TestNodeUpdate(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.NodeUpdate(context.Background(), "node_id", NodeUpdateOptions{
_, err = client.NodeUpdate(t.Context(), "node_id", NodeUpdateOptions{
Version: swarm.Version{},
Spec: swarm.NodeSpec{},
})

9
client/plugin_disable_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ func TestPluginDisableError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.PluginDisable(context.Background(), "plugin_name", PluginDisableOptions{})
_, err = client.PluginDisable(t.Context(), "plugin_name", PluginDisableOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.PluginDisable(context.Background(), "", PluginDisableOptions{})
_, err = client.PluginDisable(t.Context(), "", PluginDisableOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.PluginDisable(context.Background(), " ", PluginDisableOptions{})
_, err = client.PluginDisable(t.Context(), " ", PluginDisableOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +36,6 @@ func TestPluginDisable(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.PluginDisable(context.Background(), "plugin_name", PluginDisableOptions{})
_, err = client.PluginDisable(t.Context(), "plugin_name", PluginDisableOptions{})
assert.NilError(t, err)
}

9
client/plugin_enable_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ func TestPluginEnableError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.PluginEnable(context.Background(), "plugin_name", PluginEnableOptions{})
_, err = client.PluginEnable(t.Context(), "plugin_name", PluginEnableOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.PluginEnable(context.Background(), "", PluginEnableOptions{})
_, err = client.PluginEnable(t.Context(), "", PluginEnableOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.PluginEnable(context.Background(), " ", PluginEnableOptions{})
_, err = client.PluginEnable(t.Context(), " ", PluginEnableOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +36,6 @@ func TestPluginEnable(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.PluginEnable(context.Background(), "plugin_name", PluginEnableOptions{})
_, err = client.PluginEnable(t.Context(), "plugin_name", PluginEnableOptions{})
assert.NilError(t, err)
}

5
client/plugin_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestPluginListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.PluginList(context.Background(), PluginListOptions{})
_, err = client.PluginList(t.Context(), PluginListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -71,7 +70,7 @@ func TestPluginList(t *testing.T) {
}))
assert.NilError(t, err)
list, err := client.PluginList(context.Background(), PluginListOptions{
list, err := client.PluginList(t.Context(), PluginListOptions{
Filters: listCase.filters,
})
assert.NilError(t, err)

8
client/plugin_push_test.go
View File

@@ -16,14 +16,14 @@ func TestPluginPushError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.PluginPush(context.Background(), "plugin_name", PluginPushOptions{})
_, err = client.PluginPush(t.Context(), "plugin_name", PluginPushOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.PluginPush(context.Background(), "", PluginPushOptions{})
_, err = client.PluginPush(t.Context(), "", PluginPushOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.PluginPush(context.Background(), " ", PluginPushOptions{})
_, err = client.PluginPush(t.Context(), " ", PluginPushOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -43,6 +43,6 @@ func TestPluginPush(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.PluginPush(context.Background(), "plugin_name", PluginPushOptions{RegistryAuth: "authtoken"})
_, err = client.PluginPush(t.Context(), "plugin_name", PluginPushOptions{RegistryAuth: "authtoken"})
assert.NilError(t, err)
}

8
client/plugin_remove_test.go
View File

@@ -14,14 +14,14 @@ func TestPluginRemoveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.PluginRemove(context.Background(), "plugin_name", PluginRemoveOptions{})
_, err = client.PluginRemove(t.Context(), "plugin_name", PluginRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.PluginRemove(context.Background(), "", PluginRemoveOptions{})
_, err = client.PluginRemove(t.Context(), "", PluginRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.PluginRemove(context.Background(), " ", PluginRemoveOptions{})
_, err = client.PluginRemove(t.Context(), " ", PluginRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +37,6 @@ func TestPluginRemove(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.PluginRemove(context.Background(), "plugin_name", PluginRemoveOptions{})
_, err = client.PluginRemove(t.Context(), "plugin_name", PluginRemoveOptions{})
assert.NilError(t, err)
}

8
client/plugin_set_test.go
View File

@@ -14,14 +14,14 @@ func TestPluginSetError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.PluginSet(context.Background(), "plugin_name", PluginSetOptions{})
_, err = client.PluginSet(t.Context(), "plugin_name", PluginSetOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.PluginSet(context.Background(), "", PluginSetOptions{})
_, err = client.PluginSet(t.Context(), "", PluginSetOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.PluginSet(context.Background(), " ", PluginSetOptions{})
_, err = client.PluginSet(t.Context(), " ", PluginSetOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +37,6 @@ func TestPluginSet(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.PluginSet(context.Background(), "plugin_name", PluginSetOptions{Args: []string{"arg1"}})
_, err = client.PluginSet(t.Context(), "plugin_name", PluginSetOptions{Args: []string{"arg1"}})
assert.NilError(t, err)
}

8
client/request_test.go
View File

@@ -64,7 +64,7 @@ func TestSetHostHeader(t *testing.T) {
}), WithHost(tc.host))
assert.NilError(t, err)
_, err = client.sendRequest(context.Background(), http.MethodGet, testEndpoint, nil, nil, nil)
_, err = client.sendRequest(t.Context(), http.MethodGet, testEndpoint, nil, nil, nil)
assert.NilError(t, err)
})
}
@@ -76,7 +76,7 @@ func TestSetHostHeader(t *testing.T) {
func TestPlainTextError(t *testing.T) {
client, err := New(WithMockClient(mockResponse(http.StatusInternalServerError, nil, "Server error")))
assert.NilError(t, err)
_, err = client.ContainerList(context.Background(), ContainerListOptions{})
_, err = client.ContainerList(t.Context(), ContainerListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -235,7 +235,7 @@ func TestCanceledContext(t *testing.T) {
}))
assert.NilError(t, err)
ctx, cancel := context.WithCancel(context.Background())
ctx, cancel := context.WithCancel(t.Context())
cancel()
_, err = client.sendRequest(ctx, http.MethodGet, testEndpoint, nil, nil, nil)
@@ -251,7 +251,7 @@ func TestDeadlineExceededContext(t *testing.T) {
}))
assert.NilError(t, err)
ctx, cancel := context.WithDeadline(context.Background(), time.Now())
ctx, cancel := context.WithDeadline(t.Context(), time.Now())
defer cancel()
<-ctx.Done()

5
client/secret_create_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,7 +13,7 @@ import (
func TestSecretCreateError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SecretCreate(context.Background(), SecretCreateOptions{})
_, err = client.SecretCreate(t.Context(), SecretCreateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -30,7 +29,7 @@ func TestSecretCreate(t *testing.T) {
}))
assert.NilError(t, err)
r, err := client.SecretCreate(context.Background(), SecretCreateOptions{})
r, err := client.SecretCreate(t.Context(), SecretCreateOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(r.ID, "test_secret"))
}

10
client/secret_inspect_test.go
View File

@@ -16,7 +16,7 @@ func TestSecretInspectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SecretInspect(context.Background(), "nothing", SecretInspectOptions{})
_, err = client.SecretInspect(t.Context(), "nothing", SecretInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -24,7 +24,7 @@ func TestSecretInspectSecretNotFound(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusNotFound, "Server error")))
assert.NilError(t, err)
_, err = client.SecretInspect(context.Background(), "unknown", SecretInspectOptions{})
_, err = client.SecretInspect(t.Context(), "unknown", SecretInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -33,11 +33,11 @@ func TestSecretInspectWithEmptyID(t *testing.T) {
return nil, errors.New("should not make request")
}))
assert.NilError(t, err)
_, err = client.SecretInspect(context.Background(), "", SecretInspectOptions{})
_, err = client.SecretInspect(t.Context(), "", SecretInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.SecretInspect(context.Background(), " ", SecretInspectOptions{})
_, err = client.SecretInspect(t.Context(), " ", SecretInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -54,7 +54,7 @@ func TestSecretInspect(t *testing.T) {
}))
assert.NilError(t, err)
res, err := client.SecretInspect(context.Background(), "secret_id", SecretInspectOptions{})
res, err := client.SecretInspect(t.Context(), "secret_id", SecretInspectOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(res.Secret.ID, "secret_id"))
}

5
client/secret_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestSecretListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SecretList(context.Background(), SecretListOptions{})
_, err = client.SecretList(t.Context(), SecretListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -62,7 +61,7 @@ func TestSecretList(t *testing.T) {
}))
assert.NilError(t, err)
res, err := client.SecretList(context.Background(), listCase.options)
res, err := client.SecretList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(res.Items, 2))
}

9
client/secret_remove_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ func TestSecretRemoveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SecretRemove(context.Background(), "secret_id", SecretRemoveOptions{})
_, err = client.SecretRemove(t.Context(), "secret_id", SecretRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.SecretRemove(context.Background(), "", SecretRemoveOptions{})
_, err = client.SecretRemove(t.Context(), "", SecretRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.SecretRemove(context.Background(), " ", SecretRemoveOptions{})
_, err = client.SecretRemove(t.Context(), " ", SecretRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +36,6 @@ func TestSecretRemove(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.SecretRemove(context.Background(), "secret_id", SecretRemoveOptions{})
_, err = client.SecretRemove(t.Context(), "secret_id", SecretRemoveOptions{})
assert.NilError(t, err)
}

9
client/secret_update_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ func TestSecretUpdateError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SecretUpdate(context.Background(), "secret_id", SecretUpdateOptions{})
_, err = client.SecretUpdate(t.Context(), "secret_id", SecretUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.SecretUpdate(context.Background(), "", SecretUpdateOptions{})
_, err = client.SecretUpdate(t.Context(), "", SecretUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.SecretUpdate(context.Background(), " ", SecretUpdateOptions{})
_, err = client.SecretUpdate(t.Context(), " ", SecretUpdateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -37,6 +36,6 @@ func TestSecretUpdate(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.SecretUpdate(context.Background(), "secret_id", SecretUpdateOptions{})
_, err = client.SecretUpdate(t.Context(), "secret_id", SecretUpdateOptions{})
assert.NilError(t, err)
}

10
client/service_inspect_test.go
View File

@@ -16,7 +16,7 @@ func TestServiceInspectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ServiceInspect(context.Background(), "nothing", ServiceInspectOptions{})
_, err = client.ServiceInspect(t.Context(), "nothing", ServiceInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -24,7 +24,7 @@ func TestServiceInspectServiceNotFound(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusNotFound, "Server error")))
assert.NilError(t, err)
_, err = client.ServiceInspect(context.Background(), "unknown", ServiceInspectOptions{})
_, err = client.ServiceInspect(t.Context(), "unknown", ServiceInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -33,11 +33,11 @@ func TestServiceInspectWithEmptyID(t *testing.T) {
return nil, errors.New("should not make request")
}))
assert.NilError(t, err)
_, err = client.ServiceInspect(context.Background(), "", ServiceInspectOptions{})
_, err = client.ServiceInspect(t.Context(), "", ServiceInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ServiceInspect(context.Background(), " ", ServiceInspectOptions{})
_, err = client.ServiceInspect(t.Context(), " ", ServiceInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -54,7 +54,7 @@ func TestServiceInspect(t *testing.T) {
}))
assert.NilError(t, err)
inspect, err := client.ServiceInspect(context.Background(), "service_id", ServiceInspectOptions{})
inspect, err := client.ServiceInspect(t.Context(), "service_id", ServiceInspectOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(inspect.Service.ID, "service_id"))
}

5
client/service_list_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"fmt"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestServiceListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ServiceList(context.Background(), ServiceListOptions{})
_, err = client.ServiceList(t.Context(), ServiceListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -62,7 +61,7 @@ func TestServiceList(t *testing.T) {
}))
assert.NilError(t, err)
list, err := client.ServiceList(context.Background(), listCase.options)
list, err := client.ServiceList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(list.Items, 2))
}

11
client/service_remove_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ func TestServiceRemoveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.ServiceRemove(context.Background(), "service_id", ServiceRemoveOptions{})
_, err = client.ServiceRemove(t.Context(), "service_id", ServiceRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
_, err = client.ServiceRemove(context.Background(), "", ServiceRemoveOptions{})
_, err = client.ServiceRemove(t.Context(), "", ServiceRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.ServiceRemove(context.Background(), " ", ServiceRemoveOptions{})
_, err = client.ServiceRemove(t.Context(), " ", ServiceRemoveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -30,7 +29,7 @@ func TestServiceRemoveNotFoundError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusNotFound, "no such service: service_id")))
assert.NilError(t, err)
_, err = client.ServiceRemove(context.Background(), "service_id", ServiceRemoveOptions{})
_, err = client.ServiceRemove(t.Context(), "service_id", ServiceRemoveOptions{})
assert.Check(t, is.ErrorContains(err, "no such service: service_id"))
assert.Check(t, is.ErrorType(err, cerrdefs.IsNotFound))
}
@@ -46,6 +45,6 @@ func TestServiceRemove(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.ServiceRemove(context.Background(), "service_id", ServiceRemoveOptions{})
_, err = client.ServiceRemove(t.Context(), "service_id", ServiceRemoveOptions{})
assert.NilError(t, err)
}

5
client/swarm_get_unlock_key_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -15,7 +14,7 @@ func TestSwarmGetUnlockKeyError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SwarmGetUnlockKey(context.Background())
_, err = client.SwarmGetUnlockKey(t.Context())
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -35,7 +34,7 @@ func TestSwarmGetUnlockKey(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.SwarmGetUnlockKey(context.Background())
result, err := client.SwarmGetUnlockKey(t.Context())
assert.NilError(t, err)
assert.Check(t, is.Equal(unlockKey, result.Key))
}

5
client/swarm_init_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,7 +13,7 @@ func TestSwarmInitError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SwarmInit(context.Background(), SwarmInitOptions{})
_, err = client.SwarmInit(t.Context(), SwarmInitOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -29,7 +28,7 @@ func TestSwarmInit(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.SwarmInit(context.Background(), SwarmInitOptions{
result, err := client.SwarmInit(t.Context(), SwarmInitOptions{
ListenAddr: "0.0.0.0:2377",
})
assert.NilError(t, err)

5
client/swarm_join_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,7 +13,7 @@ func TestSwarmJoinError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SwarmJoin(context.Background(), SwarmJoinOptions{})
_, err = client.SwarmJoin(t.Context(), SwarmJoinOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -29,7 +28,7 @@ func TestSwarmJoin(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.SwarmJoin(context.Background(), SwarmJoinOptions{
_, err = client.SwarmJoin(t.Context(), SwarmJoinOptions{
ListenAddr: "0.0.0.0:2377",
})
assert.NilError(t, err)

4
client/swarm_leave_test.go
View File

@@ -15,7 +15,7 @@ func TestSwarmLeaveError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SwarmLeave(context.Background(), SwarmLeaveOptions{})
_, err = client.SwarmLeave(t.Context(), SwarmLeaveOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -48,7 +48,7 @@ func TestSwarmLeave(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.SwarmLeave(context.Background(), SwarmLeaveOptions{Force: leaveCase.force})
_, err = client.SwarmLeave(t.Context(), SwarmLeaveOptions{Force: leaveCase.force})
assert.NilError(t, err)
}
}

5
client/swarm_unlock_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,7 +13,7 @@ func TestSwarmUnlockError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.SwarmUnlock(context.Background(), SwarmUnlockOptions{Key: "SWMKEY-1-y6guTZNTwpQeTL5RhUfOsdBdXoQjiB2GADHSRJvbXeU"})
_, err = client.SwarmUnlock(t.Context(), SwarmUnlockOptions{Key: "SWMKEY-1-y6guTZNTwpQeTL5RhUfOsdBdXoQjiB2GADHSRJvbXeU"})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -29,6 +28,6 @@ func TestSwarmUnlock(t *testing.T) {
}))
assert.NilError(t, err)
_, err = client.SwarmUnlock(context.Background(), SwarmUnlockOptions{Key: "SWMKEY-1-y6guTZNTwpQeTL5RhUfOsdBdXoQjiB2GADHSRJvbXeU"})
_, err = client.SwarmUnlock(t.Context(), SwarmUnlockOptions{Key: "SWMKEY-1-y6guTZNTwpQeTL5RhUfOsdBdXoQjiB2GADHSRJvbXeU"})
assert.NilError(t, err)
}

15
client/system_events_test.go
View File

@@ -2,7 +2,6 @@ package client
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
@@ -37,8 +36,8 @@ func TestEventsErrorInOptions(t *testing.T) {
for _, tc := range errorCases {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
events := client.Events(context.Background(), tc.options)
err = <-events.Err
res := client.Events(t.Context(), tc.options)
err = <-res.Err
assert.Check(t, is.ErrorContains(err, tc.expectedError))
}
}
@@ -46,8 +45,8 @@ func TestEventsErrorInOptions(t *testing.T) {
func TestEventsErrorFromServer(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
events := client.Events(context.Background(), EventsListOptions{})
err = <-events.Err
res := client.Events(t.Context(), EventsListOptions{})
err = <-res.Err
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -133,18 +132,18 @@ func TestEvents(t *testing.T) {
}))
assert.NilError(t, err)
events := client.Events(context.Background(), eventsCase.options)
res := client.Events(t.Context(), eventsCase.options)
loop:
for {
select {
case err := <-events.Err:
case err := <-res.Err:
if err != nil && !errors.Is(err, io.EOF) {
t.Fatal(err)
}
break loop
case e := <-events.Messages:
case e := <-res.Messages:
_, ok := eventsCase.expectedEvents[e.Actor.ID]
assert.Check(t, ok, "event received not expected with action %s & id %s", e.Action, e.Actor.ID)
}

9
client/system_info_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -14,14 +13,14 @@ import (
func TestInfoServerError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.Info(context.Background(), InfoOptions{})
_, err = client.Info(t.Context(), InfoOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
func TestInfoInvalidResponseJSONError(t *testing.T) {
client, err := New(WithMockClient(mockResponse(http.StatusOK, nil, "invalid json")))
assert.NilError(t, err)
_, err = client.Info(context.Background(), InfoOptions{})
_, err = client.Info(t.Context(), InfoOptions{})
assert.Check(t, is.ErrorContains(err, "invalid character"))
}
@@ -38,7 +37,7 @@ func TestInfo(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.Info(context.Background(), InfoOptions{})
result, err := client.Info(t.Context(), InfoOptions{})
assert.NilError(t, err)
info := result.Info
@@ -69,7 +68,7 @@ func TestInfoWithDiscoveredDevices(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.Info(context.Background(), InfoOptions{})
result, err := client.Info(t.Context(), InfoOptions{})
assert.NilError(t, err)
info := result.Info

9
client/task_inspect_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"errors"
"net/http"
"testing"
@@ -16,7 +15,7 @@ func TestTaskInspectError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.TaskInspect(context.Background(), "nothing", TaskInspectOptions{})
_, err = client.TaskInspect(t.Context(), "nothing", TaskInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -25,11 +24,11 @@ func TestTaskInspectWithEmptyID(t *testing.T) {
return nil, errors.New("should not make request")
}))
assert.NilError(t, err)
_, err = client.TaskInspect(context.Background(), "", TaskInspectOptions{})
_, err = client.TaskInspect(t.Context(), "", TaskInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
_, err = client.TaskInspect(context.Background(), " ", TaskInspectOptions{})
_, err = client.TaskInspect(t.Context(), " ", TaskInspectOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInvalidArgument))
assert.Check(t, is.ErrorContains(err, "value is empty"))
}
@@ -46,7 +45,7 @@ func TestTaskInspect(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.TaskInspect(context.Background(), "task_id", TaskInspectOptions{})
result, err := client.TaskInspect(t.Context(), "task_id", TaskInspectOptions{})
assert.NilError(t, err)
assert.Check(t, is.Equal(result.Task.ID, "task_id"))
}

4
client/task_list_test.go
View File

@@ -16,7 +16,7 @@ func TestTaskListError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.TaskList(context.Background(), TaskListOptions{})
_, err = client.TaskList(t.Context(), TaskListOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -61,7 +61,7 @@ func TestTaskList(t *testing.T) {
}))
assert.NilError(t, err)
result, err := client.TaskList(context.Background(), listCase.options)
result, err := client.TaskList(t.Context(), listCase.options)
assert.NilError(t, err)
assert.Check(t, is.Len(result.Items, 2))
}

5
client/volume_create_test.go
View File

@@ -1,7 +1,6 @@
package client
import (
"context"
"net/http"
"testing"
@@ -15,7 +14,7 @@ func TestVolumeCreateError(t *testing.T) {
client, err := New(WithMockClient(errorMock(http.StatusInternalServerError, "Server error")))
assert.NilError(t, err)
_, err = client.VolumeCreate(context.Background(), VolumeCreateOptions{})
_, err = client.VolumeCreate(t.Context(), VolumeCreateOptions{})
assert.Check(t, is.ErrorType(err, cerrdefs.IsInternal))
}
@@ -34,7 +33,7 @@ func TestVolumeCreate(t *testing.T) {
}))
assert.NilError(t, err)
res, err := client.VolumeCreate(context.Background(), VolumeCreateOptions{
res, err := client.VolumeCreate(t.Context(), VolumeCreateOptions{
Name: "myvolume",
Driver: "mydriver",
DriverOpts: map[string]string{