| package service |
| |
| import ( |
| "reflect" |
| "sort" |
| "testing" |
| "time" |
| |
| "github.com/docker/docker/api/types/container" |
| mounttypes "github.com/docker/docker/api/types/mount" |
| "github.com/docker/docker/api/types/swarm" |
| "github.com/docker/docker/pkg/testutil/assert" |
| ) |
| |
| func TestUpdateServiceArgs(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("args", "the \"new args\"") |
| |
| spec := &swarm.ServiceSpec{} |
| cspec := &spec.TaskTemplate.ContainerSpec |
| cspec.Args = []string{"old", "args"} |
| |
| updateService(flags, spec) |
| assert.EqualStringSlice(t, cspec.Args, []string{"the", "new args"}) |
| } |
| |
| func TestUpdateLabels(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("label-add", "toadd=newlabel") |
| flags.Set("label-rm", "toremove") |
| |
| labels := map[string]string{ |
| "toremove": "thelabeltoremove", |
| "tokeep": "value", |
| } |
| |
| updateLabels(flags, &labels) |
| assert.Equal(t, len(labels), 2) |
| assert.Equal(t, labels["tokeep"], "value") |
| assert.Equal(t, labels["toadd"], "newlabel") |
| } |
| |
| func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("label-rm", "dne") |
| |
| labels := map[string]string{"foo": "theoldlabel"} |
| updateLabels(flags, &labels) |
| assert.Equal(t, len(labels), 1) |
| } |
| |
| func TestUpdatePlacement(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("constraint-add", "node=toadd") |
| flags.Set("constraint-rm", "node!=toremove") |
| |
| placement := &swarm.Placement{ |
| Constraints: []string{"node!=toremove", "container=tokeep"}, |
| } |
| |
| updatePlacement(flags, placement) |
| assert.Equal(t, len(placement.Constraints), 2) |
| assert.Equal(t, placement.Constraints[0], "container=tokeep") |
| assert.Equal(t, placement.Constraints[1], "node=toadd") |
| } |
| |
| func TestUpdateEnvironment(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("env-add", "toadd=newenv") |
| flags.Set("env-rm", "toremove") |
| |
| envs := []string{"toremove=theenvtoremove", "tokeep=value"} |
| |
| updateEnvironment(flags, &envs) |
| assert.Equal(t, len(envs), 2) |
| // Order has been removed in updateEnvironment (map) |
| sort.Strings(envs) |
| assert.Equal(t, envs[0], "toadd=newenv") |
| assert.Equal(t, envs[1], "tokeep=value") |
| } |
| |
| func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("env-add", "foo=newenv") |
| flags.Set("env-add", "foo=dupe") |
| flags.Set("env-rm", "foo") |
| |
| envs := []string{"foo=value"} |
| |
| updateEnvironment(flags, &envs) |
| assert.Equal(t, len(envs), 0) |
| } |
| |
| func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) { |
| // Test case for #25404 |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("env-add", "A=b") |
| |
| envs := []string{"A=c"} |
| |
| updateEnvironment(flags, &envs) |
| assert.Equal(t, len(envs), 1) |
| assert.Equal(t, envs[0], "A=b") |
| } |
| |
| func TestUpdateGroups(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("group-add", "wheel") |
| flags.Set("group-add", "docker") |
| flags.Set("group-rm", "root") |
| flags.Set("group-add", "foo") |
| flags.Set("group-rm", "docker") |
| |
| groups := []string{"bar", "root"} |
| |
| updateGroups(flags, &groups) |
| assert.Equal(t, len(groups), 3) |
| assert.Equal(t, groups[0], "bar") |
| assert.Equal(t, groups[1], "foo") |
| assert.Equal(t, groups[2], "wheel") |
| } |
| |
| func TestUpdateDNSConfig(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| |
| // IPv4, with duplicates |
| flags.Set("dns-add", "1.1.1.1") |
| flags.Set("dns-add", "1.1.1.1") |
| flags.Set("dns-add", "2.2.2.2") |
| flags.Set("dns-rm", "3.3.3.3") |
| flags.Set("dns-rm", "2.2.2.2") |
| // IPv6 |
| flags.Set("dns-add", "2001:db8:abc8::1") |
| // Invalid dns record |
| assert.Error(t, flags.Set("dns-add", "x.y.z.w"), "x.y.z.w is not an ip address") |
| |
| // domains with duplicates |
| flags.Set("dns-search-add", "example.com") |
| flags.Set("dns-search-add", "example.com") |
| flags.Set("dns-search-add", "example.org") |
| flags.Set("dns-search-rm", "example.org") |
| // Invalid dns search domain |
| assert.Error(t, flags.Set("dns-search-add", "example$com"), "example$com is not a valid domain") |
| |
| flags.Set("dns-option-add", "ndots:9") |
| flags.Set("dns-option-rm", "timeout:3") |
| |
| config := &swarm.DNSConfig{ |
| Nameservers: []string{"3.3.3.3", "5.5.5.5"}, |
| Search: []string{"localdomain"}, |
| Options: []string{"timeout:3"}, |
| } |
| |
| updateDNSConfig(flags, &config) |
| |
| assert.Equal(t, len(config.Nameservers), 3) |
| assert.Equal(t, config.Nameservers[0], "1.1.1.1") |
| assert.Equal(t, config.Nameservers[1], "2001:db8:abc8::1") |
| assert.Equal(t, config.Nameservers[2], "5.5.5.5") |
| |
| assert.Equal(t, len(config.Search), 2) |
| assert.Equal(t, config.Search[0], "example.com") |
| assert.Equal(t, config.Search[1], "localdomain") |
| |
| assert.Equal(t, len(config.Options), 1) |
| assert.Equal(t, config.Options[0], "ndots:9") |
| } |
| |
| func TestUpdateMounts(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("mount-add", "type=volume,source=vol2,target=/toadd") |
| flags.Set("mount-rm", "/toremove") |
| |
| mounts := []mounttypes.Mount{ |
| {Target: "/toremove", Source: "vol1", Type: mounttypes.TypeBind}, |
| {Target: "/tokeep", Source: "vol3", Type: mounttypes.TypeBind}, |
| } |
| |
| updateMounts(flags, &mounts) |
| assert.Equal(t, len(mounts), 2) |
| assert.Equal(t, mounts[0].Target, "/toadd") |
| assert.Equal(t, mounts[1].Target, "/tokeep") |
| |
| } |
| |
| func TestUpdateMountsWithDuplicateMounts(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("mount-add", "type=volume,source=vol4,target=/toadd") |
| |
| mounts := []mounttypes.Mount{ |
| {Target: "/tokeep1", Source: "vol1", Type: mounttypes.TypeBind}, |
| {Target: "/toadd", Source: "vol2", Type: mounttypes.TypeBind}, |
| {Target: "/tokeep2", Source: "vol3", Type: mounttypes.TypeBind}, |
| } |
| |
| updateMounts(flags, &mounts) |
| assert.Equal(t, len(mounts), 3) |
| assert.Equal(t, mounts[0].Target, "/tokeep1") |
| assert.Equal(t, mounts[1].Target, "/tokeep2") |
| assert.Equal(t, mounts[2].Target, "/toadd") |
| } |
| |
| func TestUpdatePorts(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("publish-add", "1000:1000") |
| flags.Set("publish-rm", "333/udp") |
| |
| portConfigs := []swarm.PortConfig{ |
| {TargetPort: 333, Protocol: swarm.PortConfigProtocolUDP}, |
| {TargetPort: 555}, |
| } |
| |
| err := updatePorts(flags, &portConfigs) |
| assert.Equal(t, err, nil) |
| assert.Equal(t, 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, targetPorts[0], 555) |
| assert.Equal(t, targetPorts[1], 1000) |
| } |
| |
| func TestUpdatePortsDuplicate(t *testing.T) { |
| // Test case for #25375 |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("publish-add", "80:80") |
| |
| portConfigs := []swarm.PortConfig{ |
| { |
| TargetPort: 80, |
| PublishedPort: 80, |
| Protocol: swarm.PortConfigProtocolTCP, |
| PublishMode: swarm.PortConfigPublishModeIngress, |
| }, |
| } |
| |
| err := updatePorts(flags, &portConfigs) |
| assert.Equal(t, err, nil) |
| assert.Equal(t, len(portConfigs), 1) |
| assert.Equal(t, portConfigs[0].TargetPort, uint32(80)) |
| } |
| |
| func TestUpdateHealthcheckTable(t *testing.T) { |
| type test struct { |
| flags [][2]string |
| initial *container.HealthConfig |
| expected *container.HealthConfig |
| err string |
| } |
| testCases := []test{ |
| { |
| flags: [][2]string{{"no-healthcheck", "true"}}, |
| initial: &container.HealthConfig{Test: []string{"CMD-SHELL", "cmd1"}, Retries: 10}, |
| expected: &container.HealthConfig{Test: []string{"NONE"}}, |
| }, |
| { |
| flags: [][2]string{{"health-cmd", "cmd1"}}, |
| initial: &container.HealthConfig{Test: []string{"NONE"}}, |
| expected: &container.HealthConfig{Test: []string{"CMD-SHELL", "cmd1"}}, |
| }, |
| { |
| flags: [][2]string{{"health-retries", "10"}}, |
| initial: &container.HealthConfig{Test: []string{"NONE"}}, |
| expected: &container.HealthConfig{Retries: 10}, |
| }, |
| { |
| flags: [][2]string{{"health-retries", "10"}}, |
| initial: &container.HealthConfig{Test: []string{"CMD", "cmd1"}}, |
| expected: &container.HealthConfig{Test: []string{"CMD", "cmd1"}, Retries: 10}, |
| }, |
| { |
| flags: [][2]string{{"health-interval", "1m"}}, |
| initial: &container.HealthConfig{Test: []string{"CMD", "cmd1"}}, |
| expected: &container.HealthConfig{Test: []string{"CMD", "cmd1"}, Interval: time.Minute}, |
| }, |
| { |
| flags: [][2]string{{"health-cmd", ""}}, |
| initial: &container.HealthConfig{Test: []string{"CMD", "cmd1"}, Retries: 10}, |
| expected: &container.HealthConfig{Retries: 10}, |
| }, |
| { |
| flags: [][2]string{{"health-retries", "0"}}, |
| initial: &container.HealthConfig{Test: []string{"CMD", "cmd1"}, Retries: 10}, |
| expected: &container.HealthConfig{Test: []string{"CMD", "cmd1"}}, |
| }, |
| { |
| flags: [][2]string{{"health-cmd", "cmd1"}, {"no-healthcheck", "true"}}, |
| err: "--no-healthcheck conflicts with --health-* options", |
| }, |
| { |
| flags: [][2]string{{"health-interval", "10m"}, {"no-healthcheck", "true"}}, |
| err: "--no-healthcheck conflicts with --health-* options", |
| }, |
| { |
| flags: [][2]string{{"health-timeout", "1m"}, {"no-healthcheck", "true"}}, |
| err: "--no-healthcheck conflicts with --health-* options", |
| }, |
| } |
| for i, c := range testCases { |
| flags := newUpdateCommand(nil).Flags() |
| for _, flag := range c.flags { |
| flags.Set(flag[0], flag[1]) |
| } |
| cspec := &swarm.ContainerSpec{ |
| Healthcheck: c.initial, |
| } |
| err := updateHealthcheck(flags, cspec) |
| if c.err != "" { |
| assert.Error(t, err, c.err) |
| } else { |
| assert.NilError(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) |
| } |
| } |
| } |
| } |
| |
| func TestUpdateHosts(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("host-add", "example.net:2.2.2.2") |
| flags.Set("host-add", "ipv6.net:2001:db8:abc8::1") |
| // remove with ipv6 should work |
| flags.Set("host-rm", "example.net:2001:db8:abc8::1") |
| // just hostname should work as well |
| flags.Set("host-rm", "example.net") |
| // bad format error |
| assert.Error(t, flags.Set("host-add", "$example.com$"), "bad format for add-host:") |
| |
| hosts := []string{"1.2.3.4 example.com", "4.3.2.1 example.org", "2001:db8:abc8::1 example.net"} |
| |
| updateHosts(flags, &hosts) |
| assert.Equal(t, len(hosts), 3) |
| assert.Equal(t, hosts[0], "1.2.3.4 example.com") |
| assert.Equal(t, hosts[1], "2001:db8:abc8::1 ipv6.net") |
| assert.Equal(t, hosts[2], "4.3.2.1 example.org") |
| } |
| |
| func TestUpdatePortsRmWithProtocol(t *testing.T) { |
| flags := newUpdateCommand(nil).Flags() |
| flags.Set("publish-add", "8081:81") |
| flags.Set("publish-add", "8082:82") |
| flags.Set("publish-rm", "80") |
| flags.Set("publish-rm", "81/tcp") |
| flags.Set("publish-rm", "82/udp") |
| |
| portConfigs := []swarm.PortConfig{ |
| { |
| TargetPort: 80, |
| PublishedPort: 8080, |
| Protocol: swarm.PortConfigProtocolTCP, |
| PublishMode: swarm.PortConfigPublishModeIngress, |
| }, |
| } |
| |
| err := updatePorts(flags, &portConfigs) |
| assert.Equal(t, err, nil) |
| assert.Equal(t, len(portConfigs), 2) |
| assert.Equal(t, portConfigs[0].TargetPort, uint32(81)) |
| assert.Equal(t, portConfigs[1].TargetPort, uint32(82)) |
| } |
| |
| // FIXME(vdemeester) port to opts.PortOpt |
| func TestValidatePort(t *testing.T) { |
| validPorts := []string{"80/tcp", "80", "80/udp"} |
| invalidPorts := map[string]string{ |
| "9999999": "out of range", |
| "80:80/tcp": "invalid port format", |
| "53:53/udp": "invalid port format", |
| "80:80": "invalid port format", |
| "80/xyz": "invalid protocol", |
| "tcp": "invalid syntax", |
| "udp": "invalid syntax", |
| "": "invalid protocol", |
| } |
| for _, port := range validPorts { |
| _, err := validatePublishRemove(port) |
| assert.Equal(t, err, nil) |
| } |
| for port, e := range invalidPorts { |
| _, err := validatePublishRemove(port) |
| assert.Error(t, err, e) |
| } |
| } |
