github.com/ttysteale/packer@v0.8.2-0.20150708160520-e5f8ea386ed8/common/download_test.go (about) 1 package common 2 3 import ( 4 "crypto/md5" 5 "encoding/hex" 6 "io/ioutil" 7 "net/http" 8 "net/http/httptest" 9 "os" 10 "testing" 11 ) 12 13 func TestDownloadClientVerifyChecksum(t *testing.T) { 14 tf, err := ioutil.TempFile("", "packer") 15 if err != nil { 16 t.Fatalf("tempfile error: %s", err) 17 } 18 defer os.Remove(tf.Name()) 19 20 // "foo" 21 checksum, err := hex.DecodeString("acbd18db4cc2f85cedef654fccc4a4d8") 22 if err != nil { 23 t.Fatalf("decode err: %s", err) 24 } 25 26 // Write the file 27 tf.Write([]byte("foo")) 28 tf.Close() 29 30 config := &DownloadConfig{ 31 Hash: md5.New(), 32 Checksum: checksum, 33 } 34 35 d := NewDownloadClient(config) 36 result, err := d.VerifyChecksum(tf.Name()) 37 if err != nil { 38 t.Fatalf("Verify err: %s", err) 39 } 40 41 if !result { 42 t.Fatal("didn't verify") 43 } 44 } 45 46 func TestDownloadClient_basic(t *testing.T) { 47 tf, _ := ioutil.TempFile("", "packer") 48 tf.Close() 49 os.Remove(tf.Name()) 50 51 ts := httptest.NewServer(http.FileServer(http.Dir("./test-fixtures/root"))) 52 defer ts.Close() 53 54 client := NewDownloadClient(&DownloadConfig{ 55 Url: ts.URL + "/basic.txt", 56 TargetPath: tf.Name(), 57 }) 58 path, err := client.Get() 59 if err != nil { 60 t.Fatalf("err: %s", err) 61 } 62 63 raw, err := ioutil.ReadFile(path) 64 if err != nil { 65 t.Fatalf("err: %s", err) 66 } 67 68 if string(raw) != "hello\n" { 69 t.Fatalf("bad: %s", string(raw)) 70 } 71 } 72 73 func TestDownloadClient_checksumBad(t *testing.T) { 74 checksum, err := hex.DecodeString("b2946ac92492d2347c6235b4d2611184") 75 if err != nil { 76 t.Fatalf("err: %s", err) 77 } 78 79 tf, _ := ioutil.TempFile("", "packer") 80 tf.Close() 81 os.Remove(tf.Name()) 82 83 ts := httptest.NewServer(http.FileServer(http.Dir("./test-fixtures/root"))) 84 defer ts.Close() 85 86 client := NewDownloadClient(&DownloadConfig{ 87 Url: ts.URL + "/basic.txt", 88 TargetPath: tf.Name(), 89 Hash: HashForType("md5"), 90 Checksum: checksum, 91 }) 92 if _, err := client.Get(); err == nil { 93 t.Fatal("should error") 94 } 95 } 96 97 func TestDownloadClient_checksumGood(t *testing.T) { 98 checksum, err := hex.DecodeString("b1946ac92492d2347c6235b4d2611184") 99 if err != nil { 100 t.Fatalf("err: %s", err) 101 } 102 103 tf, _ := ioutil.TempFile("", "packer") 104 tf.Close() 105 os.Remove(tf.Name()) 106 107 ts := httptest.NewServer(http.FileServer(http.Dir("./test-fixtures/root"))) 108 defer ts.Close() 109 110 client := NewDownloadClient(&DownloadConfig{ 111 Url: ts.URL + "/basic.txt", 112 TargetPath: tf.Name(), 113 Hash: HashForType("md5"), 114 Checksum: checksum, 115 }) 116 path, err := client.Get() 117 if err != nil { 118 t.Fatalf("err: %s", err) 119 } 120 121 raw, err := ioutil.ReadFile(path) 122 if err != nil { 123 t.Fatalf("err: %s", err) 124 } 125 126 if string(raw) != "hello\n" { 127 t.Fatalf("bad: %s", string(raw)) 128 } 129 } 130 131 func TestDownloadClient_checksumNoDownload(t *testing.T) { 132 checksum, err := hex.DecodeString("3740570a423feec44c2a759225a9fcf9") 133 if err != nil { 134 t.Fatalf("err: %s", err) 135 } 136 137 ts := httptest.NewServer(http.FileServer(http.Dir("./test-fixtures/root"))) 138 defer ts.Close() 139 140 client := NewDownloadClient(&DownloadConfig{ 141 Url: ts.URL + "/basic.txt", 142 TargetPath: "./test-fixtures/root/another.txt", 143 Hash: HashForType("md5"), 144 Checksum: checksum, 145 }) 146 path, err := client.Get() 147 if err != nil { 148 t.Fatalf("err: %s", err) 149 } 150 151 raw, err := ioutil.ReadFile(path) 152 if err != nil { 153 t.Fatalf("err: %s", err) 154 } 155 156 // If this says "hello" it means we downloaded it. We faked out 157 // the downloader above by giving it the checksum for "another", but 158 // requested the download of "hello" 159 if string(raw) != "another\n" { 160 t.Fatalf("bad: %s", string(raw)) 161 } 162 } 163 164 func TestDownloadClient_resume(t *testing.T) { 165 tf, _ := ioutil.TempFile("", "packer") 166 tf.Write([]byte("w")) 167 tf.Close() 168 169 ts := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) { 170 if r.Method == "HEAD" { 171 rw.Header().Set("Accept-Ranges", "bytes") 172 rw.WriteHeader(204) 173 return 174 } 175 176 http.ServeFile(rw, r, "./test-fixtures/root/basic.txt") 177 })) 178 defer ts.Close() 179 180 client := NewDownloadClient(&DownloadConfig{ 181 Url: ts.URL, 182 TargetPath: tf.Name(), 183 }) 184 path, err := client.Get() 185 if err != nil { 186 t.Fatalf("err: %s", err) 187 } 188 189 raw, err := ioutil.ReadFile(path) 190 if err != nil { 191 t.Fatalf("err: %s", err) 192 } 193 194 if string(raw) != "wello\n" { 195 t.Fatalf("bad: %s", string(raw)) 196 } 197 } 198 199 func TestDownloadClient_usesDefaultUserAgent(t *testing.T) { 200 tf, err := ioutil.TempFile("", "packer") 201 if err != nil { 202 t.Fatalf("tempfile error: %s", err) 203 } 204 defer os.Remove(tf.Name()) 205 206 defaultUserAgent := "" 207 asserted := false 208 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 209 if defaultUserAgent == "" { 210 defaultUserAgent = r.UserAgent() 211 } else { 212 incomingUserAgent := r.UserAgent() 213 if incomingUserAgent != defaultUserAgent { 214 t.Fatalf("Expected user agent %s, got: %s", defaultUserAgent, incomingUserAgent) 215 } 216 217 asserted = true 218 } 219 })) 220 221 req, err := http.NewRequest("GET", server.URL, nil) 222 if err != nil { 223 t.Fatal(err) 224 } 225 226 httpClient := &http.Client{ 227 Transport: &http.Transport{ 228 Proxy: http.ProxyFromEnvironment, 229 }, 230 } 231 232 _, err = httpClient.Do(req) 233 if err != nil { 234 t.Fatal(err) 235 } 236 237 config := &DownloadConfig{ 238 Url: server.URL, 239 TargetPath: tf.Name(), 240 } 241 242 client := NewDownloadClient(config) 243 _, err = client.Get() 244 if err != nil { 245 t.Fatal(err) 246 } 247 248 if !asserted { 249 t.Fatal("User-Agent never observed") 250 } 251 } 252 253 func TestDownloadClient_setsUserAgent(t *testing.T) { 254 tf, err := ioutil.TempFile("", "packer") 255 if err != nil { 256 t.Fatalf("tempfile error: %s", err) 257 } 258 defer os.Remove(tf.Name()) 259 260 asserted := false 261 server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { 262 asserted = true 263 if r.UserAgent() != "fancy user agent" { 264 t.Fatalf("Expected useragent fancy user agent, got: %s", r.UserAgent()) 265 } 266 })) 267 config := &DownloadConfig{ 268 Url: server.URL, 269 TargetPath: tf.Name(), 270 UserAgent: "fancy user agent", 271 } 272 273 client := NewDownloadClient(config) 274 _, err = client.Get() 275 if err != nil { 276 t.Fatal(err) 277 } 278 279 if !asserted { 280 t.Fatal("HTTP request never made") 281 } 282 } 283 284 func TestHashForType(t *testing.T) { 285 if h := HashForType("md5"); h == nil { 286 t.Fatalf("md5 hash is nil") 287 } else { 288 h.Write([]byte("foo")) 289 result := h.Sum(nil) 290 291 expected := "acbd18db4cc2f85cedef654fccc4a4d8" 292 actual := hex.EncodeToString(result) 293 if actual != expected { 294 t.Fatalf("bad hash: %s", actual) 295 } 296 } 297 298 if h := HashForType("sha1"); h == nil { 299 t.Fatalf("sha1 hash is nil") 300 } else { 301 h.Write([]byte("foo")) 302 result := h.Sum(nil) 303 304 expected := "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33" 305 actual := hex.EncodeToString(result) 306 if actual != expected { 307 t.Fatalf("bad hash: %s", actual) 308 } 309 } 310 311 if h := HashForType("sha256"); h == nil { 312 t.Fatalf("sha256 hash is nil") 313 } else { 314 h.Write([]byte("foo")) 315 result := h.Sum(nil) 316 317 expected := "2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae" 318 actual := hex.EncodeToString(result) 319 if actual != expected { 320 t.Fatalf("bad hash: %s", actual) 321 } 322 } 323 324 if h := HashForType("sha512"); h == nil { 325 t.Fatalf("sha512 hash is nil") 326 } else { 327 h.Write([]byte("foo")) 328 result := h.Sum(nil) 329 330 expected := "f7fbba6e0636f890e56fbbf3283e524c6fa3204ae298382d624741d0dc6638326e282c41be5e4254d8820772c5518a2c5a8c0c7f7eda19594a7eb539453e1ed7" 331 actual := hex.EncodeToString(result) 332 if actual != expected { 333 t.Fatalf("bad hash: %s", actual) 334 } 335 } 336 337 if HashForType("fake") != nil { 338 t.Fatalf("fake hash is not nil") 339 } 340 }