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  }