moby/opts/opts_test.go

package opts // import "github.com/docker/docker/opts"

import (
	"fmt"
	"strings"
	"testing"

	"gotest.tools/v3/assert"
	is "gotest.tools/v3/assert/cmp"
)

func TestValidateIPAddress(t *testing.T) {
	tests := []struct {
		doc         string
		input       string
		expectedOut string
		expectedErr string
	}{
		{
			doc:         "IPv4 loopback",
			input:       `127.0.0.1`,
			expectedOut: `127.0.0.1`,
		},
		{
			doc:         "IPv4 loopback with whitespace",
			input:       ` 127.0.0.1 `,
			expectedOut: `127.0.0.1`,
		},
		{
			doc:         "IPv6 loopback long form",
			input:       `0:0:0:0:0:0:0:1`,
			expectedOut: `::1`,
		},
		{
			doc:         "IPv6 loopback",
			input:       `::1`,
			expectedOut: `::1`,
		},
		{
			doc:         "IPv6 loopback with whitespace",
			input:       ` ::1 `,
			expectedOut: `::1`,
		},
		{
			doc:         "IPv6 lowercase",
			input:       `2001:db8::68`,
			expectedOut: `2001:db8::68`,
		},
		{
			doc:         "IPv6 uppercase",
			input:       `2001:DB8::68`,
			expectedOut: `2001:db8::68`,
		},
		{
			doc:         "IPv6 with brackets",
			input:       `[::1]`,
			expectedErr: `IP address is not correctly formatted: [::1]`,
		},
		{
			doc:         "IPv4 partial",
			input:       `127`,
			expectedErr: `IP address is not correctly formatted: 127`,
		},
		{
			doc:         "random invalid string",
			input:       `random invalid string`,
			expectedErr: `IP address is not correctly formatted: random invalid string`,
		},
	}

	for _, tc := range tests {
		tc := tc
		t.Run(tc.input, func(t *testing.T) {
			actualOut, actualErr := ValidateIPAddress(tc.input)
			assert.Check(t, is.Equal(tc.expectedOut, actualOut))
			if tc.expectedErr == "" {
				assert.Check(t, actualErr)
			} else {
				assert.Check(t, is.Error(actualErr, tc.expectedErr))
			}
		})
	}
}

func TestMapOpts(t *testing.T) {
	tmpMap := make(map[string]string)
	o := NewMapOpts(tmpMap, logOptsValidator)
	o.Set("max-size=1")
	if o.String() != "map[max-size:1]" {
		t.Errorf("%s != [map[max-size:1]", o.String())
	}

	o.Set("max-file=2")
	if len(tmpMap) != 2 {
		t.Errorf("map length %d != 2", len(tmpMap))
	}

	if tmpMap["max-file"] != "2" {
		t.Errorf("max-file = %s != 2", tmpMap["max-file"])
	}

	if tmpMap["max-size"] != "1" {
		t.Errorf("max-size = %s != 1", tmpMap["max-size"])
	}
	if o.Set("dummy-val=3") == nil {
		t.Error("validator is not being called")
	}
}

func TestListOptsWithoutValidator(t *testing.T) {
	o := NewListOpts(nil)
	o.Set("foo")
	if o.String() != "[foo]" {
		t.Errorf("%s != [foo]", o.String())
	}
	o.Set("bar")
	if o.Len() != 2 {
		t.Errorf("%d != 2", o.Len())
	}
	o.Set("bar")
	if o.Len() != 3 {
		t.Errorf("%d != 3", o.Len())
	}
	if !o.Get("bar") {
		t.Error(`o.Get("bar") == false`)
	}
	if o.Get("baz") {
		t.Error(`o.Get("baz") == true`)
	}
	o.Delete("foo")
	if o.String() != "[bar bar]" {
		t.Errorf("%s != [bar bar]", o.String())
	}
	listOpts := o.GetAll()
	if len(listOpts) != 2 || listOpts[0] != "bar" || listOpts[1] != "bar" {
		t.Errorf("Expected [[bar bar]], got [%v]", listOpts)
	}
	mapListOpts := o.GetMap()
	if len(mapListOpts) != 1 {
		t.Errorf("Expected [map[bar:{}]], got [%v]", mapListOpts)
	}
}

func TestListOptsWithValidator(t *testing.T) {
	// Re-using logOptsvalidator (used by MapOpts)
	o := NewListOpts(logOptsValidator)
	o.Set("foo")
	if o.String() != "" {
		t.Errorf(`%s != ""`, o.String())
	}
	o.Set("foo=bar")
	if o.String() != "" {
		t.Errorf(`%s != ""`, o.String())
	}
	o.Set("max-file=2")
	if o.Len() != 1 {
		t.Errorf("%d != 1", o.Len())
	}
	if !o.Get("max-file=2") {
		t.Error(`o.Get("max-file=2") == false`)
	}
	if o.Get("baz") {
		t.Error(`o.Get("baz") == true`)
	}
	o.Delete("max-file=2")
	if o.String() != "" {
		t.Errorf(`%s != ""`, o.String())
	}
}

func TestValidateDNSSearch(t *testing.T) {
	valid := []string{
		`.`,
		`a`,
		`a.`,
		`1.foo`,
		`17.foo`,
		`foo.bar`,
		`foo.bar.baz`,
		`foo.bar.`,
		`foo.bar.baz`,
		`foo1.bar2`,
		`foo1.bar2.baz`,
		`1foo.2bar.`,
		`1foo.2bar.baz`,
		`foo-1.bar-2`,
		`foo-1.bar-2.baz`,
		`foo-1.bar-2.`,
		`foo-1.bar-2.baz`,
		`1-foo.2-bar`,
		`1-foo.2-bar.baz`,
		`1-foo.2-bar.`,
		`1-foo.2-bar.baz`,
	}

	invalid := []string{
		``,
		` `,
		`  `,
		`17`,
		`17.`,
		`.17`,
		`17-.`,
		`17-.foo`,
		`.foo`,
		`foo-.bar`,
		`-foo.bar`,
		`foo.bar-`,
		`foo.bar-.baz`,
		`foo.-bar`,
		`foo.-bar.baz`,
		`foo.bar.baz.this.should.fail.on.long.name.because.it.is.longer.thanitshouldbethis.should.fail.on.long.name.because.it.is.longer.thanitshouldbethis.should.fail.on.long.name.because.it.is.longer.thanitshouldbethis.should.fail.on.long.name.because.it.is.longer.thanitshouldbe`,
	}

	for _, domain := range valid {
		if ret, err := ValidateDNSSearch(domain); err != nil || ret == "" {
			t.Fatalf("ValidateDNSSearch(`"+domain+"`) got %s %s", ret, err)
		}
	}

	for _, domain := range invalid {
		if ret, err := ValidateDNSSearch(domain); err == nil || ret != "" {
			t.Fatalf("ValidateDNSSearch(`"+domain+"`) got %s %s", ret, err)
		}
	}
}

func TestValidateLabel(t *testing.T) {
	testCases := []struct {
		name           string
		label          string
		expectedResult string
		expectedErr    string
	}{
		{
			name:        "lable with bad attribute format",
			label:       "label",
			expectedErr: "bad attribute format: label",
		},
		{
			name:           "label with general format",
			label:          "key1=value1",
			expectedResult: "key1=value1",
		},
		{
			name:           "label with more than one =",
			label:          "key1=value1=value2",
			expectedResult: "key1=value1=value2",
		},
		{
			name:           "label with one more",
			label:          "key1=value1=value2=value3",
			expectedResult: "key1=value1=value2=value3",
		},
		{
			name:           "label with no reserved com.docker.*",
			label:          "com.dockerpsychnotreserved.label=value",
			expectedResult: "com.dockerpsychnotreserved.label=value",
		},
		{
			name:           "label with no reserved io.docker.*",
			label:          "io.dockerproject.not=reserved",
			expectedResult: "io.dockerproject.not=reserved",
		},
		{
			name:           "label with no reserved org.dockerproject.*",
			label:          "org.docker.not=reserved",
			expectedResult: "org.docker.not=reserved",
		},
		{
			name:        "label with reserved com.docker.*",
			label:       "com.docker.feature=enabled",
			expectedErr: "label com.docker.feature=enabled is not allowed: the namespaces com.docker.*, io.docker.*, and org.dockerproject.* are reserved for internal use",
		},
		{
			name:        "label with reserved upcase com.docker.* ",
			label:       "COM.docker.feature=enabled",
			expectedErr: "label COM.docker.feature=enabled is not allowed: the namespaces com.docker.*, io.docker.*, and org.dockerproject.* are reserved for internal use",
		},
		{
			name:        "label with reserved io.docker.*",
			label:       "io.docker.configuration=0",
			expectedErr: "label io.docker.configuration=0 is not allowed: the namespaces com.docker.*, io.docker.*, and org.dockerproject.* are reserved for internal use",
		},
		{
			name:        "label with reserved upcase io.docker.*",
			label:       "io.DOCKER.CONFIGURATion=0",
			expectedErr: "label io.DOCKER.CONFIGURATion=0 is not allowed: the namespaces com.docker.*, io.docker.*, and org.dockerproject.* are reserved for internal use",
		},
		{
			name:        "label with reserved org.dockerproject.*",
			label:       "org.dockerproject.setting=on",
			expectedErr: "label org.dockerproject.setting=on is not allowed: the namespaces com.docker.*, io.docker.*, and org.dockerproject.* are reserved for internal use",
		},
		{
			name:        "label with reserved upcase org.dockerproject.*",
			label:       "Org.Dockerproject.Setting=on",
			expectedErr: "label Org.Dockerproject.Setting=on is not allowed: the namespaces com.docker.*, io.docker.*, and org.dockerproject.* are reserved for internal use",
		},
	}

	for _, testCase := range testCases {
		testCase := testCase
		t.Run(testCase.name, func(t *testing.T) {
			result, err := ValidateLabel(testCase.label)

			if testCase.expectedErr != "" {
				assert.Error(t, err, testCase.expectedErr)
			} else {
				assert.NilError(t, err)
			}
			if testCase.expectedResult != "" {
				assert.Check(t, is.Equal(result, testCase.expectedResult))
			}
		})
	}
}

func logOptsValidator(val string) (string, error) {
	allowedKeys := map[string]string{"max-size": "1", "max-file": "2"}
	vals := strings.Split(val, "=")
	if allowedKeys[vals[0]] != "" {
		return val, nil
	}
	return "", fmt.Errorf("invalid key %s", vals[0])
}

func TestNamedListOpts(t *testing.T) {
	var v []string
	o := NewNamedListOptsRef("foo-name", &v, nil)

	o.Set("foo")
	if o.String() != "[foo]" {
		t.Errorf("%s != [foo]", o.String())
	}
	if o.Name() != "foo-name" {
		t.Errorf("%s != foo-name", o.Name())
	}
	if len(v) != 1 {
		t.Errorf("expected foo to be in the values, got %v", v)
	}
}

func TestNamedMapOpts(t *testing.T) {
	tmpMap := make(map[string]string)
	o := NewNamedMapOpts("max-name", tmpMap, nil)

	o.Set("max-size=1")
	if o.String() != "map[max-size:1]" {
		t.Errorf("%s != [map[max-size:1]", o.String())
	}
	if o.Name() != "max-name" {
		t.Errorf("%s != max-name", o.Name())
	}
	if _, exist := tmpMap["max-size"]; !exist {
		t.Errorf("expected map-size to be in the values, got %v", tmpMap)
	}
}

func TestParseLink(t *testing.T) {
	t.Run("name and alias", func(t *testing.T) {
		name, alias, err := ParseLink("name:alias")
		assert.Check(t, err)
		assert.Check(t, is.Equal(name, "name"))
		assert.Check(t, is.Equal(alias, "alias"))
	})
	t.Run("short format", func(t *testing.T) {
		name, alias, err := ParseLink("name")
		assert.Check(t, err)
		assert.Check(t, is.Equal(name, "name"))
		assert.Check(t, is.Equal(alias, "name"))
	})
	t.Run("empty string", func(t *testing.T) {
		_, _, err := ParseLink("")
		assert.Check(t, is.Error(err, "empty string specified for links"))
	})
	t.Run("more than two colons", func(t *testing.T) {
		_, _, err := ParseLink("link:alias:wrong")
		assert.Check(t, is.Error(err, "bad format for links: link:alias:wrong"))
	})
	t.Run("legacy format", func(t *testing.T) {
		name, alias, err := ParseLink("/foo:/c1/bar")
		assert.Check(t, err)
		assert.Check(t, is.Equal(name, "foo"))
		assert.Check(t, is.Equal(alias, "bar"))
	})
}

func TestMapMapOpts(t *testing.T) {
	tmpMap := make(map[string]map[string]string)
	validator := func(val string) (string, error) {
		if strings.HasPrefix(val, "invalid-key=") {
			return "", fmt.Errorf("invalid key %s", val)
		}
		return val, nil
	}
	o := NewMapMapOpts(tmpMap, validator)
	o.Set("r1=k11=v11")
	assert.Check(t, is.DeepEqual(tmpMap, map[string]map[string]string{"r1": {"k11": "v11"}}))

	o.Set("r2=k21=v21")
	assert.Check(t, is.Len(tmpMap, 2))

	if err := o.Set("invalid-syntax"); err == nil {
		t.Error("invalid mapping syntax is not being caught")
	}

	if err := o.Set("k=invalid-syntax"); err == nil {
		t.Error("invalid value syntax is not being caught")
	}

	o.Set("r1=k12=v12")
	assert.Check(t, is.DeepEqual(tmpMap["r1"], map[string]string{"k11": "v11", "k12": "v12"}))

	if o.Set(`invalid-key={"k":"v"}`) == nil {
		t.Error("validator is not being called")
	}
}