toolshed/docker-cli
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Automated migration

Browse Source 
Signed-off-by: Daniel Nephin <dnephin@docker.com>
This commit is contained in:
Daniel Nephin
2018-03-05 18:53:52 -05:00
parent 5ef8835f23
commit 39c2ca57c1
158 changed files with 1812 additions and 1727 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
cli/command/service/generic_resource_opts_test.go
View File

@ -3,7 +3,8 @@ package service
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestValidateSingleGenericResource(t *testing.T) {
@ -12,11 +13,11 @@ func TestValidateSingleGenericResource(t *testing.T) {
for _, v := range incorrect {
_, err := ValidateSingleGenericResource(v)
assert.Error(t, err)
assert.Check(t, is.ErrorContains(err, ""))
}
for _, v := range correct {
_, err := ValidateSingleGenericResource(v)
assert.NoError(t, err)
assert.Check(t, err)
}
}

5
cli/command/service/inspect_test.go
View File

@ -10,7 +10,8 @@ import (
"github.com/docker/cli/cli/command/formatter"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/swarm"
"github.com/stretchr/testify/assert"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func formatServiceInspect(t *testing.T, format formatter.Format, now time.Time) string {
@ -130,5 +131,5 @@ func TestJSONFormatWithNoUpdateConfig(t *testing.T) {
if err := json.Unmarshal([]byte(s2), &m2); err != nil {
t.Fatal(err)
}
assert.Equal(t, m1, m2)
assert.Check(t, is.DeepEqual(m1, m2))
}

4
cli/command/service/list_test.go
View File

@ -6,8 +6,8 @@ import (
"github.com/docker/cli/internal/test"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/swarm"
"github.com/gotestyourself/gotestyourself/assert"
"github.com/gotestyourself/gotestyourself/golden"
"github.com/stretchr/testify/assert"
"golang.org/x/net/context"
)
@ -23,6 +23,6 @@ func TestServiceListOrder(t *testing.T) {
})
cmd := newListCommand(cli)
cmd.Flags().Set("format", "{{.Name}}")
assert.NoError(t, cmd.Execute())
assert.Check(t, cmd.Execute())
golden.Assert(t, cli.OutBuffer().String(), "service-list-sort.golden")
}

48
cli/command/service/opts_test.go
View File

@ -10,45 +10,45 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/swarm"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
func TestMemBytesString(t *testing.T) {
var mem opts.MemBytes = 1048576
assert.Equal(t, "1MiB", mem.String())
assert.Check(t, is.Equal("1MiB", mem.String()))
}
func TestMemBytesSetAndValue(t *testing.T) {
var mem opts.MemBytes
assert.NoError(t, mem.Set("5kb"))
assert.Equal(t, int64(5120), mem.Value())
assert.Check(t, mem.Set("5kb"))
assert.Check(t, is.Equal(int64(5120), mem.Value()))
}
func TestNanoCPUsString(t *testing.T) {
var cpus opts.NanoCPUs = 6100000000
assert.Equal(t, "6.100", cpus.String())
assert.Check(t, is.Equal("6.100", cpus.String()))
}
func TestNanoCPUsSetAndValue(t *testing.T) {
var cpus opts.NanoCPUs
assert.NoError(t, cpus.Set("0.35"))
assert.Equal(t, int64(350000000), cpus.Value())
assert.Check(t, cpus.Set("0.35"))
assert.Check(t, is.Equal(int64(350000000), cpus.Value()))
}
func TestUint64OptString(t *testing.T) {
value := uint64(2345678)
opt := Uint64Opt{value: &value}
assert.Equal(t, "2345678", opt.String())
assert.Check(t, is.Equal("2345678", opt.String()))
opt = Uint64Opt{}
assert.Equal(t, "", opt.String())
assert.Check(t, is.Equal("", opt.String()))
}
func TestUint64OptSetAndValue(t *testing.T) {
var opt Uint64Opt
assert.NoError(t, opt.Set("14445"))
assert.Equal(t, uint64(14445), *opt.Value())
assert.Check(t, opt.Set("14445"))
assert.Check(t, is.Equal(uint64(14445), *opt.Value()))
}
func TestHealthCheckOptionsToHealthConfig(t *testing.T) {
@ -61,14 +61,14 @@ func TestHealthCheckOptionsToHealthConfig(t *testing.T) {
retries: 10,
}
config, err := opt.toHealthConfig()
assert.NoError(t, err)
assert.Equal(t, &container.HealthConfig{
assert.Check(t, err)
assert.Check(t, is.DeepEqual(&container.HealthConfig{
Test: []string{"CMD-SHELL", "curl"},
Interval: time.Second,
Timeout: time.Second,
StartPeriod: time.Second,
Retries: 10,
}, config)
}, config))
}
func TestHealthCheckOptionsToHealthConfigNoHealthcheck(t *testing.T) {
@ -76,10 +76,10 @@ func TestHealthCheckOptionsToHealthConfigNoHealthcheck(t *testing.T) {
noHealthcheck: true,
}
config, err := opt.toHealthConfig()
assert.NoError(t, err)
assert.Equal(t, &container.HealthConfig{
assert.Check(t, err)
assert.Check(t, is.DeepEqual(&container.HealthConfig{
Test: []string{"NONE"},
}, config)
}, config))
}
func TestHealthCheckOptionsToHealthConfigConflict(t *testing.T) {
@ -88,7 +88,7 @@ func TestHealthCheckOptionsToHealthConfigConflict(t *testing.T) {
noHealthcheck: true,
}
_, err := opt.toHealthConfig()
assert.EqualError(t, err, "--no-healthcheck conflicts with --health-* options")
assert.Check(t, is.Error(err, "--no-healthcheck conflicts with --health-* options"))
}
func TestResourceOptionsToResourceRequirements(t *testing.T) {
@ -109,7 +109,7 @@ func TestResourceOptionsToResourceRequirements(t *testing.T) {
for _, opt := range incorrectOptions {
_, err := opt.ToResourceRequirements()
assert.Error(t, err)
assert.Check(t, is.ErrorContains(err, ""))
}
correctOptions := []resourceOptions{
@ -123,8 +123,8 @@ func TestResourceOptionsToResourceRequirements(t *testing.T) {
for _, opt := range correctOptions {
r, err := opt.ToResourceRequirements()
assert.NoError(t, err)
assert.Len(t, r.Reservations.GenericResources, len(opt.resGenericResources))
assert.Check(t, err)
assert.Check(t, is.Len(r.Reservations.GenericResources, len(opt.resGenericResources)))
}
}
@ -159,6 +159,6 @@ func TestToServiceNetwork(t *testing.T) {
ctx := context.Background()
flags := newCreateCommand(nil).Flags()
service, err := o.ToService(ctx, client, flags)
require.NoError(t, err)
assert.Equal(t, []swarm.NetworkAttachmentConfig{{Target: "id111"}, {Target: "id555"}, {Target: "id999"}}, service.TaskTemplate.Networks)
assert.NilError(t, err)
assert.Check(t, is.DeepEqual([]swarm.NetworkAttachmentConfig{{Target: "id111"}, {Target: "id555"}, {Target: "id999"}}, service.TaskTemplate.Networks))
}

9
cli/command/service/progress/progress_test.go
View File

@ -7,7 +7,8 @@ import (
"github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/pkg/progress"
"github.com/stretchr/testify/assert"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
)
type mockProgress struct {
@ -36,9 +37,9 @@ func (u updaterTester) testUpdater(tasks []swarm.Task, expectedConvergence bool,
u.p.clear()
converged, err := u.updater.update(u.service, tasks, u.activeNodes, u.rollback)
assert.NoError(u.t, err)
assert.Equal(u.t, expectedConvergence, converged)
assert.Equal(u.t, expectedProgress, u.p.p)
assert.Check(u.t, err)
assert.Check(u.t, is.Equal(expectedConvergence, converged))
assert.Check(u.t, is.DeepEqual(expectedProgress, u.p.p))
}
func TestReplicatedProgressUpdaterOneReplica(t *testing.T) {

24
cli/command/service/ps_test.go
View File

@ -8,8 +8,8 @@ import (
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
"github.com/docker/docker/api/types/swarm"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@ -26,22 +26,22 @@ func TestCreateFilter(t *testing.T) {
}
filter := opts.NewFilterOpt()
require.NoError(t, filter.Set("node=somenode"))
assert.NilError(t, filter.Set("node=somenode"))
options := psOptions{
services: []string{"idmatch", "idprefix", "namematch", "notfound"},
filter: filter,
}
actual, notfound, err := createFilter(context.Background(), client, options)
require.NoError(t, err)
assert.Equal(t, notfound, []string{"no such service: notfound"})
assert.NilError(t, err)
assert.Check(t, is.DeepEqual(notfound, []string{"no such service: notfound"}))
expected := filters.NewArgs()
expected.Add("service", "idmatch")
expected.Add("service", "idprefixmatch")
expected.Add("service", "cccccccc")
expected.Add("node", "somenode")
assert.Equal(t, expected, actual)
assert.Check(t, is.DeepEqual(expected, actual))
}
func TestCreateFilterWithAmbiguousIDPrefixError(t *testing.T) {
@ -58,7 +58,7 @@ func TestCreateFilterWithAmbiguousIDPrefixError(t *testing.T) {
filter: opts.NewFilterOpt(),
}
_, _, err := createFilter(context.Background(), client, options)
assert.EqualError(t, err, "multiple services found with provided prefix: aaa")
assert.Check(t, is.Error(err, "multiple services found with provided prefix: aaa"))
}
func TestCreateFilterNoneFound(t *testing.T) {
@ -68,7 +68,7 @@ func TestCreateFilterNoneFound(t *testing.T) {
filter: opts.NewFilterOpt(),
}
_, _, err := createFilter(context.Background(), client, options)
assert.EqualError(t, err, "no such service: foo\nno such service: notfound")
assert.Check(t, is.Error(err, "no such service: foo\nno such service: notfound"))
}
func TestRunPSWarnsOnNotFound(t *testing.T) {
@ -87,7 +87,7 @@ func TestRunPSWarnsOnNotFound(t *testing.T) {
format: "{{.ID}}",
}
err := runPS(cli, options)
assert.EqualError(t, err, "no such service: bar")
assert.Check(t, is.Error(err, "no such service: bar"))
}
func TestRunPSQuiet(t *testing.T) {
@ -102,8 +102,8 @@ func TestRunPSQuiet(t *testing.T) {
cli := test.NewFakeCli(client)
err := runPS(cli, psOptions{services: []string{"foo"}, quiet: true, filter: opts.NewFilterOpt()})
require.NoError(t, err)
assert.Equal(t, "sxabyp0obqokwekpun4rjo0b3\n", cli.OutBuffer().String())
assert.NilError(t, err)
assert.Check(t, is.Equal("sxabyp0obqokwekpun4rjo0b3\n", cli.OutBuffer().String()))
}
func TestUpdateNodeFilter(t *testing.T) {
@ -125,5 +125,5 @@ func TestUpdateNodeFilter(t *testing.T) {
expected.Add("node", "one")
expected.Add("node", "two")
expected.Add("node", selfNodeID)
assert.Equal(t, expected, filter)
assert.Check(t, is.DeepEqual(expected, filter))
}

7
cli/command/service/rollback_test.go
View File

@ -10,7 +10,8 @@ import (
"github.com/docker/cli/internal/test/testutil"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/swarm"
"github.com/stretchr/testify/assert"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@ -50,8 +51,8 @@ func TestRollback(t *testing.T) {
cmd.SetArgs(tc.args)
cmd.Flags().Set("quiet", "true")
cmd.SetOutput(ioutil.Discard)
assert.NoError(t, cmd.Execute())
assert.Equal(t, strings.TrimSpace(cli.ErrBuffer().String()), tc.expectedDockerCliErr)
assert.Check(t, cmd.Execute())
assert.Check(t, is.Equal(strings.TrimSpace(cli.ErrBuffer().String()), tc.expectedDockerCliErr))
}
}

196
cli/command/service/update_test.go
View File

@ -12,8 +12,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/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/gotestyourself/gotestyourself/assert"
is "github.com/gotestyourself/gotestyourself/assert/cmp"
"golang.org/x/net/context"
)
@ -30,7 +30,7 @@ func TestUpdateServiceArgs(t *testing.T) {
cspec.Args = []string{"old", "args"}
updateService(nil, nil, flags, spec)
assert.Equal(t, []string{"the", "new args"}, cspec.Args)
assert.Check(t, is.DeepEqual([]string{"the", "new args"}, cspec.Args))
}
func TestUpdateLabels(t *testing.T) {
@ -44,9 +44,9 @@ func TestUpdateLabels(t *testing.T) {
}
updateLabels(flags, &labels)
assert.Len(t, labels, 2)
assert.Equal(t, "value", labels["tokeep"])
assert.Equal(t, "newlabel", labels["toadd"])
assert.Check(t, is.Len(labels, 2))
assert.Check(t, is.Equal("value", labels["tokeep"]))
assert.Check(t, is.Equal("newlabel", labels["toadd"]))
}
func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) {
@ -55,7 +55,7 @@ func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) {
labels := map[string]string{"foo": "theoldlabel"}
updateLabels(flags, &labels)
assert.Len(t, labels, 1)
assert.Check(t, is.Len(labels, 1))
}
func TestUpdatePlacementConstraints(t *testing.T) {
@ -68,9 +68,9 @@ func TestUpdatePlacementConstraints(t *testing.T) {
}
updatePlacementConstraints(flags, placement)
require.Len(t, placement.Constraints, 2)
assert.Equal(t, "container=tokeep", placement.Constraints[0])
assert.Equal(t, "node=toadd", placement.Constraints[1])
assert.Assert(t, is.Len(placement.Constraints, 2))
assert.Check(t, is.Equal("container=tokeep", placement.Constraints[0]))
assert.Check(t, is.Equal("node=toadd", placement.Constraints[1]))
}
func TestUpdatePlacementPrefs(t *testing.T) {
@ -94,9 +94,9 @@ func TestUpdatePlacementPrefs(t *testing.T) {
}
updatePlacementPreferences(flags, placement)
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)
assert.Assert(t, is.Len(placement.Preferences, 2))
assert.Check(t, is.Equal("node.labels.row", placement.Preferences[0].Spread.SpreadDescriptor))
assert.Check(t, is.Equal("node.labels.dc", placement.Preferences[1].Spread.SpreadDescriptor))
}
func TestUpdateEnvironment(t *testing.T) {
@ -107,11 +107,11 @@ func TestUpdateEnvironment(t *testing.T) {
envs := []string{"toremove=theenvtoremove", "tokeep=value"}
updateEnvironment(flags, &envs)
require.Len(t, envs, 2)
assert.Assert(t, is.Len(envs, 2))
// Order has been removed in updateEnvironment (map)
sort.Strings(envs)
assert.Equal(t, "toadd=newenv", envs[0])
assert.Equal(t, "tokeep=value", envs[1])
assert.Check(t, is.Equal("toadd=newenv", envs[0]))
assert.Check(t, is.Equal("tokeep=value", envs[1]))
}
func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) {
@ -123,7 +123,7 @@ func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) {
envs := []string{"foo=value"}
updateEnvironment(flags, &envs)
assert.Len(t, envs, 0)
assert.Check(t, is.Len(envs, 0))
}
func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) {
@ -134,8 +134,8 @@ func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) {
envs := []string{"A=c"}
updateEnvironment(flags, &envs)
require.Len(t, envs, 1)
assert.Equal(t, "A=b", envs[0])
assert.Assert(t, is.Len(envs, 1))
assert.Check(t, is.Equal("A=b", envs[0]))
}
func TestUpdateGroups(t *testing.T) {
@ -149,10 +149,10 @@ func TestUpdateGroups(t *testing.T) {
groups := []string{"bar", "root"}
updateGroups(flags, &groups)
require.Len(t, groups, 3)
assert.Equal(t, "bar", groups[0])
assert.Equal(t, "foo", groups[1])
assert.Equal(t, "wheel", groups[2])
assert.Assert(t, is.Len(groups, 3))
assert.Check(t, is.Equal("bar", groups[0]))
assert.Check(t, is.Equal("foo", groups[1]))
assert.Check(t, is.Equal("wheel", groups[2]))
}
func TestUpdateDNSConfig(t *testing.T) {
@ -188,17 +188,17 @@ func TestUpdateDNSConfig(t *testing.T) {
updateDNSConfig(flags, &config)
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.Assert(t, is.Len(config.Nameservers, 3))
assert.Check(t, is.Equal("1.1.1.1", config.Nameservers[0]))
assert.Check(t, is.Equal("2001:db8:abc8::1", config.Nameservers[1]))
assert.Check(t, is.Equal("5.5.5.5", config.Nameservers[2]))
require.Len(t, config.Search, 2)
assert.Equal(t, "example.com", config.Search[0])
assert.Equal(t, "localdomain", config.Search[1])
assert.Assert(t, is.Len(config.Search, 2))
assert.Check(t, is.Equal("example.com", config.Search[0]))
assert.Check(t, is.Equal("localdomain", config.Search[1]))
require.Len(t, config.Options, 1)
assert.Equal(t, config.Options[0], "ndots:9")
assert.Assert(t, is.Len(config.Options, 1))
assert.Check(t, is.Equal(config.Options[0], "ndots:9"))
}
func TestUpdateMounts(t *testing.T) {
@ -212,9 +212,9 @@ func TestUpdateMounts(t *testing.T) {
}
updateMounts(flags, &mounts)
require.Len(t, mounts, 2)
assert.Equal(t, "/toadd", mounts[0].Target)
assert.Equal(t, "/tokeep", mounts[1].Target)
assert.Assert(t, is.Len(mounts, 2))
assert.Check(t, is.Equal("/toadd", mounts[0].Target))
assert.Check(t, is.Equal("/tokeep", mounts[1].Target))
}
func TestUpdateMountsWithDuplicateMounts(t *testing.T) {
@ -228,10 +228,10 @@ func TestUpdateMountsWithDuplicateMounts(t *testing.T) {
}
updateMounts(flags, &mounts)
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)
assert.Assert(t, is.Len(mounts, 3))
assert.Check(t, is.Equal("/tokeep1", mounts[0].Target))
assert.Check(t, is.Equal("/tokeep2", mounts[1].Target))
assert.Check(t, is.Equal("/toadd", mounts[2].Target))
}
func TestUpdatePorts(t *testing.T) {
@ -245,13 +245,13 @@ func TestUpdatePorts(t *testing.T) {
}
err := updatePorts(flags, &portConfigs)
assert.NoError(t, err)
require.Len(t, portConfigs, 2)
assert.Check(t, err)
assert.Assert(t, is.Len(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, 555, targetPorts[0])
assert.Equal(t, 1000, targetPorts[1])
assert.Check(t, is.Equal(555, targetPorts[0]))
assert.Check(t, is.Equal(1000, targetPorts[1]))
}
func TestUpdatePortsDuplicate(t *testing.T) {
@ -269,9 +269,9 @@ func TestUpdatePortsDuplicate(t *testing.T) {
}
err := updatePorts(flags, &portConfigs)
assert.NoError(t, err)
require.Len(t, portConfigs, 1)
assert.Equal(t, uint32(80), portConfigs[0].TargetPort)
assert.Check(t, err)
assert.Assert(t, is.Len(portConfigs, 1))
assert.Check(t, is.Equal(uint32(80), portConfigs[0].TargetPort))
}
func TestUpdateHealthcheckTable(t *testing.T) {
@ -345,9 +345,9 @@ func TestUpdateHealthcheckTable(t *testing.T) {
}
err := updateHealthcheck(flags, cspec)
if c.err != "" {
assert.EqualError(t, err, c.err)
assert.Check(t, is.Error(err, c.err))
} else {
assert.NoError(t, err)
assert.Check(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)
}
@ -370,8 +370,8 @@ func TestUpdateHosts(t *testing.T) {
expected := []string{"1.2.3.4 example.com", "4.3.2.1 example.org", "2001:db8:abc8::1 ipv6.net"}
err := updateHosts(flags, &hosts)
assert.NoError(t, err)
assert.Equal(t, expected, hosts)
assert.Check(t, err)
assert.Check(t, is.DeepEqual(expected, hosts))
}
func TestUpdateHostsPreservesOrder(t *testing.T) {
@ -382,8 +382,8 @@ func TestUpdateHostsPreservesOrder(t *testing.T) {
hosts := []string{}
err := updateHosts(flags, &hosts)
assert.NoError(t, err)
assert.Equal(t, []string{"127.0.0.2 foobar", "127.0.0.1 foobar", "127.0.0.3 foobar"}, hosts)
assert.Check(t, err)
assert.Check(t, is.DeepEqual([]string{"127.0.0.2 foobar", "127.0.0.1 foobar", "127.0.0.3 foobar"}, hosts))
}
func TestUpdatePortsRmWithProtocol(t *testing.T) {
@ -404,10 +404,10 @@ func TestUpdatePortsRmWithProtocol(t *testing.T) {
}
err := updatePorts(flags, &portConfigs)
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)
assert.Check(t, err)
assert.Assert(t, is.Len(portConfigs, 2))
assert.Check(t, is.Equal(uint32(81), portConfigs[0].TargetPort))
assert.Check(t, is.Equal(uint32(82), portConfigs[1].TargetPort))
}
type secretAPIClientMock struct {
@ -461,11 +461,11 @@ func TestUpdateSecretUpdateInPlace(t *testing.T) {
updatedSecrets, err := getUpdatedSecrets(apiClient, flags, secrets)
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)
assert.Check(t, err)
assert.Assert(t, is.Len(updatedSecrets, 1))
assert.Check(t, is.Equal("tn9qiblgnuuut11eufquw5dev", updatedSecrets[0].SecretID))
assert.Check(t, is.Equal("foo", updatedSecrets[0].SecretName))
assert.Check(t, is.Equal("foo2", updatedSecrets[0].File.Name))
}
func TestUpdateReadOnly(t *testing.T) {
@ -480,18 +480,18 @@ func TestUpdateReadOnly(t *testing.T) {
flags := newUpdateCommand(nil).Flags()
flags.Set("read-only", "true")
updateService(nil, nil, flags, spec)
assert.True(t, cspec.ReadOnly)
assert.Check(t, cspec.ReadOnly)
// Update without --read-only, no change
flags = newUpdateCommand(nil).Flags()
updateService(nil, nil, flags, spec)
assert.True(t, cspec.ReadOnly)
assert.Check(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.False(t, cspec.ReadOnly)
assert.Check(t, !cspec.ReadOnly)
}
func TestUpdateStopSignal(t *testing.T) {
@ -506,74 +506,74 @@ func TestUpdateStopSignal(t *testing.T) {
flags := newUpdateCommand(nil).Flags()
flags.Set("stop-signal", "SIGUSR1")
updateService(nil, nil, flags, spec)
assert.Equal(t, "SIGUSR1", cspec.StopSignal)
assert.Check(t, is.Equal("SIGUSR1", cspec.StopSignal))
// Update without --stop-signal, no change
flags = newUpdateCommand(nil).Flags()
updateService(nil, nil, flags, spec)
assert.Equal(t, "SIGUSR1", cspec.StopSignal)
assert.Check(t, is.Equal("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, "SIGWINCH", cspec.StopSignal)
assert.Check(t, is.Equal("SIGWINCH", cspec.StopSignal))
}
func TestUpdateIsolationValid(t *testing.T) {
flags := newUpdateCommand(nil).Flags()
err := flags.Set("isolation", "process")
require.NoError(t, err)
assert.NilError(t, err)
spec := swarm.ServiceSpec{
TaskTemplate: swarm.TaskSpec{
ContainerSpec: &swarm.ContainerSpec{},
},
}
err = updateService(context.Background(), nil, flags, &spec)
require.NoError(t, err)
assert.Equal(t, container.IsolationProcess, spec.TaskTemplate.ContainerSpec.Isolation)
assert.NilError(t, err)
assert.Check(t, is.Equal(container.IsolationProcess, spec.TaskTemplate.ContainerSpec.Isolation))
}
func TestUpdateIsolationInvalid(t *testing.T) {
// validation depends on daemon os / version so validation should be done on the daemon side
flags := newUpdateCommand(nil).Flags()
err := flags.Set("isolation", "test")
require.NoError(t, err)
assert.NilError(t, err)
spec := swarm.ServiceSpec{
TaskTemplate: swarm.TaskSpec{
ContainerSpec: &swarm.ContainerSpec{},
},
}
err = updateService(context.Background(), nil, flags, &spec)
require.NoError(t, err)
assert.Equal(t, container.Isolation("test"), spec.TaskTemplate.ContainerSpec.Isolation)
assert.NilError(t, err)
assert.Check(t, is.Equal(container.Isolation("test"), spec.TaskTemplate.ContainerSpec.Isolation))
}
func TestAddGenericResources(t *testing.T) {
task := &swarm.TaskSpec{}
flags := newUpdateCommand(nil).Flags()
assert.Nil(t, addGenericResources(flags, task))
assert.Check(t, addGenericResources(flags, task))
flags.Set(flagGenericResourcesAdd, "foo=1")
assert.NoError(t, addGenericResources(flags, task))
assert.Len(t, task.Resources.Reservations.GenericResources, 1)
assert.Check(t, addGenericResources(flags, task))
assert.Check(t, is.Len(task.Resources.Reservations.GenericResources, 1))
// Checks that foo isn't added a 2nd time
flags = newUpdateCommand(nil).Flags()
flags.Set(flagGenericResourcesAdd, "bar=1")
assert.NoError(t, addGenericResources(flags, task))
assert.Len(t, task.Resources.Reservations.GenericResources, 2)
assert.Check(t, addGenericResources(flags, task))
assert.Check(t, is.Len(task.Resources.Reservations.GenericResources, 2))
}
func TestRemoveGenericResources(t *testing.T) {
task := &swarm.TaskSpec{}
flags := newUpdateCommand(nil).Flags()
assert.Nil(t, removeGenericResources(flags, task))
assert.Check(t, removeGenericResources(flags, task))
flags.Set(flagGenericResourcesRemove, "foo")
assert.Error(t, removeGenericResources(flags, task))
assert.Check(t, is.ErrorContains(removeGenericResources(flags, task), ""))
flags = newUpdateCommand(nil).Flags()
flags.Set(flagGenericResourcesAdd, "foo=1")
@ -584,8 +584,8 @@ func TestRemoveGenericResources(t *testing.T) {
flags = newUpdateCommand(nil).Flags()
flags.Set(flagGenericResourcesRemove, "foo")
assert.NoError(t, removeGenericResources(flags, task))
assert.Len(t, task.Resources.Reservations.GenericResources, 1)
assert.Check(t, removeGenericResources(flags, task))
assert.Check(t, is.Len(task.Resources.Reservations.GenericResources, 1))
}
func TestUpdateNetworks(t *testing.T) {
@ -618,38 +618,38 @@ func TestUpdateNetworks(t *testing.T) {
flags := newUpdateCommand(nil).Flags()
err := flags.Set(flagNetworkAdd, "aaa-network")
require.NoError(t, err)
assert.NilError(t, err)
err = updateService(ctx, client, flags, &svc)
require.NoError(t, err)
assert.Equal(t, []swarm.NetworkAttachmentConfig{{Target: "id555"}, {Target: "id999"}}, svc.TaskTemplate.Networks)
assert.NilError(t, err)
assert.Check(t, is.DeepEqual([]swarm.NetworkAttachmentConfig{{Target: "id555"}, {Target: "id999"}}, svc.TaskTemplate.Networks))
flags = newUpdateCommand(nil).Flags()
err = flags.Set(flagNetworkAdd, "aaa-network")
require.NoError(t, err)
assert.NilError(t, err)
err = updateService(ctx, client, flags, &svc)
assert.EqualError(t, err, "service is already attached to network aaa-network")
assert.Equal(t, []swarm.NetworkAttachmentConfig{{Target: "id555"}, {Target: "id999"}}, svc.TaskTemplate.Networks)
assert.Check(t, is.Error(err, "service is already attached to network aaa-network"))
assert.Check(t, is.DeepEqual([]swarm.NetworkAttachmentConfig{{Target: "id555"}, {Target: "id999"}}, svc.TaskTemplate.Networks))
flags = newUpdateCommand(nil).Flags()
err = flags.Set(flagNetworkAdd, "id555")
require.NoError(t, err)
assert.NilError(t, err)
err = updateService(ctx, client, flags, &svc)
assert.EqualError(t, err, "service is already attached to network id555")
assert.Equal(t, []swarm.NetworkAttachmentConfig{{Target: "id555"}, {Target: "id999"}}, svc.TaskTemplate.Networks)
assert.Check(t, is.Error(err, "service is already attached to network id555"))
assert.Check(t, is.DeepEqual([]swarm.NetworkAttachmentConfig{{Target: "id555"}, {Target: "id999"}}, svc.TaskTemplate.Networks))
flags = newUpdateCommand(nil).Flags()
err = flags.Set(flagNetworkRemove, "id999")
require.NoError(t, err)
assert.NilError(t, err)
err = updateService(ctx, client, flags, &svc)
assert.NoError(t, err)
assert.Equal(t, []swarm.NetworkAttachmentConfig{{Target: "id555"}}, svc.TaskTemplate.Networks)
assert.Check(t, err)
assert.Check(t, is.DeepEqual([]swarm.NetworkAttachmentConfig{{Target: "id555"}}, svc.TaskTemplate.Networks))
flags = newUpdateCommand(nil).Flags()
err = flags.Set(flagNetworkAdd, "mmm-network")
require.NoError(t, err)
assert.NilError(t, err)
err = flags.Set(flagNetworkRemove, "aaa-network")
require.NoError(t, err)
assert.NilError(t, err)
err = updateService(ctx, client, flags, &svc)
assert.NoError(t, err)
assert.Equal(t, []swarm.NetworkAttachmentConfig{{Target: "id999"}}, svc.TaskTemplate.Networks)
assert.Check(t, err)
assert.Check(t, is.DeepEqual([]swarm.NetworkAttachmentConfig{{Target: "id999"}}, svc.TaskTemplate.Networks))
}