github.com/szyn/goreleaser@v0.76.1-0.20180517112710-333da09a1297/pipeline/archive/archive_test.go (about) 1 package archive 2 3 import ( 4 "archive/tar" 5 "compress/gzip" 6 "io" 7 "os" 8 "path/filepath" 9 "testing" 10 11 "github.com/goreleaser/goreleaser/config" 12 "github.com/goreleaser/goreleaser/context" 13 "github.com/goreleaser/goreleaser/internal/artifact" 14 "github.com/goreleaser/goreleaser/internal/testlib" 15 "github.com/stretchr/testify/assert" 16 ) 17 18 func TestDescription(t *testing.T) { 19 assert.NotEmpty(t, Pipe{}.String()) 20 } 21 22 func TestRunPipe(t *testing.T) { 23 folder, back := testlib.Mktmp(t) 24 defer back() 25 var dist = filepath.Join(folder, "dist") 26 assert.NoError(t, os.Mkdir(dist, 0755)) 27 assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) 28 assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) 29 _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) 30 assert.NoError(t, err) 31 _, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) 32 assert.NoError(t, err) 33 _, err = os.Create(filepath.Join(folder, "README.md")) 34 assert.NoError(t, err) 35 for _, format := range []string{"tar.gz", "zip"} { 36 t.Run("Archive format "+format, func(tt *testing.T) { 37 var ctx = context.New( 38 config.Project{ 39 Dist: dist, 40 ProjectName: "foobar", 41 Archive: config.Archive{ 42 NameTemplate: defaultNameTemplate, 43 Files: []string{ 44 "README.*", 45 }, 46 FormatOverrides: []config.FormatOverride{ 47 { 48 Goos: "windows", 49 Format: "zip", 50 }, 51 }, 52 }, 53 }, 54 ) 55 ctx.Artifacts.Add(artifact.Artifact{ 56 Goos: "darwin", 57 Goarch: "amd64", 58 Name: "mybin", 59 Path: filepath.Join(dist, "darwinamd64", "mybin"), 60 Type: artifact.Binary, 61 Extra: map[string]string{ 62 "Binary": "mybin", 63 }, 64 }) 65 ctx.Artifacts.Add(artifact.Artifact{ 66 Goos: "windows", 67 Goarch: "amd64", 68 Name: "mybin.exe", 69 Path: filepath.Join(dist, "windowsamd64", "mybin.exe"), 70 Type: artifact.Binary, 71 Extra: map[string]string{ 72 "Binary": "mybin", 73 "Extension": ".exe", 74 }, 75 }) 76 ctx.Version = "0.0.1" 77 ctx.Config.Archive.Format = format 78 assert.NoError(tt, Pipe{}.Run(ctx)) 79 var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)) 80 darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0] 81 windows := archives.Filter(artifact.ByGoos("windows")).List()[0] 82 assert.Equal(tt, "foobar_0.0.1_darwin_amd64."+format, darwin.Name) 83 assert.Equal(tt, "foobar_0.0.1_windows_amd64.zip", windows.Name) 84 assert.Len(tt, archives.List(), 2) 85 }) 86 } 87 88 // Check archive contents 89 f, err := os.Open(filepath.Join(dist, "foobar_0.0.1_darwin_amd64.tar.gz")) 90 assert.NoError(t, err) 91 defer func() { assert.NoError(t, f.Close()) }() 92 gr, err := gzip.NewReader(f) 93 assert.NoError(t, err) 94 defer func() { assert.NoError(t, gr.Close()) }() 95 r := tar.NewReader(gr) 96 for _, n := range []string{"README.md", "mybin"} { 97 h, err := r.Next() 98 if err == io.EOF { 99 break 100 } 101 assert.NoError(t, err) 102 assert.Equal(t, n, h.Name) 103 } 104 } 105 106 func TestRunPipeBinary(t *testing.T) { 107 folder, back := testlib.Mktmp(t) 108 defer back() 109 var dist = filepath.Join(folder, "dist") 110 assert.NoError(t, os.Mkdir(dist, 0755)) 111 assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) 112 assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) 113 _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) 114 assert.NoError(t, err) 115 _, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) 116 assert.NoError(t, err) 117 _, err = os.Create(filepath.Join(folder, "README.md")) 118 assert.NoError(t, err) 119 var ctx = context.New( 120 config.Project{ 121 Dist: dist, 122 Archive: config.Archive{ 123 Format: "binary", 124 NameTemplate: defaultBinaryNameTemplate, 125 }, 126 }, 127 ) 128 ctx.Version = "0.0.1" 129 ctx.Artifacts.Add(artifact.Artifact{ 130 Goos: "darwin", 131 Goarch: "amd64", 132 Name: "mybin", 133 Path: filepath.Join(dist, "darwinamd64", "mybin"), 134 Type: artifact.Binary, 135 Extra: map[string]string{ 136 "Binary": "mybin", 137 }, 138 }) 139 ctx.Artifacts.Add(artifact.Artifact{ 140 Goos: "windows", 141 Goarch: "amd64", 142 Name: "mybin.exe", 143 Path: filepath.Join(dist, "windowsamd64", "mybin.exe"), 144 Type: artifact.Binary, 145 Extra: map[string]string{ 146 "Binary": "mybin", 147 "Ext": ".exe", 148 }, 149 }) 150 assert.NoError(t, Pipe{}.Run(ctx)) 151 var binaries = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary)) 152 darwin := binaries.Filter(artifact.ByGoos("darwin")).List()[0] 153 windows := binaries.Filter(artifact.ByGoos("windows")).List()[0] 154 assert.Equal(t, "mybin_0.0.1_darwin_amd64", darwin.Name) 155 assert.Equal(t, "mybin_0.0.1_windows_amd64.exe", windows.Name) 156 assert.Len(t, binaries.List(), 2) 157 } 158 159 func TestRunPipeDistRemoved(t *testing.T) { 160 var ctx = context.New( 161 config.Project{ 162 Dist: "/path/nope", 163 Archive: config.Archive{ 164 NameTemplate: "nope", 165 Format: "zip", 166 }, 167 }, 168 ) 169 ctx.Artifacts.Add(artifact.Artifact{ 170 Goos: "windows", 171 Goarch: "amd64", 172 Name: "mybin.exe", 173 Path: filepath.Join("/path/to/nope", "windowsamd64", "mybin.exe"), 174 Type: artifact.Binary, 175 Extra: map[string]string{ 176 "Binary": "mybin", 177 "Extension": ".exe", 178 }, 179 }) 180 assert.EqualError(t, Pipe{}.Run(ctx), `failed to create directory /path/nope/nope.zip: open /path/nope/nope.zip: no such file or directory`) 181 } 182 183 func TestRunPipeInvalidGlob(t *testing.T) { 184 folder, back := testlib.Mktmp(t) 185 defer back() 186 var dist = filepath.Join(folder, "dist") 187 assert.NoError(t, os.Mkdir(dist, 0755)) 188 assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) 189 _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) 190 assert.NoError(t, err) 191 var ctx = context.New( 192 config.Project{ 193 Dist: dist, 194 Archive: config.Archive{ 195 NameTemplate: "foo", 196 Format: "zip", 197 Files: []string{ 198 "[x-]", 199 }, 200 }, 201 }, 202 ) 203 ctx.Artifacts.Add(artifact.Artifact{ 204 Goos: "darwin", 205 Goarch: "amd64", 206 Name: "mybin", 207 Path: filepath.Join("dist", "darwinamd64", "mybin"), 208 Type: artifact.Binary, 209 Extra: map[string]string{ 210 "Binary": "mybin", 211 }, 212 }) 213 assert.EqualError(t, Pipe{}.Run(ctx), `failed to find files to archive: globbing failed for pattern [x-]: file does not exist`) 214 } 215 216 func TestRunPipeWrap(t *testing.T) { 217 folder, back := testlib.Mktmp(t) 218 defer back() 219 var dist = filepath.Join(folder, "dist") 220 assert.NoError(t, os.Mkdir(dist, 0755)) 221 assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) 222 _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) 223 assert.NoError(t, err) 224 _, err = os.Create(filepath.Join(folder, "README.md")) 225 assert.NoError(t, err) 226 var ctx = context.New( 227 config.Project{ 228 Dist: dist, 229 Archive: config.Archive{ 230 NameTemplate: "foo", 231 WrapInDirectory: true, 232 Format: "tar.gz", 233 Files: []string{ 234 "README.*", 235 }, 236 }, 237 }, 238 ) 239 ctx.Artifacts.Add(artifact.Artifact{ 240 Goos: "darwin", 241 Goarch: "amd64", 242 Name: "mybin", 243 Path: filepath.Join("dist", "darwinamd64", "mybin"), 244 Type: artifact.Binary, 245 Extra: map[string]string{ 246 "Binary": "mybin", 247 }, 248 }) 249 assert.NoError(t, Pipe{}.Run(ctx)) 250 251 // Check archive contents 252 f, err := os.Open(filepath.Join(dist, "foo.tar.gz")) 253 assert.NoError(t, err) 254 defer func() { assert.NoError(t, f.Close()) }() 255 gr, err := gzip.NewReader(f) 256 assert.NoError(t, err) 257 defer func() { assert.NoError(t, gr.Close()) }() 258 r := tar.NewReader(gr) 259 for _, n := range []string{"README.md", "mybin"} { 260 h, err := r.Next() 261 if err == io.EOF { 262 break 263 } 264 assert.NoError(t, err) 265 assert.Equal(t, filepath.Join("foo", n), h.Name) 266 } 267 } 268 269 func TestDefault(t *testing.T) { 270 var ctx = &context.Context{ 271 Config: config.Project{ 272 Archive: config.Archive{}, 273 }, 274 } 275 assert.NoError(t, Pipe{}.Default(ctx)) 276 assert.NotEmpty(t, ctx.Config.Archive.NameTemplate) 277 assert.Equal(t, "tar.gz", ctx.Config.Archive.Format) 278 assert.NotEmpty(t, ctx.Config.Archive.Files) 279 } 280 281 func TestDefaultSet(t *testing.T) { 282 var ctx = &context.Context{ 283 Config: config.Project{ 284 Archive: config.Archive{ 285 NameTemplate: "foo", 286 Format: "zip", 287 Files: []string{ 288 "foo", 289 }, 290 }, 291 }, 292 } 293 assert.NoError(t, Pipe{}.Default(ctx)) 294 assert.Equal(t, "foo", ctx.Config.Archive.NameTemplate) 295 assert.Equal(t, "zip", ctx.Config.Archive.Format) 296 assert.Equal(t, "foo", ctx.Config.Archive.Files[0]) 297 } 298 299 func TestDefaultFormatBinary(t *testing.T) { 300 var ctx = &context.Context{ 301 Config: config.Project{ 302 Archive: config.Archive{ 303 Format: "binary", 304 }, 305 }, 306 } 307 assert.NoError(t, Pipe{}.Default(ctx)) 308 assert.Equal(t, defaultBinaryNameTemplate, ctx.Config.Archive.NameTemplate) 309 } 310 311 func TestFormatFor(t *testing.T) { 312 var ctx = &context.Context{ 313 Config: config.Project{ 314 Archive: config.Archive{ 315 Format: "tar.gz", 316 FormatOverrides: []config.FormatOverride{ 317 { 318 Goos: "windows", 319 Format: "zip", 320 }, 321 }, 322 }, 323 }, 324 } 325 assert.Equal(t, "zip", packageFormat(ctx, "windows")) 326 assert.Equal(t, "tar.gz", packageFormat(ctx, "linux")) 327 } 328 329 func TestBinaryOverride(t *testing.T) { 330 folder, back := testlib.Mktmp(t) 331 defer back() 332 var dist = filepath.Join(folder, "dist") 333 assert.NoError(t, os.Mkdir(dist, 0755)) 334 assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) 335 assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) 336 _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) 337 assert.NoError(t, err) 338 _, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) 339 assert.NoError(t, err) 340 _, err = os.Create(filepath.Join(folder, "README.md")) 341 assert.NoError(t, err) 342 for _, format := range []string{"tar.gz", "zip"} { 343 t.Run("Archive format "+format, func(tt *testing.T) { 344 var ctx = context.New( 345 config.Project{ 346 Dist: dist, 347 ProjectName: "foobar", 348 Archive: config.Archive{ 349 NameTemplate: defaultNameTemplate, 350 Files: []string{ 351 "README.*", 352 }, 353 FormatOverrides: []config.FormatOverride{ 354 { 355 Goos: "windows", 356 Format: "binary", 357 }, 358 }, 359 }, 360 }, 361 ) 362 ctx.Artifacts.Add(artifact.Artifact{ 363 Goos: "darwin", 364 Goarch: "amd64", 365 Name: "mybin", 366 Path: filepath.Join(dist, "darwinamd64", "mybin"), 367 Type: artifact.Binary, 368 Extra: map[string]string{ 369 "Binary": "mybin", 370 }, 371 }) 372 ctx.Artifacts.Add(artifact.Artifact{ 373 Goos: "windows", 374 Goarch: "amd64", 375 Name: "mybin.exe", 376 Path: filepath.Join(dist, "windowsamd64", "mybin.exe"), 377 Type: artifact.Binary, 378 Extra: map[string]string{ 379 "Binary": "mybin", 380 "Ext": ".exe", 381 }, 382 }) 383 ctx.Version = "0.0.1" 384 ctx.Config.Archive.Format = format 385 386 assert.NoError(tt, Pipe{}.Run(ctx)) 387 var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)) 388 darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0] 389 assert.Equal(tt, "foobar_0.0.1_darwin_amd64."+format, darwin.Name) 390 391 archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary)) 392 windows := archives.Filter(artifact.ByGoos("windows")).List()[0] 393 assert.Equal(tt, "foobar_0.0.1_windows_amd64.exe", windows.Name) 394 395 }) 396 } 397 }