github.com/kim0/docker@v0.6.2-0.20161130212042-4addda3f07e7/daemon/config_test.go (about) 1 package daemon 2 3 import ( 4 "io/ioutil" 5 "os" 6 "strings" 7 "testing" 8 9 "github.com/docker/docker/opts" 10 "github.com/docker/docker/pkg/testutil/assert" 11 "github.com/spf13/pflag" 12 ) 13 14 func TestDaemonConfigurationNotFound(t *testing.T) { 15 _, err := MergeDaemonConfigurations(&Config{}, nil, "/tmp/foo-bar-baz-docker") 16 if err == nil || !os.IsNotExist(err) { 17 t.Fatalf("expected does not exist error, got %v", err) 18 } 19 } 20 21 func TestDaemonBrokenConfiguration(t *testing.T) { 22 f, err := ioutil.TempFile("", "docker-config-") 23 if err != nil { 24 t.Fatal(err) 25 } 26 27 configFile := f.Name() 28 f.Write([]byte(`{"Debug": tru`)) 29 f.Close() 30 31 _, err = MergeDaemonConfigurations(&Config{}, nil, configFile) 32 if err == nil { 33 t.Fatalf("expected error, got %v", err) 34 } 35 } 36 37 func TestParseClusterAdvertiseSettings(t *testing.T) { 38 _, err := parseClusterAdvertiseSettings("something", "") 39 if err != errDiscoveryDisabled { 40 t.Fatalf("expected discovery disabled error, got %v\n", err) 41 } 42 43 _, err = parseClusterAdvertiseSettings("", "something") 44 if err == nil { 45 t.Fatalf("expected discovery store error, got %v\n", err) 46 } 47 48 _, err = parseClusterAdvertiseSettings("etcd", "127.0.0.1:8080") 49 if err != nil { 50 t.Fatal(err) 51 } 52 } 53 54 func TestFindConfigurationConflicts(t *testing.T) { 55 config := map[string]interface{}{"authorization-plugins": "foobar"} 56 flags := pflag.NewFlagSet("test", pflag.ContinueOnError) 57 58 flags.String("authorization-plugins", "", "") 59 assert.NilError(t, flags.Set("authorization-plugins", "asdf")) 60 61 assert.Error(t, 62 findConfigurationConflicts(config, flags), 63 "authorization-plugins: (from flag: asdf, from file: foobar)") 64 } 65 66 func TestFindConfigurationConflictsWithNamedOptions(t *testing.T) { 67 config := map[string]interface{}{"hosts": []string{"qwer"}} 68 flags := pflag.NewFlagSet("test", pflag.ContinueOnError) 69 70 var hosts []string 71 flags.VarP(opts.NewNamedListOptsRef("hosts", &hosts, opts.ValidateHost), "host", "H", "Daemon socket(s) to connect to") 72 assert.NilError(t, flags.Set("host", "tcp://127.0.0.1:4444")) 73 assert.NilError(t, flags.Set("host", "unix:///var/run/docker.sock")) 74 75 assert.Error(t, findConfigurationConflicts(config, flags), "hosts") 76 } 77 78 func TestDaemonConfigurationMergeConflicts(t *testing.T) { 79 f, err := ioutil.TempFile("", "docker-config-") 80 if err != nil { 81 t.Fatal(err) 82 } 83 84 configFile := f.Name() 85 f.Write([]byte(`{"debug": true}`)) 86 f.Close() 87 88 flags := pflag.NewFlagSet("test", pflag.ContinueOnError) 89 flags.Bool("debug", false, "") 90 flags.Set("debug", "false") 91 92 _, err = MergeDaemonConfigurations(&Config{}, flags, configFile) 93 if err == nil { 94 t.Fatal("expected error, got nil") 95 } 96 if !strings.Contains(err.Error(), "debug") { 97 t.Fatalf("expected debug conflict, got %v", err) 98 } 99 } 100 101 func TestDaemonConfigurationMergeConflictsWithInnerStructs(t *testing.T) { 102 f, err := ioutil.TempFile("", "docker-config-") 103 if err != nil { 104 t.Fatal(err) 105 } 106 107 configFile := f.Name() 108 f.Write([]byte(`{"tlscacert": "/etc/certificates/ca.pem"}`)) 109 f.Close() 110 111 flags := pflag.NewFlagSet("test", pflag.ContinueOnError) 112 flags.String("tlscacert", "", "") 113 flags.Set("tlscacert", "~/.docker/ca.pem") 114 115 _, err = MergeDaemonConfigurations(&Config{}, flags, configFile) 116 if err == nil { 117 t.Fatal("expected error, got nil") 118 } 119 if !strings.Contains(err.Error(), "tlscacert") { 120 t.Fatalf("expected tlscacert conflict, got %v", err) 121 } 122 } 123 124 func TestFindConfigurationConflictsWithUnknownKeys(t *testing.T) { 125 config := map[string]interface{}{"tls-verify": "true"} 126 flags := pflag.NewFlagSet("test", pflag.ContinueOnError) 127 128 flags.Bool("tlsverify", false, "") 129 err := findConfigurationConflicts(config, flags) 130 if err == nil { 131 t.Fatal("expected error, got nil") 132 } 133 if !strings.Contains(err.Error(), "the following directives don't match any configuration option: tls-verify") { 134 t.Fatalf("expected tls-verify conflict, got %v", err) 135 } 136 } 137 138 func TestFindConfigurationConflictsWithMergedValues(t *testing.T) { 139 var hosts []string 140 config := map[string]interface{}{"hosts": "tcp://127.0.0.1:2345"} 141 flags := pflag.NewFlagSet("base", pflag.ContinueOnError) 142 flags.VarP(opts.NewNamedListOptsRef("hosts", &hosts, nil), "host", "H", "") 143 144 err := findConfigurationConflicts(config, flags) 145 if err != nil { 146 t.Fatal(err) 147 } 148 149 flags.Set("host", "unix:///var/run/docker.sock") 150 err = findConfigurationConflicts(config, flags) 151 if err == nil { 152 t.Fatal("expected error, got nil") 153 } 154 if !strings.Contains(err.Error(), "hosts: (from flag: [unix:///var/run/docker.sock], from file: tcp://127.0.0.1:2345)") { 155 t.Fatalf("expected hosts conflict, got %v", err) 156 } 157 } 158 159 func TestValidateConfiguration(t *testing.T) { 160 c1 := &Config{ 161 CommonConfig: CommonConfig{ 162 Labels: []string{"one"}, 163 }, 164 } 165 166 err := ValidateConfiguration(c1) 167 if err == nil { 168 t.Fatal("expected error, got nil") 169 } 170 171 c2 := &Config{ 172 CommonConfig: CommonConfig{ 173 Labels: []string{"one=two"}, 174 }, 175 } 176 177 err = ValidateConfiguration(c2) 178 if err != nil { 179 t.Fatalf("expected no error, got error %v", err) 180 } 181 182 c3 := &Config{ 183 CommonConfig: CommonConfig{ 184 DNS: []string{"1.1.1.1"}, 185 }, 186 } 187 188 err = ValidateConfiguration(c3) 189 if err != nil { 190 t.Fatalf("expected no error, got error %v", err) 191 } 192 193 c4 := &Config{ 194 CommonConfig: CommonConfig{ 195 DNS: []string{"1.1.1.1o"}, 196 }, 197 } 198 199 err = ValidateConfiguration(c4) 200 if err == nil { 201 t.Fatal("expected error, got nil") 202 } 203 204 c5 := &Config{ 205 CommonConfig: CommonConfig{ 206 DNSSearch: []string{"a.b.c"}, 207 }, 208 } 209 210 err = ValidateConfiguration(c5) 211 if err != nil { 212 t.Fatalf("expected no error, got error %v", err) 213 } 214 215 c6 := &Config{ 216 CommonConfig: CommonConfig{ 217 DNSSearch: []string{"123456"}, 218 }, 219 } 220 221 err = ValidateConfiguration(c6) 222 if err == nil { 223 t.Fatal("expected error, got nil") 224 } 225 }