github.com/dinever/docker@v1.11.1/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/mflag" 11 ) 12 13 func TestDaemonConfigurationMerge(t *testing.T) { 14 f, err := ioutil.TempFile("", "docker-config-") 15 if err != nil { 16 t.Fatal(err) 17 } 18 19 configFile := f.Name() 20 f.Write([]byte(`{"debug": true}`)) 21 f.Close() 22 23 c := &Config{ 24 CommonConfig: CommonConfig{ 25 AutoRestart: true, 26 LogConfig: LogConfig{ 27 Type: "syslog", 28 Config: map[string]string{"tag": "test"}, 29 }, 30 }, 31 } 32 33 cc, err := MergeDaemonConfigurations(c, nil, configFile) 34 if err != nil { 35 t.Fatal(err) 36 } 37 if !cc.Debug { 38 t.Fatalf("expected %v, got %v\n", true, cc.Debug) 39 } 40 if !cc.AutoRestart { 41 t.Fatalf("expected %v, got %v\n", true, cc.AutoRestart) 42 } 43 if cc.LogConfig.Type != "syslog" { 44 t.Fatalf("expected syslog config, got %q\n", cc.LogConfig) 45 } 46 } 47 48 func TestDaemonConfigurationNotFound(t *testing.T) { 49 _, err := MergeDaemonConfigurations(&Config{}, nil, "/tmp/foo-bar-baz-docker") 50 if err == nil || !os.IsNotExist(err) { 51 t.Fatalf("expected does not exist error, got %v", err) 52 } 53 } 54 55 func TestDaemonBrokenConfiguration(t *testing.T) { 56 f, err := ioutil.TempFile("", "docker-config-") 57 if err != nil { 58 t.Fatal(err) 59 } 60 61 configFile := f.Name() 62 f.Write([]byte(`{"Debug": tru`)) 63 f.Close() 64 65 _, err = MergeDaemonConfigurations(&Config{}, nil, configFile) 66 if err == nil { 67 t.Fatalf("expected error, got %v", err) 68 } 69 } 70 71 func TestParseClusterAdvertiseSettings(t *testing.T) { 72 _, err := parseClusterAdvertiseSettings("something", "") 73 if err != errDiscoveryDisabled { 74 t.Fatalf("expected discovery disabled error, got %v\n", err) 75 } 76 77 _, err = parseClusterAdvertiseSettings("", "something") 78 if err == nil { 79 t.Fatalf("expected discovery store error, got %v\n", err) 80 } 81 82 _, err = parseClusterAdvertiseSettings("etcd", "127.0.0.1:8080") 83 if err != nil { 84 t.Fatal(err) 85 } 86 } 87 88 func TestFindConfigurationConflicts(t *testing.T) { 89 config := map[string]interface{}{"authorization-plugins": "foobar"} 90 flags := mflag.NewFlagSet("test", mflag.ContinueOnError) 91 92 flags.String([]string{"-authorization-plugins"}, "", "") 93 if err := flags.Set("-authorization-plugins", "asdf"); err != nil { 94 t.Fatal(err) 95 } 96 97 err := findConfigurationConflicts(config, flags) 98 if err == nil { 99 t.Fatal("expected error, got nil") 100 } 101 if !strings.Contains(err.Error(), "authorization-plugins: (from flag: asdf, from file: foobar)") { 102 t.Fatalf("expected authorization-plugins conflict, got %v", err) 103 } 104 } 105 106 func TestFindConfigurationConflictsWithNamedOptions(t *testing.T) { 107 config := map[string]interface{}{"hosts": []string{"qwer"}} 108 flags := mflag.NewFlagSet("test", mflag.ContinueOnError) 109 110 var hosts []string 111 flags.Var(opts.NewNamedListOptsRef("hosts", &hosts, opts.ValidateHost), []string{"H", "-host"}, "Daemon socket(s) to connect to") 112 if err := flags.Set("-host", "tcp://127.0.0.1:4444"); err != nil { 113 t.Fatal(err) 114 } 115 if err := flags.Set("H", "unix:///var/run/docker.sock"); err != nil { 116 t.Fatal(err) 117 } 118 119 err := findConfigurationConflicts(config, flags) 120 if err == nil { 121 t.Fatal("expected error, got nil") 122 } 123 if !strings.Contains(err.Error(), "hosts") { 124 t.Fatalf("expected hosts conflict, got %v", err) 125 } 126 } 127 128 func TestDaemonConfigurationMergeConflicts(t *testing.T) { 129 f, err := ioutil.TempFile("", "docker-config-") 130 if err != nil { 131 t.Fatal(err) 132 } 133 134 configFile := f.Name() 135 f.Write([]byte(`{"debug": true}`)) 136 f.Close() 137 138 flags := mflag.NewFlagSet("test", mflag.ContinueOnError) 139 flags.Bool([]string{"debug"}, false, "") 140 flags.Set("debug", "false") 141 142 _, err = MergeDaemonConfigurations(&Config{}, flags, configFile) 143 if err == nil { 144 t.Fatal("expected error, got nil") 145 } 146 if !strings.Contains(err.Error(), "debug") { 147 t.Fatalf("expected debug conflict, got %v", err) 148 } 149 } 150 151 func TestDaemonConfigurationMergeConflictsWithInnerStructs(t *testing.T) { 152 f, err := ioutil.TempFile("", "docker-config-") 153 if err != nil { 154 t.Fatal(err) 155 } 156 157 configFile := f.Name() 158 f.Write([]byte(`{"tlscacert": "/etc/certificates/ca.pem"}`)) 159 f.Close() 160 161 flags := mflag.NewFlagSet("test", mflag.ContinueOnError) 162 flags.String([]string{"tlscacert"}, "", "") 163 flags.Set("tlscacert", "~/.docker/ca.pem") 164 165 _, err = MergeDaemonConfigurations(&Config{}, flags, configFile) 166 if err == nil { 167 t.Fatal("expected error, got nil") 168 } 169 if !strings.Contains(err.Error(), "tlscacert") { 170 t.Fatalf("expected tlscacert conflict, got %v", err) 171 } 172 } 173 174 func TestFindConfigurationConflictsWithUnknownKeys(t *testing.T) { 175 config := map[string]interface{}{"tls-verify": "true"} 176 flags := mflag.NewFlagSet("test", mflag.ContinueOnError) 177 178 flags.Bool([]string{"-tlsverify"}, false, "") 179 err := findConfigurationConflicts(config, flags) 180 if err == nil { 181 t.Fatal("expected error, got nil") 182 } 183 if !strings.Contains(err.Error(), "the following directives don't match any configuration option: tls-verify") { 184 t.Fatalf("expected tls-verify conflict, got %v", err) 185 } 186 } 187 188 func TestFindConfigurationConflictsWithMergedValues(t *testing.T) { 189 var hosts []string 190 config := map[string]interface{}{"hosts": "tcp://127.0.0.1:2345"} 191 base := mflag.NewFlagSet("base", mflag.ContinueOnError) 192 base.Var(opts.NewNamedListOptsRef("hosts", &hosts, nil), []string{"H", "-host"}, "") 193 194 flags := mflag.NewFlagSet("test", mflag.ContinueOnError) 195 mflag.Merge(flags, base) 196 197 err := findConfigurationConflicts(config, flags) 198 if err != nil { 199 t.Fatal(err) 200 } 201 202 flags.Set("-host", "unix:///var/run/docker.sock") 203 err = findConfigurationConflicts(config, flags) 204 if err == nil { 205 t.Fatal("expected error, got nil") 206 } 207 if !strings.Contains(err.Error(), "hosts: (from flag: [unix:///var/run/docker.sock], from file: tcp://127.0.0.1:2345)") { 208 t.Fatalf("expected hosts conflict, got %v", err) 209 } 210 } 211 212 func TestValidateConfiguration(t *testing.T) { 213 c1 := &Config{ 214 CommonConfig: CommonConfig{ 215 Labels: []string{"one"}, 216 }, 217 } 218 219 err := validateConfiguration(c1) 220 if err == nil { 221 t.Fatal("expected error, got nil") 222 } 223 224 c2 := &Config{ 225 CommonConfig: CommonConfig{ 226 Labels: []string{"one=two"}, 227 }, 228 } 229 230 err = validateConfiguration(c2) 231 if err != nil { 232 t.Fatalf("expected no error, got error %v", err) 233 } 234 235 c3 := &Config{ 236 CommonConfig: CommonConfig{ 237 DNS: []string{"1.1.1.1"}, 238 }, 239 } 240 241 err = validateConfiguration(c3) 242 if err != nil { 243 t.Fatalf("expected no error, got error %v", err) 244 } 245 246 c4 := &Config{ 247 CommonConfig: CommonConfig{ 248 DNS: []string{"1.1.1.1o"}, 249 }, 250 } 251 252 err = validateConfiguration(c4) 253 if err == nil { 254 t.Fatal("expected error, got nil") 255 } 256 257 c5 := &Config{ 258 CommonConfig: CommonConfig{ 259 DNSSearch: []string{"a.b.c"}, 260 }, 261 } 262 263 err = validateConfiguration(c5) 264 if err != nil { 265 t.Fatalf("expected no error, got error %v", err) 266 } 267 268 c6 := &Config{ 269 CommonConfig: CommonConfig{ 270 DNSSearch: []string{"123456"}, 271 }, 272 } 273 274 err = validateConfiguration(c6) 275 if err == nil { 276 t.Fatal("expected error, got nil") 277 } 278 }