github.com/marianogappa/goreleaser@v0.26.2-0.20170715090149-96acd0a9fc46/pipeline/build/build_test.go (about)

     1  package build
     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/buildtarget"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  var emptyEnv []string
    17  
    18  func TestPipeDescription(t *testing.T) {
    19  	assert.NotEmpty(t, Pipe{}.Description())
    20  }
    21  
    22  func TestRun(t *testing.T) {
    23  	assert.NoError(t, run(buildtarget.Runtime, []string{"go", "list", "./..."}, emptyEnv))
    24  }
    25  
    26  func TestRunInvalidCommand(t *testing.T) {
    27  	assert.Error(t, run(buildtarget.Runtime, []string{"gggggo", "nope"}, emptyEnv))
    28  }
    29  
    30  func TestBuild(t *testing.T) {
    31  	assert := assert.New(t)
    32  	var config = config.Project{
    33  		Builds: []config.Build{
    34  			{
    35  				Binary: "testing",
    36  				Flags:  "-n",
    37  				Env:    []string{"BLAH=1"},
    38  			},
    39  		},
    40  	}
    41  	var ctx = &context.Context{
    42  		Config:  config,
    43  		Folders: map[string]string{},
    44  	}
    45  	assert.NoError(doBuild(ctx, ctx.Config.Builds[0], buildtarget.Runtime))
    46  }
    47  
    48  func TestRunFullPipe(t *testing.T) {
    49  	assert := assert.New(t)
    50  	folder, err := ioutil.TempDir("", "goreleasertest")
    51  	assert.NoError(err)
    52  	var binary = filepath.Join(folder, "testing")
    53  	var pre = filepath.Join(folder, "pre")
    54  	var post = filepath.Join(folder, "post")
    55  	var config = config.Project{
    56  		Dist: folder,
    57  		Builds: []config.Build{
    58  			{
    59  				Binary:  "testing",
    60  				Flags:   "-v",
    61  				Ldflags: "-X main.test=testing",
    62  				Hooks: config.Hooks{
    63  					Pre:  "touch " + pre,
    64  					Post: "touch " + post,
    65  				},
    66  				Goos: []string{
    67  					runtime.GOOS,
    68  				},
    69  				Goarch: []string{
    70  					runtime.GOARCH,
    71  				},
    72  			},
    73  		},
    74  	}
    75  	var ctx = &context.Context{
    76  		Config:  config,
    77  		Folders: map[string]string{},
    78  	}
    79  	assert.NoError(Pipe{}.Run(ctx))
    80  	assert.True(exists(binary), binary)
    81  	assert.True(exists(pre), pre)
    82  	assert.True(exists(post), post)
    83  }
    84  
    85  func TestRunPipeFormatBinary(t *testing.T) {
    86  	assert := assert.New(t)
    87  	folder, err := ioutil.TempDir("", "goreleasertest")
    88  	assert.NoError(err)
    89  	var binary = filepath.Join(folder, "binary-testing")
    90  	var config = config.Project{
    91  		ProjectName: "testing",
    92  		Dist:        folder,
    93  		Builds: []config.Build{
    94  			{
    95  				Binary: "testing",
    96  				Goos: []string{
    97  					runtime.GOOS,
    98  				},
    99  				Goarch: []string{
   100  					runtime.GOARCH,
   101  				},
   102  			},
   103  		},
   104  		Archive: config.Archive{
   105  			Format:       "binary",
   106  			NameTemplate: "binary-{{.Binary}}",
   107  		},
   108  	}
   109  	var ctx = &context.Context{
   110  		Config:  config,
   111  		Folders: map[string]string{},
   112  	}
   113  	assert.NoError(Pipe{}.Run(ctx))
   114  	assert.True(exists(binary))
   115  }
   116  
   117  func TestRunPipeArmBuilds(t *testing.T) {
   118  	assert := assert.New(t)
   119  	folder, err := ioutil.TempDir("", "goreleasertest")
   120  	assert.NoError(err)
   121  	var binary = filepath.Join(folder, "armtesting")
   122  	var config = config.Project{
   123  		Dist: folder,
   124  		Builds: []config.Build{
   125  			{
   126  				Binary:  "armtesting",
   127  				Flags:   "-v",
   128  				Ldflags: "-X main.test=armtesting",
   129  				Goos: []string{
   130  					"linux",
   131  				},
   132  				Goarch: []string{
   133  					"arm",
   134  					"arm64",
   135  				},
   136  				Goarm: []string{
   137  					"6",
   138  				},
   139  			},
   140  		},
   141  	}
   142  	var ctx = &context.Context{
   143  		Config:  config,
   144  		Folders: map[string]string{},
   145  	}
   146  	assert.NoError(Pipe{}.Run(ctx))
   147  	assert.True(exists(binary), binary)
   148  }
   149  
   150  func TestBuildFailed(t *testing.T) {
   151  	assert := assert.New(t)
   152  	var config = config.Project{
   153  		Builds: []config.Build{
   154  			{
   155  				Flags: "-flag-that-dont-exists-to-force-failure",
   156  				Goos: []string{
   157  					runtime.GOOS,
   158  				},
   159  				Goarch: []string{
   160  					runtime.GOARCH,
   161  				},
   162  			},
   163  		},
   164  	}
   165  	var ctx = &context.Context{
   166  		Config:  config,
   167  		Folders: map[string]string{},
   168  	}
   169  	assert.Error(Pipe{}.Run(ctx))
   170  }
   171  
   172  func TestRunPipeWithInvalidOS(t *testing.T) {
   173  	assert := assert.New(t)
   174  	var config = config.Project{
   175  		Builds: []config.Build{
   176  			{
   177  				Flags: "-v",
   178  				Goos: []string{
   179  					"windows",
   180  				},
   181  				Goarch: []string{
   182  					"arm",
   183  				},
   184  			},
   185  		},
   186  	}
   187  	var ctx = &context.Context{
   188  		Config:  config,
   189  		Folders: map[string]string{},
   190  	}
   191  	assert.NoError(Pipe{}.Run(ctx))
   192  }
   193  
   194  func TestRunInvalidNametemplate(t *testing.T) {
   195  	var assert = assert.New(t)
   196  	for _, format := range []string{"tar.gz", "zip", "binary"} {
   197  		var ctx = &context.Context{
   198  			Config: config.Project{
   199  				ProjectName: "nameeeee",
   200  				Builds: []config.Build{
   201  					{
   202  						Binary: "namet{{.est}",
   203  						Flags:  "-v",
   204  						Goos: []string{
   205  							runtime.GOOS,
   206  						},
   207  						Goarch: []string{
   208  							runtime.GOARCH,
   209  						},
   210  					},
   211  				},
   212  				Archive: config.Archive{
   213  					Format:       format,
   214  					NameTemplate: "{{.Binary}",
   215  				},
   216  			},
   217  		}
   218  		assert.Error(Pipe{}.Run(ctx))
   219  	}
   220  }
   221  
   222  func TestRunInvalidLdflags(t *testing.T) {
   223  	var assert = assert.New(t)
   224  	var ctx = &context.Context{
   225  		Folders: map[string]string{},
   226  		Config: config.Project{
   227  			Builds: []config.Build{
   228  				{
   229  					Binary:  "nametest",
   230  					Flags:   "-v",
   231  					Ldflags: "-s -w -X main.version={{.Version}",
   232  					Goos: []string{
   233  						runtime.GOOS,
   234  					},
   235  					Goarch: []string{
   236  						runtime.GOARCH,
   237  					},
   238  				},
   239  			},
   240  		},
   241  	}
   242  	assert.Error(Pipe{}.Run(ctx))
   243  }
   244  
   245  func TestRunPipeFailingHooks(t *testing.T) {
   246  	assert := assert.New(t)
   247  	var config = config.Project{
   248  		Builds: []config.Build{
   249  			{
   250  				Hooks: config.Hooks{},
   251  				Goos: []string{
   252  					runtime.GOOS,
   253  				},
   254  				Goarch: []string{
   255  					runtime.GOARCH,
   256  				},
   257  			},
   258  		},
   259  	}
   260  	var ctx = &context.Context{
   261  		Config:  config,
   262  		Folders: map[string]string{},
   263  	}
   264  	t.Run("pre-hook", func(t *testing.T) {
   265  		ctx.Config.Builds[0].Hooks.Pre = "exit 1"
   266  		assert.Error(Pipe{}.Run(ctx))
   267  	})
   268  	t.Run("post-hook", func(t *testing.T) {
   269  		ctx.Config.Builds[0].Hooks.Post = "exit 1"
   270  		assert.Error(Pipe{}.Run(ctx))
   271  	})
   272  }
   273  
   274  func exists(file string) bool {
   275  	_, err := os.Stat(file)
   276  	return !os.IsNotExist(err)
   277  }