mirror of
https://github.com/rancher/os.git
synced 2025-06-24 14:01:34 +00:00
308 lines
7.1 KiB
Go
308 lines
7.1 KiB
Go
package docker
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/rancherio/os/config"
|
|
"github.com/rancherio/rancher-compose/librcompose/project"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
dockerClient "github.com/fsouza/go-dockerclient"
|
|
"os"
|
|
)
|
|
|
|
func testDockerHost(t *testing.T) {
|
|
assert := require.New(t)
|
|
assert.Equal(os.Getenv("DOCKER_HOST"), config.DOCKER_HOST)
|
|
}
|
|
|
|
func TestHash(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
hash := getHash(&config.ContainerConfig{
|
|
Id: "id",
|
|
Cmd: "1 2 3",
|
|
})
|
|
|
|
hash2 := getHash(&config.ContainerConfig{
|
|
Id: "id2",
|
|
Cmd: "1 2 3",
|
|
})
|
|
|
|
hash3 := getHash(&config.ContainerConfig{
|
|
Id: "id3",
|
|
Cmd: "1 2 3 4",
|
|
})
|
|
|
|
assert.Equal("d601444333c7fb4cb955bcca36c5ed59b6fa8c3f", hash, "")
|
|
assert.NotEqual(hash, hash2, "")
|
|
assert.NotEqual(hash2, hash3, "")
|
|
assert.NotEqual(hash, hash3, "")
|
|
}
|
|
|
|
func TestHash2(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
cfg := &config.ContainerConfig{
|
|
Id: "docker-volumes",
|
|
Cmd: "",
|
|
MigrateVolumes: false,
|
|
ReloadConfig: false,
|
|
CreateOnly: true,
|
|
Service: &project.ServiceConfig{
|
|
CapAdd: nil,
|
|
CapDrop: nil,
|
|
CpuShares: 0,
|
|
Command: project.NewCommand(),
|
|
Detach: "",
|
|
Dns: project.NewStringorslice(),
|
|
DnsSearch: project.NewStringorslice(),
|
|
DomainName: "",
|
|
Entrypoint: project.NewCommand(),
|
|
EnvFile: project.NewStringorslice(),
|
|
Environment: project.NewMaporEqualSlice([]string{}),
|
|
Hostname: "",
|
|
Image: "state",
|
|
Labels: project.NewSliceorMap(map[string]string{
|
|
"io.rancher.os.createonly": "true",
|
|
"io.rancher.os.scope": "system"}),
|
|
Links: project.NewMaporColonSlice(nil),
|
|
LogDriver: "json-file",
|
|
MemLimit: 0,
|
|
Name: "",
|
|
Net: "none",
|
|
Pid: "",
|
|
Ipc: "",
|
|
Ports: nil,
|
|
Privileged: true,
|
|
Restart: "",
|
|
ReadOnly: true,
|
|
StdinOpen: false,
|
|
Tty: false,
|
|
User: "",
|
|
Volumes: []string{
|
|
"/var/lib/docker:/var/lib/docker",
|
|
"/var/lib/rancher/conf:/var/lib/rancher/conf",
|
|
"/var/lib/system-docker:/var/lib/system-docker"},
|
|
VolumesFrom: nil,
|
|
WorkingDir: "",
|
|
Expose: nil,
|
|
ExternalLinks: nil},
|
|
}
|
|
|
|
for i := 0; i < 1000; i++ {
|
|
assert.Equal(getHash(cfg), getHash(cfg), fmt.Sprintf("Failed at iteration: %v", i))
|
|
}
|
|
}
|
|
|
|
func TestBool2String(t *testing.T) {
|
|
assert := require.New(t)
|
|
assert.Equal("true", fmt.Sprint(true), "")
|
|
}
|
|
|
|
func TestParse(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
cfg := &config.ContainerConfig{
|
|
Cmd: "--name c1 " +
|
|
"-d " +
|
|
"--rm " +
|
|
"--privileged " +
|
|
"test/image " +
|
|
"arg1 " +
|
|
"arg2 ",
|
|
}
|
|
|
|
c := NewContainer("", cfg).Parse()
|
|
|
|
assert.NoError(c.Err, "")
|
|
assert.Equal(cfg.Id, "c1", "Id doesn't match")
|
|
assert.Equal(c.Name, "c1", "Name doesn't match")
|
|
assert.True(c.remove, "Remove doesn't match")
|
|
assert.True(c.detach, "Detach doesn't match")
|
|
assert.Equal(c.Config.Cmd.Len(), 2, "Args doesn't match")
|
|
assert.Equal(c.Config.Cmd.Slice()[0], "arg1", "Arg1 doesn't match")
|
|
assert.Equal(c.Config.Cmd.Slice()[1], "arg2", "Arg2 doesn't match")
|
|
assert.True(c.HostConfig.Privileged, "Privileged doesn't match")
|
|
}
|
|
|
|
func TestIdFromName(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
cfg := &config.ContainerConfig{
|
|
Cmd: "--name foo -v /test busybox echo hi",
|
|
}
|
|
|
|
assert.Equal("", cfg.Id)
|
|
NewContainer(config.DOCKER_HOST, cfg)
|
|
assert.Equal("foo", cfg.Id)
|
|
}
|
|
|
|
func testMigrateVolumes(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
Cmd: "--name foo -v /test busybox echo hi",
|
|
}).Parse().Start().Lookup()
|
|
|
|
assert.NoError(c.Err, "")
|
|
|
|
test_path, ok := c.Container.Volumes["/test"]
|
|
assert.True(ok, "")
|
|
|
|
c2 := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
MigrateVolumes: true,
|
|
Cmd: "--name foo -v /test2 busybox echo hi",
|
|
}).Parse().Start().Lookup()
|
|
|
|
assert.NoError(c2.Err, "")
|
|
|
|
assert.True(c2.Container != nil)
|
|
|
|
_, ok = c2.Container.Volumes["/test2"]
|
|
assert.True(ok, "")
|
|
assert.Equal(test_path, c2.Container.Volumes["/test"])
|
|
|
|
c.Delete()
|
|
c2.Delete()
|
|
}
|
|
|
|
func testRollback(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
Cmd: "--name rollback busybox echo hi",
|
|
}).Parse().Start().Lookup()
|
|
|
|
assert.NoError(c.Err, "")
|
|
assert.Equal("rollback", c.Container.Name)
|
|
|
|
c2 := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
Cmd: "--name rollback busybox echo bye",
|
|
}).Parse().Start().Lookup()
|
|
|
|
assert.Equal("rollback", c2.Container.Name)
|
|
assert.NoError(c2.Err, "")
|
|
assert.NotEqual(c.Container.ID, c2.Container.ID)
|
|
|
|
c3 := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
Cmd: "--name rollback busybox echo hi",
|
|
}).Parse().Start().Lookup()
|
|
|
|
assert.NoError(c3.Err, "")
|
|
assert.Equal(c.Container.ID, c3.Container.ID)
|
|
assert.Equal("rollback", c3.Container.Name)
|
|
|
|
c2.Reset().Lookup()
|
|
assert.NoError(c2.Err, "")
|
|
assert.True(strings.HasPrefix(c2.Container.Name, "rollback-"))
|
|
|
|
c.Delete()
|
|
c2.Delete()
|
|
}
|
|
|
|
func testStart(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
Cmd: "--pid=host --privileged --rm busybox echo hi",
|
|
}).Parse().Start().Lookup()
|
|
|
|
assert.NoError(c.Err, "")
|
|
|
|
assert.True(c.HostConfig.Privileged, "")
|
|
assert.True(c.Container.HostConfig.Privileged, "")
|
|
assert.Equal("host", c.Container.HostConfig.PidMode, "")
|
|
|
|
c.Delete()
|
|
}
|
|
|
|
func testLookup(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
cfg := &config.ContainerConfig{
|
|
Cmd: "--rm busybox echo hi",
|
|
}
|
|
c := NewContainer(config.DOCKER_HOST, cfg).Parse().Start()
|
|
|
|
cfg2 := &config.ContainerConfig{
|
|
Cmd: "--rm busybox echo hi2",
|
|
}
|
|
c2 := NewContainer(config.DOCKER_HOST, cfg2).Parse().Start()
|
|
|
|
assert.NoError(c.Err, "")
|
|
assert.NoError(c2.Err, "")
|
|
|
|
c1Lookup := NewContainer(config.DOCKER_HOST, cfg).Lookup()
|
|
c2Lookup := NewContainer(config.DOCKER_HOST, cfg2).Lookup()
|
|
|
|
assert.NoError(c1Lookup.Err, "")
|
|
assert.NoError(c2Lookup.Err, "")
|
|
|
|
assert.Equal(c.Container.ID, c1Lookup.Container.ID, "")
|
|
assert.Equal(c2.Container.ID, c2Lookup.Container.ID, "")
|
|
|
|
c.Delete()
|
|
c2.Delete()
|
|
}
|
|
|
|
func testDelete(t *testing.T) {
|
|
assert := require.New(t)
|
|
|
|
c := NewContainer(config.DOCKER_HOST, &config.ContainerConfig{
|
|
Cmd: "--rm busybox echo hi",
|
|
}).Parse()
|
|
|
|
assert.False(c.Exists())
|
|
assert.NoError(c.Err, "")
|
|
|
|
c.Start()
|
|
assert.NoError(c.Err, "")
|
|
c.Reset()
|
|
assert.NoError(c.Err, "")
|
|
|
|
assert.True(c.Exists())
|
|
assert.NoError(c.Err, "")
|
|
|
|
c.Delete()
|
|
assert.NoError(c.Err, "")
|
|
|
|
c.Reset()
|
|
assert.False(c.Exists())
|
|
assert.NoError(c.Err, "")
|
|
}
|
|
|
|
func testDockerClientNames(t *testing.T) {
|
|
assert := require.New(t)
|
|
client, err := dockerClient.NewClient(config.DOCKER_HOST)
|
|
|
|
assert.NoError(err, "")
|
|
|
|
c, err := client.CreateContainer(dockerClient.CreateContainerOptions{
|
|
Name: "foo",
|
|
Config: &dockerClient.Config{
|
|
Image: "ubuntu",
|
|
},
|
|
})
|
|
|
|
assert.NoError(err, "")
|
|
assert.Equal("foo", c.Name)
|
|
|
|
c2, err := client.InspectContainer(c.ID)
|
|
|
|
assert.NoError(err, "")
|
|
assert.Equal("/foo", c2.Name)
|
|
|
|
c2, err = inspect(client, c.ID)
|
|
|
|
assert.NoError(err, "")
|
|
assert.Equal("foo", c2.Name)
|
|
|
|
client.RemoveContainer(dockerClient.RemoveContainerOptions{
|
|
ID: c2.ID,
|
|
Force: true,
|
|
})
|
|
}
|