func TestEngineCpusMemory(t *testing.T) { engine := NewEngine("test", 0, engOpts) engine.setState(stateUnhealthy) assert.False(t, engine.isConnected()) client := mockclient.NewMockClient() apiClient := engineapimock.NewMockClient() apiClient.On("Info", mock.Anything).Return(mockInfo, nil) apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil) apiClient.On("NetworkList", mock.Anything, mock.AnythingOfType("NetworkListOptions"), ).Return([]types.NetworkResource{}, nil) apiClient.On("VolumeList", mock.Anything, mock.AnythingOfType("Args"), ).Return(types.VolumesListResponse{}, nil) apiClient.On("ImageList", mock.Anything, mock.AnythingOfType("ImageListOptions")).Return([]types.Image{}, nil) apiClient.On("ContainerList", mock.Anything, types.ContainerListOptions{All: true, Size: false}).Return([]types.Container{}, nil) apiClient.On("Events", mock.Anything, mock.AnythingOfType("EventsOptions")).Return(&nopCloser{infiniteRead{}}, nil) assert.NoError(t, engine.ConnectWithClient(client, apiClient)) assert.True(t, engine.isConnected()) assert.True(t, engine.IsHealthy()) assert.Equal(t, engine.UsedCpus(), int64(0)) assert.Equal(t, engine.UsedMemory(), int64(0)) client.Mock.AssertExpectations(t) apiClient.Mock.AssertExpectations(t) }
func TestEngineSpecs(t *testing.T) { engine := NewEngine("test", 0) assert.False(t, engine.isConnected()) client := mockclient.NewMockClient() client.On("Info").Return(mockInfo, nil) client.On("Version").Return(mockVersion, nil) client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil) client.On("ListImages").Return([]*dockerclient.Image{}, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() assert.NoError(t, engine.ConnectWithClient(client)) assert.True(t, engine.isConnected()) assert.True(t, engine.IsHealthy()) assert.Equal(t, engine.Cpus, mockInfo.NCPU) assert.Equal(t, engine.Memory, mockInfo.MemTotal) assert.Equal(t, engine.Labels["storagedriver"], mockInfo.Driver) assert.Equal(t, engine.Labels["executiondriver"], mockInfo.ExecutionDriver) assert.Equal(t, engine.Labels["kernelversion"], mockInfo.KernelVersion) assert.Equal(t, engine.Labels["operatingsystem"], mockInfo.OperatingSystem) assert.Equal(t, engine.Labels["foo"], "bar") client.Mock.AssertExpectations(t) }
func TestStopContainer_DefaultSuccess(t *testing.T) { c := Container{ containerInfo: &dockerclient.ContainerInfo{ Name: "foo", Id: "abc123", Config: &dockerclient.ContainerConfig{}, }, } ci := &dockerclient.ContainerInfo{ State: &dockerclient.State{ Running: false, }, } api := mockclient.NewMockClient() api.On("KillContainer", "abc123", "SIGTERM").Return(nil) api.On("InspectContainer", "abc123").Return(ci, nil).Once() api.On("RemoveContainer", "abc123", true, false).Return(nil) api.On("InspectContainer", "abc123").Return(&dockerclient.ContainerInfo{}, errors.New("Not Found")) client := dockerClient{api: api} err := client.StopContainer(c, time.Second) assert.NoError(t, err) api.AssertExpectations(t) }
func TestNodeContainerLookup(t *testing.T) { node := NewNode("test-node", 0) assert.False(t, node.isConnected()) client := mockclient.NewMockClient() client.On("Info").Return(mockInfo, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() client.On("ListContainers", true, false, "").Return([]dockerclient.Container{{Id: "container-id", Names: []string{"/container-name1", "/container-name2"}}}, nil).Once() client.On("ListImages").Return([]*dockerclient.Image{}, nil).Once() client.On("InspectContainer", "container-id").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once() assert.NoError(t, node.connectClient(client)) assert.True(t, node.isConnected()) // Invalid lookup assert.Nil(t, node.Container("invalid-id")) assert.Nil(t, node.Container("")) // Container ID lookup. assert.NotNil(t, node.Container("container-id")) // Container ID prefix lookup. assert.NotNil(t, node.Container("container-")) // Container name lookup. assert.NotNil(t, node.Container("container-name1")) assert.NotNil(t, node.Container("container-name2")) // Container node/name matching. assert.NotNil(t, node.Container("id/container-name1")) assert.NotNil(t, node.Container("id/container-name2")) client.Mock.AssertExpectations(t) }
func TestUsedCpus(t *testing.T) { var ( containerNcpu = []int64{1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47} hostNcpu = []int64{1, 2, 4, 8, 10, 12, 16, 20, 32, 36, 40, 48} ) engine := NewEngine("test", 0) client := mockclient.NewMockClient() for _, hn := range hostNcpu { for _, cn := range containerNcpu { if cn <= hn { mockInfo.NCPU = hn cpuShares := int64(math.Ceil(float64(cn*1024) / float64(mockInfo.NCPU))) client.On("Info").Return(mockInfo, nil) client.On("Version").Return(mockVersion, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() client.On("ListImages").Return([]*dockerclient.Image{}, nil).Once() client.On("ListContainers", true, false, "").Return([]dockerclient.Container{{Id: "test"}}, nil).Once() client.On("InspectContainer", "test").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: cpuShares}}, nil).Once() engine.ConnectWithClient(client) assert.Equal(t, engine.UsedCpus(), cn) } } } }
func TestContainerRemovedDuringRefresh(t *testing.T) { var ( container1 = dockerclient.Container{Id: "c1"} container2 = dockerclient.Container{Id: "c2"} info1 *dockerclient.ContainerInfo info2 = &dockerclient.ContainerInfo{Id: "c2", Config: &dockerclient.ContainerConfig{}} ) engine := NewEngine("test", 0) assert.False(t, engine.isConnected()) // A container is removed before it can be inspected. client := mockclient.NewMockClient() client.On("Info").Return(mockInfo, nil) client.On("Version").Return(mockVersion, nil) client.On("ListImages").Return([]*dockerclient.Image{}, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() client.On("ListContainers", true, false, "").Return([]dockerclient.Container{container1, container2}, nil) client.On("InspectContainer", "c1").Return(info1, errors.New("Not found")) client.On("InspectContainer", "c2").Return(info2, nil) assert.NoError(t, engine.ConnectWithClient(client)) assert.Nil(t, engine.RefreshContainers(true)) // List of containers is still valid containers := engine.Containers() assert.Len(t, containers, 1) assert.Equal(t, containers[0].Id, "c2") client.Mock.AssertExpectations(t) }
func TestEngineSpecs(t *testing.T) { engine := NewEngine("test", 0, engOpts) engine.setState(stateUnhealthy) assert.False(t, engine.isConnected()) client := mockclient.NewMockClient() apiClient := engineapimock.NewMockClient() apiClient.On("Info", mock.Anything).Return(mockInfo, nil) apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil) apiClient.On("NetworkList", mock.Anything, mock.AnythingOfType("NetworkListOptions"), ).Return([]types.NetworkResource{}, nil) apiClient.On("VolumeList", mock.Anything, mock.AnythingOfType("Args"), ).Return(types.VolumesListResponse{}, nil) apiClient.On("ImageList", mock.Anything, mock.AnythingOfType("ImageListOptions")).Return([]types.Image{}, nil) apiClient.On("ContainerList", mock.Anything, types.ContainerListOptions{All: true, Size: false}).Return([]types.Container{}, nil) apiClient.On("Events", mock.Anything, mock.AnythingOfType("EventsOptions")).Return(&nopCloser{infiniteRead{}}, nil) assert.NoError(t, engine.ConnectWithClient(client, apiClient)) assert.True(t, engine.isConnected()) assert.True(t, engine.IsHealthy()) assert.Equal(t, engine.Cpus, int64(mockInfo.NCPU)) assert.Equal(t, engine.Memory, mockInfo.MemTotal) assert.Equal(t, engine.Labels["storagedriver"], mockInfo.Driver) assert.Equal(t, engine.Labels["executiondriver"], mockInfo.ExecutionDriver) assert.Equal(t, engine.Labels["kernelversion"], mockInfo.KernelVersion) assert.Equal(t, engine.Labels["operatingsystem"], mockInfo.OperatingSystem) assert.Equal(t, engine.Labels["foo"], "bar") client.Mock.AssertExpectations(t) apiClient.Mock.AssertExpectations(t) }
func TestStopContainer_CustomSignalSuccess(t *testing.T) { c := Container{ containerInfo: &dockerclient.ContainerInfo{ Name: "foo", Id: "abc123", Config: &dockerclient.ContainerConfig{ Labels: map[string]string{"com.centurylinklabs.watchtower.stop-signal": "SIGUSR1"}}, }, } ci := &dockerclient.ContainerInfo{ State: &dockerclient.State{ Running: false, }, } api := mockclient.NewMockClient() api.On("KillContainer", "abc123", "SIGUSR1").Return(nil) api.On("InspectContainer", "abc123").Return(ci, nil).Once() api.On("RemoveContainer", "abc123", true, false).Return(nil) api.On("InspectContainer", "abc123").Return(&dockerclient.ContainerInfo{}, errors.New("Not Found")) client := dockerClient{api: api} err := client.StopContainer(c, time.Second) assert.NoError(t, err) api.AssertExpectations(t) }
func TestCreateContainer(t *testing.T) { var ( config = &ContainerConfig{dockerclient.ContainerConfig{ Image: "busybox", CpuShares: 1, Cmd: []string{"date"}, Tty: false, }} engine = NewEngine("test", 0) client = mockclient.NewMockClient() ) client.On("Info").Return(mockInfo, nil) client.On("Version").Return(mockVersion, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil).Once() client.On("ListImages").Return([]*dockerclient.Image{}, nil).Once() assert.NoError(t, engine.ConnectWithClient(client)) assert.True(t, engine.isConnected()) mockConfig := config.ContainerConfig mockConfig.CpuShares = int64(math.Ceil(float64(config.CpuShares*1024) / float64(mockInfo.NCPU))) mockConfig.HostConfig.CpuShares = mockConfig.CpuShares // Everything is ok name := "test1" id := "id1" client.On("CreateContainer", &mockConfig, name).Return(id, nil).Once() client.On("ListContainers", true, false, fmt.Sprintf(`{"id":[%q]}`, id)).Return([]dockerclient.Container{{Id: id}}, nil).Once() client.On("ListImages").Return([]*dockerclient.Image{}, nil).Once() client.On("InspectContainer", id).Return(&dockerclient.ContainerInfo{Config: &config.ContainerConfig}, nil).Once() container, err := engine.Create(config, name, false) assert.Nil(t, err) assert.Equal(t, container.Id, id) assert.Len(t, engine.Containers(), 1) // Image not found, pullImage == false name = "test2" mockConfig.CpuShares = int64(math.Ceil(float64(config.CpuShares*1024) / float64(mockInfo.NCPU))) client.On("CreateContainer", &mockConfig, name).Return("", dockerclient.ErrNotFound).Once() container, err = engine.Create(config, name, false) assert.Equal(t, err, dockerclient.ErrNotFound) assert.Nil(t, container) // Image not found, pullImage == true, and the image can be pulled successfully name = "test3" id = "id3" mockConfig.CpuShares = int64(math.Ceil(float64(config.CpuShares*1024) / float64(mockInfo.NCPU))) client.On("PullImage", config.Image+":latest", mock.Anything).Return(nil).Once() client.On("CreateContainer", &mockConfig, name).Return("", dockerclient.ErrNotFound).Once() client.On("CreateContainer", &mockConfig, name).Return(id, nil).Once() client.On("ListContainers", true, false, fmt.Sprintf(`{"id":[%q]}`, id)).Return([]dockerclient.Container{{Id: id}}, nil).Once() client.On("ListImages").Return([]*dockerclient.Image{}, nil).Once() client.On("InspectContainer", id).Return(&dockerclient.ContainerInfo{Config: &config.ContainerConfig}, nil).Once() container, err = engine.Create(config, name, true) assert.Nil(t, err) assert.Equal(t, container.Id, id) assert.Len(t, engine.Containers(), 2) }
func TestResolveImage_WhenImageExisting(t *testing.T) { c := mockclient.NewMockClient() c.On("InspectImage", "Foo").Return(&dockerclient.ImageInfo{Id: "ytu678"}, nil) e := DockerEndpoint{client: c} imageID, err := e.ResolveImage("Foo") assert.NoError(t, err) assert.Equal(t, "ytu678", imageID) }
func TestDockerEndpointVersion_ErroredClient(t *testing.T) { c := mockclient.NewMockClient() c.On("Version").Return(&dockerclient.Version{Version: ""}, errors.New("test error")) e := DockerEndpoint{client: c} v, err := e.Version() assert.Empty(t, "", v) assert.EqualError(t, err, "test error") }
func TestOutdatedNode(t *testing.T) { node := NewNode("test", 0) client := mockclient.NewMockClient() client.On("Info").Return(&dockerclient.Info{}, nil) assert.Error(t, node.connectClient(client)) assert.False(t, node.IsConnected()) client.Mock.AssertExpectations(t) }
func TestDockerEndpointVersion_Successful(t *testing.T) { c := mockclient.NewMockClient() c.On("Version").Return(&dockerclient.Version{Version: "1.6.1"}, nil).Once() e := DockerEndpoint{client: c} v, err := e.Version() assert.NoError(t, err) assert.Equal(t, "1.6.1", v) c.AssertExpectations(t) }
func TestRemoveContainer_Success(t *testing.T) { c := mockclient.NewMockClient() c.On("RemoveContainer", "foo", true, false).Return(nil) e := DockerEndpoint{client: c} err := e.RemoveContainer("foo") assert.NoError(t, err) c.AssertExpectations(t) }
func TestOutdatedEngine(t *testing.T) { engine := NewEngine("test", 0) client := mockclient.NewMockClient() client.On("Info").Return(&dockerclient.Info{}, nil) assert.Error(t, engine.ConnectWithClient(client)) assert.False(t, engine.isConnected()) client.Mock.AssertExpectations(t) }
func TestListContainers_ListError(t *testing.T) { api := mockclient.NewMockClient() api.On("ListContainers", false, false, "").Return([]dockerclient.Container{}, errors.New("oops")) client := dockerClient{api: api} _, err := client.ListContainers(allContainers) assert.Error(t, err) assert.EqualError(t, err, "oops") api.AssertExpectations(t) }
func TestResolveImage_WhenInitialInspectErrors(t *testing.T) { c := mockclient.NewMockClient() c.On("InspectImage", "Foo").Return(&dockerclient.ImageInfo{}, errors.New("oops")) e := DockerEndpoint{client: c} imageID, err := e.ResolveImage("Foo") assert.Equal(t, "", imageID) assert.EqualError(t, err, "oops") c.AssertExpectations(t) }
func TestResolveImage_WhenImageDoesNotExist(t *testing.T) { c := mockclient.NewMockClient() c.On("InspectImage", "Foo").Return(&dockerclient.ImageInfo{}, dockerclient.ErrNotFound).Once() c.On("PullImage", "Foo", mock.Anything).Return(nil) c.On("InspectImage", "Foo").Return(&dockerclient.ImageInfo{Id: "yui890"}, nil).Once() e := DockerEndpoint{client: c} imageID, err := e.ResolveImage("Foo") assert.NoError(t, err) assert.Equal(t, "yui890", imageID) c.AssertExpectations(t) }
func TestResolveImage_WhenPullErrors(t *testing.T) { c := mockclient.NewMockClient() c.On("InspectImage", "Foo").Return(&dockerclient.ImageInfo{}, dockerclient.ErrNotFound).Once() c.On("PullImage", "Foo", mock.Anything).Return(errors.New("uh-oh")) e := DockerEndpoint{client: c} imageID, err := e.ResolveImage("Foo") assert.Equal(t, "", imageID) assert.EqualError(t, err, "uh-oh") c.AssertExpectations(t) }
func TestInspectContainer_Success(t *testing.T) { expected := &dockerclient.ContainerInfo{Id: "foo"} c := mockclient.NewMockClient() c.On("InspectContainer", "foo").Return(expected, nil) e := DockerEndpoint{client: c} container, err := e.InspectContainer("foo") assert.NoError(t, err) assert.Equal(t, expected, container) c.AssertExpectations(t) }
func TestListContainers_InspectContainerError(t *testing.T) { api := mockclient.NewMockClient() api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo", Names: []string{"bar"}}}, nil) api.On("InspectContainer", "foo").Return(&dockerclient.ContainerInfo{}, errors.New("uh-oh")) client := dockerClient{api: api} _, err := client.ListContainers(allContainers) assert.Error(t, err) assert.EqualError(t, err, "uh-oh") api.AssertExpectations(t) }
func TestImportImage(t *testing.T) { // create cluster c := &Cluster{ engines: make(map[string]*cluster.Engine), } // create engione id := "test-engine" engine := cluster.NewEngine(id, 0, engOpts) engine.Name = id engine.ID = id // create mock client client := mockclient.NewMockClient() apiClient := engineapimock.NewMockClient() apiClient.On("Info", mock.Anything).Return(mockInfo, nil) apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil) apiClient.On("NetworkList", mock.Anything, mock.AnythingOfType("NetworkListOptions"), ).Return([]types.NetworkResource{}, nil) apiClient.On("VolumeList", mock.Anything, mock.Anything).Return(types.VolumesListResponse{}, nil) apiClient.On("Events", mock.Anything, mock.AnythingOfType("EventsOptions")).Return(&nopCloser{bytes.NewBufferString("")}, nil) apiClient.On("ImageList", mock.Anything, mock.AnythingOfType("ImageListOptions")).Return([]types.Image{}, nil) apiClient.On("ContainerList", mock.Anything, types.ContainerListOptions{All: true, Size: false}).Return([]types.Container{}, nil).Once() // connect client engine.ConnectWithClient(client, apiClient) // add engine to cluster c.engines[engine.ID] = engine // import success readCloser := nopCloser{bytes.NewBufferString("ok")} apiClient.On("ImageImport", mock.Anything, mock.AnythingOfType("types.ImageImportSource"), mock.Anything, mock.AnythingOfType("types.ImageImportOptions")).Return(readCloser, nil).Once() callback := func(what, status string, err error) { // import success assert.Nil(t, err) } c.Import("-", "testImageOK", "latest", bytes.NewReader(nil), callback) // import error readCloser = nopCloser{bytes.NewBufferString("error")} err := fmt.Errorf("Import error") apiClient.On("ImageImport", mock.Anything, mock.AnythingOfType("types.ImageImportSource"), mock.Anything, mock.AnythingOfType("types.ImageImportOptions")).Return(readCloser, err).Once() callback = func(what, status string, err error) { // import error assert.NotNil(t, err) } c.Import("-", "testImageError", "latest", bytes.NewReader(nil), callback) }
func TestNodeConnectionFailure(t *testing.T) { node := NewNode("test", 0) assert.False(t, node.IsConnected()) // Always fail. client := mockclient.NewMockClient() client.On("Info").Return(&dockerclient.Info{}, errors.New("fail")) // Connect() should fail and IsConnected() return false. assert.Error(t, node.connectClient(client)) assert.False(t, node.IsConnected()) client.Mock.AssertExpectations(t) }
func TestEngineConnectionFailure(t *testing.T) { engine := NewEngine("test", 0) assert.False(t, engine.isConnected()) // Always fail. client := mockclient.NewMockClient() client.On("Info").Return(&dockerclient.Info{}, errors.New("fail")) // Connect() should fail and isConnected() return false. assert.Error(t, engine.ConnectWithClient(client)) assert.False(t, engine.isConnected()) client.Mock.AssertExpectations(t) }
func TestEngineState(t *testing.T) { engine := NewEngine("test", 0, engOpts) engine.setState(stateUnhealthy) assert.False(t, engine.isConnected()) client := mockclient.NewMockClient() apiClient := engineapimock.NewMockClient() apiClient.On("Info", mock.Anything).Return(mockInfo, nil) apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil) apiClient.On("NetworkList", mock.Anything, mock.AnythingOfType("NetworkListOptions"), ).Return([]types.NetworkResource{}, nil) apiClient.On("VolumeList", mock.Anything, mock.AnythingOfType("Args"), ).Return(types.VolumesListResponse{}, nil) apiClient.On("Events", mock.Anything, mock.AnythingOfType("EventsOptions")).Return(&nopCloser{infiniteRead{}}, nil) // The client will return one container at first, then a second one will appear. apiClient.On("ImageList", mock.Anything, mock.AnythingOfType("ImageListOptions")).Return([]types.Image{}, nil).Once() apiClient.On("ContainerList", mock.Anything, types.ContainerListOptions{All: true, Size: false}).Return([]types.Container{{ID: "one"}}, nil).Once() apiClient.On("ContainerInspect", mock.Anything, "one").Return(types.ContainerJSON{ContainerJSONBase: &types.ContainerJSONBase{HostConfig: &containertypes.HostConfig{Resources: containertypes.Resources{CPUShares: 100}}}, Config: &containertypes.Config{}, NetworkSettings: &types.NetworkSettings{Networks: nil}}, nil).Once() filterArgs := filters.NewArgs() filterArgs.Add("id", "two") apiClient.On("ContainerList", mock.Anything, types.ContainerListOptions{All: true, Size: false, Filter: filterArgs}).Return([]types.Container{{ID: "two"}}, nil).Once() apiClient.On("ContainerInspect", mock.Anything, "two").Return(types.ContainerJSON{ContainerJSONBase: &types.ContainerJSONBase{HostConfig: &containertypes.HostConfig{Resources: containertypes.Resources{CPUShares: 100}}}, Config: &containertypes.Config{}, NetworkSettings: &types.NetworkSettings{Networks: nil}}, nil).Once() assert.NoError(t, engine.ConnectWithClient(client, apiClient)) assert.True(t, engine.isConnected()) // The engine should only have a single container at this point. containers := engine.Containers() assert.Len(t, containers, 1) if containers[0].ID != "one" { t.Fatalf("Missing container: one") } // Fake an event which will trigger a refresh. The second container will appear. engine.handler(events.Message{ID: "two", Status: "created"}) containers = engine.Containers() assert.Len(t, containers, 2) if containers[0].ID != "one" && containers[1].ID != "one" { t.Fatalf("Missing container: one") } if containers[0].ID != "two" && containers[1].ID != "two" { t.Fatalf("Missing container: two") } client.Mock.AssertExpectations(t) apiClient.Mock.AssertExpectations(t) }
func TestImportImage(t *testing.T) { // create cluster c := &Cluster{ engines: make(map[string]*cluster.Engine), } // create engione id := "test-engine" engine := cluster.NewEngine(id, 0) engine.Name = id engine.ID = id // create mock client client := mockclient.NewMockClient() client.On("Info").Return(mockInfo, nil) client.On("Version").Return(mockVersion, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() client.On("ListContainers", true, false, "").Return([]dockerclient.Container{}, nil).Once() client.On("ListImages", mock.Anything).Return([]*dockerclient.Image{}, nil) client.On("ListVolumes", mock.Anything).Return([]*dockerclient.Volume{}, nil) client.On("ListNetworks", mock.Anything).Return([]*dockerclient.NetworkResource{}, nil) // connect client engine.ConnectWithClient(client) // add engine to cluster c.engines[engine.ID] = engine // import success readCloser := nopCloser{bytes.NewBufferString("ok")} client.On("ImportImage", mock.Anything, mock.Anything, mock.Anything, mock.AnythingOfType("*io.PipeReader")).Return(readCloser, nil).Once() callback := func(what, status string, err error) { // import success assert.Nil(t, err) } c.Import("-", "testImageOK", "latest", bytes.NewReader(nil), callback) // import error readCloser = nopCloser{bytes.NewBufferString("error")} err := fmt.Errorf("Import error") client.On("ImportImage", mock.Anything, mock.Anything, mock.Anything, mock.AnythingOfType("*io.PipeReader")).Return(readCloser, err).Once() callback = func(what, status string, err error) { // import error assert.NotNil(t, err) } c.Import("-", "testImageError", "latest", bytes.NewReader(nil), callback) }
func TestLoadImage(t *testing.T) { // create cluster c := &Cluster{ engines: make(map[string]*cluster.Engine), } // create engione id := "test-engine" engine := cluster.NewEngine(id, 0, engOpts) engine.Name = id engine.ID = id // create mock client client := mockclient.NewMockClient() apiClient := engineapimock.NewMockClient() apiClient.On("Info", mock.Anything).Return(mockInfo, nil) apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil) apiClient.On("NetworkList", mock.Anything, mock.AnythingOfType("NetworkListOptions"), ).Return([]types.NetworkResource{}, nil) apiClient.On("VolumeList", mock.Anything, mock.Anything).Return(types.VolumesListResponse{}, nil) apiClient.On("Events", mock.Anything, mock.AnythingOfType("EventsOptions")).Return(&nopCloser{bytes.NewBufferString("")}, nil) apiClient.On("ImageList", mock.Anything, mock.AnythingOfType("ImageListOptions")).Return([]types.Image{}, nil) apiClient.On("ContainerList", mock.Anything, types.ContainerListOptions{All: true, Size: false}).Return([]types.Container{}, nil).Once() // connect client engine.ConnectWithClient(client, apiClient) // add engine to cluster c.engines[engine.ID] = engine // load success readCloser := nopCloser{bytes.NewBufferString("")} apiClient.On("ImageLoad", mock.Anything, mock.AnythingOfType("*io.PipeReader"), false).Return(types.ImageLoadResponse{Body: readCloser}, nil).Once() callback := func(what, status string, err error) { //if load OK, err will be nil assert.Nil(t, err) } c.Load(bytes.NewReader(nil), callback) // load error err := fmt.Errorf("Load error") apiClient.On("ImageLoad", mock.Anything, mock.AnythingOfType("*io.PipeReader"), false).Return(types.ImageLoadResponse{}, err).Once() callback = func(what, status string, err error) { // load error, err is not nil assert.NotNil(t, err) } c.Load(bytes.NewReader(nil), callback) }
func TestListContainers_Filter(t *testing.T) { ci := &dockerclient.ContainerInfo{Image: "abc123", Config: &dockerclient.ContainerConfig{Image: "img"}} ii := &dockerclient.ImageInfo{} api := mockclient.NewMockClient() api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo", Names: []string{"bar"}}}, nil) api.On("InspectContainer", "foo").Return(ci, nil) api.On("InspectImage", "abc123").Return(ii, nil) client := dockerClient{api: api} cs, err := client.ListContainers(noContainers) assert.NoError(t, err) assert.Len(t, cs, 0) api.AssertExpectations(t) }
func TestListContainers_InspectImageError(t *testing.T) { ci := &dockerclient.ContainerInfo{Image: "abc123", Config: &dockerclient.ContainerConfig{Image: "img"}} ii := &dockerclient.ImageInfo{} api := mockclient.NewMockClient() api.On("ListContainers", false, false, "").Return([]dockerclient.Container{{Id: "foo", Names: []string{"bar"}}}, nil) api.On("InspectContainer", "foo").Return(ci, nil) api.On("InspectImage", "abc123").Return(ii, errors.New("whoops")) client := dockerClient{api: api} _, err := client.ListContainers(allContainers) assert.Error(t, err) assert.EqualError(t, err, "whoops") api.AssertExpectations(t) }
func TestEngineState(t *testing.T) { engine := NewEngine("test", 0, engOpts) engine.setState(stateUnhealthy) assert.False(t, engine.isConnected()) client := mockclient.NewMockClient() apiClient := engineapimock.NewMockClient() apiClient.On("Info", mock.Anything).Return(mockInfo, nil) apiClient.On("ServerVersion", mock.Anything).Return(mockVersion, nil) apiClient.On("NetworkList", mock.Anything, mock.AnythingOfType("NetworkListOptions"), ).Return([]types.NetworkResource{}, nil) apiClient.On("VolumeList", mock.Anything, mock.AnythingOfType("Args"), ).Return(types.VolumesListResponse{}, nil) client.On("StartMonitorEvents", mock.Anything, mock.Anything, mock.Anything).Return() // The client will return one container at first, then a second one will appear. client.On("ListContainers", true, false, "").Return([]dockerclient.Container{{Id: "one"}}, nil).Once() apiClient.On("ImageList", mock.Anything, mock.AnythingOfType("ImageListOptions")).Return([]types.Image{}, nil).Once() client.On("InspectContainer", "one").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once() client.On("ListContainers", true, false, fmt.Sprintf("{%q:[%q]}", "id", "two")).Return([]dockerclient.Container{{Id: "two"}}, nil).Once() client.On("InspectContainer", "two").Return(&dockerclient.ContainerInfo{Config: &dockerclient.ContainerConfig{CpuShares: 100}}, nil).Once() assert.NoError(t, engine.ConnectWithClient(client, apiClient)) assert.True(t, engine.isConnected()) // The engine should only have a single container at this point. containers := engine.Containers() assert.Len(t, containers, 1) if containers[0].Id != "one" { t.Fatalf("Missing container: one") } // Fake an event which will trigger a refresh. The second container will appear. engine.handler(&dockerclient.Event{ID: "two", Status: "created"}, nil) containers = engine.Containers() assert.Len(t, containers, 2) if containers[0].Id != "one" && containers[1].Id != "one" { t.Fatalf("Missing container: one") } if containers[0].Id != "two" && containers[1].Id != "two" { t.Fatalf("Missing container: two") } client.Mock.AssertExpectations(t) apiClient.Mock.AssertExpectations(t) }