go/goreleaser
go/goreleaser
1
0
Fork 0
mirror of https://github.com/goreleaser/goreleaser.git synced 2025-03-21 21:07:19 +02:00
Code Issues Releases Activity

fixed build tests

Browse Source
This commit is contained in:
Carlos Alexandro Becker 2017-07-01 13:21:07 -03:00
parent bc7eba4860
commit a9d6f0ab8c
No known key found for this signature in database
GPG Key ID: E61E2F7DC14AB940
3 changed files with 135 additions and 114 deletions

180
pipeline/build/build_test.go

@ -29,16 +29,20 @@ func TestRunInvalidCommand(t *testing.T) {
func TestBuild(t *testing.T) { func TestBuild(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var config = config.Project{ var config = config.Project{
Build: config.Build{ Builds: []config.Build{
Binary: "testing", {
Flags: "-n", Binary: "testing",
Env: []string{"BLAH=1"}, Flags: "-n",
Env: []string{"BLAH=1"},
},
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
Folders: map[string]string{},
Binaries: map[string]string{},
} }
assert.NoError(build(ctx, "build_test", runtimeTarget)) assert.NoError(doBuild(ctx, ctx.Config.Builds[0], runtimeTarget))
} }
func TestRunFullPipe(t *testing.T) { func TestRunFullPipe(t *testing.T) {
@ -50,25 +54,28 @@ func TestRunFullPipe(t *testing.T) {
var post = filepath.Join(folder, "post") var post = filepath.Join(folder, "post")
var config = config.Project{ var config = config.Project{
Dist: folder, Dist: folder,
Build: config.Build{ Builds: []config.Build{
Binary: "testing", {
Flags: "-v", Binary: "testing",
Ldflags: "-X main.test=testing", Flags: "-v",
Hooks: config.Hooks{ Ldflags: "-X main.test=testing",
Pre: "touch " + pre, Hooks: config.Hooks{
Post: "touch " + post, Pre: "touch " + pre,
}, Post: "touch " + post,
Goos: []string{ },
runtime.GOOS, Goos: []string{
}, runtime.GOOS,
Goarch: []string{ },
runtime.GOARCH, Goarch: []string{
runtime.GOARCH,
},
}, },
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
Archives: map[string]string{}, Folders: map[string]string{},
Binaries: map[string]string{},
} }
assert.NoError(Pipe{}.Run(ctx)) assert.NoError(Pipe{}.Run(ctx))
assert.True(exists(binary), binary) assert.True(exists(binary), binary)
@ -83,25 +90,28 @@ func TestRunPipeArmBuilds(t *testing.T) {
var binary = filepath.Join(folder, "armtesting") var binary = filepath.Join(folder, "armtesting")
var config = config.Project{ var config = config.Project{
Dist: folder, Dist: folder,
Build: config.Build{ Builds: []config.Build{
Binary: "armtesting", {
Flags: "-v", Binary: "armtesting",
Ldflags: "-X main.test=armtesting", Flags: "-v",
Goos: []string{ Ldflags: "-X main.test=armtesting",
"linux", Goos: []string{
}, "linux",
Goarch: []string{ },
"arm", Goarch: []string{
"arm64", "arm",
}, "arm64",
Goarm: []string{ },
"6", Goarm: []string{
"6",
},
}, },
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
Archives: map[string]string{}, Folders: map[string]string{},
Binaries: map[string]string{},
} }
assert.NoError(Pipe{}.Run(ctx)) assert.NoError(Pipe{}.Run(ctx))
assert.True(exists(binary), binary) assert.True(exists(binary), binary)
@ -110,19 +120,22 @@ func TestRunPipeArmBuilds(t *testing.T) {
func TestBuildFailed(t *testing.T) { func TestBuildFailed(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var config = config.Project{ var config = config.Project{
Build: config.Build{ Builds: []config.Build{
Flags: "-flag-that-dont-exists-to-force-failure", {
Goos: []string{ Flags: "-flag-that-dont-exists-to-force-failure",
runtime.GOOS, Goos: []string{
}, runtime.GOOS,
Goarch: []string{ },
runtime.GOARCH, Goarch: []string{
runtime.GOARCH,
},
}, },
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
Archives: map[string]string{}, Folders: map[string]string{},
Binaries: map[string]string{},
} }
assert.Error(Pipe{}.Run(ctx)) assert.Error(Pipe{}.Run(ctx))
} }
@ -130,19 +143,22 @@ func TestBuildFailed(t *testing.T) {
func TestRunPipeWithInvalidOS(t *testing.T) { func TestRunPipeWithInvalidOS(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var config = config.Project{ var config = config.Project{
Build: config.Build{ Builds: []config.Build{
Flags: "-v", {
Goos: []string{ Flags: "-v",
"windows", Goos: []string{
}, "windows",
Goarch: []string{ },
"arm", Goarch: []string{
"arm",
},
}, },
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
Archives: map[string]string{}, Folders: map[string]string{},
Binaries: map[string]string{},
} }
assert.NoError(Pipe{}.Run(ctx)) assert.NoError(Pipe{}.Run(ctx))
} }
@ -151,14 +167,16 @@ func TestRunInvalidNametemplate(t *testing.T) {
var assert = assert.New(t) var assert = assert.New(t)
var ctx = &context.Context{ var ctx = &context.Context{
Config: config.Project{ Config: config.Project{
Build: config.Build{ Builds: []config.Build{
Binary: "nametest", {
Flags: "-v", Binary: "nametest",
Goos: []string{ Flags: "-v",
runtime.GOOS, Goos: []string{
}, runtime.GOOS,
Goarch: []string{ },
runtime.GOARCH, Goarch: []string{
runtime.GOARCH,
},
}, },
}, },
Archive: config.Archive{ Archive: config.Archive{
@ -172,17 +190,20 @@ func TestRunInvalidNametemplate(t *testing.T) {
func TestRunInvalidLdflags(t *testing.T) { func TestRunInvalidLdflags(t *testing.T) {
var assert = assert.New(t) var assert = assert.New(t)
var ctx = &context.Context{ var ctx = &context.Context{
Archives: map[string]string{}, Folders: map[string]string{},
Binaries: map[string]string{},
Config: config.Project{ Config: config.Project{
Build: config.Build{ Builds: []config.Build{
Binary: "nametest", {
Flags: "-v", Binary: "nametest",
Ldflags: "-s -w -X main.version={{.Version}", Flags: "-v",
Goos: []string{ Ldflags: "-s -w -X main.version={{.Version}",
runtime.GOOS, Goos: []string{
}, runtime.GOOS,
Goarch: []string{ },
runtime.GOARCH, Goarch: []string{
runtime.GOARCH,
},
}, },
}, },
}, },
@ -193,26 +214,29 @@ func TestRunInvalidLdflags(t *testing.T) {
func TestRunPipeFailingHooks(t *testing.T) { func TestRunPipeFailingHooks(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var config = config.Project{ var config = config.Project{
Build: config.Build{ Builds: []config.Build{
Hooks: config.Hooks{}, {
Goos: []string{ Hooks: config.Hooks{},
runtime.GOOS, Goos: []string{
}, runtime.GOOS,
Goarch: []string{ },
runtime.GOARCH, Goarch: []string{
runtime.GOARCH,
},
}, },
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
Archives: map[string]string{}, Folders: map[string]string{},
Binaries: map[string]string{},
} }
t.Run("pre-hook", func(t *testing.T) { t.Run("pre-hook", func(t *testing.T) {
ctx.Config.Build.Hooks.Pre = "exit 1" ctx.Config.Builds[0].Hooks.Pre = "exit 1"
assert.Error(Pipe{}.Run(ctx)) assert.Error(Pipe{}.Run(ctx))
}) })
t.Run("post-hook", func(t *testing.T) { t.Run("post-hook", func(t *testing.T) {
ctx.Config.Build.Hooks.Post = "exit 1" ctx.Config.Builds[0].Hooks.Post = "exit 1"
assert.Error(Pipe{}.Run(ctx)) assert.Error(Pipe{}.Run(ctx))
}) })
} }

14
pipeline/build/ldflags_test.go

@ -11,8 +11,10 @@ import (
func TestLdFlagsFullTemplate(t *testing.T) { func TestLdFlagsFullTemplate(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var config = config.Project{ var config = config.Project{
Build: config.Build{ Builds: []config.Build{
Ldflags: "-s -w -X main.version={{.Version}} -X main.tag={{.Tag}} -X main.date={{.Date}} -X main.commit={{.Commit}}", {
Ldflags: "-s -w -X main.version={{.Version}} -X main.tag={{.Tag}} -X main.date={{.Date}} -X main.commit={{.Commit}}",
},
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
@ -23,7 +25,7 @@ func TestLdFlagsFullTemplate(t *testing.T) {
Version: "1.2.3", Version: "1.2.3",
Config: config, Config: config,
} }
flags, err := ldflags(ctx) flags, err := ldflags(ctx, ctx.Config.Builds[0])
assert.NoError(err) assert.NoError(err)
assert.Contains(flags, "-s -w") assert.Contains(flags, "-s -w")
assert.Contains(flags, "-X main.version=1.2.3") assert.Contains(flags, "-X main.version=1.2.3")
@ -35,14 +37,14 @@ func TestLdFlagsFullTemplate(t *testing.T) {
func TestInvalidTemplate(t *testing.T) { func TestInvalidTemplate(t *testing.T) {
assert := assert.New(t) assert := assert.New(t)
var config = config.Project{ var config = config.Project{
Build: config.Build{ Builds: []config.Build{
Ldflags: "{invalid{.Template}}}{{}}}", {Ldflags: "{invalid{.Template}}}{{}}}"},
}, },
} }
var ctx = &context.Context{ var ctx = &context.Context{
Config: config, Config: config,
} }
flags, err := ldflags(ctx) flags, err := ldflags(ctx, ctx.Config.Builds[0])
assert.Error(err) assert.Error(err)
assert.Equal(flags, "") assert.Equal(flags, "")
} }

55
pipeline/build/target_test.go

@ -5,40 +5,35 @@ import (
"testing" "testing"
"github.com/goreleaser/goreleaser/config" "github.com/goreleaser/goreleaser/config"
"github.com/goreleaser/goreleaser/context"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
) )
func TestAllBuildTargets(t *testing.T) { func TestAllBuildTargets(t *testing.T) {
var assert = assert.New(t) var assert = assert.New(t)
var ctx = &context.Context{ var build = config.Build{
Config: config.Project{ Goos: []string{
Build: config.Build{ "linux",
Goos: []string{ "darwin",
"linux", "freebsd",
"darwin", },
"freebsd", Goarch: []string{
}, "386",
Goarch: []string{ "amd64",
"386", "arm",
"amd64", "arm64",
"arm", },
"arm64", Goarm: []string{
}, "6",
Goarm: []string{ "7",
"6", },
"7", Ignore: []config.IgnoredBuild{
}, {
Ignore: []config.IgnoredBuild{ Goos: "darwin",
{ Goarch: "386",
Goos: "darwin", }, {
Goarch: "386", Goos: "linux",
}, { Goarch: "arm",
Goos: "linux", Goarm: "7",
Goarch: "arm",
Goarm: "7",
},
},
}, },
}, },
} }
@ -52,7 +47,7 @@ func TestAllBuildTargets(t *testing.T) {
{"freebsd", "amd64", ""}, {"freebsd", "amd64", ""},
{"freebsd", "arm", "6"}, {"freebsd", "arm", "6"},
{"freebsd", "arm", "7"}, {"freebsd", "arm", "7"},
}, buildTargets(ctx)) }, buildTargets(build))
} }
func TestValidGoosGoarchCombos(t *testing.T) { func TestValidGoosGoarchCombos(t *testing.T) {