github.com/nalind/docker@v1.5.0/engine/env_test.go (about) 1 package engine 2 3 import ( 4 "bytes" 5 "encoding/json" 6 "testing" 7 8 "github.com/docker/docker/pkg/testutils" 9 ) 10 11 func TestEnvLenZero(t *testing.T) { 12 env := &Env{} 13 if env.Len() != 0 { 14 t.Fatalf("%d", env.Len()) 15 } 16 } 17 18 func TestEnvLenNotZero(t *testing.T) { 19 env := &Env{} 20 env.Set("foo", "bar") 21 env.Set("ga", "bu") 22 if env.Len() != 2 { 23 t.Fatalf("%d", env.Len()) 24 } 25 } 26 27 func TestEnvLenDup(t *testing.T) { 28 env := &Env{ 29 "foo=bar", 30 "foo=baz", 31 "a=b", 32 } 33 // len(env) != env.Len() 34 if env.Len() != 2 { 35 t.Fatalf("%d", env.Len()) 36 } 37 } 38 39 func TestEnvGetDup(t *testing.T) { 40 env := &Env{ 41 "foo=bar", 42 "foo=baz", 43 "foo=bif", 44 } 45 expected := "bif" 46 if v := env.Get("foo"); v != expected { 47 t.Fatalf("expect %q, got %q", expected, v) 48 } 49 } 50 51 func TestNewJob(t *testing.T) { 52 job := mkJob(t, "dummy", "--level=awesome") 53 if job.Name != "dummy" { 54 t.Fatalf("Wrong job name: %s", job.Name) 55 } 56 if len(job.Args) != 1 { 57 t.Fatalf("Wrong number of job arguments: %d", len(job.Args)) 58 } 59 if job.Args[0] != "--level=awesome" { 60 t.Fatalf("Wrong job arguments: %s", job.Args[0]) 61 } 62 } 63 64 func TestSetenv(t *testing.T) { 65 job := mkJob(t, "dummy") 66 job.Setenv("foo", "bar") 67 if val := job.Getenv("foo"); val != "bar" { 68 t.Fatalf("Getenv returns incorrect value: %s", val) 69 } 70 71 job.Setenv("bar", "") 72 if val := job.Getenv("bar"); val != "" { 73 t.Fatalf("Getenv returns incorrect value: %s", val) 74 } 75 if val := job.Getenv("nonexistent"); val != "" { 76 t.Fatalf("Getenv returns incorrect value: %s", val) 77 } 78 } 79 80 func TestSetenvBool(t *testing.T) { 81 job := mkJob(t, "dummy") 82 job.SetenvBool("foo", true) 83 if val := job.GetenvBool("foo"); !val { 84 t.Fatalf("GetenvBool returns incorrect value: %t", val) 85 } 86 87 job.SetenvBool("bar", false) 88 if val := job.GetenvBool("bar"); val { 89 t.Fatalf("GetenvBool returns incorrect value: %t", val) 90 } 91 92 if val := job.GetenvBool("nonexistent"); val { 93 t.Fatalf("GetenvBool returns incorrect value: %t", val) 94 } 95 } 96 97 func TestSetenvInt(t *testing.T) { 98 job := mkJob(t, "dummy") 99 100 job.SetenvInt("foo", -42) 101 if val := job.GetenvInt("foo"); val != -42 { 102 t.Fatalf("GetenvInt returns incorrect value: %d", val) 103 } 104 105 job.SetenvInt("bar", 42) 106 if val := job.GetenvInt("bar"); val != 42 { 107 t.Fatalf("GetenvInt returns incorrect value: %d", val) 108 } 109 if val := job.GetenvInt("nonexistent"); val != 0 { 110 t.Fatalf("GetenvInt returns incorrect value: %d", val) 111 } 112 } 113 114 func TestSetenvList(t *testing.T) { 115 job := mkJob(t, "dummy") 116 117 job.SetenvList("foo", []string{"bar"}) 118 if val := job.GetenvList("foo"); len(val) != 1 || val[0] != "bar" { 119 t.Fatalf("GetenvList returns incorrect value: %v", val) 120 } 121 122 job.SetenvList("bar", nil) 123 if val := job.GetenvList("bar"); val != nil { 124 t.Fatalf("GetenvList returns incorrect value: %v", val) 125 } 126 if val := job.GetenvList("nonexistent"); val != nil { 127 t.Fatalf("GetenvList returns incorrect value: %v", val) 128 } 129 } 130 131 func TestEnviron(t *testing.T) { 132 job := mkJob(t, "dummy") 133 job.Setenv("foo", "bar") 134 val, exists := job.Environ()["foo"] 135 if !exists { 136 t.Fatalf("foo not found in the environ") 137 } 138 if val != "bar" { 139 t.Fatalf("bar not found in the environ") 140 } 141 } 142 143 func TestMultiMap(t *testing.T) { 144 e := &Env{} 145 e.Set("foo", "bar") 146 e.Set("bar", "baz") 147 e.Set("hello", "world") 148 m := e.MultiMap() 149 e2 := &Env{} 150 e2.Set("old_key", "something something something") 151 e2.InitMultiMap(m) 152 if v := e2.Get("old_key"); v != "" { 153 t.Fatalf("%#v", v) 154 } 155 if v := e2.Get("bar"); v != "baz" { 156 t.Fatalf("%#v", v) 157 } 158 if v := e2.Get("hello"); v != "world" { 159 t.Fatalf("%#v", v) 160 } 161 } 162 163 func testMap(l int) [][2]string { 164 res := make([][2]string, l) 165 for i := 0; i < l; i++ { 166 t := [2]string{testutils.RandomString(5), testutils.RandomString(20)} 167 res[i] = t 168 } 169 return res 170 } 171 172 func BenchmarkSet(b *testing.B) { 173 fix := testMap(100) 174 b.ResetTimer() 175 for i := 0; i < b.N; i++ { 176 env := &Env{} 177 for _, kv := range fix { 178 env.Set(kv[0], kv[1]) 179 } 180 } 181 } 182 183 func BenchmarkSetJson(b *testing.B) { 184 fix := testMap(100) 185 type X struct { 186 f string 187 } 188 b.ResetTimer() 189 for i := 0; i < b.N; i++ { 190 env := &Env{} 191 for _, kv := range fix { 192 if err := env.SetJson(kv[0], X{kv[1]}); err != nil { 193 b.Fatal(err) 194 } 195 } 196 } 197 } 198 199 func BenchmarkGet(b *testing.B) { 200 fix := testMap(100) 201 env := &Env{} 202 for _, kv := range fix { 203 env.Set(kv[0], kv[1]) 204 } 205 b.ResetTimer() 206 for i := 0; i < b.N; i++ { 207 for _, kv := range fix { 208 env.Get(kv[0]) 209 } 210 } 211 } 212 213 func BenchmarkGetJson(b *testing.B) { 214 fix := testMap(100) 215 env := &Env{} 216 type X struct { 217 f string 218 } 219 for _, kv := range fix { 220 env.SetJson(kv[0], X{kv[1]}) 221 } 222 b.ResetTimer() 223 for i := 0; i < b.N; i++ { 224 for _, kv := range fix { 225 if err := env.GetJson(kv[0], &X{}); err != nil { 226 b.Fatal(err) 227 } 228 } 229 } 230 } 231 232 func BenchmarkEncode(b *testing.B) { 233 fix := testMap(100) 234 env := &Env{} 235 type X struct { 236 f string 237 } 238 // half a json 239 for i, kv := range fix { 240 if i%2 != 0 { 241 if err := env.SetJson(kv[0], X{kv[1]}); err != nil { 242 b.Fatal(err) 243 } 244 continue 245 } 246 env.Set(kv[0], kv[1]) 247 } 248 var writer bytes.Buffer 249 b.ResetTimer() 250 for i := 0; i < b.N; i++ { 251 env.Encode(&writer) 252 writer.Reset() 253 } 254 } 255 256 func BenchmarkDecode(b *testing.B) { 257 fix := testMap(100) 258 env := &Env{} 259 type X struct { 260 f string 261 } 262 // half a json 263 for i, kv := range fix { 264 if i%2 != 0 { 265 if err := env.SetJson(kv[0], X{kv[1]}); err != nil { 266 b.Fatal(err) 267 } 268 continue 269 } 270 env.Set(kv[0], kv[1]) 271 } 272 var writer bytes.Buffer 273 env.Encode(&writer) 274 denv := &Env{} 275 reader := bytes.NewReader(writer.Bytes()) 276 b.ResetTimer() 277 for i := 0; i < b.N; i++ { 278 err := denv.Decode(reader) 279 if err != nil { 280 b.Fatal(err) 281 } 282 reader.Seek(0, 0) 283 } 284 } 285 286 func TestLongNumbers(t *testing.T) { 287 type T struct { 288 TestNum int64 289 } 290 v := T{67108864} 291 var buf bytes.Buffer 292 e := &Env{} 293 e.SetJson("Test", v) 294 if err := e.Encode(&buf); err != nil { 295 t.Fatal(err) 296 } 297 res := make(map[string]T) 298 if err := json.Unmarshal(buf.Bytes(), &res); err != nil { 299 t.Fatal(err) 300 } 301 if res["Test"].TestNum != v.TestNum { 302 t.Fatalf("TestNum %d, expected %d", res["Test"].TestNum, v.TestNum) 303 } 304 } 305 306 func TestLongNumbersArray(t *testing.T) { 307 type T struct { 308 TestNum []int64 309 } 310 v := T{[]int64{67108864}} 311 var buf bytes.Buffer 312 e := &Env{} 313 e.SetJson("Test", v) 314 if err := e.Encode(&buf); err != nil { 315 t.Fatal(err) 316 } 317 res := make(map[string]T) 318 if err := json.Unmarshal(buf.Bytes(), &res); err != nil { 319 t.Fatal(err) 320 } 321 if res["Test"].TestNum[0] != v.TestNum[0] { 322 t.Fatalf("TestNum %d, expected %d", res["Test"].TestNum, v.TestNum) 323 } 324 }