gitee.com/mirrors_opencollective/goreleaser@v0.45.0/pipeline/fpm/fpm_test.go (about)

     1  package fpm
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"path/filepath"
     7  	"runtime"
     8  	"testing"
     9  
    10  	"github.com/goreleaser/goreleaser/config"
    11  	"github.com/goreleaser/goreleaser/context"
    12  	"github.com/goreleaser/goreleaser/internal/artifact"
    13  	"github.com/goreleaser/goreleaser/internal/testlib"
    14  	"github.com/stretchr/testify/assert"
    15  )
    16  
    17  func TestDescription(t *testing.T) {
    18  	assert.NotEmpty(t, Pipe{}.String())
    19  }
    20  
    21  func TestRunPipeNoFormats(t *testing.T) {
    22  	var ctx = &context.Context{
    23  		Version:     "1.0.0",
    24  		Config:      config.Project{},
    25  		Parallelism: runtime.NumCPU(),
    26  	}
    27  	testlib.AssertSkipped(t, Pipe{}.Run(ctx))
    28  }
    29  
    30  func TestRunPipe(t *testing.T) {
    31  	folder, err := ioutil.TempDir("", "archivetest")
    32  	assert.NoError(t, err)
    33  	var dist = filepath.Join(folder, "dist")
    34  	assert.NoError(t, os.Mkdir(dist, 0755))
    35  	assert.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755))
    36  	var binPath = filepath.Join(dist, "mybin", "mybin")
    37  	_, err = os.Create(binPath)
    38  	assert.NoError(t, err)
    39  	var ctx = context.New(config.Project{
    40  		ProjectName: "mybin",
    41  		Dist:        dist,
    42  		FPM: config.FPM{
    43  			NameTemplate: defaultNameTemplate,
    44  			Formats:      []string{"deb", "rpm"},
    45  			Dependencies: []string{"make"},
    46  			Conflicts:    []string{"git"},
    47  			Description:  "Some description",
    48  			License:      "MIT",
    49  			Maintainer:   "me@me",
    50  			Vendor:       "asdf",
    51  			Homepage:     "https://goreleaser.github.io",
    52  		},
    53  	})
    54  	ctx.Version = "1.0.0"
    55  	for _, goos := range []string{"linux", "darwin"} {
    56  		for _, goarch := range []string{"amd64", "386"} {
    57  			ctx.Artifacts.Add(artifact.Artifact{
    58  				Name:   "mybin",
    59  				Path:   binPath,
    60  				Goarch: goarch,
    61  				Goos:   goos,
    62  				Type:   artifact.Binary,
    63  			})
    64  		}
    65  	}
    66  	assert.NoError(t, Pipe{}.Run(ctx))
    67  }
    68  
    69  func TestNoFPMInPath(t *testing.T) {
    70  	var path = os.Getenv("PATH")
    71  	defer func() {
    72  		assert.NoError(t, os.Setenv("PATH", path))
    73  	}()
    74  	assert.NoError(t, os.Setenv("PATH", ""))
    75  	var ctx = &context.Context{
    76  		Version:     "1.0.0",
    77  		Parallelism: runtime.NumCPU(),
    78  		Config: config.Project{
    79  			FPM: config.FPM{
    80  				Formats: []string{"deb", "rpm"},
    81  			},
    82  		},
    83  	}
    84  	assert.EqualError(t, Pipe{}.Run(ctx), ErrNoFPM.Error())
    85  }
    86  
    87  func TestInvalidNameTemplate(t *testing.T) {
    88  	var ctx = &context.Context{
    89  		Parallelism: runtime.NumCPU(),
    90  		Artifacts:   artifact.New(),
    91  		Config: config.Project{
    92  			FPM: config.FPM{
    93  				NameTemplate: "{{.Foo}",
    94  				Formats:      []string{"deb"},
    95  			},
    96  		},
    97  	}
    98  	ctx.Artifacts.Add(artifact.Artifact{
    99  		Name:   "mybin",
   100  		Goos:   "linux",
   101  		Goarch: "amd64",
   102  		Type:   artifact.Binary,
   103  	})
   104  	assert.Contains(t, Pipe{}.Run(ctx).Error(), `template: {{.Foo}:1: unexpected "}" in operand`)
   105  }
   106  
   107  func TestCreateFileDoesntExist(t *testing.T) {
   108  	folder, err := ioutil.TempDir("", "archivetest")
   109  	assert.NoError(t, err)
   110  	var dist = filepath.Join(folder, "dist")
   111  	assert.NoError(t, os.Mkdir(dist, 0755))
   112  	assert.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755))
   113  	var ctx = context.New(config.Project{
   114  		Dist: dist,
   115  		FPM: config.FPM{
   116  			Formats: []string{"deb", "rpm"},
   117  			Files: map[string]string{
   118  				"testdata/testfile.txt": "/var/lib/test/testfile.txt",
   119  			},
   120  		},
   121  	})
   122  	ctx.Version = "1.0.0"
   123  	ctx.Artifacts.Add(artifact.Artifact{
   124  		Name:   "mybin",
   125  		Path:   filepath.Join(dist, "mybin", "mybin"),
   126  		Goos:   "linux",
   127  		Goarch: "amd64",
   128  		Type:   artifact.Binary,
   129  	})
   130  	assert.Contains(t, Pipe{}.Run(ctx).Error(), `dist/mybin/mybin', does it exist?`)
   131  }
   132  
   133  func TestCmd(t *testing.T) {
   134  	cmd := cmd(context.New(config.Project{}), []string{"--help"})
   135  	assert.NotEmpty(t, cmd.Env)
   136  	assert.Contains(t, cmd.Env[0], gnuTarPath)
   137  }
   138  
   139  func TestDefault(t *testing.T) {
   140  	var ctx = &context.Context{
   141  		Config: config.Project{
   142  			FPM: config.FPM{},
   143  		},
   144  	}
   145  	assert.NoError(t, Pipe{}.Default(ctx))
   146  	assert.Equal(t, "/usr/local/bin", ctx.Config.FPM.Bindir)
   147  	assert.Equal(t, defaultNameTemplate, ctx.Config.FPM.NameTemplate)
   148  }
   149  
   150  func TestDefaultSet(t *testing.T) {
   151  	var ctx = &context.Context{
   152  		Config: config.Project{
   153  			FPM: config.FPM{
   154  				Bindir:       "/bin",
   155  				NameTemplate: "foo",
   156  			},
   157  		},
   158  	}
   159  	assert.NoError(t, Pipe{}.Default(ctx))
   160  	assert.Equal(t, "/bin", ctx.Config.FPM.Bindir)
   161  	assert.Equal(t, "foo", ctx.Config.FPM.NameTemplate)
   162  }