hostconfig_test.go

package runconfig

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"testing"
)

func TestNetworkModeTest(t *testing.T) {
	networkModes := map[NetworkMode][]bool{
		// private, bridge, host, container, none, default
		"":                         {true, false, false, false, false, false},
		"something:weird":          {true, false, false, false, false, false},
		"bridge":                   {true, true, false, false, false, false},
		DefaultDaemonNetworkMode(): {true, true, false, false, false, false},
		"host":           {false, false, true, false, false, false},
		"container:name": {false, false, false, true, false, false},
		"none":           {true, false, false, false, true, false},
		"default":        {true, false, false, false, false, true},
	}
	networkModeNames := map[NetworkMode]string{
		"":                         "",
		"something:weird":          "",
		"bridge":                   "bridge",
		DefaultDaemonNetworkMode(): "bridge",
		"host":           "host",
		"container:name": "container",
		"none":           "none",
		"default":        "default",
	}
	for networkMode, state := range networkModes {
		if networkMode.IsPrivate() != state[0] {
			t.Fatalf("NetworkMode.IsPrivate for %v should have been %v but was %v", networkMode, state[0], networkMode.IsPrivate())
		}
		if networkMode.IsBridge() != state[1] {
			t.Fatalf("NetworkMode.IsBridge for %v should have been %v but was %v", networkMode, state[1], networkMode.IsBridge())
		}
		if networkMode.IsHost() != state[2] {
			t.Fatalf("NetworkMode.IsHost for %v should have been %v but was %v", networkMode, state[2], networkMode.IsHost())
		}
		if networkMode.IsContainer() != state[3] {
			t.Fatalf("NetworkMode.IsContainer for %v should have been %v but was %v", networkMode, state[3], networkMode.IsContainer())
		}
		if networkMode.IsNone() != state[4] {
			t.Fatalf("NetworkMode.IsNone for %v should have been %v but was %v", networkMode, state[4], networkMode.IsNone())
		}
		if networkMode.IsDefault() != state[5] {
			t.Fatalf("NetworkMode.IsDefault for %v should have been %v but was %v", networkMode, state[5], networkMode.IsDefault())
		}
		if networkMode.NetworkName() != networkModeNames[networkMode] {
			t.Fatalf("Expected name %v, got %v", networkModeNames[networkMode], networkMode.NetworkName())
		}
	}
}

func TestIpcModeTest(t *testing.T) {
	ipcModes := map[IpcMode][]bool{
		// private, host, container, valid
		"":                         {true, false, false, true},
		"something:weird":          {true, false, false, false},
		":weird":                   {true, false, false, true},
		"host":                     {false, true, false, true},
		"container:name":           {false, false, true, true},
		"container:name:something": {false, false, true, false},
		"container:":               {false, false, true, false},
	}
	for ipcMode, state := range ipcModes {
		if ipcMode.IsPrivate() != state[0] {
			t.Fatalf("IpcMode.IsPrivate for %v should have been %v but was %v", ipcMode, state[0], ipcMode.IsPrivate())
		}
		if ipcMode.IsHost() != state[1] {
			t.Fatalf("IpcMode.IsHost for %v should have been %v but was %v", ipcMode, state[1], ipcMode.IsHost())
		}
		if ipcMode.IsContainer() != state[2] {
			t.Fatalf("IpcMode.IsContainer for %v should have been %v but was %v", ipcMode, state[2], ipcMode.IsContainer())
		}
		if ipcMode.Valid() != state[3] {
			t.Fatalf("IpcMode.Valid for %v should have been %v but was %v", ipcMode, state[3], ipcMode.Valid())
		}
	}
	containerIpcModes := map[IpcMode]string{
		"":                      "",
		"something":             "",
		"something:weird":       "weird",
		"container":             "",
		"container:":            "",
		"container:name":        "name",
		"container:name1:name2": "name1:name2",
	}
	for ipcMode, container := range containerIpcModes {
		if ipcMode.Container() != container {
			t.Fatalf("Expected %v for %v but was %v", container, ipcMode, ipcMode.Container())
		}
	}
}

func TestUTSModeTest(t *testing.T) {
	utsModes := map[UTSMode][]bool{
		// private, host, valid
		"":                {true, false, true},
		"something:weird": {true, false, false},
		"host":            {false, true, true},
		"host:name":       {true, false, true},
	}
	for utsMode, state := range utsModes {
		if utsMode.IsPrivate() != state[0] {
			t.Fatalf("UtsMode.IsPrivate for %v should have been %v but was %v", utsMode, state[0], utsMode.IsPrivate())
		}
		if utsMode.IsHost() != state[1] {
			t.Fatalf("UtsMode.IsHost for %v should have been %v but was %v", utsMode, state[1], utsMode.IsHost())
		}
		if utsMode.Valid() != state[2] {
			t.Fatalf("UtsMode.Valid for %v should have been %v but was %v", utsMode, state[2], utsMode.Valid())
		}
	}
}

func TestPidModeTest(t *testing.T) {
	pidModes := map[PidMode][]bool{
		// private, host, valid
		"":                {true, false, true},
		"something:weird": {true, false, false},
		"host":            {false, true, true},
		"host:name":       {true, false, true},
	}
	for pidMode, state := range pidModes {
		if pidMode.IsPrivate() != state[0] {
			t.Fatalf("PidMode.IsPrivate for %v should have been %v but was %v", pidMode, state[0], pidMode.IsPrivate())
		}
		if pidMode.IsHost() != state[1] {
			t.Fatalf("PidMode.IsHost for %v should have been %v but was %v", pidMode, state[1], pidMode.IsHost())
		}
		if pidMode.Valid() != state[2] {
			t.Fatalf("PidMode.Valid for %v should have been %v but was %v", pidMode, state[2], pidMode.Valid())
		}
	}
}

func TestRestartPolicy(t *testing.T) {
	restartPolicies := map[RestartPolicy][]bool{
		// none, always, failure
		RestartPolicy{}:                {false, false, false},
		RestartPolicy{"something", 0}:  {false, false, false},
		RestartPolicy{"no", 0}:         {true, false, false},
		RestartPolicy{"always", 0}:     {false, true, false},
		RestartPolicy{"on-failure", 0}: {false, false, true},
	}
	for restartPolicy, state := range restartPolicies {
		if restartPolicy.IsNone() != state[0] {
			t.Fatalf("RestartPolicy.IsNone for %v should have been %v but was %v", restartPolicy, state[0], restartPolicy.IsNone())
		}
		if restartPolicy.IsAlways() != state[1] {
			t.Fatalf("RestartPolicy.IsAlways for %v should have been %v but was %v", restartPolicy, state[1], restartPolicy.IsAlways())
		}
		if restartPolicy.IsOnFailure() != state[2] {
			t.Fatalf("RestartPolicy.IsOnFailure for %v should have been %v but was %v", restartPolicy, state[2], restartPolicy.IsOnFailure())
		}
	}
}

func TestLxcConfigMarshalJSON(t *testing.T) {
	lxcConfigs := map[*LxcConfig]string{
		nil:          "",
		&LxcConfig{}: "null",
		&LxcConfig{
			[]KeyValuePair{{"key1", "value1"}},
		}: `[{"Key":"key1","Value":"value1"}]`,
	}

	for lxcconfig, expected := range lxcConfigs {
		data, err := lxcconfig.MarshalJSON()
		if err != nil {
			t.Fatal(err)
		}
		if string(data) != expected {
			t.Fatalf("Expected %v, got %v", expected, string(data))
		}
	}
}

func TestLxcConfigUnmarshalJSON(t *testing.T) {
	keyvaluePairs := map[string][]KeyValuePair{
		"":   {{"key1", "value1"}},
		"[]": {},
		`[{"Key":"key2","Value":"value2"}]`: {{"key2", "value2"}},
	}
	for json, expectedParts := range keyvaluePairs {
		lxcConfig := &LxcConfig{
			[]KeyValuePair{{"key1", "value1"}},
		}
		if err := lxcConfig.UnmarshalJSON([]byte(json)); err != nil {
			t.Fatal(err)
		}

		actualParts := lxcConfig.Slice()
		if len(actualParts) != len(expectedParts) {
			t.Fatalf("Expected %v keyvaluePairs, got %v (%v)", len(expectedParts), len(actualParts), expectedParts)
		}
		for index, part := range actualParts {
			if part != expectedParts[index] {
				t.Fatalf("Expected %v, got %v", expectedParts, actualParts)
				break
			}
		}
	}
}

func TestMergeConfigs(t *testing.T) {
	expectedHostname := "hostname"
	expectedContainerIDFile := "containerIdFile"
	config := &Config{
		Hostname: expectedHostname,
	}
	hostConfig := &HostConfig{
		ContainerIDFile: expectedContainerIDFile,
	}
	containerConfigWrapper := MergeConfigs(config, hostConfig)
	if containerConfigWrapper.Config.Hostname != expectedHostname {
		t.Fatalf("containerConfigWrapper config hostname expected %v got %v", expectedHostname, containerConfigWrapper.Config.Hostname)
	}
	if containerConfigWrapper.InnerHostConfig.ContainerIDFile != expectedContainerIDFile {
		t.Fatalf("containerConfigWrapper hostconfig containerIdfile expected %v got %v", expectedContainerIDFile, containerConfigWrapper.InnerHostConfig.ContainerIDFile)
	}
	if containerConfigWrapper.Cpuset != "" {
		t.Fatalf("Expected empty Cpuset, got %v", containerConfigWrapper.Cpuset)
	}
}

func TestDecodeHostConfig(t *testing.T) {
	fixtures := []struct {
		file string
	}{
		{"fixtures/container_hostconfig_1_14.json"},
		{"fixtures/container_hostconfig_1_19.json"},
	}

	for _, f := range fixtures {
		b, err := ioutil.ReadFile(f.file)
		if err != nil {
			t.Fatal(err)
		}

		c, err := DecodeHostConfig(bytes.NewReader(b))
		if err != nil {
			t.Fatal(fmt.Errorf("Error parsing %s: %v", f, err))
		}

		if c.Privileged != false {
			t.Fatalf("Expected privileged false, found %v\n", c.Privileged)
		}

		if l := len(c.Binds); l != 1 {
			t.Fatalf("Expected 1 bind, found %d\n", l)
		}

		if c.CapAdd.Len() != 1 && c.CapAdd.Slice()[0] != "NET_ADMIN" {
			t.Fatalf("Expected CapAdd NET_ADMIN, got %v", c.CapAdd)
		}

		if c.CapDrop.Len() != 1 && c.CapDrop.Slice()[0] != "NET_ADMIN" {
			t.Fatalf("Expected CapDrop MKNOD, got %v", c.CapDrop)
		}
	}
}

func TestCapListUnmarshalSliceAndString(t *testing.T) {
	var cl *CapList
	cap0, err := json.Marshal([]string{"CAP_SOMETHING"})
	if err != nil {
		t.Fatal(err)
	}
	if err := json.Unmarshal(cap0, &cl); err != nil {
		t.Fatal(err)
	}

	slice := cl.Slice()
	if len(slice) != 1 {
		t.Fatalf("expected 1 element after unmarshal: %q", slice)
	}

	if slice[0] != "CAP_SOMETHING" {
		t.Fatalf("expected `CAP_SOMETHING`, got: %q", slice[0])
	}

	cap1, err := json.Marshal("CAP_SOMETHING")
	if err != nil {
		t.Fatal(err)
	}
	if err := json.Unmarshal(cap1, &cl); err != nil {
		t.Fatal(err)
	}

	slice = cl.Slice()
	if len(slice) != 1 {
		t.Fatalf("expected 1 element after unmarshal: %q", slice)
	}

	if slice[0] != "CAP_SOMETHING" {
		t.Fatalf("expected `CAP_SOMETHING`, got: %q", slice[0])
	}
}