github.com/remind101/go-getter@v0.0.0-20180809191950-4bda8fa99001/get_test.go (about) 1 package getter 2 3 import ( 4 "os" 5 "path/filepath" 6 "strings" 7 "testing" 8 ) 9 10 func TestGet_badSchema(t *testing.T) { 11 dst := tempDir(t) 12 u := testModule("basic") 13 u = strings.Replace(u, "file", "nope", -1) 14 15 if err := Get(dst, u); err == nil { 16 t.Fatal("should error") 17 } 18 } 19 20 func TestGet_file(t *testing.T) { 21 dst := tempDir(t) 22 u := testModule("basic") 23 24 if err := Get(dst, u); err != nil { 25 t.Fatalf("err: %s", err) 26 } 27 28 mainPath := filepath.Join(dst, "main.tf") 29 if _, err := os.Stat(mainPath); err != nil { 30 t.Fatalf("err: %s", err) 31 } 32 } 33 34 // https://github.com/hashicorp/terraform/issues/11438 35 func TestGet_fileDecompressorExt(t *testing.T) { 36 dst := tempDir(t) 37 u := testModule("basic-tgz") 38 39 if err := Get(dst, u); err != nil { 40 t.Fatalf("err: %s", err) 41 } 42 43 mainPath := filepath.Join(dst, "main.tf") 44 if _, err := os.Stat(mainPath); err != nil { 45 t.Fatalf("err: %s", err) 46 } 47 } 48 49 // https://github.com/hashicorp/terraform/issues/8418 50 func TestGet_filePercent2F(t *testing.T) { 51 dst := tempDir(t) 52 u := testModule("basic%2Ftest") 53 54 if err := Get(dst, u); err != nil { 55 t.Fatalf("err: %s", err) 56 } 57 58 mainPath := filepath.Join(dst, "main.tf") 59 if _, err := os.Stat(mainPath); err != nil { 60 t.Fatalf("err: %s", err) 61 } 62 } 63 64 func TestGet_fileDetect(t *testing.T) { 65 dst := tempDir(t) 66 u := filepath.Join("./test-fixtures", "basic") 67 pwd, err := os.Getwd() 68 if err != nil { 69 t.Fatalf("err: %s", err) 70 } 71 72 client := &Client{ 73 Src: u, 74 Dst: dst, 75 Pwd: pwd, 76 Dir: true, 77 } 78 79 if err := client.Get(); err != nil { 80 t.Fatalf("err: %s", err) 81 } 82 83 mainPath := filepath.Join(dst, "main.tf") 84 if _, err := os.Stat(mainPath); err != nil { 85 t.Fatalf("err: %s", err) 86 } 87 } 88 89 func TestGet_fileForced(t *testing.T) { 90 dst := tempDir(t) 91 u := testModule("basic") 92 u = "file::" + u 93 94 if err := Get(dst, u); err != nil { 95 t.Fatalf("err: %s", err) 96 } 97 98 mainPath := filepath.Join(dst, "main.tf") 99 if _, err := os.Stat(mainPath); err != nil { 100 t.Fatalf("err: %s", err) 101 } 102 } 103 104 func TestGet_fileSubdir(t *testing.T) { 105 dst := tempDir(t) 106 u := testModule("basic//subdir") 107 108 if err := Get(dst, u); err != nil { 109 t.Fatalf("err: %s", err) 110 } 111 112 mainPath := filepath.Join(dst, "sub.tf") 113 if _, err := os.Stat(mainPath); err != nil { 114 t.Fatalf("err: %s", err) 115 } 116 } 117 118 func TestGet_archive(t *testing.T) { 119 dst := tempDir(t) 120 u := filepath.Join("./test-fixtures", "archive.tar.gz") 121 u, _ = filepath.Abs(u) 122 123 if err := Get(dst, u); err != nil { 124 t.Fatalf("err: %s", err) 125 } 126 127 mainPath := filepath.Join(dst, "main.tf") 128 if _, err := os.Stat(mainPath); err != nil { 129 t.Fatalf("err: %s", err) 130 } 131 } 132 133 func TestGetAny_archive(t *testing.T) { 134 dst := tempDir(t) 135 u := filepath.Join("./test-fixtures", "archive.tar.gz") 136 u, _ = filepath.Abs(u) 137 138 if err := GetAny(dst, u); err != nil { 139 t.Fatalf("err: %s", err) 140 } 141 142 mainPath := filepath.Join(dst, "main.tf") 143 if _, err := os.Stat(mainPath); err != nil { 144 t.Fatalf("err: %s", err) 145 } 146 } 147 148 func TestGet_archiveRooted(t *testing.T) { 149 dst := tempDir(t) 150 u := testModule("archive-rooted/archive.tar.gz") 151 if err := Get(dst, u); err != nil { 152 t.Fatalf("err: %s", err) 153 } 154 155 mainPath := filepath.Join(dst, "root", "hello.txt") 156 if _, err := os.Stat(mainPath); err != nil { 157 t.Fatalf("err: %s", err) 158 } 159 } 160 161 func TestGet_archiveSubdirWild(t *testing.T) { 162 dst := tempDir(t) 163 u := testModule("archive-rooted/archive.tar.gz") 164 u += "//*" 165 if err := Get(dst, u); err != nil { 166 t.Fatalf("err: %s", err) 167 } 168 169 mainPath := filepath.Join(dst, "hello.txt") 170 if _, err := os.Stat(mainPath); err != nil { 171 t.Fatalf("err: %s", err) 172 } 173 } 174 175 func TestGet_archiveSubdirWildMultiMatch(t *testing.T) { 176 dst := tempDir(t) 177 u := testModule("archive-rooted-multi/archive.tar.gz") 178 u += "//*" 179 if err := Get(dst, u); err == nil { 180 t.Fatal("should error") 181 } else if !strings.Contains(err.Error(), "multiple") { 182 t.Fatalf("err: %s", err) 183 } 184 } 185 186 func TestGetAny_file(t *testing.T) { 187 dst := tempDir(t) 188 u := testModule("basic-file/foo.txt") 189 190 if err := GetAny(dst, u); err != nil { 191 t.Fatalf("err: %s", err) 192 } 193 194 mainPath := filepath.Join(dst, "foo.txt") 195 if _, err := os.Stat(mainPath); err != nil { 196 t.Fatalf("err: %s", err) 197 } 198 } 199 200 func TestGetAny_dir(t *testing.T) { 201 dst := tempDir(t) 202 u := filepath.Join("./test-fixtures", "basic") 203 u, _ = filepath.Abs(u) 204 205 if err := GetAny(dst, u); err != nil { 206 t.Fatalf("err: %s", err) 207 } 208 209 check := []string{ 210 "main.tf", 211 "foo/main.tf", 212 } 213 214 for _, name := range check { 215 mainPath := filepath.Join(dst, name) 216 if _, err := os.Stat(mainPath); err != nil { 217 t.Fatalf("err: %s", err) 218 } 219 } 220 } 221 222 func TestGetFile(t *testing.T) { 223 dst := tempFile(t) 224 u := testModule("basic-file/foo.txt") 225 226 if err := GetFile(dst, u); err != nil { 227 t.Fatalf("err: %s", err) 228 } 229 230 // Verify the main file exists 231 assertContents(t, dst, "Hello\n") 232 } 233 234 func TestGetFile_archive(t *testing.T) { 235 dst := tempFile(t) 236 u := testModule("basic-file-archive/archive.tar.gz") 237 238 if err := GetFile(dst, u); err != nil { 239 t.Fatalf("err: %s", err) 240 } 241 242 // Verify the main file exists 243 assertContents(t, dst, "Hello\n") 244 } 245 246 func TestGetFile_archiveChecksum(t *testing.T) { 247 dst := tempFile(t) 248 u := testModule( 249 "basic-file-archive/archive.tar.gz?checksum=md5:fbd90037dacc4b1ab40811d610dde2f0") 250 251 if err := GetFile(dst, u); err != nil { 252 t.Fatalf("err: %s", err) 253 } 254 255 // Verify the main file exists 256 assertContents(t, dst, "Hello\n") 257 } 258 259 func TestGetFile_archiveNoUnarchive(t *testing.T) { 260 dst := tempFile(t) 261 u := testModule("basic-file-archive/archive.tar.gz") 262 u += "?archive=false" 263 264 if err := GetFile(dst, u); err != nil { 265 t.Fatalf("err: %s", err) 266 } 267 268 // Verify the main file exists 269 actual := testMD5(t, dst) 270 expected := "fbd90037dacc4b1ab40811d610dde2f0" 271 if actual != expected { 272 t.Fatalf("bad: %s", actual) 273 } 274 } 275 276 func TestGetFile_checksum(t *testing.T) { 277 cases := []struct { 278 Append string 279 Err bool 280 }{ 281 { 282 "", 283 false, 284 }, 285 286 // MD5 287 { 288 "?checksum=md5:09f7e02f1290be211da707a266f153b3", 289 false, 290 }, 291 { 292 "?checksum=md5:09f7e02f1290be211da707a266f153b4", 293 true, 294 }, 295 296 // SHA1 297 { 298 "?checksum=sha1:1d229271928d3f9e2bb0375bd6ce5db6c6d348d9", 299 false, 300 }, 301 { 302 "?checksum=sha1:1d229271928d3f9e2bb0375bd6ce5db6c6d348d0", 303 true, 304 }, 305 306 // SHA256 307 { 308 "?checksum=sha256:66a045b452102c59d840ec097d59d9467e13a3f34f6494e539ffd32c1bb35f18", 309 false, 310 }, 311 { 312 "?checksum=sha256:66a045b452102c59d840ec097d59d9467e13a3f34f6494e539ffd32c1bb35f19", 313 true, 314 }, 315 316 // SHA512 317 { 318 "?checksum=sha512:c2bad2223811194582af4d1508ac02cd69eeeeedeeb98d54fcae4dcefb13cc882e7640328206603d3fb9cd5f949a9be0db054dd34fbfa190c498a5fe09750cef", 319 false, 320 }, 321 { 322 "?checksum=sha512:c2bad2223811194582af4d1508ac02cd69eeeeedeeb98d54fcae4dcefb13cc882e7640328206603d3fb9cd5f949a9be0db054dd34fbfa190c498a5fe09750ced", 323 true, 324 }, 325 } 326 327 for _, tc := range cases { 328 u := testModule("basic-file/foo.txt") + tc.Append 329 330 func() { 331 dst := tempFile(t) 332 defer os.Remove(dst) 333 if err := GetFile(dst, u); (err != nil) != tc.Err { 334 t.Fatalf("append: %s\n\nerr: %s", tc.Append, err) 335 } 336 337 // Verify the main file exists 338 assertContents(t, dst, "Hello\n") 339 }() 340 } 341 } 342 343 func TestGetFile_checksumURL(t *testing.T) { 344 dst := tempFile(t) 345 u := testModule("basic-file/foo.txt") + "?checksum=md5:09f7e02f1290be211da707a266f153b3" 346 347 getter := &MockGetter{Proxy: new(FileGetter)} 348 client := &Client{ 349 Src: u, 350 Dst: dst, 351 Dir: false, 352 Getters: map[string]Getter{ 353 "file": getter, 354 }, 355 } 356 357 if err := client.Get(); err != nil { 358 t.Fatalf("err: %s", err) 359 } 360 361 if v := getter.GetFileURL.Query().Get("checksum"); v != "" { 362 t.Fatalf("bad: %s", v) 363 } 364 } 365 366 func TestGetFile_filename(t *testing.T) { 367 dst := tempDir(t) 368 u := testModule("basic-file/foo.txt") 369 370 u += "?filename=bar.txt" 371 372 if err := GetAny(dst, u); err != nil { 373 t.Fatalf("err: %s", err) 374 } 375 376 mainPath := filepath.Join(dst, "bar.txt") 377 if _, err := os.Stat(mainPath); err != nil { 378 t.Fatalf("err: %s", err) 379 } 380 }