github.com/szyn/goreleaser@v0.76.1-0.20180517112710-333da09a1297/pipeline/build/build_test.go (about) 1 package build 2 3 import ( 4 "errors" 5 "os" 6 "path/filepath" 7 "testing" 8 9 api "github.com/goreleaser/goreleaser/build" 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 var fakeArtifact = artifact.Artifact{ 18 Name: "fake", 19 } 20 21 type fakeBuilder struct { 22 fail bool 23 } 24 25 func (*fakeBuilder) WithDefaults(build config.Build) config.Build { 26 return build 27 } 28 29 var errFailedBuild = errors.New("fake builder failed") 30 31 func (f *fakeBuilder) Build(ctx *context.Context, build config.Build, options api.Options) error { 32 if f.fail { 33 return errFailedBuild 34 } 35 ctx.Artifacts.Add(fakeArtifact) 36 return nil 37 } 38 39 func init() { 40 api.Register("fake", &fakeBuilder{}) 41 api.Register("fakeFail", &fakeBuilder{ 42 fail: true, 43 }) 44 } 45 46 func TestPipeDescription(t *testing.T) { 47 assert.NotEmpty(t, Pipe{}.String()) 48 } 49 50 func TestBuild(t *testing.T) { 51 var config = config.Project{ 52 Builds: []config.Build{ 53 { 54 Lang: "fake", 55 Binary: "testing.v{{.Version}}", 56 Flags: []string{"-n"}, 57 Env: []string{"BLAH=1"}, 58 }, 59 }, 60 } 61 var ctx = &context.Context{ 62 Artifacts: artifact.New(), 63 Git: context.GitInfo{ 64 CurrentTag: "v1.2.3", 65 Commit: "123", 66 }, 67 Version: "1.2.3", 68 Config: config, 69 } 70 error := doBuild(ctx, ctx.Config.Builds[0], "darwin_amd64") 71 assert.NoError(t, error) 72 } 73 74 func TestRunPipe(t *testing.T) { 75 var config = config.Project{ 76 Builds: []config.Build{ 77 { 78 Lang: "fake", 79 Binary: "testing", 80 Flags: []string{"-v"}, 81 Ldflags: []string{"-X main.test=testing"}, 82 Targets: []string{"whatever"}, 83 }, 84 }, 85 } 86 var ctx = context.New(config) 87 assert.NoError(t, Pipe{}.Run(ctx)) 88 assert.Equal(t, ctx.Artifacts.List(), []artifact.Artifact{fakeArtifact}) 89 } 90 91 func TestRunFullPipe(t *testing.T) { 92 folder, back := testlib.Mktmp(t) 93 defer back() 94 var pre = filepath.Join(folder, "pre") 95 var post = filepath.Join(folder, "post") 96 var config = config.Project{ 97 Builds: []config.Build{ 98 { 99 Lang: "fake", 100 Binary: "testing", 101 Flags: []string{"-v"}, 102 Ldflags: []string{"-X main.test=testing"}, 103 Hooks: config.Hooks{ 104 Pre: "touch " + pre, 105 Post: "touch " + post, 106 }, 107 Targets: []string{"whatever"}, 108 }, 109 }, 110 } 111 var ctx = context.New(config) 112 assert.NoError(t, Pipe{}.Run(ctx)) 113 assert.Equal(t, ctx.Artifacts.List(), []artifact.Artifact{fakeArtifact}) 114 assert.True(t, exists(pre), pre) 115 assert.True(t, exists(post), post) 116 } 117 118 func TestRunFullPipeFail(t *testing.T) { 119 folder, back := testlib.Mktmp(t) 120 defer back() 121 var pre = filepath.Join(folder, "pre") 122 var post = filepath.Join(folder, "post") 123 var config = config.Project{ 124 Builds: []config.Build{ 125 { 126 Lang: "fakeFail", 127 Binary: "testing", 128 Flags: []string{"-v"}, 129 Ldflags: []string{"-X main.test=testing"}, 130 Hooks: config.Hooks{ 131 Pre: "touch " + pre, 132 Post: "touch " + post, 133 }, 134 Targets: []string{"whatever"}, 135 }, 136 }, 137 } 138 var ctx = context.New(config) 139 assert.EqualError(t, Pipe{}.Run(ctx), errFailedBuild.Error()) 140 assert.Empty(t, ctx.Artifacts.List()) 141 assert.True(t, exists(pre), pre) 142 assert.False(t, exists(post), post) 143 } 144 145 func TestRunPipeFailingHooks(t *testing.T) { 146 var config = config.Project{ 147 Builds: []config.Build{ 148 { 149 Lang: "fake", 150 Binary: "hooks", 151 Hooks: config.Hooks{}, 152 Targets: []string{"whatever"}, 153 }, 154 }, 155 } 156 t.Run("pre-hook", func(t *testing.T) { 157 var ctx = context.New(config) 158 ctx.Config.Builds[0].Hooks.Pre = "exit 1" 159 ctx.Config.Builds[0].Hooks.Post = "echo post" 160 assert.EqualError(t, Pipe{}.Run(ctx), `pre hook failed: `) 161 }) 162 t.Run("post-hook", func(t *testing.T) { 163 var ctx = context.New(config) 164 ctx.Config.Builds[0].Hooks.Pre = "echo pre" 165 ctx.Config.Builds[0].Hooks.Post = "exit 1" 166 assert.EqualError(t, Pipe{}.Run(ctx), `post hook failed: `) 167 }) 168 } 169 170 func TestDefaultNoBuilds(t *testing.T) { 171 var ctx = &context.Context{ 172 Config: config.Project{}, 173 } 174 assert.NoError(t, Pipe{}.Default(ctx)) 175 } 176 177 func TestDefaultExpandEnv(t *testing.T) { 178 assert.NoError(t, os.Setenv("BAR", "FOOBAR")) 179 var ctx = &context.Context{ 180 Config: config.Project{ 181 Builds: []config.Build{ 182 { 183 Env: []string{ 184 "FOO=bar_$BAR", 185 }, 186 }, 187 }, 188 }, 189 } 190 assert.NoError(t, Pipe{}.Default(ctx)) 191 var env = ctx.Config.Builds[0].Env[0] 192 assert.Equal(t, "FOO=bar_FOOBAR", env) 193 } 194 195 func TestDefaultEmptyBuild(t *testing.T) { 196 var ctx = &context.Context{ 197 Config: config.Project{ 198 Release: config.Release{ 199 GitHub: config.Repo{ 200 Name: "foo", 201 }, 202 }, 203 Builds: []config.Build{ 204 {}, 205 }, 206 }, 207 } 208 assert.NoError(t, Pipe{}.Default(ctx)) 209 var build = ctx.Config.Builds[0] 210 assert.Equal(t, ctx.Config.Release.GitHub.Name, build.Binary) 211 assert.Equal(t, ".", build.Main) 212 assert.Equal(t, []string{"linux", "darwin"}, build.Goos) 213 assert.Equal(t, []string{"amd64", "386"}, build.Goarch) 214 assert.Equal(t, []string{"6"}, build.Goarm) 215 assert.Len(t, build.Ldflags, 1) 216 assert.Equal(t, "-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}", build.Ldflags[0]) 217 } 218 219 func TestDefaultPartialBuilds(t *testing.T) { 220 var ctx = &context.Context{ 221 Config: config.Project{ 222 Builds: []config.Build{ 223 { 224 Binary: "bar", 225 Goos: []string{"linux"}, 226 Main: "./cmd/main.go", 227 }, 228 { 229 Binary: "foo", 230 Ldflags: []string{"-s -w"}, 231 Goarch: []string{"386"}, 232 }, 233 }, 234 }, 235 } 236 assert.NoError(t, Pipe{}.Default(ctx)) 237 t.Run("build0", func(t *testing.T) { 238 var build = ctx.Config.Builds[0] 239 assert.Equal(t, "bar", build.Binary) 240 assert.Equal(t, "./cmd/main.go", build.Main) 241 assert.Equal(t, []string{"linux"}, build.Goos) 242 assert.Equal(t, []string{"amd64", "386"}, build.Goarch) 243 assert.Equal(t, []string{"6"}, build.Goarm) 244 assert.Len(t, build.Ldflags, 1) 245 assert.Equal(t, "-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}", build.Ldflags[0]) 246 }) 247 t.Run("build1", func(t *testing.T) { 248 var build = ctx.Config.Builds[1] 249 assert.Equal(t, "foo", build.Binary) 250 assert.Equal(t, ".", build.Main) 251 assert.Equal(t, []string{"linux", "darwin"}, build.Goos) 252 assert.Equal(t, []string{"386"}, build.Goarch) 253 assert.Equal(t, []string{"6"}, build.Goarm) 254 assert.Len(t, build.Ldflags, 1) 255 assert.Equal(t, "-s -w", build.Ldflags[0]) 256 }) 257 } 258 259 func TestDefaultFillSingleBuild(t *testing.T) { 260 _, back := testlib.Mktmp(t) 261 defer back() 262 263 var ctx = &context.Context{ 264 Config: config.Project{ 265 Release: config.Release{ 266 GitHub: config.Repo{ 267 Name: "foo", 268 }, 269 }, 270 SingleBuild: config.Build{ 271 Main: "testreleaser", 272 }, 273 }, 274 } 275 assert.NoError(t, Pipe{}.Default(ctx)) 276 assert.Len(t, ctx.Config.Builds, 1) 277 assert.Equal(t, ctx.Config.Builds[0].Binary, "foo") 278 } 279 280 func TestExtWindows(t *testing.T) { 281 assert.Equal(t, ".exe", extFor("windows_amd64")) 282 assert.Equal(t, ".exe", extFor("windows_386")) 283 } 284 285 func TestExtOthers(t *testing.T) { 286 assert.Empty(t, "", extFor("linux_amd64")) 287 assert.Empty(t, "", extFor("linuxwin_386")) 288 assert.Empty(t, "", extFor("winasdasd_sad")) 289 } 290 291 func TestBinaryFullTemplate(t *testing.T) { 292 var config = config.Project{ 293 Builds: []config.Build{ 294 { 295 Binary: `-s -w -X main.version={{.Version}} -X main.tag={{.Tag}} -X main.date={{.Date}} -X main.commit={{.Commit}} -X "main.foo={{.Env.FOO}}"`, 296 }, 297 }, 298 } 299 var ctx = &context.Context{ 300 Git: context.GitInfo{ 301 CurrentTag: "v1.2.3", 302 Commit: "123", 303 }, 304 Version: "1.2.3", 305 Config: config, 306 Env: map[string]string{"FOO": "123"}, 307 } 308 binary, err := binary(ctx, ctx.Config.Builds[0]) 309 assert.NoError(t, err) 310 assert.Contains(t, binary, "-s -w") 311 assert.Contains(t, binary, "-X main.version=1.2.3") 312 assert.Contains(t, binary, "-X main.tag=v1.2.3") 313 assert.Contains(t, binary, "-X main.commit=123") 314 assert.Contains(t, binary, "-X main.date=") 315 assert.Contains(t, binary, `-X "main.foo=123"`) 316 } 317 318 // 319 // Helpers 320 // 321 322 func exists(file string) bool { 323 _, err := os.Stat(file) 324 return !os.IsNotExist(err) 325 }