github.com/portworx/docker@v1.12.1/api/client/service/update_test.go (about)

     1  package service
     2  
     3  import (
     4  	"sort"
     5  	"testing"
     6  
     7  	"github.com/docker/docker/pkg/testutil/assert"
     8  	"github.com/docker/engine-api/types/swarm"
     9  )
    10  
    11  func TestUpdateServiceArgs(t *testing.T) {
    12  	flags := newUpdateCommand(nil).Flags()
    13  	flags.Set("args", "the \"new args\"")
    14  
    15  	spec := &swarm.ServiceSpec{}
    16  	cspec := &spec.TaskTemplate.ContainerSpec
    17  	cspec.Args = []string{"old", "args"}
    18  
    19  	updateService(flags, spec)
    20  	assert.EqualStringSlice(t, cspec.Args, []string{"the", "new args"})
    21  }
    22  
    23  func TestUpdateLabels(t *testing.T) {
    24  	flags := newUpdateCommand(nil).Flags()
    25  	flags.Set("label-add", "toadd=newlabel")
    26  	flags.Set("label-rm", "toremove")
    27  
    28  	labels := map[string]string{
    29  		"toremove": "thelabeltoremove",
    30  		"tokeep":   "value",
    31  	}
    32  
    33  	updateLabels(flags, &labels)
    34  	assert.Equal(t, len(labels), 2)
    35  	assert.Equal(t, labels["tokeep"], "value")
    36  	assert.Equal(t, labels["toadd"], "newlabel")
    37  }
    38  
    39  func TestUpdateLabelsRemoveALabelThatDoesNotExist(t *testing.T) {
    40  	flags := newUpdateCommand(nil).Flags()
    41  	flags.Set("label-rm", "dne")
    42  
    43  	labels := map[string]string{"foo": "theoldlabel"}
    44  	updateLabels(flags, &labels)
    45  	assert.Equal(t, len(labels), 1)
    46  }
    47  
    48  func TestUpdatePlacement(t *testing.T) {
    49  	flags := newUpdateCommand(nil).Flags()
    50  	flags.Set("constraint-add", "node=toadd")
    51  	flags.Set("constraint-rm", "node!=toremove")
    52  
    53  	placement := &swarm.Placement{
    54  		Constraints: []string{"node!=toremove", "container=tokeep"},
    55  	}
    56  
    57  	updatePlacement(flags, placement)
    58  	assert.Equal(t, len(placement.Constraints), 2)
    59  	assert.Equal(t, placement.Constraints[0], "container=tokeep")
    60  	assert.Equal(t, placement.Constraints[1], "node=toadd")
    61  }
    62  
    63  func TestUpdateEnvironment(t *testing.T) {
    64  	flags := newUpdateCommand(nil).Flags()
    65  	flags.Set("env-add", "toadd=newenv")
    66  	flags.Set("env-rm", "toremove")
    67  
    68  	envs := []string{"toremove=theenvtoremove", "tokeep=value"}
    69  
    70  	updateEnvironment(flags, &envs)
    71  	assert.Equal(t, len(envs), 2)
    72  	// Order has been removed in updateEnvironment (map)
    73  	sort.Strings(envs)
    74  	assert.Equal(t, envs[0], "toadd=newenv")
    75  	assert.Equal(t, envs[1], "tokeep=value")
    76  }
    77  
    78  func TestUpdateEnvironmentWithDuplicateValues(t *testing.T) {
    79  	flags := newUpdateCommand(nil).Flags()
    80  	flags.Set("env-add", "foo=newenv")
    81  	flags.Set("env-add", "foo=dupe")
    82  	flags.Set("env-rm", "foo")
    83  
    84  	envs := []string{"foo=value"}
    85  
    86  	updateEnvironment(flags, &envs)
    87  	assert.Equal(t, len(envs), 0)
    88  }
    89  
    90  func TestUpdateEnvironmentWithDuplicateKeys(t *testing.T) {
    91  	// Test case for #25404
    92  	flags := newUpdateCommand(nil).Flags()
    93  	flags.Set("env-add", "A=b")
    94  
    95  	envs := []string{"A=c"}
    96  
    97  	updateEnvironment(flags, &envs)
    98  	assert.Equal(t, len(envs), 1)
    99  	assert.Equal(t, envs[0], "A=b")
   100  }
   101  
   102  func TestUpdateMounts(t *testing.T) {
   103  	flags := newUpdateCommand(nil).Flags()
   104  	flags.Set("mount-add", "type=volume,target=/toadd")
   105  	flags.Set("mount-rm", "/toremove")
   106  
   107  	mounts := []swarm.Mount{
   108  		{Target: "/toremove", Type: swarm.MountTypeBind},
   109  		{Target: "/tokeep", Type: swarm.MountTypeBind},
   110  	}
   111  
   112  	updateMounts(flags, &mounts)
   113  	assert.Equal(t, len(mounts), 2)
   114  	assert.Equal(t, mounts[0].Target, "/tokeep")
   115  	assert.Equal(t, mounts[1].Target, "/toadd")
   116  }
   117  
   118  func TestUpdatePorts(t *testing.T) {
   119  	flags := newUpdateCommand(nil).Flags()
   120  	flags.Set("publish-add", "1000:1000")
   121  	flags.Set("publish-rm", "333/udp")
   122  
   123  	portConfigs := []swarm.PortConfig{
   124  		{TargetPort: 333, Protocol: swarm.PortConfigProtocolUDP},
   125  		{TargetPort: 555},
   126  	}
   127  
   128  	err := updatePorts(flags, &portConfigs)
   129  	assert.Equal(t, err, nil)
   130  	assert.Equal(t, len(portConfigs), 2)
   131  	// Do a sort to have the order (might have changed by map)
   132  	targetPorts := []int{int(portConfigs[0].TargetPort), int(portConfigs[1].TargetPort)}
   133  	sort.Ints(targetPorts)
   134  	assert.Equal(t, targetPorts[0], 555)
   135  	assert.Equal(t, targetPorts[1], 1000)
   136  }
   137  
   138  func TestUpdatePortsDuplicateEntries(t *testing.T) {
   139  	// Test case for #25375
   140  	flags := newUpdateCommand(nil).Flags()
   141  	flags.Set("publish-add", "80:80")
   142  
   143  	portConfigs := []swarm.PortConfig{
   144  		{TargetPort: 80, PublishedPort: 80},
   145  	}
   146  
   147  	err := updatePorts(flags, &portConfigs)
   148  	assert.Equal(t, err, nil)
   149  	assert.Equal(t, len(portConfigs), 1)
   150  	assert.Equal(t, portConfigs[0].TargetPort, uint32(80))
   151  }
   152  
   153  func TestUpdatePortsDuplicateKeys(t *testing.T) {
   154  	// Test case for #25375
   155  	flags := newUpdateCommand(nil).Flags()
   156  	flags.Set("publish-add", "80:20")
   157  
   158  	portConfigs := []swarm.PortConfig{
   159  		{TargetPort: 80, PublishedPort: 80},
   160  	}
   161  
   162  	err := updatePorts(flags, &portConfigs)
   163  	assert.Equal(t, err, nil)
   164  	assert.Equal(t, len(portConfigs), 1)
   165  	assert.Equal(t, portConfigs[0].TargetPort, uint32(20))
   166  }
   167  
   168  func TestUpdatePortsConflictingFlags(t *testing.T) {
   169  	// Test case for #25375
   170  	flags := newUpdateCommand(nil).Flags()
   171  	flags.Set("publish-add", "80:80")
   172  	flags.Set("publish-add", "80:20")
   173  
   174  	portConfigs := []swarm.PortConfig{
   175  		{TargetPort: 80, PublishedPort: 80},
   176  	}
   177  
   178  	err := updatePorts(flags, &portConfigs)
   179  	assert.Error(t, err, "conflicting port mapping")
   180  }