go/goreleaser
go/goreleaser
1
0
Fork 0
mirror of https://github.com/goreleaser/goreleaser.git synced 2024-12-27 01:33:39 +02:00
Code Issues Releases Activity

chore: gofumpt & lint (#2190)

Browse Source 
Signed-off-by: Carlos Becker <caarlos0@gmail.com>
This commit is contained in:
Carlos Alexandro Becker 2021-04-25 14:20:49 -03:00 committed by GitHub
parent 5866b9cb63
commit 860b4a8f81
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
61 changed files with 721 additions and 706 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.golangci.yml
View File

@ -1,3 +1,8 @@
linters: linters:
enable: enable:
- thelper - thelper
- gofumpt
- tparallel
- unconvert
- unparam
- wastedassign

8
cmd/build.go
View File

@ -38,14 +38,14 @@ func newBuildCmd() *buildCmd {
root := &buildCmd{} root := &buildCmd{}
// nolint: dupl // nolint: dupl
cmd := &cobra.Command{ cmd := &cobra.Command{
Use: "build", Use: "build",
Aliases: []string{"b"}, Aliases: []string{"b"},
Short: "Builds the current project", Short: "Builds the current project",
Long: `The build command allows you to execute only a subset of the pipeline, i.e. only the build step with its dependencies. Long: `The build command allows you to execute only a subset of the pipeline, i.e. only the build step with its dependencies.
It allows you to quickly check if your GoReleaser build configurations are doing what you expect. It allows you to quickly check if your GoReleaser build configurations are doing what you expect.
Finally, it allows you to generate a local build for your current machine only using the `+ "`--single-target`"+` option, and specific build IDs using the `+"`--id`"+` option. Finally, it allows you to generate a local build for your current machine only using the ` + "`--single-target`" + ` option, and specific build IDs using the ` + "`--id`" + ` option.
`, `,
SilenceUsage: true, SilenceUsage: true,
SilenceErrors: true, SilenceErrors: true,

6
cmd/check.go
View File

@ -18,8 +18,8 @@ type checkCmd struct {
} }
func newCheckCmd() *checkCmd { func newCheckCmd() *checkCmd {
var root = &checkCmd{} root := &checkCmd{}
var cmd = &cobra.Command{ cmd := &cobra.Command{
Use: "check", Use: "check",
Aliases: []string{"c"}, Aliases: []string{"c"},
Short: "Checks if configuration is valid", Short: "Checks if configuration is valid",
@ -31,7 +31,7 @@ func newCheckCmd() *checkCmd {
if err != nil { if err != nil {
return err return err
} }
var ctx = context.New(cfg) ctx := context.New(cfg)
ctx.Deprecated = root.deprecated ctx.Deprecated = root.deprecated
if err := ctrlc.Default.Run(ctx, func() error { if err := ctrlc.Default.Run(ctx, func() error {

10
cmd/check_test.go
View File

@ -7,31 +7,31 @@ import (
) )
func TestCheckConfig(t *testing.T) { func TestCheckConfig(t *testing.T) {
var cmd = newCheckCmd() cmd := newCheckCmd()
cmd.cmd.SetArgs([]string{"-f", "testdata/good.yml"}) cmd.cmd.SetArgs([]string{"-f", "testdata/good.yml"})
require.NoError(t, cmd.cmd.Execute()) require.NoError(t, cmd.cmd.Execute())
} }
func TestCheckConfigThatDoesNotExist(t *testing.T) { func TestCheckConfigThatDoesNotExist(t *testing.T) {
var cmd = newCheckCmd() cmd := newCheckCmd()
cmd.cmd.SetArgs([]string{"-f", "testdata/nope.yml"}) cmd.cmd.SetArgs([]string{"-f", "testdata/nope.yml"})
require.EqualError(t, cmd.cmd.Execute(), "open testdata/nope.yml: no such file or directory") require.EqualError(t, cmd.cmd.Execute(), "open testdata/nope.yml: no such file or directory")
} }
func TestCheckConfigUnmarshalError(t *testing.T) { func TestCheckConfigUnmarshalError(t *testing.T) {
var cmd = newCheckCmd() cmd := newCheckCmd()
cmd.cmd.SetArgs([]string{"-f", "testdata/unmarshal_error.yml"}) cmd.cmd.SetArgs([]string{"-f", "testdata/unmarshal_error.yml"})
require.EqualError(t, cmd.cmd.Execute(), "yaml: unmarshal errors:\n line 1: field foo not found in type config.Project") require.EqualError(t, cmd.cmd.Execute(), "yaml: unmarshal errors:\n line 1: field foo not found in type config.Project")
} }
func TestCheckConfigInvalid(t *testing.T) { func TestCheckConfigInvalid(t *testing.T) {
var cmd = newCheckCmd() cmd := newCheckCmd()
cmd.cmd.SetArgs([]string{"-f", "testdata/invalid.yml"}) cmd.cmd.SetArgs([]string{"-f", "testdata/invalid.yml"})
require.EqualError(t, cmd.cmd.Execute(), "invalid config: found 2 builds with the ID 'a', please fix your config") require.EqualError(t, cmd.cmd.Execute(), "invalid config: found 2 builds with the ID 'a', please fix your config")
} }
func TestCheckConfigDeprecated(t *testing.T) { func TestCheckConfigDeprecated(t *testing.T) {
var cmd = newCheckCmd() cmd := newCheckCmd()
cmd.cmd.SetArgs([]string{"-f", "testdata/good.yml", "--deprecated"}) cmd.cmd.SetArgs([]string{"-f", "testdata/good.yml", "--deprecated"})
require.EqualError(t, cmd.cmd.Execute(), "config is valid, but uses deprecated properties, check logs above for details") require.EqualError(t, cmd.cmd.Execute(), "config is valid, but uses deprecated properties, check logs above for details")
} }

4
cmd/config_test.go
View File

@ -17,7 +17,7 @@ func TestConfigFlagNotSetButExists(t *testing.T) {
"goreleaser.yaml", "goreleaser.yaml",
} { } {
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
var folder = setup(t) folder := setup(t)
require.NoError(t, os.Rename( require.NoError(t, os.Rename(
filepath.Join(folder, "goreleaser.yml"), filepath.Join(folder, "goreleaser.yml"),
filepath.Join(folder, name), filepath.Join(folder, name),
@ -30,7 +30,7 @@ func TestConfigFlagNotSetButExists(t *testing.T) {
} }
func TestConfigFileDoesntExist(t *testing.T) { func TestConfigFileDoesntExist(t *testing.T) {
var folder = setup(t) folder := setup(t)
err := os.Remove(filepath.Join(folder, "goreleaser.yml")) err := os.Remove(filepath.Join(folder, "goreleaser.yml"))
require.NoError(t, err) require.NoError(t, err)
proj, err := loadConfig("") proj, err := loadConfig("")

20
cmd/release_test.go
View File

@ -10,7 +10,7 @@ import (
func TestRelease(t *testing.T) { func TestRelease(t *testing.T) {
setup(t) setup(t)
var cmd = newReleaseCmd() cmd := newReleaseCmd()
cmd.cmd.SetArgs([]string{"--snapshot", "--timeout=1m", "--parallelism=2", "--deprecated"}) cmd.cmd.SetArgs([]string{"--snapshot", "--timeout=1m", "--parallelism=2", "--deprecated"})
require.NoError(t, cmd.cmd.Execute()) require.NoError(t, cmd.cmd.Execute())
} }
@ -18,7 +18,7 @@ func TestRelease(t *testing.T) {
func TestReleaseInvalidConfig(t *testing.T) { func TestReleaseInvalidConfig(t *testing.T) {
setup(t) setup(t)
createFile(t, "goreleaser.yml", "foo: bar") createFile(t, "goreleaser.yml", "foo: bar")
var cmd = newReleaseCmd() cmd := newReleaseCmd()
cmd.cmd.SetArgs([]string{"--snapshot", "--timeout=1m", "--parallelism=2", "--deprecated"}) cmd.cmd.SetArgs([]string{"--snapshot", "--timeout=1m", "--parallelism=2", "--deprecated"})
require.EqualError(t, cmd.cmd.Execute(), "yaml: unmarshal errors:\n line 1: field foo not found in type config.Project") require.EqualError(t, cmd.cmd.Execute(), "yaml: unmarshal errors:\n line 1: field foo not found in type config.Project")
} }
@ -26,18 +26,18 @@ func TestReleaseInvalidConfig(t *testing.T) {
func TestReleaseBrokenProject(t *testing.T) { func TestReleaseBrokenProject(t *testing.T) {
setup(t) setup(t)
createFile(t, "main.go", "not a valid go file") createFile(t, "main.go", "not a valid go file")
var cmd = newReleaseCmd() cmd := newReleaseCmd()
cmd.cmd.SetArgs([]string{"--snapshot", "--timeout=1m", "--parallelism=2"}) cmd.cmd.SetArgs([]string{"--snapshot", "--timeout=1m", "--parallelism=2"})
require.EqualError(t, cmd.cmd.Execute(), "failed to parse dir: .: main.go:1:1: expected 'package', found not") require.EqualError(t, cmd.cmd.Execute(), "failed to parse dir: .: main.go:1:1: expected 'package', found not")
} }
func TestReleaseFlags(t *testing.T) { func TestReleaseFlags(t *testing.T) {
var setup = func(opts releaseOpts) *context.Context { setup := func(opts releaseOpts) *context.Context {
return setupReleaseContext(context.New(config.Project{}), opts) return setupReleaseContext(context.New(config.Project{}), opts)
} }
t.Run("snapshot", func(t *testing.T) { t.Run("snapshot", func(t *testing.T) {
var ctx = setup(releaseOpts{ ctx := setup(releaseOpts{
snapshot: true, snapshot: true,
}) })
require.True(t, ctx.Snapshot) require.True(t, ctx.Snapshot)
@ -46,7 +46,7 @@ func TestReleaseFlags(t *testing.T) {
}) })
t.Run("skips", func(t *testing.T) { t.Run("skips", func(t *testing.T) {
var ctx = setup(releaseOpts{ ctx := setup(releaseOpts{
skipPublish: true, skipPublish: true,
skipSign: true, skipSign: true,
skipValidate: true, skipValidate: true,
@ -63,10 +63,10 @@ func TestReleaseFlags(t *testing.T) {
}) })
t.Run("notes", func(t *testing.T) { t.Run("notes", func(t *testing.T) {
var notes = "foo.md" notes := "foo.md"
var header = "header.md" header := "header.md"
var footer = "footer.md" footer := "footer.md"
var ctx = setup(releaseOpts{ ctx := setup(releaseOpts{
releaseNotes: notes, releaseNotes: notes,
releaseHeader: header, releaseHeader: header,
releaseFooter: footer, releaseFooter: footer,

26
cmd/root_test.go
View File

@ -8,14 +8,14 @@ import (
) )
func TestRootCmd(t *testing.T) { func TestRootCmd(t *testing.T) {
var mem = &exitMemento{} mem := &exitMemento{}
Execute("1.2.3", mem.Exit, []string{"-h"}) Execute("1.2.3", mem.Exit, []string{"-h"})
require.Equal(t, 0, mem.code) require.Equal(t, 0, mem.code)
} }
func TestRootCmdHelp(t *testing.T) { func TestRootCmdHelp(t *testing.T) {
var mem = &exitMemento{} mem := &exitMemento{}
var cmd = newRootCmd("", mem.Exit).cmd cmd := newRootCmd("", mem.Exit).cmd
cmd.SetArgs([]string{"-h"}) cmd.SetArgs([]string{"-h"})
require.NoError(t, cmd.Execute()) require.NoError(t, cmd.Execute())
require.Equal(t, 0, mem.code) require.Equal(t, 0, mem.code)
@ -23,8 +23,8 @@ func TestRootCmdHelp(t *testing.T) {
func TestRootCmdVersion(t *testing.T) { func TestRootCmdVersion(t *testing.T) {
var b bytes.Buffer var b bytes.Buffer
var mem = &exitMemento{} mem := &exitMemento{}
var cmd = newRootCmd("1.2.3", mem.Exit).cmd cmd := newRootCmd("1.2.3", mem.Exit).cmd
cmd.SetOut(&b) cmd.SetOut(&b)
cmd.SetArgs([]string{"-v"}) cmd.SetArgs([]string{"-v"})
require.NoError(t, cmd.Execute()) require.NoError(t, cmd.Execute())
@ -33,31 +33,31 @@ func TestRootCmdVersion(t *testing.T) {
} }
func TestRootCmdExitCode(t *testing.T) { func TestRootCmdExitCode(t *testing.T) {
var mem = &exitMemento{} mem := &exitMemento{}
var cmd = newRootCmd("", mem.Exit) cmd := newRootCmd("", mem.Exit)
var args = []string{"check", "--deprecated", "-f", "testdata/good.yml"} args := []string{"check", "--deprecated", "-f", "testdata/good.yml"}
cmd.Execute(args) cmd.Execute(args)
require.Equal(t, 2, mem.code) require.Equal(t, 2, mem.code)
} }
func TestRootRelease(t *testing.T) { func TestRootRelease(t *testing.T) {
setup(t) setup(t)
var mem = &exitMemento{} mem := &exitMemento{}
var cmd = newRootCmd("", mem.Exit) cmd := newRootCmd("", mem.Exit)
cmd.Execute([]string{}) cmd.Execute([]string{})
require.Equal(t, 1, mem.code) require.Equal(t, 1, mem.code)
} }
func TestRootReleaseDebug(t *testing.T) { func TestRootReleaseDebug(t *testing.T) {
setup(t) setup(t)
var mem = &exitMemento{} mem := &exitMemento{}
var cmd = newRootCmd("", mem.Exit) cmd := newRootCmd("", mem.Exit)
cmd.Execute([]string{"r", "--debug"}) cmd.Execute([]string{"r", "--debug"})
require.Equal(t, 1, mem.code) require.Equal(t, 1, mem.code)
} }
func TestShouldPrependRelease(t *testing.T) { func TestShouldPrependRelease(t *testing.T) {
var result = func(args []string) bool { result := func(args []string) bool {
return shouldPrependRelease(newRootCmd("1", func(_ int) {}).cmd, args) return shouldPrependRelease(newRootCmd("1", func(_ int) {}).cmd, args)
} }

8
internal/artifact/artifact.go
View File

@ -154,7 +154,7 @@ func (artifacts Artifacts) List() []*Artifact {
// GroupByPlatform groups the artifacts by their platform. // GroupByPlatform groups the artifacts by their platform.
func (artifacts Artifacts) GroupByPlatform() map[string][]*Artifact { func (artifacts Artifacts) GroupByPlatform() map[string][]*Artifact {
var result = map[string][]*Artifact{} result := map[string][]*Artifact{}
for _, a := range artifacts.items { for _, a := range artifacts.items {
plat := a.Goos + a.Goarch + a.Goarm + a.Gomips plat := a.Goos + a.Goarch + a.Goarm + a.Gomips
result[plat] = append(result[plat], a) result[plat] = append(result[plat], a)
@ -208,7 +208,7 @@ func ByType(t Type) Filter {
// ByFormats filters artifacts by a `Format` extra field. // ByFormats filters artifacts by a `Format` extra field.
func ByFormats(formats ...string) Filter { func ByFormats(formats ...string) Filter {
var filters = make([]Filter, 0, len(formats)) filters := make([]Filter, 0, len(formats))
for _, format := range formats { for _, format := range formats {
format := format format := format
filters = append(filters, func(a *Artifact) bool { filters = append(filters, func(a *Artifact) bool {
@ -220,7 +220,7 @@ func ByFormats(formats ...string) Filter {
// ByIDs filter artifacts by an `ID` extra field. // ByIDs filter artifacts by an `ID` extra field.
func ByIDs(ids ...string) Filter { func ByIDs(ids ...string) Filter {
var filters = make([]Filter, 0, len(ids)) filters := make([]Filter, 0, len(ids))
for _, id := range ids { for _, id := range ids {
id := id id := id
filters = append(filters, func(a *Artifact) bool { filters = append(filters, func(a *Artifact) bool {
@ -266,7 +266,7 @@ func (artifacts *Artifacts) Filter(filter Filter) Artifacts {
return *artifacts return *artifacts
} }
var result = New() result := New()
for _, a := range artifacts.items { for _, a := range artifacts.items {
if filter(a) { if filter(a) {
result.items = append(result.items, a) result.items = append(result.items, a)

3
internal/client/gitea_test.go
View File

@ -162,7 +162,6 @@ func (s *GetExistingReleaseSuite) TestReleaseExists() {
require.NotNil(t, result) require.NotNil(t, result)
require.Equal(t, *result, release) require.Equal(t, *result, release)
require.NoError(t, err) require.NoError(t, err)
} }
func TestGetExistingReleaseSuite(t *testing.T) { func TestGetExistingReleaseSuite(t *testing.T) {
@ -409,7 +408,7 @@ func TestGiteaUploadSuite(t *testing.T) {
} }
func TestGiteaReleaseURLTemplate(t *testing.T) { func TestGiteaReleaseURLTemplate(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
GiteaURLs: config.GiteaURLs{ GiteaURLs: config.GiteaURLs{
API: "https://gitea.com/api/v1", API: "https://gitea.com/api/v1",
Download: "https://gitea.com", Download: "https://gitea.com",

12
internal/client/github.go
View File

@ -139,16 +139,16 @@ func (c *githubClient) CreateRelease(ctx *context.Context, body string) (string,
} }
data := &github.RepositoryRelease{ data := &github.RepositoryRelease{
Name: github.String(title), Name: github.String(title),
TagName: github.String(ctx.Git.CurrentTag), TagName: github.String(ctx.Git.CurrentTag),
Body: github.String(body), Body: github.String(body),
Draft: github.Bool(ctx.Config.Release.Draft), Draft: github.Bool(ctx.Config.Release.Draft),
Prerelease: github.Bool(ctx.PreRelease), Prerelease: github.Bool(ctx.PreRelease),
} }
if ctx.Config.Release.DiscussionCategoryName != "" { if ctx.Config.Release.DiscussionCategoryName != "" {
data.DiscussionCategoryName = github.String(ctx.Config.Release.DiscussionCategoryName) data.DiscussionCategoryName = github.String(ctx.Config.Release.DiscussionCategoryName)
} }
release, _, err = c.client.Repositories.GetReleaseByTag( release, _, err = c.client.Repositories.GetReleaseByTag(
ctx, ctx,
ctx.Config.Release.GitHub.Owner, ctx.Config.Release.GitHub.Owner,

6
internal/client/github_test.go
View File

@ -48,7 +48,7 @@ func TestNewGitHubClient(t *testing.T) {
} }
func TestGitHubUploadReleaseIDNotInt(t *testing.T) { func TestGitHubUploadReleaseIDNotInt(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
client, err := NewGitHub(ctx, ctx.Token) client, err := NewGitHub(ctx, ctx.Token)
require.NoError(t, err) require.NoError(t, err)
@ -60,7 +60,7 @@ func TestGitHubUploadReleaseIDNotInt(t *testing.T) {
} }
func TestGitHubReleaseURLTemplate(t *testing.T) { func TestGitHubReleaseURLTemplate(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
GitHubURLs: config.GitHubURLs{ GitHubURLs: config.GitHubURLs{
// default URL would otherwise be set via pipe/defaults // default URL would otherwise be set via pipe/defaults
Download: DefaultGitHubDownloadURL, Download: DefaultGitHubDownloadURL,
@ -83,7 +83,7 @@ func TestGitHubReleaseURLTemplate(t *testing.T) {
} }
func TestGitHubCreateReleaseWrongNameTemplate(t *testing.T) { func TestGitHubCreateReleaseWrongNameTemplate(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Release: config.Release{ Release: config.Release{
NameTemplate: "{{.dddddddddd", NameTemplate: "{{.dddddddddd",
}, },

6
internal/client/gitlab.go
View File

@ -34,7 +34,7 @@ func NewGitLab(ctx *context.Context, token string) (Client, error) {
InsecureSkipVerify: ctx.Config.GitLabURLs.SkipTLSVerify, InsecureSkipVerify: ctx.Config.GitLabURLs.SkipTLSVerify,
}, },
} }
var options = []gitlab.ClientOptionFunc{ options := []gitlab.ClientOptionFunc{
gitlab.WithHTTPClient(&http.Client{ gitlab.WithHTTPClient(&http.Client{
Transport: transport, Transport: transport,
}), }),
@ -52,7 +52,6 @@ func NewGitLab(ctx *context.Context, token string) (Client, error) {
// CloseMilestone closes a given milestone. // CloseMilestone closes a given milestone.
func (c *gitlabClient) CloseMilestone(ctx *context.Context, repo Repo, title string) error { func (c *gitlabClient) CloseMilestone(ctx *context.Context, repo Repo, title string) error {
milestone, err := c.getMilestoneByTitle(repo, title) milestone, err := c.getMilestoneByTitle(repo, title)
if err != nil { if err != nil {
return err return err
} }
@ -287,7 +286,6 @@ func (c *gitlabClient) Upload(
file.Name(), file.Name(),
nil, nil,
) )
if err != nil { if err != nil {
return err return err
} }
@ -308,7 +306,6 @@ func (c *gitlabClient) Upload(
Name: &name, Name: &name,
URL: &linkURL, URL: &linkURL,
}) })
if err != nil { if err != nil {
return RetriableError{err} return RetriableError{err}
} }
@ -360,7 +357,6 @@ func (c *gitlabClient) getMilestoneByTitle(repo Repo, title string) (*gitlab.Mil
for { for {
milestones, resp, err := c.client.Milestones.ListMilestones(repo.String(), opts) milestones, resp, err := c.client.Milestones.ListMilestones(repo.String(), opts)
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
internal/client/gitlab_test.go
View File

@ -35,7 +35,7 @@ func TestFailToExtractHashFromProjectFileURL(t *testing.T) {
} }
func TestGitLabReleaseURLTemplate(t *testing.T) { func TestGitLabReleaseURLTemplate(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
GitLabURLs: config.GitLabURLs{ GitLabURLs: config.GitLabURLs{
// default URL would otherwise be set via pipe/defaults // default URL would otherwise be set via pipe/defaults
Download: DefaultGitLabDownloadURL, Download: DefaultGitLabDownloadURL,

6
internal/exec/exec_test.go
View File

@ -29,7 +29,7 @@ func TestExecute(t *testing.T) {
// Preload artifacts // Preload artifacts
ctx.Artifacts = artifact.New() ctx.Artifacts = artifact.New()
var folder = t.TempDir() folder := t.TempDir()
for _, a := range []struct { for _, a := range []struct {
id string id string
ext string ext string
@ -43,8 +43,8 @@ func TestExecute(t *testing.T) {
{"checksum", "sum", artifact.Checksum}, {"checksum", "sum", artifact.Checksum},
{"signature", "sig", artifact.Signature}, {"signature", "sig", artifact.Signature},
} { } {
var file = filepath.Join(folder, "a."+a.ext) file := filepath.Join(folder, "a."+a.ext)
require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0644)) require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0o644))
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "a." + a.ext, Name: "a." + a.ext,
Goos: "linux", Goos: "linux",

4
internal/extrafiles/extra_files.go
View File

@ -12,7 +12,7 @@ import (
// Find resolves extra files globs et al into a map of names/paths or an error. // Find resolves extra files globs et al into a map of names/paths or an error.
func Find(files []config.ExtraFile) (map[string]string, error) { func Find(files []config.ExtraFile) (map[string]string, error) {
var result = map[string]string{} result := map[string]string{}
for _, extra := range files { for _, extra := range files {
if extra.Glob == "" { if extra.Glob == "" {
continue continue
@ -27,7 +27,7 @@ func Find(files []config.ExtraFile) (map[string]string, error) {
log.Debugf("ignoring directory %s", file) log.Debugf("ignoring directory %s", file)
continue continue
} }
var name = filepath.Base(file) name := filepath.Base(file)
if old, ok := result[name]; ok { if old, ok := result[name]; ok {
log.Warnf("overriding %s with %s for name %s", old, file, name) log.Warnf("overriding %s with %s for name %s", old, file, name)
} }

4
internal/git/git.go
View File

@ -19,12 +19,12 @@ func IsRepo() bool {
// RunEnv runs a git command with the specified env vars and returns its output or errors. // RunEnv runs a git command with the specified env vars and returns its output or errors.
func RunEnv(env map[string]string, args ...string) (string, error) { func RunEnv(env map[string]string, args ...string) (string, error) {
// TODO: use exex.CommandContext here and refactor. // TODO: use exex.CommandContext here and refactor.
var extraArgs = []string{ extraArgs := []string{
"-c", "log.showSignature=false", "-c", "log.showSignature=false",
} }
args = append(extraArgs, args...) args = append(extraArgs, args...)
/* #nosec */ /* #nosec */
var cmd = exec.Command("git", args...) cmd := exec.Command("git", args...)
if env != nil { if env != nil {
cmd.Env = []string{} cmd.Env = []string{}

16
internal/http/http.go
View File

@ -121,13 +121,13 @@ func getUsername(ctx *context.Context, upload *config.Upload, kind string) strin
return upload.Username return upload.Username
} }
var key = fmt.Sprintf("%s_%s_USERNAME", strings.ToUpper(kind), strings.ToUpper(upload.Name)) key := fmt.Sprintf("%s_%s_USERNAME", strings.ToUpper(kind), strings.ToUpper(upload.Name))
return ctx.Env[key] return ctx.Env[key]
} }
// password is optional // password is optional
func getPassword(ctx *context.Context, upload *config.Upload, kind string) string { func getPassword(ctx *context.Context, upload *config.Upload, kind string) string {
var key = fmt.Sprintf("%s_%s_SECRET", strings.ToUpper(kind), strings.ToUpper(upload.Name)) key := fmt.Sprintf("%s_%s_SECRET", strings.ToUpper(kind), strings.ToUpper(upload.Name))
return ctx.Env[key] return ctx.Env[key]
} }
@ -176,7 +176,7 @@ func Upload(ctx *context.Context, uploads []config.Upload, kind string, check Re
return err return err
} }
var filter = artifact.Or(filters...) filter := artifact.Or(filters...)
if len(upload.IDs) > 0 { if len(upload.IDs) > 0 {
filter = artifact.And(filter, artifact.ByIDs(upload.IDs...)) filter = artifact.And(filter, artifact.ByIDs(upload.IDs...))
} }
@ -189,9 +189,9 @@ func Upload(ctx *context.Context, uploads []config.Upload, kind string, check Re
} }
func uploadWithFilter(ctx *context.Context, upload *config.Upload, filter artifact.Filter, kind string, check ResponseChecker) error { func uploadWithFilter(ctx *context.Context, upload *config.Upload, filter artifact.Filter, kind string, check ResponseChecker) error {
var artifacts = ctx.Artifacts.Filter(filter).List() artifacts := ctx.Artifacts.Filter(filter).List()
log.Debugf("will upload %d artifacts", len(artifacts)) log.Debugf("will upload %d artifacts", len(artifacts))
var g = semerrgroup.New(ctx.Parallelism) g := semerrgroup.New(ctx.Parallelism)
for _, artifact := range artifacts { for _, artifact := range artifacts {
artifact := artifact artifact := artifact
g.Go(func() error { g.Go(func() error {
@ -233,7 +233,7 @@ func uploadAsset(ctx *context.Context, upload *config.Upload, artifact *artifact
} }
log.Debugf("generated target url: %s", targetURL) log.Debugf("generated target url: %s", targetURL)
var headers = map[string]string{} headers := map[string]string{}
if upload.CustomHeaders != nil { if upload.CustomHeaders != nil {
for name, value := range upload.CustomHeaders { for name, value := range upload.CustomHeaders {
resolvedValue, err := resolveHeaderTemplate(ctx, upload, artifact, value) resolvedValue, err := resolveHeaderTemplate(ctx, upload, artifact, value)
@ -364,7 +364,7 @@ func executeHTTPRequest(ctx *context.Context, upload *config.Upload, req *h.Requ
// resolveTargetTemplate returns the resolved target template with replaced variables // resolveTargetTemplate returns the resolved target template with replaced variables
// Those variables can be replaced by the given context, goos, goarch, goarm and more. // Those variables can be replaced by the given context, goos, goarch, goarm and more.
func resolveTargetTemplate(ctx *context.Context, upload *config.Upload, artifact *artifact.Artifact) (string, error) { func resolveTargetTemplate(ctx *context.Context, upload *config.Upload, artifact *artifact.Artifact) (string, error) {
var replacements = map[string]string{} replacements := map[string]string{}
if upload.Mode == ModeBinary { if upload.Mode == ModeBinary {
// TODO: multiple archives here // TODO: multiple archives here
replacements = ctx.Config.Archives[0].Replacements replacements = ctx.Config.Archives[0].Replacements
@ -377,7 +377,7 @@ func resolveTargetTemplate(ctx *context.Context, upload *config.Upload, artifact
// resolveHeaderTemplate returns the resolved custom header template with replaced variables // resolveHeaderTemplate returns the resolved custom header template with replaced variables
// Those variables can be replaced by the given context, goos, goarch, goarm and more. // Those variables can be replaced by the given context, goos, goarch, goarm and more.
func resolveHeaderTemplate(ctx *context.Context, upload *config.Upload, artifact *artifact.Artifact, headerValue string) (string, error) { func resolveHeaderTemplate(ctx *context.Context, upload *config.Upload, artifact *artifact.Artifact, headerValue string) (string, error) {
var replacements = map[string]string{} replacements := map[string]string{}
if upload.Mode == ModeBinary { if upload.Mode == ModeBinary {
// TODO: multiple archives here // TODO: multiple archives here
replacements = ctx.Config.Archives[0].Replacements replacements = ctx.Config.Archives[0].Replacements

68
internal/http/http_test.go
View File

@ -21,8 +21,8 @@ import (
) )
func TestAssetOpenDefault(t *testing.T) { func TestAssetOpenDefault(t *testing.T) {
var tf = filepath.Join(t.TempDir(), "asset") tf := filepath.Join(t.TempDir(), "asset")
require.NoError(t, os.WriteFile(tf, []byte("a"), 0765)) require.NoError(t, os.WriteFile(tf, []byte("a"), 0o765))
a, err := assetOpenDefault("blah", &artifact.Artifact{ a, err := assetOpenDefault("blah", &artifact.Artifact{
Path: tf, Path: tf,
@ -237,7 +237,7 @@ func TestUpload(t *testing.T) {
ctx.Env["TEST_A_USERNAME"] = "u2" ctx.Env["TEST_A_USERNAME"] = "u2"
ctx.Version = "2.1.0" ctx.Version = "2.1.0"
ctx.Artifacts = artifact.New() ctx.Artifacts = artifact.New()
var folder = t.TempDir() folder := t.TempDir()
for _, a := range []struct { for _, a := range []struct {
ext string ext string
typ artifact.Type typ artifact.Type
@ -250,8 +250,8 @@ func TestUpload(t *testing.T) {
{"sum", artifact.Checksum}, {"sum", artifact.Checksum},
{"sig", artifact.Signature}, {"sig", artifact.Signature},
} { } {
var file = filepath.Join(folder, "a."+a.ext) file := filepath.Join(folder, "a."+a.ext)
require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0644)) require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0o644))
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "a." + a.ext, Name: "a." + a.ext,
Goos: "linux", Goos: "linux",
@ -273,7 +273,8 @@ func TestUpload(t *testing.T) {
setup func(*httptest.Server) (*context.Context, config.Upload) setup func(*httptest.Server) (*context.Context, config.Upload)
check func(r []*h.Request) error check func(r []*h.Request) error
}{ }{
{"wrong-mode", true, true, true, true, {
"wrong-mode", true, true, true, true,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: "wrong-mode", Mode: "wrong-mode",
@ -285,7 +286,8 @@ func TestUpload(t *testing.T) {
}, },
checks(), checks(),
}, },
{"username-from-env", true, true, false, false, {
"username-from-env", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeArchive, Mode: ModeArchive,
@ -299,7 +301,8 @@ func TestUpload(t *testing.T) {
check{"/blah/2.1.0/a.tar", "u2", "x", content, map[string]string{}}, check{"/blah/2.1.0/a.tar", "u2", "x", content, map[string]string{}},
), ),
}, },
{"post", true, true, false, false, {
"post", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Method: h.MethodPost, Method: h.MethodPost,
@ -315,7 +318,8 @@ func TestUpload(t *testing.T) {
check{"/blah/2.1.0/a.tar", "u1", "x", content, map[string]string{}}, check{"/blah/2.1.0/a.tar", "u1", "x", content, map[string]string{}},
), ),
}, },
{"archive", true, true, false, false, {
"archive", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeArchive, Mode: ModeArchive,
@ -330,7 +334,8 @@ func TestUpload(t *testing.T) {
check{"/blah/2.1.0/a.tar", "u1", "x", content, map[string]string{}}, check{"/blah/2.1.0/a.tar", "u1", "x", content, map[string]string{}},
), ),
}, },
{"archive_with_os_tmpl", true, true, false, false, {
"archive_with_os_tmpl", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeArchive, Mode: ModeArchive,
@ -345,7 +350,8 @@ func TestUpload(t *testing.T) {
check{"/blah/2.1.0/linux/amd64/a.tar", "u1", "x", content, map[string]string{}}, check{"/blah/2.1.0/linux/amd64/a.tar", "u1", "x", content, map[string]string{}},
), ),
}, },
{"archive_with_ids", true, true, false, false, {
"archive_with_ids", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeArchive, Mode: ModeArchive,
@ -361,7 +367,8 @@ func TestUpload(t *testing.T) {
check{"/blah/2.1.0/a.tar", "u1", "x", content, map[string]string{}}, check{"/blah/2.1.0/a.tar", "u1", "x", content, map[string]string{}},
), ),
}, },
{"binary", true, true, false, false, {
"binary", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -373,7 +380,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{}}), checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{}}),
}, },
{"binary_with_os_tmpl", true, true, false, false, {
"binary_with_os_tmpl", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -385,7 +393,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/Linux/amd64/a.ubi", "u2", "x", content, map[string]string{}}), checks(check{"/blah/2.1.0/Linux/amd64/a.ubi", "u2", "x", content, map[string]string{}}),
}, },
{"binary_with_ids", true, true, false, false, {
"binary_with_ids", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -398,7 +407,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{}}), checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{}}),
}, },
{"binary-add-ending-bar", true, true, false, false, {
"binary-add-ending-bar", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -410,7 +420,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{}}), checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{}}),
}, },
{"archive-with-checksum-and-signature", true, true, false, false, {
"archive-with-checksum-and-signature", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeArchive, Mode: ModeArchive,
@ -429,7 +440,8 @@ func TestUpload(t *testing.T) {
check{"/blah/2.1.0/a.sig", "u3", "x", content, map[string]string{}}, check{"/blah/2.1.0/a.sig", "u3", "x", content, map[string]string{}},
), ),
}, },
{"bad-template", true, true, true, true, {
"bad-template", true, true, true, true,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -443,7 +455,8 @@ func TestUpload(t *testing.T) {
}, },
checks(), checks(),
}, },
{"failed-request", true, true, true, true, {
"failed-request", true, true, true, true,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -457,7 +470,8 @@ func TestUpload(t *testing.T) {
}, },
checks(), checks(),
}, },
{"broken-cert", false, true, false, true, {
"broken-cert", false, true, false, true,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -471,7 +485,8 @@ func TestUpload(t *testing.T) {
}, },
checks(), checks(),
}, },
{"skip-publishing", true, true, true, true, {
"skip-publishing", true, true, true, true,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
c := *ctx c := *ctx
c.SkipPublish = true c.SkipPublish = true
@ -479,7 +494,8 @@ func TestUpload(t *testing.T) {
}, },
checks(), checks(),
}, },
{"checksumheader", true, true, false, false, {
"checksumheader", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -492,7 +508,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{"-x-sha256": "5e2bf57d3f40c4b6df69daf1936cb766f832374b4fc0259a7cbff06e2f70f269"}}), checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{"-x-sha256": "5e2bf57d3f40c4b6df69daf1936cb766f832374b4fc0259a7cbff06e2f70f269"}}),
}, },
{"custom-headers", true, true, false, false, {
"custom-headers", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -507,7 +524,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{"x-custom-header-name": "custom-header-value"}}), checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{"x-custom-header-name": "custom-header-value"}}),
}, },
{"custom-headers-with-template", true, true, false, false, {
"custom-headers-with-template", true, true, false, false,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -522,7 +540,8 @@ func TestUpload(t *testing.T) {
}, },
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{"x-project-name": "blah"}}), checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content, map[string]string{"x-project-name": "blah"}}),
}, },
{"invalid-template-in-custom-headers", true, true, true, true, {
"invalid-template-in-custom-headers", true, true, true, true,
func(s *httptest.Server) (*context.Context, config.Upload) { func(s *httptest.Server) (*context.Context, config.Upload) {
return ctx, config.Upload{ return ctx, config.Upload{
Mode: ModeBinary, Mode: ModeBinary,
@ -572,7 +591,6 @@ func TestUpload(t *testing.T) {
}) })
} }
} }
} }
func cert(srv *httptest.Server) string { func cert(srv *httptest.Server) string {

4
internal/ids/ids_test.go
View File

@ -7,14 +7,14 @@ import (
) )
func TestIDs(t *testing.T) { func TestIDs(t *testing.T) {
var ids = New("foos") ids := New("foos")
ids.Inc("foo") ids.Inc("foo")
ids.Inc("bar") ids.Inc("bar")
require.NoError(t, ids.Validate()) require.NoError(t, ids.Validate())
} }
func TestIDsError(t *testing.T) { func TestIDsError(t *testing.T) {
var ids = New("builds") ids := New("builds")
ids.Inc("foo") ids.Inc("foo")
ids.Inc("bar") ids.Inc("bar")
ids.Inc("foo") ids.Inc("foo")

18
internal/pipe/archive/archive.go
View File

@ -46,12 +46,12 @@ func (Pipe) String() string {
// Default sets the pipe defaults. // Default sets the pipe defaults.
func (Pipe) Default(ctx *context.Context) error { func (Pipe) Default(ctx *context.Context) error {
var ids = ids.New("archives") ids := ids.New("archives")
if len(ctx.Config.Archives) == 0 { if len(ctx.Config.Archives) == 0 {
ctx.Config.Archives = append(ctx.Config.Archives, config.Archive{}) ctx.Config.Archives = append(ctx.Config.Archives, config.Archive{})
} }
for i := range ctx.Config.Archives { for i := range ctx.Config.Archives {
var archive = &ctx.Config.Archives[i] archive := &ctx.Config.Archives[i]
if archive.Format == "" { if archive.Format == "" {
archive.Format = "tar.gz" archive.Format = "tar.gz"
} }
@ -88,10 +88,10 @@ func (Pipe) Default(ctx *context.Context) error {
// Run the pipe. // Run the pipe.
func (Pipe) Run(ctx *context.Context) error { func (Pipe) Run(ctx *context.Context) error {
var g = semerrgroup.New(ctx.Parallelism) g := semerrgroup.New(ctx.Parallelism)
for i, archive := range ctx.Config.Archives { for i, archive := range ctx.Config.Archives {
archive := archive archive := archive
var artifacts = ctx.Artifacts.Filter( artifacts := ctx.Artifacts.Filter(
artifact.And( artifact.And(
artifact.ByType(artifact.Binary), artifact.ByType(artifact.Binary),
artifact.ByIDs(archive.Builds...), artifact.ByIDs(archive.Builds...),
@ -115,7 +115,7 @@ func (Pipe) Run(ctx *context.Context) error {
} }
func checkArtifacts(artifacts map[string][]*artifact.Artifact) error { func checkArtifacts(artifacts map[string][]*artifact.Artifact) error {
var lens = map[int]bool{} lens := map[int]bool{}
for _, v := range artifacts { for _, v := range artifacts {
lens[len(v)] = true lens[len(v)] = true
} }
@ -126,7 +126,7 @@ func checkArtifacts(artifacts map[string][]*artifact.Artifact) error {
} }
func create(ctx *context.Context, arch config.Archive, binaries []*artifact.Artifact) error { func create(ctx *context.Context, arch config.Archive, binaries []*artifact.Artifact) error {
var format = packageFormat(arch, binaries[0].Goos) format := packageFormat(arch, binaries[0].Goos)
folder, err := tmpl.New(ctx). folder, err := tmpl.New(ctx).
WithArtifact(binaries[0], arch.Replacements). WithArtifact(binaries[0], arch.Replacements).
Apply(arch.NameTemplate) Apply(arch.NameTemplate)
@ -135,7 +135,7 @@ func create(ctx *context.Context, arch config.Archive, binaries []*artifact.Arti
} }
archivePath := filepath.Join(ctx.Config.Dist, folder+"."+format) archivePath := filepath.Join(ctx.Config.Dist, folder+"."+format)
lock.Lock() lock.Lock()
if err := os.MkdirAll(filepath.Dir(archivePath), 0755|os.ModeDir); err != nil { if err := os.MkdirAll(filepath.Dir(archivePath), 0o755|os.ModeDir); err != nil {
lock.Unlock() lock.Unlock()
return err return err
} }
@ -151,7 +151,7 @@ func create(ctx *context.Context, arch config.Archive, binaries []*artifact.Arti
lock.Unlock() lock.Unlock()
defer archiveFile.Close() defer archiveFile.Close()
var log = log.WithField("archive", archivePath) log := log.WithField("archive", archivePath)
log.Info("creating") log.Info("creating")
template := tmpl.New(ctx). template := tmpl.New(ctx).
@ -161,7 +161,7 @@ func create(ctx *context.Context, arch config.Archive, binaries []*artifact.Arti
return err return err
} }
var a = NewEnhancedArchive(archive.New(archiveFile), wrap) a := NewEnhancedArchive(archive.New(archiveFile), wrap)
defer a.Close() defer a.Close()
files, err := findFiles(template, arch) files, err := findFiles(template, arch)

158
internal/pipe/archive/archive_test.go
View File

@ -25,19 +25,19 @@ func TestDescription(t *testing.T) {
func createFakeBinary(t *testing.T, dist, arch, bin string) { func createFakeBinary(t *testing.T, dist, arch, bin string) {
t.Helper() t.Helper()
var path = filepath.Join(dist, arch, bin) path := filepath.Join(dist, arch, bin)
require.NoError(t, os.MkdirAll(filepath.Dir(path), 0755)) require.NoError(t, os.MkdirAll(filepath.Dir(path), 0o755))
f, err := os.Create(path) f, err := os.Create(path)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
} }
func TestRunPipe(t *testing.T) { func TestRunPipe(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
for _, format := range []string{"tar.gz", "zip"} { for _, format := range []string{"tar.gz", "zip"} {
t.Run("Archive format "+format, func(t *testing.T) { t.Run("Archive format "+format, func(t *testing.T) {
var dist = filepath.Join(folder, format+"_dist") dist := filepath.Join(folder, format+"_dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
for _, arch := range []string{"darwinamd64", "linux386", "linuxarm7", "linuxmipssoftfloat"} { for _, arch := range []string{"darwinamd64", "linux386", "linuxarm7", "linuxmipssoftfloat"} {
createFakeBinary(t, dist, arch, "bin/mybin") createFakeBinary(t, dist, arch, "bin/mybin")
} }
@ -47,11 +47,11 @@ func TestRunPipe(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
} }
require.NoError(t, os.MkdirAll(filepath.Join(folder, "foo", "bar", "foobar"), 0755)) require.NoError(t, os.MkdirAll(filepath.Join(folder, "foo", "bar", "foobar"), 0o755))
f, err := os.Create(filepath.Join(filepath.Join(folder, "foo", "bar", "foobar", "blah.txt"))) f, err := os.Create(filepath.Join(filepath.Join(folder, "foo", "bar", "foobar", "blah.txt")))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
ProjectName: "foobar", ProjectName: "foobar",
@ -74,7 +74,7 @@ func TestRunPipe(t *testing.T) {
}, },
}, },
) )
var darwinBuild = &artifact.Artifact{ darwinBuild := &artifact.Artifact{
Goos: "darwin", Goos: "darwin",
Goarch: "amd64", Goarch: "amd64",
Name: "bin/mybin", Name: "bin/mybin",
@ -85,7 +85,7 @@ func TestRunPipe(t *testing.T) {
"ID": "default", "ID": "default",
}, },
} }
var linux386Build = &artifact.Artifact{ linux386Build := &artifact.Artifact{
Goos: "linux", Goos: "linux",
Goarch: "386", Goarch: "386",
Name: "bin/mybin", Name: "bin/mybin",
@ -96,7 +96,7 @@ func TestRunPipe(t *testing.T) {
"ID": "default", "ID": "default",
}, },
} }
var linuxArmBuild = &artifact.Artifact{ linuxArmBuild := &artifact.Artifact{
Goos: "linux", Goos: "linux",
Goarch: "arm", Goarch: "arm",
Goarm: "7", Goarm: "7",
@ -108,7 +108,7 @@ func TestRunPipe(t *testing.T) {
"ID": "default", "ID": "default",
}, },
} }
var linuxMipsBuild = &artifact.Artifact{ linuxMipsBuild := &artifact.Artifact{
Goos: "linux", Goos: "linux",
Goarch: "mips", Goarch: "mips",
Gomips: "softfloat", Gomips: "softfloat",
@ -120,7 +120,7 @@ func TestRunPipe(t *testing.T) {
"ID": "default", "ID": "default",
}, },
} }
var windowsBuild = &artifact.Artifact{ windowsBuild := &artifact.Artifact{
Goos: "windows", Goos: "windows",
Goarch: "amd64", Goarch: "amd64",
Name: "bin/mybin.exe", Name: "bin/mybin.exe",
@ -141,7 +141,7 @@ func TestRunPipe(t *testing.T) {
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
ctx.Config.Archives[0].Format = format ctx.Config.Archives[0].Format = format
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)).List() archives := ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)).List()
for _, arch := range archives { for _, arch := range archives {
require.Equal(t, "myid", arch.Extra["ID"].(string), "all archives should have the archive ID set") require.Equal(t, "myid", arch.Extra["ID"].(string), "all archives should have the archive ID set")
} }
@ -183,14 +183,14 @@ func TestRunPipe(t *testing.T) {
} }
func TestRunPipeDifferentBinaryCount(t *testing.T) { func TestRunPipeDifferentBinaryCount(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
for _, arch := range []string{"darwinamd64", "linuxamd64"} { for _, arch := range []string{"darwinamd64", "linuxamd64"} {
createFakeBinary(t, dist, arch, "bin/mybin") createFakeBinary(t, dist, arch, "bin/mybin")
} }
createFakeBinary(t, dist, "darwinamd64", "bin/foobar") createFakeBinary(t, dist, "darwinamd64", "bin/foobar")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: dist, Dist: dist,
ProjectName: "foobar", ProjectName: "foobar",
Archives: []config.Archive{ Archives: []config.Archive{
@ -202,7 +202,7 @@ func TestRunPipeDifferentBinaryCount(t *testing.T) {
}, },
}, },
}) })
var darwinBuild = &artifact.Artifact{ darwinBuild := &artifact.Artifact{
Goos: "darwin", Goos: "darwin",
Goarch: "amd64", Goarch: "amd64",
Name: "bin/mybin", Name: "bin/mybin",
@ -213,7 +213,7 @@ func TestRunPipeDifferentBinaryCount(t *testing.T) {
"ID": "default", "ID": "default",
}, },
} }
var darwinBuild2 = &artifact.Artifact{ darwinBuild2 := &artifact.Artifact{
Goos: "darwin", Goos: "darwin",
Goarch: "amd64", Goarch: "amd64",
Name: "bin/foobar", Name: "bin/foobar",
@ -224,7 +224,7 @@ func TestRunPipeDifferentBinaryCount(t *testing.T) {
"ID": "foobar", "ID": "foobar",
}, },
} }
var linuxArmBuild = &artifact.Artifact{ linuxArmBuild := &artifact.Artifact{
Goos: "linux", Goos: "linux",
Goarch: "amd64", Goarch: "amd64",
Name: "bin/mybin", Name: "bin/mybin",
@ -254,10 +254,10 @@ func TestRunPipeDifferentBinaryCount(t *testing.T) {
} }
func TestRunPipeNoBinaries(t *testing.T) { func TestRunPipeNoBinaries(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: dist, Dist: dist,
ProjectName: "foobar", ProjectName: "foobar",
Archives: []config.Archive{{}}, Archives: []config.Archive{{}},
@ -275,7 +275,7 @@ func zipFiles(t *testing.T, path string) []string {
require.NoError(t, err) require.NoError(t, err)
r, err := zip.NewReader(f, info.Size()) r, err := zip.NewReader(f, info.Size())
require.NoError(t, err) require.NoError(t, err)
var paths = make([]string, len(r.File)) paths := make([]string, len(r.File))
for i, zf := range r.File { for i, zf := range r.File {
paths[i] = zf.Name paths[i] = zf.Name
} }
@ -290,7 +290,7 @@ func tarFiles(t *testing.T, path string) []string {
gr, err := gzip.NewReader(f) gr, err := gzip.NewReader(f)
require.NoError(t, err) require.NoError(t, err)
defer gr.Close() defer gr.Close()
var r = tar.NewReader(gr) r := tar.NewReader(gr)
var paths []string var paths []string
for { for {
next, err := r.Next() next, err := r.Next()
@ -304,11 +304,11 @@ func tarFiles(t *testing.T, path string) []string {
} }
func TestRunPipeBinary(t *testing.T) { func TestRunPipeBinary(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
@ -318,7 +318,7 @@ func TestRunPipeBinary(t *testing.T) {
f, err = os.Create(filepath.Join(folder, "README.md")) f, err = os.Create(filepath.Join(folder, "README.md"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
Archives: []config.Archive{ Archives: []config.Archive{
@ -356,7 +356,7 @@ func TestRunPipeBinary(t *testing.T) {
}, },
}) })
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
var binaries = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary)) binaries := ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary))
darwin := binaries.Filter(artifact.ByGoos("darwin")).List()[0] darwin := binaries.Filter(artifact.ByGoos("darwin")).List()[0]
windows := binaries.Filter(artifact.ByGoos("windows")).List()[0] windows := binaries.Filter(artifact.ByGoos("windows")).List()[0]
require.Equal(t, "mybin_0.0.1_darwin_amd64", darwin.Name) require.Equal(t, "mybin_0.0.1_darwin_amd64", darwin.Name)
@ -365,7 +365,7 @@ func TestRunPipeBinary(t *testing.T) {
} }
func TestRunPipeDistRemoved(t *testing.T) { func TestRunPipeDistRemoved(t *testing.T) {
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: "/tmp/path/to/nope", Dist: "/tmp/path/to/nope",
Archives: []config.Archive{ Archives: []config.Archive{
@ -395,14 +395,14 @@ func TestRunPipeDistRemoved(t *testing.T) {
} }
func TestRunPipeInvalidGlob(t *testing.T) { func TestRunPipeInvalidGlob(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
Archives: []config.Archive{ Archives: []config.Archive{
@ -433,14 +433,14 @@ func TestRunPipeInvalidGlob(t *testing.T) {
} }
func TestRunPipeInvalidNameTemplate(t *testing.T) { func TestRunPipeInvalidNameTemplate(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
Archives: []config.Archive{ Archives: []config.Archive{
@ -468,14 +468,14 @@ func TestRunPipeInvalidNameTemplate(t *testing.T) {
} }
func TestRunPipeInvalidFilesNameTemplate(t *testing.T) { func TestRunPipeInvalidFilesNameTemplate(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
Archives: []config.Archive{ Archives: []config.Archive{
@ -506,14 +506,14 @@ func TestRunPipeInvalidFilesNameTemplate(t *testing.T) {
} }
func TestRunPipeInvalidWrapInDirectoryTemplate(t *testing.T) { func TestRunPipeInvalidWrapInDirectoryTemplate(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
Archives: []config.Archive{ Archives: []config.Archive{
@ -542,17 +542,17 @@ func TestRunPipeInvalidWrapInDirectoryTemplate(t *testing.T) {
} }
func TestRunPipeWrap(t *testing.T) { func TestRunPipeWrap(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
f, err = os.Create(filepath.Join(folder, "README.md")) f, err = os.Create(filepath.Join(folder, "README.md"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
Archives: []config.Archive{ Archives: []config.Archive{
@ -585,7 +585,7 @@ func TestRunPipeWrap(t *testing.T) {
}) })
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)).List() archives := ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)).List()
require.Len(t, archives, 1) require.Len(t, archives, 1)
require.Equal(t, "foo_macOS", archives[0].ExtraOr("WrappedIn", "")) require.Equal(t, "foo_macOS", archives[0].ExtraOr("WrappedIn", ""))
@ -608,7 +608,7 @@ func TestRunPipeWrap(t *testing.T) {
} }
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Archives: []config.Archive{}, Archives: []config.Archive{},
}, },
@ -620,7 +620,7 @@ func TestDefault(t *testing.T) {
} }
func TestDefaultSet(t *testing.T) { func TestDefaultSet(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Archives: []config.Archive{ Archives: []config.Archive{
{ {
@ -641,7 +641,7 @@ func TestDefaultSet(t *testing.T) {
} }
func TestDefaultFormatBinary(t *testing.T) { func TestDefaultFormatBinary(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Archives: []config.Archive{ Archives: []config.Archive{
{ {
@ -655,7 +655,7 @@ func TestDefaultFormatBinary(t *testing.T) {
} }
func TestFormatFor(t *testing.T) { func TestFormatFor(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Archives: []config.Archive{ Archives: []config.Archive{
{ {
@ -676,11 +676,11 @@ func TestFormatFor(t *testing.T) {
} }
func TestBinaryOverride(t *testing.T) { func TestBinaryOverride(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
@ -692,7 +692,7 @@ func TestBinaryOverride(t *testing.T) {
require.NoError(t, f.Close()) require.NoError(t, f.Close())
for _, format := range []string{"tar.gz", "zip"} { for _, format := range []string{"tar.gz", "zip"} {
t.Run("Archive format "+format, func(t *testing.T) { t.Run("Archive format "+format, func(t *testing.T) {
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
ProjectName: "foobar", ProjectName: "foobar",
@ -741,7 +741,7 @@ func TestBinaryOverride(t *testing.T) {
ctx.Config.Archives[0].Format = format ctx.Config.Archives[0].Format = format
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)) archives := ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive))
darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0] darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0]
require.Equal(t, "foobar_0.0.1_darwin_amd64."+format, darwin.Name) require.Equal(t, "foobar_0.0.1_darwin_amd64."+format, darwin.Name)
require.Equal(t, format, darwin.ExtraOr("Format", "")) require.Equal(t, format, darwin.ExtraOr("Format", ""))
@ -756,18 +756,18 @@ func TestBinaryOverride(t *testing.T) {
} }
func TestRunPipeSameArchiveFilename(t *testing.T) { func TestRunPipeSameArchiveFilename(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0o755))
f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) f, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
f, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) f, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
ProjectName: "foobar", ProjectName: "foobar",
@ -815,7 +815,7 @@ func TestRunPipeSameArchiveFilename(t *testing.T) {
} }
func TestDuplicateFilesInsideArchive(t *testing.T) { func TestDuplicateFilesInsideArchive(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
f, err := ioutil.TempFile(folder, "") f, err := ioutil.TempFile(folder, "")
require.NoError(t, err) require.NoError(t, err)
@ -856,7 +856,7 @@ func TestWrapInDirectory(t *testing.T) {
} }
func TestSeveralArchivesWithTheSameID(t *testing.T) { func TestSeveralArchivesWithTheSameID(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Archives: []config.Archive{ Archives: []config.Archive{
{ {

56
internal/pipe/artifactory/artifactory_test.go
View File

@ -35,18 +35,14 @@ func teardown() {
server.Close() server.Close()
} }
func testMethod(t *testing.T, r *http.Request, want string) { func requireMethodPut(t *testing.T, r *http.Request) {
t.Helper() t.Helper()
if got := r.Method; got != want { require.Equal(t, http.MethodPut, r.Method)
t.Errorf("Request method: %v, want %v", got, want)
}
} }
func testHeader(t *testing.T, r *http.Request, header, want string) { func requireHeader(t *testing.T, r *http.Request, header, want string) {
t.Helper() t.Helper()
if got := r.Header.Get(header); got != want { require.Equal(t, want, r.Header.Get(header))
t.Errorf("Header.Get(%q) returned %q, want %q", header, got, want)
}
} }
// TODO: improve all tests bellow by checking wether the mocked handlers // TODO: improve all tests bellow by checking wether the mocked handlers
@ -66,10 +62,10 @@ func TestRunPipe_ModeBinary(t *testing.T) {
// Dummy artifactories // Dummy artifactories
mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -92,10 +88,10 @@ func TestRunPipe_ModeBinary(t *testing.T) {
}`) }`)
}) })
mux.HandleFunc("/example-repo-local/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -118,10 +114,10 @@ func TestRunPipe_ModeBinary(t *testing.T) {
}`) }`)
}) })
mux.HandleFunc("/production-repo-remote/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/production-repo-remote/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "productionuser" with secret "productionuser-apikey" // Basic auth of user "productionuser" with secret "productionuser-apikey"
testHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5") requireHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -144,10 +140,10 @@ func TestRunPipe_ModeBinary(t *testing.T) {
}`) }`)
}) })
mux.HandleFunc("/production-repo-remote/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/production-repo-remote/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "productionuser" with secret "productionuser-apikey" // Basic auth of user "productionuser" with secret "productionuser-apikey"
testHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5") requireHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -255,9 +251,9 @@ func TestRunPipe_ModeArchive(t *testing.T) {
// Dummy artifactories // Dummy artifactories
mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.tar.gz", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.tar.gz", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -281,9 +277,9 @@ func TestRunPipe_ModeArchive(t *testing.T) {
uploads.Store("targz", true) uploads.Store("targz", true)
}) })
mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.deb", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.deb", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -399,10 +395,10 @@ func TestRunPipe_BadCredentials(t *testing.T) {
// Dummy artifactories // Dummy artifactories
mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusUnauthorized) w.WriteHeader(http.StatusUnauthorized)
fmt.Fprint(w, `{ fmt.Fprint(w, `{
@ -459,10 +455,10 @@ func TestRunPipe_UnparsableErrorResponse(t *testing.T) {
// Dummy artifactories // Dummy artifactories
mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusUnauthorized) w.WriteHeader(http.StatusUnauthorized)
fmt.Fprint(w, `...{ fmt.Fprint(w, `...{

2
internal/pipe/before/before_test.go
View File

@ -60,7 +60,7 @@ func TestRunPipeFail(t *testing.T) {
} }
func TestRunWithEnv(t *testing.T) { func TestRunWithEnv(t *testing.T) {
var f = filepath.Join(t.TempDir(), "testfile") f := filepath.Join(t.TempDir(), "testfile")
require.NoError(t, Pipe{}.Run(context.New( require.NoError(t, Pipe{}.Run(context.New(
config.Project{ config.Project{
Env: []string{ Env: []string{

24
internal/pipe/blob/blob_test.go
View File

@ -23,7 +23,7 @@ func TestNoBlob(t *testing.T) {
func TestDefaultsNoConfig(t *testing.T) { func TestDefaultsNoConfig(t *testing.T) {
errorString := "bucket or provider cannot be empty" errorString := "bucket or provider cannot be empty"
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Blobs: []config.Blob{ Blobs: []config.Blob{
{}, {},
}, },
@ -33,7 +33,7 @@ func TestDefaultsNoConfig(t *testing.T) {
func TestDefaultsNoBucket(t *testing.T) { func TestDefaultsNoBucket(t *testing.T) {
errorString := "bucket or provider cannot be empty" errorString := "bucket or provider cannot be empty"
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Blobs: []config.Blob{ Blobs: []config.Blob{
{ {
Provider: "azblob", Provider: "azblob",
@ -45,7 +45,7 @@ func TestDefaultsNoBucket(t *testing.T) {
func TestDefaultsNoProvider(t *testing.T) { func TestDefaultsNoProvider(t *testing.T) {
errorString := "bucket or provider cannot be empty" errorString := "bucket or provider cannot be empty"
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Blobs: []config.Blob{ Blobs: []config.Blob{
{ {
Bucket: "goreleaser-bucket", Bucket: "goreleaser-bucket",
@ -56,7 +56,7 @@ func TestDefaultsNoProvider(t *testing.T) {
} }
func TestDefaults(t *testing.T) { func TestDefaults(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Blobs: []config.Blob{ Blobs: []config.Blob{
{ {
Bucket: "foo", Bucket: "foo",
@ -86,7 +86,7 @@ func TestDefaults(t *testing.T) {
} }
func TestDefaultsWithProvider(t *testing.T) { func TestDefaultsWithProvider(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Blobs: []config.Blob{ Blobs: []config.Blob{
{ {
Bucket: "foo", Bucket: "foo",
@ -110,7 +110,7 @@ func TestPipe_Publish(t *testing.T) {
} }
func TestPipe_PublishExtraFiles(t *testing.T) { func TestPipe_PublishExtraFiles(t *testing.T) {
var extra = []config.ExtraFile{ extra := []config.ExtraFile{
{ {
Glob: "./testdata/file.golden", Glob: "./testdata/file.golden",
}, },
@ -122,14 +122,14 @@ func pipePublish(t *testing.T, extra []config.ExtraFile) {
t.Helper() t.Helper()
gcloudCredentials, _ := filepath.Abs("./testdata/credentials.json") gcloudCredentials, _ := filepath.Abs("./testdata/credentials.json")
var folder = t.TempDir() folder := t.TempDir()
tgzpath := filepath.Join(folder, "bin.tar.gz") tgzpath := filepath.Join(folder, "bin.tar.gz")
debpath := filepath.Join(folder, "bin.deb") debpath := filepath.Join(folder, "bin.deb")
require.NoError(t, os.WriteFile(tgzpath, []byte("fake\ntargz"), 0744)) require.NoError(t, os.WriteFile(tgzpath, []byte("fake\ntargz"), 0o744))
require.NoError(t, os.WriteFile(debpath, []byte("fake\ndeb"), 0744)) require.NoError(t, os.WriteFile(debpath, []byte("fake\ndeb"), 0o744))
// Azure Blob Context // Azure Blob Context
var azblobctx = context.New(config.Project{ azblobctx := context.New(config.Project{
Dist: folder, Dist: folder,
ProjectName: "testupload", ProjectName: "testupload",
Blobs: []config.Blob{ Blobs: []config.Blob{
@ -154,7 +154,7 @@ func pipePublish(t *testing.T, extra []config.ExtraFile) {
}) })
// Google Cloud Storage Context // Google Cloud Storage Context
var gsctx = context.New(config.Project{ gsctx := context.New(config.Project{
Dist: folder, Dist: folder,
ProjectName: "testupload", ProjectName: "testupload",
Blobs: []config.Blob{ Blobs: []config.Blob{
@ -180,7 +180,7 @@ func pipePublish(t *testing.T, extra []config.ExtraFile) {
}) })
// AWS S3 Context // AWS S3 Context
var s3ctx = context.New(config.Project{ s3ctx := context.New(config.Project{
Dist: folder, Dist: folder,
ProjectName: "testupload", ProjectName: "testupload",
Blobs: []config.Blob{ Blobs: []config.Blob{

15
internal/pipe/blob/upload.go
View File

@ -40,7 +40,7 @@ func urlFor(ctx *context.Context, conf config.Blob) (string, error) {
return bucketURL, nil return bucketURL, nil
} }
var query = url.Values{} query := url.Values{}
if conf.Endpoint != "" { if conf.Endpoint != "" {
query.Add("endpoint", conf.Endpoint) query.Add("endpoint", conf.Endpoint)
query.Add("s3ForcePathStyle", "true") query.Add("s3ForcePathStyle", "true")
@ -73,7 +73,7 @@ func doUpload(ctx *context.Context, conf config.Blob) error {
return err return err
} }
var filter = artifact.Or( filter := artifact.Or(
artifact.ByType(artifact.UploadableArchive), artifact.ByType(artifact.UploadableArchive),
artifact.ByType(artifact.UploadableBinary), artifact.ByType(artifact.UploadableBinary),
artifact.ByType(artifact.UploadableSourceArchive), artifact.ByType(artifact.UploadableSourceArchive),
@ -85,19 +85,19 @@ func doUpload(ctx *context.Context, conf config.Blob) error {
filter = artifact.And(filter, artifact.ByIDs(conf.IDs...)) filter = artifact.And(filter, artifact.ByIDs(conf.IDs...))
} }
var up = newUploader(ctx) up := newUploader(ctx)
if err := up.Open(ctx, bucketURL); err != nil { if err := up.Open(ctx, bucketURL); err != nil {
return handleError(err, bucketURL) return handleError(err, bucketURL)
} }
defer up.Close() defer up.Close()
var g = semerrgroup.New(ctx.Parallelism) g := semerrgroup.New(ctx.Parallelism)
for _, artifact := range ctx.Artifacts.Filter(filter).List() { for _, artifact := range ctx.Artifacts.Filter(filter).List() {
artifact := artifact artifact := artifact
g.Go(func() error { g.Go(func() error {
// TODO: replace this with ?prefix=folder on the bucket url // TODO: replace this with ?prefix=folder on the bucket url
var dataFile = artifact.Path dataFile := artifact.Path
var uploadFile = path.Join(folder, artifact.Name) uploadFile := path.Join(folder, artifact.Name)
err := uploadData(ctx, conf, up, dataFile, uploadFile, bucketURL) err := uploadData(ctx, conf, up, dataFile, uploadFile, bucketURL)
@ -113,7 +113,7 @@ func doUpload(ctx *context.Context, conf config.Blob) error {
name := name name := name
fullpath := fullpath fullpath := fullpath
g.Go(func() error { g.Go(func() error {
var uploadFile = path.Join(folder, name) uploadFile := path.Join(folder, name)
err := uploadData(ctx, conf, up, fullpath, uploadFile, bucketURL) err := uploadData(ctx, conf, up, fullpath, uploadFile, bucketURL)
@ -215,6 +215,7 @@ func (u *productionUploader) Close() error {
} }
return u.bucket.Close() return u.bucket.Close()
} }
func (u *productionUploader) Open(ctx *context.Context, bucket string) error { func (u *productionUploader) Open(ctx *context.Context, bucket string) error {
log.WithFields(log.Fields{ log.WithFields(log.Fields{
"bucket": bucket, "bucket": bucket,

87
internal/pipe/brew/brew_test.go
View File

@ -91,9 +91,9 @@ func TestFullFormulae(t *testing.T) {
}), data) }), data)
require.NoError(t, err) require.NoError(t, err)
var golden = "testdata/test.rb.golden" golden := "testdata/test.rb.golden"
if *update { if *update {
err := os.WriteFile(golden, []byte(formulae), 0655) err := os.WriteFile(golden, []byte(formulae), 0o655)
require.NoError(t, err) require.NoError(t, err)
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
@ -111,9 +111,9 @@ func TestFullFormulaeLinuxOnly(t *testing.T) {
}), data) }), data)
require.NoError(t, err) require.NoError(t, err)
var golden = "testdata/test_linux_only.rb.golden" golden := "testdata/test_linux_only.rb.golden"
if *update { if *update {
err := os.WriteFile(golden, []byte(formulae), 0655) err := os.WriteFile(golden, []byte(formulae), 0o655)
require.NoError(t, err) require.NoError(t, err)
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
@ -131,7 +131,7 @@ func TestFormulaeSimple(t *testing.T) {
} }
func TestSplit(t *testing.T) { func TestSplit(t *testing.T) {
var parts = split("system \"true\"\nsystem \"#{bin}/foo -h\"") parts := split("system \"true\"\nsystem \"#{bin}/foo -h\"")
require.Equal(t, []string{"system \"true\"", "system \"#{bin}/foo -h\""}, parts) require.Equal(t, []string{"system \"true\"", "system \"#{bin}/foo -h\""}, parts)
parts = split("") parts = split("")
require.Equal(t, []string{}, parts) require.Equal(t, []string{}, parts)
@ -180,8 +180,8 @@ func TestRunPipe(t *testing.T) {
}, },
} { } {
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = &context.Context{ ctx := &context.Context{
Git: context.GitInfo{ Git: context.GitInfo{
CurrentTag: "v1.0.1", CurrentTag: "v1.0.1",
}, },
@ -223,7 +223,7 @@ func TestRunPipe(t *testing.T) {
"ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460", "ArtifactUploadHash": "820ead5d9d2266c728dce6d4d55b6460",
}, },
}) })
var path = filepath.Join(folder, "bin.tar.gz") path := filepath.Join(folder, "bin.tar.gz")
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "bin.tar.gz", Name: "bin.tar.gz",
Path: path, Path: path,
@ -241,13 +241,13 @@ func TestRunPipe(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
client := &DummyClient{} client := &DummyClient{}
var distFile = filepath.Join(folder, name+".rb") distFile := filepath.Join(folder, name+".rb")
require.NoError(t, doRun(ctx, ctx.Config.Brews[0], client)) require.NoError(t, doRun(ctx, ctx.Config.Brews[0], client))
require.True(t, client.CreatedFile) require.True(t, client.CreatedFile)
var golden = fmt.Sprintf("testdata/%s.rb.golden", name) golden := fmt.Sprintf("testdata/%s.rb.golden", name)
if *update { if *update {
require.NoError(t, os.WriteFile(golden, []byte(client.Content), 0655)) require.NoError(t, os.WriteFile(golden, []byte(client.Content), 0o655))
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)
@ -261,8 +261,8 @@ func TestRunPipe(t *testing.T) {
} }
func TestRunPipeNameTemplate(t *testing.T) { func TestRunPipeNameTemplate(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = &context.Context{ ctx := &context.Context{
Git: context.GitInfo{ Git: context.GitInfo{
CurrentTag: "v1.0.1", CurrentTag: "v1.0.1",
}, },
@ -288,7 +288,7 @@ func TestRunPipeNameTemplate(t *testing.T) {
}, },
}, },
} }
var path = filepath.Join(folder, "bin.tar.gz") path := filepath.Join(folder, "bin.tar.gz")
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "bin.tar.gz", Name: "bin.tar.gz",
Path: path, Path: path,
@ -306,13 +306,13 @@ func TestRunPipeNameTemplate(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
client := &DummyClient{} client := &DummyClient{}
var distFile = filepath.Join(folder, "foo_is_bar.rb") distFile := filepath.Join(folder, "foo_is_bar.rb")
require.NoError(t, doRun(ctx, ctx.Config.Brews[0], client)) require.NoError(t, doRun(ctx, ctx.Config.Brews[0], client))
require.True(t, client.CreatedFile) require.True(t, client.CreatedFile)
var golden = "testdata/foo_is_bar.rb.golden" golden := "testdata/foo_is_bar.rb.golden"
if *update { if *update {
require.NoError(t, os.WriteFile(golden, []byte(client.Content), 0655)) require.NoError(t, os.WriteFile(golden, []byte(client.Content), 0o655))
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)
@ -324,8 +324,8 @@ func TestRunPipeNameTemplate(t *testing.T) {
} }
func TestRunPipeMultipleBrewsWithSkip(t *testing.T) { func TestRunPipeMultipleBrewsWithSkip(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = &context.Context{ ctx := &context.Context{
Git: context.GitInfo{ Git: context.GitInfo{
CurrentTag: "v1.0.1", CurrentTag: "v1.0.1",
}, },
@ -373,7 +373,7 @@ func TestRunPipeMultipleBrewsWithSkip(t *testing.T) {
}, },
}, },
} }
var path = filepath.Join(folder, "bin.tar.gz") path := filepath.Join(folder, "bin.tar.gz")
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "bin.tar.gz", Name: "bin.tar.gz",
Path: path, Path: path,
@ -391,16 +391,15 @@ func TestRunPipeMultipleBrewsWithSkip(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var cli = &DummyClient{} cli := &DummyClient{}
require.EqualError(t, publishAll(ctx, cli), `brew.skip_upload is set`) require.EqualError(t, publishAll(ctx, cli), `brew.skip_upload is set`)
require.True(t, cli.CreatedFile) require.True(t, cli.CreatedFile)
for _, brew := range ctx.Config.Brews { for _, brew := range ctx.Config.Brews {
var distFile = filepath.Join(folder, brew.Name+".rb") distFile := filepath.Join(folder, brew.Name+".rb")
_, err := os.Stat(distFile) _, err := os.Stat(distFile)
require.NoError(t, err, "file should exist: "+distFile) require.NoError(t, err, "file should exist: "+distFile)
} }
} }
func TestRunPipeForMultipleArmVersions(t *testing.T) { func TestRunPipeForMultipleArmVersions(t *testing.T) {
@ -415,8 +414,8 @@ func TestRunPipeForMultipleArmVersions(t *testing.T) {
ctx.Config.Brews[0].Goarm = "7" ctx.Config.Brews[0].Goarm = "7"
}, },
} { } {
var folder = t.TempDir() folder := t.TempDir()
var ctx = &context.Context{ ctx := &context.Context{
TokenType: context.TokenTypeGitHub, TokenType: context.TokenTypeGitHub,
Git: context.GitInfo{ Git: context.GitInfo{
CurrentTag: "v1.0.1", CurrentTag: "v1.0.1",
@ -493,7 +492,7 @@ func TestRunPipeForMultipleArmVersions(t *testing.T) {
goarm: "7", goarm: "7",
}, },
} { } {
var path = filepath.Join(folder, fmt.Sprintf("%s.tar.gz", a.name)) path := filepath.Join(folder, fmt.Sprintf("%s.tar.gz", a.name))
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: fmt.Sprintf("%s.tar.gz", a.name), Name: fmt.Sprintf("%s.tar.gz", a.name),
Path: path, Path: path,
@ -512,13 +511,13 @@ func TestRunPipeForMultipleArmVersions(t *testing.T) {
} }
client := &DummyClient{} client := &DummyClient{}
var distFile = filepath.Join(folder, name+".rb") distFile := filepath.Join(folder, name+".rb")
require.NoError(t, doRun(ctx, ctx.Config.Brews[0], client)) require.NoError(t, doRun(ctx, ctx.Config.Brews[0], client))
require.True(t, client.CreatedFile) require.True(t, client.CreatedFile)
var golden = fmt.Sprintf("testdata/%s.rb.golden", name) golden := fmt.Sprintf("testdata/%s.rb.golden", name)
if *update { if *update {
require.NoError(t, os.WriteFile(golden, []byte(client.Content), 0655)) require.NoError(t, os.WriteFile(golden, []byte(client.Content), 0o655))
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)
@ -531,7 +530,7 @@ func TestRunPipeForMultipleArmVersions(t *testing.T) {
} }
func TestRunPipeNoBuilds(t *testing.T) { func TestRunPipeNoBuilds(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
TokenType: context.TokenTypeGitHub, TokenType: context.TokenTypeGitHub,
Config: config.Project{ Config: config.Project{
Brews: []config.Homebrew{ Brews: []config.Homebrew{
@ -550,7 +549,7 @@ func TestRunPipeNoBuilds(t *testing.T) {
} }
func TestRunPipeMultipleArchivesSameOsBuild(t *testing.T) { func TestRunPipeMultipleArchivesSameOsBuild(t *testing.T) {
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Brews: []config.Homebrew{ Brews: []config.Homebrew{
{ {
@ -697,7 +696,7 @@ func TestRunPipeMultipleArchivesSameOsBuild(t *testing.T) {
} }
func TestRunPipeBrewNotSetup(t *testing.T) { func TestRunPipeBrewNotSetup(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
client := &DummyClient{} client := &DummyClient{}
@ -706,7 +705,7 @@ func TestRunPipeBrewNotSetup(t *testing.T) {
} }
func TestRunPipeBinaryRelease(t *testing.T) { func TestRunPipeBinaryRelease(t *testing.T) {
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Brews: []config.Homebrew{ Brews: []config.Homebrew{
{ {
@ -731,8 +730,8 @@ func TestRunPipeBinaryRelease(t *testing.T) {
} }
func TestRunPipeNoUpload(t *testing.T) { func TestRunPipeNoUpload(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: folder, Dist: folder,
ProjectName: "foo", ProjectName: "foo",
Release: config.Release{}, Release: config.Release{},
@ -747,7 +746,7 @@ func TestRunPipeNoUpload(t *testing.T) {
}) })
ctx.TokenType = context.TokenTypeGitHub ctx.TokenType = context.TokenTypeGitHub
ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"} ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"}
var path = filepath.Join(folder, "whatever.tar.gz") path := filepath.Join(folder, "whatever.tar.gz")
f, err := os.Create(path) f, err := os.Create(path)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
@ -764,7 +763,7 @@ func TestRunPipeNoUpload(t *testing.T) {
}) })
client := &DummyClient{} client := &DummyClient{}
var assertNoPublish = func(t *testing.T) { assertNoPublish := func(t *testing.T) {
t.Helper() t.Helper()
testlib.AssertSkipped(t, doRun(ctx, ctx.Config.Brews[0], client)) testlib.AssertSkipped(t, doRun(ctx, ctx.Config.Brews[0], client))
require.False(t, client.CreatedFile) require.False(t, client.CreatedFile)
@ -784,8 +783,8 @@ func TestRunPipeNoUpload(t *testing.T) {
} }
func TestRunEmptyTokenType(t *testing.T) { func TestRunEmptyTokenType(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: folder, Dist: folder,
ProjectName: "foo", ProjectName: "foo",
Release: config.Release{}, Release: config.Release{},
@ -799,7 +798,7 @@ func TestRunEmptyTokenType(t *testing.T) {
}, },
}) })
ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"} ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"}
var path = filepath.Join(folder, "whatever.tar.gz") path := filepath.Join(folder, "whatever.tar.gz")
f, err := os.Create(path) f, err := os.Create(path)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
@ -819,8 +818,8 @@ func TestRunEmptyTokenType(t *testing.T) {
} }
func TestRunTokenTypeNotImplementedForBrew(t *testing.T) { func TestRunTokenTypeNotImplementedForBrew(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: folder, Dist: folder,
ProjectName: "foo", ProjectName: "foo",
Release: config.Release{}, Release: config.Release{},
@ -835,7 +834,7 @@ func TestRunTokenTypeNotImplementedForBrew(t *testing.T) {
}) })
ctx.TokenType = context.TokenTypeGitea ctx.TokenType = context.TokenTypeGitea
ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"} ctx.Git = context.GitInfo{CurrentTag: "v1.0.1"}
var path = filepath.Join(folder, "whatever.tar.gz") path := filepath.Join(folder, "whatever.tar.gz")
f, err := os.Create(path) f, err := os.Create(path)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
@ -857,7 +856,7 @@ func TestRunTokenTypeNotImplementedForBrew(t *testing.T) {
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
var ctx = &context.Context{ ctx := &context.Context{
TokenType: context.TokenTypeGitHub, TokenType: context.TokenTypeGitHub,
Config: config.Project{ Config: config.Project{
ProjectName: "myproject", ProjectName: "myproject",

138
internal/pipe/build/build_test.go
View File

@ -16,8 +16,10 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
var errFailedBuild = errors.New("fake builder failed") var (
var errFailedDefault = errors.New("fake builder defaults failed") errFailedBuild = errors.New("fake builder failed")
errFailedDefault = errors.New("fake builder defaults failed")
)
type fakeBuilder struct { type fakeBuilder struct {
fail bool fail bool
@ -35,10 +37,10 @@ func (f *fakeBuilder) Build(ctx *context.Context, build config.Build, options ap
if f.fail { if f.fail {
return errFailedBuild return errFailedBuild
} }
if err := os.MkdirAll(filepath.Dir(options.Path), 0755); err != nil { if err := os.MkdirAll(filepath.Dir(options.Path), 0o755); err != nil {
return err return err
} }
if err := os.WriteFile(options.Path, []byte("foo"), 0755); err != nil { if err := os.WriteFile(options.Path, []byte("foo"), 0o755); err != nil {
return err return err
} }
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
@ -62,8 +64,8 @@ func TestPipeDescription(t *testing.T) {
} }
func TestBuild(t *testing.T) { func TestBuild(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -74,7 +76,7 @@ func TestBuild(t *testing.T) {
}, },
}, },
} }
var ctx = &context.Context{ ctx := &context.Context{
Artifacts: artifact.New(), Artifacts: artifact.New(),
Git: context.GitInfo{ Git: context.GitInfo{
CurrentTag: "v1.2.3", CurrentTag: "v1.2.3",
@ -90,8 +92,8 @@ func TestBuild(t *testing.T) {
} }
func TestRunPipe(t *testing.T) { func TestRunPipe(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -103,7 +105,7 @@ func TestRunPipe(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "2.4.5" ctx.Git.CurrentTag = "2.4.5"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Equal(t, ctx.Artifacts.List(), []*artifact.Artifact{{ require.Equal(t, ctx.Artifacts.List(), []*artifact.Artifact{{
@ -112,10 +114,10 @@ func TestRunPipe(t *testing.T) {
} }
func TestRunFullPipe(t *testing.T) { func TestRunFullPipe(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var pre = filepath.Join(folder, "pre") pre := filepath.Join(folder, "pre")
var post = filepath.Join(folder, "post") post := filepath.Join(folder, "post")
var config = config.Project{ config := config.Project{
Builds: []config.Build{ Builds: []config.Build{
{ {
ID: "build1", ID: "build1",
@ -136,7 +138,7 @@ func TestRunFullPipe(t *testing.T) {
}, },
Dist: folder, Dist: folder,
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "2.4.5" ctx.Git.CurrentTag = "2.4.5"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Equal(t, ctx.Artifacts.List(), []*artifact.Artifact{{ require.Equal(t, ctx.Artifacts.List(), []*artifact.Artifact{{
@ -148,10 +150,10 @@ func TestRunFullPipe(t *testing.T) {
} }
func TestRunFullPipeFail(t *testing.T) { func TestRunFullPipeFail(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var pre = filepath.Join(folder, "pre") pre := filepath.Join(folder, "pre")
var post = filepath.Join(folder, "post") post := filepath.Join(folder, "post")
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -171,7 +173,7 @@ func TestRunFullPipeFail(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "2.4.5" ctx.Git.CurrentTag = "2.4.5"
require.EqualError(t, Pipe{}.Run(ctx), errFailedBuild.Error()) require.EqualError(t, Pipe{}.Run(ctx), errFailedBuild.Error())
require.Empty(t, ctx.Artifacts.List()) require.Empty(t, ctx.Artifacts.List())
@ -179,8 +181,8 @@ func TestRunFullPipeFail(t *testing.T) {
} }
func TestRunPipeFailingHooks(t *testing.T) { func TestRunPipeFailingHooks(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var cfg = config.Project{ cfg := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -192,14 +194,14 @@ func TestRunPipeFailingHooks(t *testing.T) {
}, },
} }
t.Run("pre-hook", func(t *testing.T) { t.Run("pre-hook", func(t *testing.T) {
var ctx = context.New(cfg) ctx := context.New(cfg)
ctx.Git.CurrentTag = "2.3.4" ctx.Git.CurrentTag = "2.3.4"
ctx.Config.Builds[0].Hooks.Pre = []config.BuildHook{{Cmd: "exit 1"}} ctx.Config.Builds[0].Hooks.Pre = []config.BuildHook{{Cmd: "exit 1"}}
ctx.Config.Builds[0].Hooks.Post = []config.BuildHook{{Cmd: "echo post"}} ctx.Config.Builds[0].Hooks.Post = []config.BuildHook{{Cmd: "echo post"}}
require.EqualError(t, Pipe{}.Run(ctx), `pre hook failed: "": exec: "exit": executable file not found in $PATH`) require.EqualError(t, Pipe{}.Run(ctx), `pre hook failed: "": exec: "exit": executable file not found in $PATH`)
}) })
t.Run("post-hook", func(t *testing.T) { t.Run("post-hook", func(t *testing.T) {
var ctx = context.New(cfg) ctx := context.New(cfg)
ctx.Git.CurrentTag = "2.3.4" ctx.Git.CurrentTag = "2.3.4"
ctx.Config.Builds[0].Hooks.Pre = []config.BuildHook{{Cmd: "echo pre"}} ctx.Config.Builds[0].Hooks.Pre = []config.BuildHook{{Cmd: "echo pre"}}
ctx.Config.Builds[0].Hooks.Post = []config.BuildHook{{Cmd: "exit 1"}} ctx.Config.Builds[0].Hooks.Post = []config.BuildHook{{Cmd: "exit 1"}}
@ -208,15 +210,15 @@ func TestRunPipeFailingHooks(t *testing.T) {
} }
func TestDefaultNoBuilds(t *testing.T) { func TestDefaultNoBuilds(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
} }
func TestDefaultFail(t *testing.T) { func TestDefaultFail(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -224,14 +226,14 @@ func TestDefaultFail(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
require.EqualError(t, Pipe{}.Default(ctx), errFailedDefault.Error()) require.EqualError(t, Pipe{}.Default(ctx), errFailedDefault.Error())
require.Empty(t, ctx.Artifacts.List()) require.Empty(t, ctx.Artifacts.List())
} }
func TestDefaultExpandEnv(t *testing.T) { func TestDefaultExpandEnv(t *testing.T) {
require.NoError(t, os.Setenv("XBAR", "FOOBAR")) require.NoError(t, os.Setenv("XBAR", "FOOBAR"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -243,12 +245,12 @@ func TestDefaultExpandEnv(t *testing.T) {
}, },
} }
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
var env = ctx.Config.Builds[0].Env[0] env := ctx.Config.Builds[0].Env[0]
require.Equal(t, "XFOO=bar_FOOBAR", env) require.Equal(t, "XFOO=bar_FOOBAR", env)
} }
func TestDefaultEmptyBuild(t *testing.T) { func TestDefaultEmptyBuild(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
ProjectName: "foo", ProjectName: "foo",
Builds: []config.Build{ Builds: []config.Build{
@ -257,7 +259,7 @@ func TestDefaultEmptyBuild(t *testing.T) {
}, },
} }
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
var build = ctx.Config.Builds[0] build := ctx.Config.Builds[0]
require.Equal(t, ctx.Config.ProjectName, build.ID) require.Equal(t, ctx.Config.ProjectName, build.ID)
require.Equal(t, ctx.Config.ProjectName, build.Binary) require.Equal(t, ctx.Config.ProjectName, build.Binary)
require.Equal(t, ".", build.Dir) require.Equal(t, ".", build.Dir)
@ -271,7 +273,7 @@ func TestDefaultEmptyBuild(t *testing.T) {
} }
func TestDefaultBuildID(t *testing.T) { func TestDefaultBuildID(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
ProjectName: "foo", ProjectName: "foo",
Builds: []config.Build{ Builds: []config.Build{
@ -285,12 +287,12 @@ func TestDefaultBuildID(t *testing.T) {
}, },
} }
require.EqualError(t, Pipe{}.Default(ctx), "found 2 builds with the ID 'foo', please fix your config") require.EqualError(t, Pipe{}.Default(ctx), "found 2 builds with the ID 'foo', please fix your config")
var build = ctx.Config.Builds[0] build := ctx.Config.Builds[0]
require.Equal(t, ctx.Config.ProjectName, build.ID) require.Equal(t, ctx.Config.ProjectName, build.ID)
} }
func TestSeveralBuildsWithTheSameID(t *testing.T) { func TestSeveralBuildsWithTheSameID(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -308,7 +310,7 @@ func TestSeveralBuildsWithTheSameID(t *testing.T) {
} }
func TestDefaultPartialBuilds(t *testing.T) { func TestDefaultPartialBuilds(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -329,7 +331,7 @@ func TestDefaultPartialBuilds(t *testing.T) {
} }
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
t.Run("build0", func(t *testing.T) { t.Run("build0", func(t *testing.T) {
var build = ctx.Config.Builds[0] build := ctx.Config.Builds[0]
require.Equal(t, "bar", build.Binary) require.Equal(t, "bar", build.Binary)
require.Equal(t, ".", build.Dir) require.Equal(t, ".", build.Dir)
require.Equal(t, "./cmd/main.go", build.Main) require.Equal(t, "./cmd/main.go", build.Main)
@ -340,7 +342,7 @@ func TestDefaultPartialBuilds(t *testing.T) {
require.Equal(t, "-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}} -X main.builtBy=goreleaser", build.Ldflags[0]) require.Equal(t, "-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}} -X main.builtBy=goreleaser", build.Ldflags[0])
}) })
t.Run("build1", func(t *testing.T) { t.Run("build1", func(t *testing.T) {
var build = ctx.Config.Builds[1] build := ctx.Config.Builds[1]
require.Equal(t, "foo", build.Binary) require.Equal(t, "foo", build.Binary)
require.Equal(t, ".", build.Main) require.Equal(t, ".", build.Main)
require.Equal(t, "baz", build.Dir) require.Equal(t, "baz", build.Dir)
@ -355,7 +357,7 @@ func TestDefaultPartialBuilds(t *testing.T) {
func TestDefaultFillSingleBuild(t *testing.T) { func TestDefaultFillSingleBuild(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
ProjectName: "foo", ProjectName: "foo",
SingleBuild: config.Build{ SingleBuild: config.Build{
@ -369,21 +371,21 @@ func TestDefaultFillSingleBuild(t *testing.T) {
} }
func TestDefaultFailSingleBuild(t *testing.T) { func TestDefaultFailSingleBuild(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
SingleBuild: config.Build{ SingleBuild: config.Build{
Lang: "fakeFailDefault", Lang: "fakeFailDefault",
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
require.EqualError(t, Pipe{}.Default(ctx), errFailedDefault.Error()) require.EqualError(t, Pipe{}.Default(ctx), errFailedDefault.Error())
require.Empty(t, ctx.Artifacts.List()) require.Empty(t, ctx.Artifacts.List())
} }
func TestSkipBuild(t *testing.T) { func TestSkipBuild(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -391,7 +393,7 @@ func TestSkipBuild(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "2.4.5" ctx.Git.CurrentTag = "2.4.5"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Len(t, ctx.Artifacts.List(), 0) require.Len(t, ctx.Artifacts.List(), 0)
@ -418,7 +420,7 @@ func TestExtOthers(t *testing.T) {
} }
func TestTemplate(t *testing.T) { func TestTemplate(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git = context.GitInfo{ ctx.Git = context.GitInfo{
CurrentTag: "v1.2.3", CurrentTag: "v1.2.3",
Commit: "123", Commit: "123",
@ -437,16 +439,16 @@ func TestTemplate(t *testing.T) {
} }
func TestRunHookEnvs(t *testing.T) { func TestRunHookEnvs(t *testing.T) {
var tmp = testlib.Mktmp(t) tmp := testlib.Mktmp(t)
var build = config.Build{ build := config.Build{
Env: []string{ Env: []string{
fmt.Sprintf("FOO=%s/foo", tmp), fmt.Sprintf("FOO=%s/foo", tmp),
fmt.Sprintf("BAR=%s/bar", tmp), fmt.Sprintf("BAR=%s/bar", tmp),
}, },
} }
var opts = api.Options{ opts := api.Options{
Name: "binary-name", Name: "binary-name",
Path: "./binary-name", Path: "./binary-name",
Target: "darwin_amd64", Target: "darwin_amd64",
@ -457,7 +459,7 @@ func TestRunHookEnvs(t *testing.T) {
} }
t.Run("valid cmd template with ctx env", func(t *testing.T) { t.Run("valid cmd template with ctx env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -470,7 +472,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("valid cmd template with build env", func(t *testing.T) { t.Run("valid cmd template with build env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -480,7 +482,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("valid cmd template with hook env", func(t *testing.T) { t.Run("valid cmd template with hook env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -495,7 +497,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("valid cmd template with ctx and build env", func(t *testing.T) { t.Run("valid cmd template with ctx and build env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -512,7 +514,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("valid cmd template with ctx and hook env", func(t *testing.T) { t.Run("valid cmd template with ctx and hook env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -531,7 +533,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("valid cmd template with build and hook env", func(t *testing.T) { t.Run("valid cmd template with build and hook env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -549,7 +551,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("valid cmd template with ctx, build and hook env", func(t *testing.T) { t.Run("valid cmd template with ctx, build and hook env", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -571,7 +573,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("invalid cmd template", func(t *testing.T) { t.Run("invalid cmd template", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -580,7 +582,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("invalid dir template", func(t *testing.T) { t.Run("invalid dir template", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -592,7 +594,7 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("invalid hook env template", func(t *testing.T) { t.Run("invalid hook env template", func(t *testing.T) {
var err = runHook(context.New(config.Project{ err := runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
build, build,
}, },
@ -606,9 +608,9 @@ func TestRunHookEnvs(t *testing.T) {
}) })
t.Run("build env inside shell", func(t *testing.T) { t.Run("build env inside shell", func(t *testing.T) {
var shell = `#!/bin/sh -e shell := `#!/bin/sh -e
touch "$BAR"` touch "$BAR"`
err := os.WriteFile(filepath.Join(tmp, "test.sh"), []byte(shell), 0750) err := os.WriteFile(filepath.Join(tmp, "test.sh"), []byte(shell), 0o750)
require.NoError(t, err) require.NoError(t, err)
err = runHook(context.New(config.Project{ err = runHook(context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
@ -621,7 +623,7 @@ touch "$BAR"`
} }
func TestBuild_hooksKnowGoosGoarch(t *testing.T) { func TestBuild_hooksKnowGoosGoarch(t *testing.T) {
var tmpDir = testlib.Mktmp(t) tmpDir := testlib.Mktmp(t)
build := config.Build{ build := config.Build{
Lang: "fake", Lang: "fake",
Goarch: []string{"amd64"}, Goarch: []string{"amd64"},
@ -652,7 +654,7 @@ func TestBuild_hooksKnowGoosGoarch(t *testing.T) {
} }
func TestPipeOnBuild_hooksRunPerTarget(t *testing.T) { func TestPipeOnBuild_hooksRunPerTarget(t *testing.T) {
var tmpDir = testlib.Mktmp(t) tmpDir := testlib.Mktmp(t)
build := config.Build{ build := config.Build{
Lang: "fake", Lang: "fake",
@ -704,7 +706,7 @@ func TestPipeOnBuild_invalidBinaryTpl(t *testing.T) {
} }
func TestBuildOptionsForTarget(t *testing.T) { func TestBuildOptionsForTarget(t *testing.T) {
var tmpDir = testlib.Mktmp(t) tmpDir := testlib.Mktmp(t)
testCases := []struct { testCases := []struct {
name string name string
@ -761,7 +763,7 @@ func TestBuildOptionsForTarget(t *testing.T) {
} }
func TestHookComplex(t *testing.T) { func TestHookComplex(t *testing.T) {
var tmp = testlib.Mktmp(t) tmp := testlib.Mktmp(t)
require.NoError(t, runHook(context.New(config.Project{}), api.Options{}, []string{}, config.BuildHooks{ require.NoError(t, runHook(context.New(config.Project{}), api.Options{}, []string{}, config.BuildHooks{
{ {
@ -785,8 +787,8 @@ func TestHookInvalidShelCommand(t *testing.T) {
} }
func TestRunHookFailWithLogs(t *testing.T) { func TestRunHookFailWithLogs(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var config = config.Project{ config := config.Project{
Dist: folder, Dist: folder,
Builds: []config.Build{ Builds: []config.Build{
{ {
@ -802,7 +804,7 @@ func TestRunHookFailWithLogs(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "2.4.5" ctx.Git.CurrentTag = "2.4.5"
require.EqualError(t, Pipe{}.Run(ctx), "pre hook failed: \"foo\\n\": exit status 1") require.EqualError(t, Pipe{}.Run(ctx), "pre hook failed: \"foo\\n\": exit status 1")
require.Empty(t, ctx.Artifacts.List()) require.Empty(t, ctx.Artifacts.List())

75
internal/pipe/changelog/changelog_test.go
View File

@ -17,14 +17,14 @@ func TestDescription(t *testing.T) {
} }
func TestChangelogProvidedViaFlag(t *testing.T) { func TestChangelogProvidedViaFlag(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseNotes = "testdata/changes.md" ctx.ReleaseNotes = "testdata/changes.md"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Equal(t, "c0ff33 coffeee\n", ctx.ReleaseNotes) require.Equal(t, "c0ff33 coffeee\n", ctx.ReleaseNotes)
} }
func TestTemplatedChangelogProvidedViaFlag(t *testing.T) { func TestTemplatedChangelogProvidedViaFlag(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseNotes = "testdata/changes-templated.md" ctx.ReleaseNotes = "testdata/changes-templated.md"
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -32,7 +32,7 @@ func TestTemplatedChangelogProvidedViaFlag(t *testing.T) {
} }
func TestChangelogProvidedViaFlagAndSkipEnabled(t *testing.T) { func TestChangelogProvidedViaFlagAndSkipEnabled(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Changelog: config.Changelog{ Changelog: config.Changelog{
Skip: true, Skip: true,
}, },
@ -43,37 +43,37 @@ func TestChangelogProvidedViaFlagAndSkipEnabled(t *testing.T) {
} }
func TestChangelogProvidedViaFlagDoesntExist(t *testing.T) { func TestChangelogProvidedViaFlagDoesntExist(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseNotes = "testdata/changes.nope" ctx.ReleaseNotes = "testdata/changes.nope"
require.EqualError(t, Pipe{}.Run(ctx), "open testdata/changes.nope: no such file or directory") require.EqualError(t, Pipe{}.Run(ctx), "open testdata/changes.nope: no such file or directory")
} }
func TestChangelogSkip(t *testing.T) { func TestChangelogSkip(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Config.Changelog.Skip = true ctx.Config.Changelog.Skip = true
testlib.AssertSkipped(t, Pipe{}.Run(ctx)) testlib.AssertSkipped(t, Pipe{}.Run(ctx))
} }
func TestReleaseHeaderProvidedViaFlagDoesntExist(t *testing.T) { func TestReleaseHeaderProvidedViaFlagDoesntExist(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseHeader = "testdata/header.nope" ctx.ReleaseHeader = "testdata/header.nope"
require.EqualError(t, Pipe{}.Run(ctx), "open testdata/header.nope: no such file or directory") require.EqualError(t, Pipe{}.Run(ctx), "open testdata/header.nope: no such file or directory")
} }
func TestReleaseFooterProvidedViaFlagDoesntExist(t *testing.T) { func TestReleaseFooterProvidedViaFlagDoesntExist(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseFooter = "testdata/footer.nope" ctx.ReleaseFooter = "testdata/footer.nope"
require.EqualError(t, Pipe{}.Run(ctx), "open testdata/footer.nope: no such file or directory") require.EqualError(t, Pipe{}.Run(ctx), "open testdata/footer.nope: no such file or directory")
} }
func TestSnapshot(t *testing.T) { func TestSnapshot(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Snapshot = true ctx.Snapshot = true
testlib.AssertSkipped(t, Pipe{}.Run(ctx)) testlib.AssertSkipped(t, Pipe{}.Run(ctx))
} }
func TestChangelog(t *testing.T) { func TestChangelog(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitCommit(t, "first") testlib.GitCommit(t, "first")
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
@ -86,7 +86,7 @@ func TestChangelog(t *testing.T) {
testlib.GitCommit(t, "Merge pull request #999 from goreleaser/some-branch") testlib.GitCommit(t, "Merge pull request #999 from goreleaser/some-branch")
testlib.GitCommit(t, "this is not a Merge pull request") testlib.GitCommit(t, "this is not a Merge pull request")
testlib.GitTag(t, "v0.0.2") testlib.GitTag(t, "v0.0.2")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: folder, Dist: folder,
Changelog: config.Changelog{ Changelog: config.Changelog{
Filters: config.Filters{ Filters: config.Filters{
@ -116,7 +116,7 @@ func TestChangelog(t *testing.T) {
} }
func TestChangelogPreviousTagEnv(t *testing.T) { func TestChangelogPreviousTagEnv(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitCommit(t, "first") testlib.GitCommit(t, "first")
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
@ -124,7 +124,7 @@ func TestChangelogPreviousTagEnv(t *testing.T) {
testlib.GitTag(t, "v0.0.2") testlib.GitTag(t, "v0.0.2")
testlib.GitCommit(t, "third") testlib.GitCommit(t, "third")
testlib.GitTag(t, "v0.0.3") testlib.GitTag(t, "v0.0.3")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: folder, Dist: folder,
Changelog: config.Changelog{Filters: config.Filters{}}, Changelog: config.Changelog{Filters: config.Filters{}},
}) })
@ -139,7 +139,7 @@ func TestChangelogPreviousTagEnv(t *testing.T) {
} }
func TestChangelogForGitlab(t *testing.T) { func TestChangelogForGitlab(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitCommit(t, "first") testlib.GitCommit(t, "first")
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
@ -152,7 +152,7 @@ func TestChangelogForGitlab(t *testing.T) {
testlib.GitCommit(t, "Merge pull request #999 from goreleaser/some-branch") testlib.GitCommit(t, "Merge pull request #999 from goreleaser/some-branch")
testlib.GitCommit(t, "this is not a Merge pull request") testlib.GitCommit(t, "this is not a Merge pull request")
testlib.GitTag(t, "v0.0.2") testlib.GitTag(t, "v0.0.2")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Dist: folder, Dist: folder,
Changelog: config.Changelog{ Changelog: config.Changelog{
Filters: config.Filters{ Filters: config.Filters{
@ -191,7 +191,7 @@ func TestChangelogSort(t *testing.T) {
testlib.GitCommit(t, "a: commit") testlib.GitCommit(t, "a: commit")
testlib.GitCommit(t, "b: commit") testlib.GitCommit(t, "b: commit")
testlib.GitTag(t, "v1.0.0") testlib.GitTag(t, "v1.0.0")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Changelog: config.Changelog{}, Changelog: config.Changelog{},
}) })
ctx.Git.CurrentTag = "v1.0.0" ctx.Git.CurrentTag = "v1.0.0"
@ -240,7 +240,7 @@ func TestChangelogSort(t *testing.T) {
} }
func TestChangelogInvalidSort(t *testing.T) { func TestChangelogInvalidSort(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Changelog: config.Changelog{ Changelog: config.Changelog{
Sort: "dope", Sort: "dope",
}, },
@ -251,7 +251,7 @@ func TestChangelogInvalidSort(t *testing.T) {
func TestChangelogOfFirstRelease(t *testing.T) { func TestChangelogOfFirstRelease(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -261,7 +261,7 @@ func TestChangelogOfFirstRelease(t *testing.T) {
testlib.GitCommit(t, msg) testlib.GitCommit(t, msg)
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Contains(t, ctx.ReleaseNotes, "## Changelog") require.Contains(t, ctx.ReleaseNotes, "## Changelog")
@ -277,7 +277,7 @@ func TestChangelogFilterInvalidRegex(t *testing.T) {
testlib.GitTag(t, "v0.0.3") testlib.GitTag(t, "v0.0.3")
testlib.GitCommit(t, "commitzzz") testlib.GitCommit(t, "commitzzz")
testlib.GitTag(t, "v0.0.4") testlib.GitTag(t, "v0.0.4")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Changelog: config.Changelog{ Changelog: config.Changelog{
Filters: config.Filters{ Filters: config.Filters{
Exclude: []string{ Exclude: []string{
@ -294,7 +294,7 @@ func TestChangelogNoTags(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitCommit(t, "first") testlib.GitCommit(t, "first")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
require.Error(t, Pipe{}.Run(ctx)) require.Error(t, Pipe{}.Run(ctx))
require.Empty(t, ctx.ReleaseNotes) require.Empty(t, ctx.ReleaseNotes)
} }
@ -302,7 +302,7 @@ func TestChangelogNoTags(t *testing.T) {
func TestChangelogOnBranchWithSameNameAsTag(t *testing.T) { func TestChangelogOnBranchWithSameNameAsTag(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -313,7 +313,7 @@ func TestChangelogOnBranchWithSameNameAsTag(t *testing.T) {
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
testlib.GitCheckoutBranch(t, "v0.0.1") testlib.GitCheckoutBranch(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Contains(t, ctx.ReleaseNotes, "## Changelog") require.Contains(t, ctx.ReleaseNotes, "## Changelog")
@ -325,10 +325,10 @@ func TestChangelogOnBranchWithSameNameAsTag(t *testing.T) {
func TestChangeLogWithReleaseHeader(t *testing.T) { func TestChangeLogWithReleaseHeader(t *testing.T) {
current, err := os.Getwd() current, err := os.Getwd()
require.NoError(t, err) require.NoError(t, err)
var tmpdir = testlib.Mktmp(t) tmpdir := testlib.Mktmp(t)
require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata")) require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata"))
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -339,7 +339,7 @@ func TestChangeLogWithReleaseHeader(t *testing.T) {
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
testlib.GitCheckoutBranch(t, "v0.0.1") testlib.GitCheckoutBranch(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
ctx.ReleaseHeader = "testdata/release-header.md" ctx.ReleaseHeader = "testdata/release-header.md"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -350,10 +350,10 @@ func TestChangeLogWithReleaseHeader(t *testing.T) {
func TestChangeLogWithTemplatedReleaseHeader(t *testing.T) { func TestChangeLogWithTemplatedReleaseHeader(t *testing.T) {
current, err := os.Getwd() current, err := os.Getwd()
require.NoError(t, err) require.NoError(t, err)
var tmpdir = testlib.Mktmp(t) tmpdir := testlib.Mktmp(t)
require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata")) require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata"))
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -364,20 +364,21 @@ func TestChangeLogWithTemplatedReleaseHeader(t *testing.T) {
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
testlib.GitCheckoutBranch(t, "v0.0.1") testlib.GitCheckoutBranch(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
ctx.ReleaseHeader = "testdata/release-header-templated.md" ctx.ReleaseHeader = "testdata/release-header-templated.md"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Contains(t, ctx.ReleaseNotes, "## Changelog") require.Contains(t, ctx.ReleaseNotes, "## Changelog")
require.Contains(t, ctx.ReleaseNotes, "test header with tag v0.0.1") require.Contains(t, ctx.ReleaseNotes, "test header with tag v0.0.1")
} }
func TestChangeLogWithReleaseFooter(t *testing.T) { func TestChangeLogWithReleaseFooter(t *testing.T) {
current, err := os.Getwd() current, err := os.Getwd()
require.NoError(t, err) require.NoError(t, err)
var tmpdir = testlib.Mktmp(t) tmpdir := testlib.Mktmp(t)
require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata")) require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata"))
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -388,7 +389,7 @@ func TestChangeLogWithReleaseFooter(t *testing.T) {
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
testlib.GitCheckoutBranch(t, "v0.0.1") testlib.GitCheckoutBranch(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
ctx.ReleaseFooter = "testdata/release-footer.md" ctx.ReleaseFooter = "testdata/release-footer.md"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -400,10 +401,10 @@ func TestChangeLogWithReleaseFooter(t *testing.T) {
func TestChangeLogWithTemplatedReleaseFooter(t *testing.T) { func TestChangeLogWithTemplatedReleaseFooter(t *testing.T) {
current, err := os.Getwd() current, err := os.Getwd()
require.NoError(t, err) require.NoError(t, err)
var tmpdir = testlib.Mktmp(t) tmpdir := testlib.Mktmp(t)
require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata")) require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata"))
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -414,7 +415,7 @@ func TestChangeLogWithTemplatedReleaseFooter(t *testing.T) {
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
testlib.GitCheckoutBranch(t, "v0.0.1") testlib.GitCheckoutBranch(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
ctx.ReleaseFooter = "testdata/release-footer-templated.md" ctx.ReleaseFooter = "testdata/release-footer-templated.md"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -426,10 +427,10 @@ func TestChangeLogWithTemplatedReleaseFooter(t *testing.T) {
func TestChangeLogWithoutReleaseFooter(t *testing.T) { func TestChangeLogWithoutReleaseFooter(t *testing.T) {
current, err := os.Getwd() current, err := os.Getwd()
require.NoError(t, err) require.NoError(t, err)
var tmpdir = testlib.Mktmp(t) tmpdir := testlib.Mktmp(t)
require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata")) require.NoError(t, os.Symlink(current+"/testdata", tmpdir+"/testdata"))
testlib.GitInit(t) testlib.GitInit(t)
var msgs = []string{ msgs := []string{
"initial commit", "initial commit",
"another one", "another one",
"one more", "one more",
@ -440,7 +441,7 @@ func TestChangeLogWithoutReleaseFooter(t *testing.T) {
} }
testlib.GitTag(t, "v0.0.1") testlib.GitTag(t, "v0.0.1")
testlib.GitCheckoutBranch(t, "v0.0.1") testlib.GitCheckoutBranch(t, "v0.0.1")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Contains(t, ctx.ReleaseNotes, "## Changelog") require.Contains(t, ctx.ReleaseNotes, "## Changelog")

39
internal/pipe/checksums/checksums_test.go
View File

@ -48,10 +48,10 @@ func TestPipe(t *testing.T) {
} }
for name, tt := range tests { for name, tt := range tests {
t.Run(name, func(t *testing.T) { t.Run(name, func(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var file = filepath.Join(folder, binary) file := filepath.Join(folder, binary)
require.NoError(t, os.WriteFile(file, []byte("some string"), 0644)) require.NoError(t, os.WriteFile(file, []byte("some string"), 0o644))
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: folder, Dist: folder,
ProjectName: binary, ProjectName: binary,
@ -101,12 +101,11 @@ func TestPipe(t *testing.T) {
} }
}) })
} }
} }
func TestPipeSkipTrue(t *testing.T) { func TestPipeSkipTrue(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: folder, Dist: folder,
Checksum: config.Checksum{ Checksum: config.Checksum{
@ -114,14 +113,14 @@ func TestPipeSkipTrue(t *testing.T) {
}, },
}, },
) )
var err = Pipe{}.Run(ctx) err := Pipe{}.Run(ctx)
testlib.AssertSkipped(t, err) testlib.AssertSkipped(t, err)
require.EqualError(t, err, pipe.ErrSkipDisabledPipe.Error()) require.EqualError(t, err, pipe.ErrSkipDisabledPipe.Error())
} }
func TestPipeFileNotExist(t *testing.T) { func TestPipeFileNotExist(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: folder, Dist: folder,
Checksum: config.Checksum{ Checksum: config.Checksum{
@ -135,7 +134,7 @@ func TestPipeFileNotExist(t *testing.T) {
Path: "/nope", Path: "/nope",
Type: artifact.UploadableBinary, Type: artifact.UploadableBinary,
}) })
var err = Pipe{}.Run(ctx) err := Pipe{}.Run(ctx)
require.Error(t, err) require.Error(t, err)
require.Contains(t, err.Error(), "/nope: no such file or directory") require.Contains(t, err.Error(), "/nope: no such file or directory")
} }
@ -152,8 +151,8 @@ func TestPipeInvalidNameTemplate(t *testing.T) {
"{{.Env.NOPE}}": `template: tmpl:1:6: executing "tmpl" at <.Env.NOPE>: map has no entry for key "NOPE"`, "{{.Env.NOPE}}": `template: tmpl:1:6: executing "tmpl" at <.Env.NOPE>: map has no entry for key "NOPE"`,
} { } {
t.Run(template, func(t *testing.T) { t.Run(template, func(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: folder, Dist: folder,
ProjectName: "name", ProjectName: "name",
@ -177,16 +176,16 @@ func TestPipeInvalidNameTemplate(t *testing.T) {
} }
func TestPipeCouldNotOpenChecksumsTxt(t *testing.T) { func TestPipeCouldNotOpenChecksumsTxt(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
binFile, err := ioutil.TempFile(folder, "goreleasertest-bin") binFile, err := ioutil.TempFile(folder, "goreleasertest-bin")
require.NoError(t, err) require.NoError(t, err)
t.Cleanup(func() { require.NoError(t, binFile.Close()) }) t.Cleanup(func() { require.NoError(t, binFile.Close()) })
_, err = binFile.WriteString("fake artifact") _, err = binFile.WriteString("fake artifact")
require.NoError(t, err) require.NoError(t, err)
var file = filepath.Join(folder, "checksums.txt") file := filepath.Join(folder, "checksums.txt")
require.NoError(t, os.WriteFile(file, []byte("some string"), 0000)) require.NoError(t, os.WriteFile(file, []byte("some string"), 0o000))
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: folder, Dist: folder,
Checksum: config.Checksum{ Checksum: config.Checksum{
@ -207,13 +206,13 @@ func TestPipeCouldNotOpenChecksumsTxt(t *testing.T) {
} }
func TestPipeWhenNoArtifacts(t *testing.T) { func TestPipeWhenNoArtifacts(t *testing.T) {
var ctx = &context.Context{} ctx := &context.Context{}
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
require.Len(t, ctx.Artifacts.List(), 0) require.Len(t, ctx.Artifacts.List(), 0)
} }
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Checksum: config.Checksum{}, Checksum: config.Checksum{},
}, },
@ -228,7 +227,7 @@ func TestDefault(t *testing.T) {
} }
func TestDefaultSet(t *testing.T) { func TestDefaultSet(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Checksum: config.Checksum{ Checksum: config.Checksum{
NameTemplate: "checksums.txt", NameTemplate: "checksums.txt",

4
internal/pipe/defaults/defaults_test.go
View File

@ -18,7 +18,7 @@ func TestFillBasicData(t *testing.T) {
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitRemoteAdd(t, "git@github.com:goreleaser/goreleaser.git") testlib.GitRemoteAdd(t, "git@github.com:goreleaser/goreleaser.git")
var ctx = &context.Context{ ctx := &context.Context{
TokenType: context.TokenTypeGitHub, TokenType: context.TokenTypeGitHub,
Config: config.Project{}, Config: config.Project{},
} }
@ -47,7 +47,7 @@ func TestFillPartial(t *testing.T) {
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitRemoteAdd(t, "git@github.com:goreleaser/goreleaser.git") testlib.GitRemoteAdd(t, "git@github.com:goreleaser/goreleaser.git")
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
GitHubURLs: config.GitHubURLs{ GitHubURLs: config.GitHubURLs{
Download: "https://github.company.com", Download: "https://github.company.com",

2
internal/pipe/dist/dist.go vendored
View File

@ -49,5 +49,5 @@ func (Pipe) Run(ctx *context.Context) (err error) {
func mkdir(ctx *context.Context) error { func mkdir(ctx *context.Context) error {
// #nosec // #nosec
return os.MkdirAll(ctx.Config.Dist, 0755) return os.MkdirAll(ctx.Config.Dist, 0o755)
} }

20
internal/pipe/dist/dist_test.go vendored
View File

@ -11,8 +11,8 @@ import (
) )
func TestDistDoesNotExist(t *testing.T) { func TestDistDoesNotExist(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError( require.NoError(
t, t,
Pipe{}.Run( Pipe{}.Run(
@ -26,13 +26,13 @@ func TestDistDoesNotExist(t *testing.T) {
} }
func TestPopulatedDistExists(t *testing.T) { func TestPopulatedDistExists(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
f, err := os.Create(filepath.Join(dist, "mybin")) f, err := os.Create(filepath.Join(dist, "mybin"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Dist: dist, Dist: dist,
}, },
@ -45,10 +45,10 @@ func TestPopulatedDistExists(t *testing.T) {
} }
func TestEmptyDistExists(t *testing.T) { func TestEmptyDistExists(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Dist: dist, Dist: dist,
}, },

7
internal/pipe/effectiveconfig/config.go
View File

@ -10,8 +10,7 @@ import (
) )
// Pipe that writes the effective config file to dist. // Pipe that writes the effective config file to dist.
type Pipe struct { type Pipe struct{}
}
func (Pipe) String() string { func (Pipe) String() string {
return "writing effective config file" return "writing effective config file"
@ -19,11 +18,11 @@ func (Pipe) String() string {
// Run the pipe. // Run the pipe.
func (Pipe) Run(ctx *context.Context) (err error) { func (Pipe) Run(ctx *context.Context) (err error) {
var path = filepath.Join(ctx.Config.Dist, "config.yaml") path := filepath.Join(ctx.Config.Dist, "config.yaml")
bts, err := yaml.Marshal(ctx.Config) bts, err := yaml.Marshal(ctx.Config)
if err != nil { if err != nil {
return err return err
} }
log.WithField("config", path).Info("writing") log.WithField("config", path).Info("writing")
return os.WriteFile(path, bts, 0644) //nolint: gosec return os.WriteFile(path, bts, 0o644) //nolint: gosec
} }

6
internal/pipe/effectiveconfig/config_test.go
View File

@ -16,10 +16,10 @@ func TestPipeDescription(t *testing.T) {
} }
func TestRun(t *testing.T) { func TestRun(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
dist := filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New( ctx := context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
}, },

2
internal/pipe/env/env.go vendored
View File

@ -28,7 +28,7 @@ func (Pipe) String() string {
} }
func setDefaultTokenFiles(ctx *context.Context) { func setDefaultTokenFiles(ctx *context.Context) {
var env = &ctx.Config.EnvFiles env := &ctx.Config.EnvFiles
if env.GitHubToken == "" { if env.GitHubToken == "" {
env.GitHubToken = "~/.config/goreleaser/github_token" env.GitHubToken = "~/.config/goreleaser/github_token"
} }

42
internal/pipe/env/env_test.go vendored
View File

@ -37,7 +37,7 @@ func TestSetDefaultTokenFiles(t *testing.T) {
func TestValidGithubEnv(t *testing.T) { func TestValidGithubEnv(t *testing.T) {
require.NoError(t, os.Setenv("GITHUB_TOKEN", "asdf")) require.NoError(t, os.Setenv("GITHUB_TOKEN", "asdf"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -49,7 +49,7 @@ func TestValidGithubEnv(t *testing.T) {
func TestValidGitlabEnv(t *testing.T) { func TestValidGitlabEnv(t *testing.T) {
require.NoError(t, os.Setenv("GITLAB_TOKEN", "qwertz")) require.NoError(t, os.Setenv("GITLAB_TOKEN", "qwertz"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -61,7 +61,7 @@ func TestValidGitlabEnv(t *testing.T) {
func TestValidGiteaEnv(t *testing.T) { func TestValidGiteaEnv(t *testing.T) {
require.NoError(t, os.Setenv("GITEA_TOKEN", "token")) require.NoError(t, os.Setenv("GITEA_TOKEN", "token"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
@ -74,7 +74,7 @@ func TestValidGiteaEnv(t *testing.T) {
func TestInvalidEnv(t *testing.T) { func TestInvalidEnv(t *testing.T) {
require.NoError(t, os.Unsetenv("GITHUB_TOKEN")) require.NoError(t, os.Unsetenv("GITHUB_TOKEN"))
require.NoError(t, os.Unsetenv("GITLAB_TOKEN")) require.NoError(t, os.Unsetenv("GITLAB_TOKEN"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.Error(t, Pipe{}.Run(ctx)) require.Error(t, Pipe{}.Run(ctx))
@ -85,7 +85,7 @@ func TestMultipleEnvTokens(t *testing.T) {
require.NoError(t, os.Setenv("GITHUB_TOKEN", "asdf")) require.NoError(t, os.Setenv("GITHUB_TOKEN", "asdf"))
require.NoError(t, os.Setenv("GITLAB_TOKEN", "qwertz")) require.NoError(t, os.Setenv("GITLAB_TOKEN", "qwertz"))
require.NoError(t, os.Setenv("GITEA_TOKEN", "token")) require.NoError(t, os.Setenv("GITEA_TOKEN", "token"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.Error(t, Pipe{}.Run(ctx)) require.Error(t, Pipe{}.Run(ctx))
@ -98,7 +98,7 @@ func TestMultipleEnvTokens(t *testing.T) {
func TestEmptyGithubFileEnv(t *testing.T) { func TestEmptyGithubFileEnv(t *testing.T) {
require.NoError(t, os.Unsetenv("GITHUB_TOKEN")) require.NoError(t, os.Unsetenv("GITHUB_TOKEN"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.Error(t, Pipe{}.Run(ctx)) require.Error(t, Pipe{}.Run(ctx))
@ -106,7 +106,7 @@ func TestEmptyGithubFileEnv(t *testing.T) {
func TestEmptyGitlabFileEnv(t *testing.T) { func TestEmptyGitlabFileEnv(t *testing.T) {
require.NoError(t, os.Unsetenv("GITLAB_TOKEN")) require.NoError(t, os.Unsetenv("GITLAB_TOKEN"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.Error(t, Pipe{}.Run(ctx)) require.Error(t, Pipe{}.Run(ctx))
@ -114,7 +114,7 @@ func TestEmptyGitlabFileEnv(t *testing.T) {
func TestEmptyGiteaFileEnv(t *testing.T) { func TestEmptyGiteaFileEnv(t *testing.T) {
require.NoError(t, os.Unsetenv("GITEA_TOKEN")) require.NoError(t, os.Unsetenv("GITEA_TOKEN"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
require.Error(t, Pipe{}.Run(ctx)) require.Error(t, Pipe{}.Run(ctx))
@ -125,8 +125,8 @@ func TestEmptyGithubEnvFile(t *testing.T) {
f, err := ioutil.TempFile(t.TempDir(), "token") f, err := ioutil.TempFile(t.TempDir(), "token")
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
require.NoError(t, os.Chmod(f.Name(), 0377)) require.NoError(t, os.Chmod(f.Name(), 0o377))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
EnvFiles: config.EnvFiles{ EnvFiles: config.EnvFiles{
GitHubToken: f.Name(), GitHubToken: f.Name(),
@ -141,8 +141,8 @@ func TestEmptyGitlabEnvFile(t *testing.T) {
f, err := ioutil.TempFile(t.TempDir(), "token") f, err := ioutil.TempFile(t.TempDir(), "token")
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
require.NoError(t, os.Chmod(f.Name(), 0377)) require.NoError(t, os.Chmod(f.Name(), 0o377))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
EnvFiles: config.EnvFiles{ EnvFiles: config.EnvFiles{
GitLabToken: f.Name(), GitLabToken: f.Name(),
@ -157,8 +157,8 @@ func TestEmptyGiteaEnvFile(t *testing.T) {
f, err := ioutil.TempFile(t.TempDir(), "token") f, err := ioutil.TempFile(t.TempDir(), "token")
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
require.NoError(t, os.Chmod(f.Name(), 0377)) require.NoError(t, os.Chmod(f.Name(), 0o377))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
EnvFiles: config.EnvFiles{ EnvFiles: config.EnvFiles{
GiteaToken: f.Name(), GiteaToken: f.Name(),
@ -170,7 +170,7 @@ func TestEmptyGiteaEnvFile(t *testing.T) {
func TestInvalidEnvChecksSkipped(t *testing.T) { func TestInvalidEnvChecksSkipped(t *testing.T) {
require.NoError(t, os.Unsetenv("GITHUB_TOKEN")) require.NoError(t, os.Unsetenv("GITHUB_TOKEN"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
SkipPublish: true, SkipPublish: true,
} }
@ -179,7 +179,7 @@ func TestInvalidEnvChecksSkipped(t *testing.T) {
func TestInvalidEnvReleaseDisabled(t *testing.T) { func TestInvalidEnvReleaseDisabled(t *testing.T) {
require.NoError(t, os.Unsetenv("GITHUB_TOKEN")) require.NoError(t, os.Unsetenv("GITHUB_TOKEN"))
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Release: config.Release{ Release: config.Release{
Disable: true, Disable: true,
@ -191,14 +191,14 @@ func TestInvalidEnvReleaseDisabled(t *testing.T) {
func TestLoadEnv(t *testing.T) { func TestLoadEnv(t *testing.T) {
t.Run("env exists", func(t *testing.T) { t.Run("env exists", func(t *testing.T) {
var env = "SUPER_SECRET_ENV" env := "SUPER_SECRET_ENV"
require.NoError(t, os.Setenv(env, "1")) require.NoError(t, os.Setenv(env, "1"))
v, err := loadEnv(env, "nope") v, err := loadEnv(env, "nope")
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, "1", v) require.Equal(t, "1", v)
}) })
t.Run("env file exists", func(t *testing.T) { t.Run("env file exists", func(t *testing.T) {
var env = "SUPER_SECRET_ENV_NOPE" env := "SUPER_SECRET_ENV_NOPE"
require.NoError(t, os.Unsetenv(env)) require.NoError(t, os.Unsetenv(env))
f, err := ioutil.TempFile(t.TempDir(), "token") f, err := ioutil.TempFile(t.TempDir(), "token")
require.NoError(t, err) require.NoError(t, err)
@ -209,7 +209,7 @@ func TestLoadEnv(t *testing.T) {
require.Equal(t, "123", v) require.Equal(t, "123", v)
}) })
t.Run("env file with an empty line at the end", func(t *testing.T) { t.Run("env file with an empty line at the end", func(t *testing.T) {
var env = "SUPER_SECRET_ENV_NOPE" env := "SUPER_SECRET_ENV_NOPE"
require.NoError(t, os.Unsetenv(env)) require.NoError(t, os.Unsetenv(env))
f, err := ioutil.TempFile(t.TempDir(), "token") f, err := ioutil.TempFile(t.TempDir(), "token")
require.NoError(t, err) require.NoError(t, err)
@ -220,13 +220,13 @@ func TestLoadEnv(t *testing.T) {
require.Equal(t, "123", v) require.Equal(t, "123", v)
}) })
t.Run("env file is not readable", func(t *testing.T) { t.Run("env file is not readable", func(t *testing.T) {
var env = "SUPER_SECRET_ENV_NOPE" env := "SUPER_SECRET_ENV_NOPE"
require.NoError(t, os.Unsetenv(env)) require.NoError(t, os.Unsetenv(env))
f, err := ioutil.TempFile(t.TempDir(), "token") f, err := ioutil.TempFile(t.TempDir(), "token")
require.NoError(t, err) require.NoError(t, err)
fmt.Fprintf(f, "123") fmt.Fprintf(f, "123")
require.NoError(t, f.Close()) require.NoError(t, f.Close())
err = os.Chmod(f.Name(), 0377) err = os.Chmod(f.Name(), 0o377)
require.NoError(t, err) require.NoError(t, err)
v, err := loadEnv(env, f.Name()) v, err := loadEnv(env, f.Name())
require.EqualError(t, err, fmt.Sprintf("open %s: permission denied", f.Name())) require.EqualError(t, err, fmt.Sprintf("open %s: permission denied", f.Name()))

26
internal/pipe/milestone/milestone_test.go
View File

@ -18,7 +18,7 @@ func TestDefaultWithRepoConfig(t *testing.T) {
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitRemoteAdd(t, "git@github.com:githubowner/githubrepo.git") testlib.GitRemoteAdd(t, "git@github.com:githubowner/githubrepo.git")
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Milestones: []config.Milestone{ Milestones: []config.Milestone{
{ {
@ -41,7 +41,7 @@ func TestDefaultWithRepoRemote(t *testing.T) {
testlib.GitInit(t) testlib.GitInit(t)
testlib.GitRemoteAdd(t, "git@github.com:githubowner/githubrepo.git") testlib.GitRemoteAdd(t, "git@github.com:githubowner/githubrepo.git")
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.TokenType = context.TokenTypeGitHub ctx.TokenType = context.TokenTypeGitHub
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
require.Equal(t, "githubrepo", ctx.Config.Milestones[0].Repo.Name) require.Equal(t, "githubrepo", ctx.Config.Milestones[0].Repo.Name)
@ -49,7 +49,7 @@ func TestDefaultWithRepoRemote(t *testing.T) {
} }
func TestDefaultWithNameTemplate(t *testing.T) { func TestDefaultWithNameTemplate(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Milestones: []config.Milestone{ Milestones: []config.Milestone{
{ {
@ -64,7 +64,7 @@ func TestDefaultWithNameTemplate(t *testing.T) {
func TestDefaultWithoutGitRepo(t *testing.T) { func TestDefaultWithoutGitRepo(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
ctx.TokenType = context.TokenTypeGitHub ctx.TokenType = context.TokenTypeGitHub
@ -74,7 +74,7 @@ func TestDefaultWithoutGitRepo(t *testing.T) {
func TestDefaultWithoutGitRepoOrigin(t *testing.T) { func TestDefaultWithoutGitRepoOrigin(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
ctx.TokenType = context.TokenTypeGitHub ctx.TokenType = context.TokenTypeGitHub
@ -85,7 +85,7 @@ func TestDefaultWithoutGitRepoOrigin(t *testing.T) {
func TestDefaultWithoutGitRepoSnapshot(t *testing.T) { func TestDefaultWithoutGitRepoSnapshot(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{}, Config: config.Project{},
} }
ctx.TokenType = context.TokenTypeGitHub ctx.TokenType = context.TokenTypeGitHub
@ -95,7 +95,7 @@ func TestDefaultWithoutGitRepoSnapshot(t *testing.T) {
} }
func TestDefaultWithoutNameTemplate(t *testing.T) { func TestDefaultWithoutNameTemplate(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Milestones: []config.Milestone{}, Milestones: []config.Milestone{},
}, },
@ -109,7 +109,7 @@ func TestString(t *testing.T) {
} }
func TestPublishCloseDisabled(t *testing.T) { func TestPublishCloseDisabled(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Milestones: []config.Milestone{ Milestones: []config.Milestone{
{ {
Close: false, Close: false,
@ -122,7 +122,7 @@ func TestPublishCloseDisabled(t *testing.T) {
} }
func TestPublishCloseEnabled(t *testing.T) { func TestPublishCloseEnabled(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Milestones: []config.Milestone{ Milestones: []config.Milestone{
{ {
Close: true, Close: true,
@ -141,7 +141,7 @@ func TestPublishCloseEnabled(t *testing.T) {
} }
func TestPublishCloseError(t *testing.T) { func TestPublishCloseError(t *testing.T) {
var config = config.Project{ config := config.Project{
Milestones: []config.Milestone{ Milestones: []config.Milestone{
{ {
Close: true, Close: true,
@ -153,7 +153,7 @@ func TestPublishCloseError(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "v1.0.0" ctx.Git.CurrentTag = "v1.0.0"
client := &DummyClient{ client := &DummyClient{
FailToCloseMilestone: true, FailToCloseMilestone: true,
@ -163,7 +163,7 @@ func TestPublishCloseError(t *testing.T) {
} }
func TestPublishCloseFailOnError(t *testing.T) { func TestPublishCloseFailOnError(t *testing.T) {
var config = config.Project{ config := config.Project{
Milestones: []config.Milestone{ Milestones: []config.Milestone{
{ {
Close: true, Close: true,
@ -176,7 +176,7 @@ func TestPublishCloseFailOnError(t *testing.T) {
}, },
}, },
} }
var ctx = context.New(config) ctx := context.New(config)
ctx.Git.CurrentTag = "v1.0.0" ctx.Git.CurrentTag = "v1.0.0"
client := &DummyClient{ client := &DummyClient{
FailToCloseMilestone: true, FailToCloseMilestone: true,

2
internal/pipe/pipe.go
View File

@ -24,7 +24,7 @@ var ErrSkipValidateEnabled = Skip("validation is disabled")
// ErrSkipDisabledPipe happens when a pipe is skipped because it is not configured. // ErrSkipDisabledPipe happens when a pipe is skipped because it is not configured.
var ErrSkipDisabledPipe = ErrSkip{ var ErrSkipDisabledPipe = ErrSkip{
reason: "pipe not configured/disabled", reason: "pipe not configured/disabled",
expected: true, expected: true,
} }

10
internal/pipe/project/project_test.go
View File

@ -10,7 +10,7 @@ import (
) )
func TestCustomProjectName(t *testing.T) { func TestCustomProjectName(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "foo", ProjectName: "foo",
Release: config.Release{ Release: config.Release{
GitHub: config.Repo{ GitHub: config.Repo{
@ -24,7 +24,7 @@ func TestCustomProjectName(t *testing.T) {
} }
func TestEmptyProjectName_DefaultsToGitHubRelease(t *testing.T) { func TestEmptyProjectName_DefaultsToGitHubRelease(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Release: config.Release{ Release: config.Release{
GitHub: config.Repo{ GitHub: config.Repo{
Owner: "bar", Owner: "bar",
@ -37,7 +37,7 @@ func TestEmptyProjectName_DefaultsToGitHubRelease(t *testing.T) {
} }
func TestEmptyProjectName_DefaultsToGitLabRelease(t *testing.T) { func TestEmptyProjectName_DefaultsToGitLabRelease(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Release: config.Release{ Release: config.Release{
GitLab: config.Repo{ GitLab: config.Repo{
Owner: "bar", Owner: "bar",
@ -50,7 +50,7 @@ func TestEmptyProjectName_DefaultsToGitLabRelease(t *testing.T) {
} }
func TestEmptyProjectName_DefaultsToGiteaRelease(t *testing.T) { func TestEmptyProjectName_DefaultsToGiteaRelease(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Release: config.Release{ Release: config.Release{
Gitea: config.Repo{ Gitea: config.Repo{
Owner: "bar", Owner: "bar",
@ -63,7 +63,7 @@ func TestEmptyProjectName_DefaultsToGiteaRelease(t *testing.T) {
} }
func TestEmptyProjectNameAndRelease(t *testing.T) { func TestEmptyProjectNameAndRelease(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Release: config.Release{ Release: config.Release{
GitHub: config.Repo{}, GitHub: config.Repo{},
}, },

2
internal/pipe/publish/publish_test.go
View File

@ -13,7 +13,7 @@ func TestDescription(t *testing.T) {
} }
func TestPublish(t *testing.T) { func TestPublish(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Config.Release.Disable = true ctx.Config.Release.Disable = true
ctx.TokenType = context.TokenTypeGitHub ctx.TokenType = context.TokenTypeGitHub
for i := range ctx.Config.Dockers { for i := range ctx.Config.Dockers {

2
internal/pipe/release/body.go
View File

@ -31,7 +31,7 @@ func describeBody(ctx *context.Context) (bytes.Buffer, error) {
dockers = append(dockers, a.Name) dockers = append(dockers, a.Name)
} }
} }
var bodyTemplate = template.Must(template.New("release").Parse(bodyTemplateText)) bodyTemplate := template.Must(template.New("release").Parse(bodyTemplateText))
err := bodyTemplate.Execute(&out, struct { err := bodyTemplate.Execute(&out, struct {
ReleaseNotes string ReleaseNotes string
DockerImages []string DockerImages []string

28
internal/pipe/release/body_test.go
View File

@ -14,8 +14,8 @@ import (
var update = flag.Bool("update", false, "update .golden files") var update = flag.Bool("update", false, "update .golden files")
func TestDescribeBody(t *testing.T) { func TestDescribeBody(t *testing.T) {
var changelog = "feature1: description\nfeature2: other description" changelog := "feature1: description\nfeature2: other description"
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseNotes = changelog ctx.ReleaseNotes = changelog
for _, d := range []string{ for _, d := range []string{
"goreleaser/goreleaser:0.40.0", "goreleaser/goreleaser:0.40.0",
@ -30,9 +30,9 @@ func TestDescribeBody(t *testing.T) {
out, err := describeBody(ctx) out, err := describeBody(ctx)
require.NoError(t, err) require.NoError(t, err)
var golden = "testdata/release1.golden" golden := "testdata/release1.golden"
if *update { if *update {
_ = os.WriteFile(golden, out.Bytes(), 0755) _ = os.WriteFile(golden, out.Bytes(), 0o755)
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)
@ -40,8 +40,8 @@ func TestDescribeBody(t *testing.T) {
} }
func TestDescribeBodyWithDockerManifest(t *testing.T) { func TestDescribeBodyWithDockerManifest(t *testing.T) {
var changelog = "feature1: description\nfeature2: other description" changelog := "feature1: description\nfeature2: other description"
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseNotes = changelog ctx.ReleaseNotes = changelog
for _, d := range []string{ for _, d := range []string{
"goreleaser/goreleaser:0.40.0", "goreleaser/goreleaser:0.40.0",
@ -69,9 +69,9 @@ func TestDescribeBodyWithDockerManifest(t *testing.T) {
out, err := describeBody(ctx) out, err := describeBody(ctx)
require.NoError(t, err) require.NoError(t, err)
var golden = "testdata/release3.golden" golden := "testdata/release3.golden"
if *update { if *update {
_ = os.WriteFile(golden, out.Bytes(), 0755) _ = os.WriteFile(golden, out.Bytes(), 0o755)
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)
@ -79,16 +79,16 @@ func TestDescribeBodyWithDockerManifest(t *testing.T) {
} }
func TestDescribeBodyNoDockerImagesNoBrews(t *testing.T) { func TestDescribeBodyNoDockerImagesNoBrews(t *testing.T) {
var changelog = "feature1: description\nfeature2: other description" changelog := "feature1: description\nfeature2: other description"
var ctx = &context.Context{ ctx := &context.Context{
ReleaseNotes: changelog, ReleaseNotes: changelog,
} }
out, err := describeBody(ctx) out, err := describeBody(ctx)
require.NoError(t, err) require.NoError(t, err)
var golden = "testdata/release2.golden" golden := "testdata/release2.golden"
if *update { if *update {
_ = os.WriteFile(golden, out.Bytes(), 0655) _ = os.WriteFile(golden, out.Bytes(), 0o655)
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)
@ -97,8 +97,8 @@ func TestDescribeBodyNoDockerImagesNoBrews(t *testing.T) {
} }
func TestDontEscapeHTML(t *testing.T) { func TestDontEscapeHTML(t *testing.T) {
var changelog = "<h1>test</h1>" changelog := "<h1>test</h1>"
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.ReleaseNotes = changelog ctx.ReleaseNotes = changelog
out, err := describeBody(ctx) out, err := describeBody(ctx)

36
internal/pipe/scoop/scoop_test.go
View File

@ -25,7 +25,7 @@ func TestDescription(t *testing.T) {
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
testlib.Mktmp(t) testlib.Mktmp(t)
var ctx = &context.Context{ ctx := &context.Context{
TokenType: context.TokenTypeGitHub, TokenType: context.TokenTypeGitHub,
Config: config.Project{ Config: config.Project{
ProjectName: "barr", ProjectName: "barr",
@ -59,19 +59,19 @@ func TestDefault(t *testing.T) {
} }
func Test_doRun(t *testing.T) { func Test_doRun(t *testing.T) {
var folder = testlib.Mktmp(t) folder := testlib.Mktmp(t)
var file = filepath.Join(folder, "archive") file := filepath.Join(folder, "archive")
require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0644)) require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0o644))
type errChecker func(*testing.T, error) type errChecker func(*testing.T, error)
var shouldErr = func(msg string) errChecker { shouldErr := func(msg string) errChecker {
return func(t *testing.T, err error) { return func(t *testing.T, err error) {
t.Helper() t.Helper()
require.Error(t, err) require.Error(t, err)
require.EqualError(t, err, msg) require.EqualError(t, err, msg)
} }
} }
var shouldNotErr = func(t *testing.T, err error) { shouldNotErr := func(t *testing.T, err error) {
t.Helper() t.Helper()
require.NoError(t, err) require.NoError(t, err)
} }
@ -731,7 +731,7 @@ func Test_doRun(t *testing.T) {
} }
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { t.Run(tt.name, func(t *testing.T) {
var ctx = tt.args.ctx ctx := tt.args.ctx
for _, a := range tt.artifacts { for _, a := range tt.artifacts {
ctx.Artifacts.Add(a) ctx.Artifacts.Add(a)
} }
@ -743,9 +743,9 @@ func Test_doRun(t *testing.T) {
} }
func Test_buildManifest(t *testing.T) { func Test_buildManifest(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var file = filepath.Join(folder, "archive") file := filepath.Join(folder, "archive")
require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0644)) require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0o644))
tests := []struct { tests := []struct {
filename string filename string
@ -915,7 +915,7 @@ func Test_buildManifest(t *testing.T) {
for _, tt := range tests { for _, tt := range tests {
t.Run(tt.filename, func(t *testing.T) { t.Run(tt.filename, func(t *testing.T) {
var ctx = tt.ctx ctx := tt.ctx
err := Pipe{}.Default(ctx) err := Pipe{}.Default(ctx)
require.NoError(t, err) require.NoError(t, err)
@ -981,7 +981,7 @@ func Test_buildManifest(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
if *update { if *update {
require.NoError(t, os.WriteFile(tt.filename, out.Bytes(), 0655)) require.NoError(t, os.WriteFile(tt.filename, out.Bytes(), 0o655))
} }
bts, err := os.ReadFile(tt.filename) bts, err := os.ReadFile(tt.filename)
require.NoError(t, err) require.NoError(t, err)
@ -991,10 +991,10 @@ func Test_buildManifest(t *testing.T) {
} }
func TestWrapInDirectory(t *testing.T) { func TestWrapInDirectory(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var file = filepath.Join(folder, "archive") file := filepath.Join(folder, "archive")
require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0644)) require.NoError(t, os.WriteFile(file, []byte("lorem ipsum"), 0o644))
var ctx = &context.Context{ ctx := &context.Context{
TokenType: context.TokenTypeGitLab, TokenType: context.TokenTypeGitLab,
Git: context.GitInfo{ Git: context.GitInfo{
CurrentTag: "v1.0.1", CurrentTag: "v1.0.1",
@ -1060,9 +1060,9 @@ func TestWrapInDirectory(t *testing.T) {
out, err := doBuildManifest(mf) out, err := doBuildManifest(mf)
require.NoError(t, err) require.NoError(t, err)
var golden = "testdata/test_buildmanifest_wrap.json.golden" golden := "testdata/test_buildmanifest_wrap.json.golden"
if *update { if *update {
require.NoError(t, os.WriteFile(golden, out.Bytes(), 0655)) require.NoError(t, os.WriteFile(golden, out.Bytes(), 0o655))
} }
bts, err := os.ReadFile(golden) bts, err := os.ReadFile(golden)
require.NoError(t, err) require.NoError(t, err)

6
internal/pipe/sign/sign.go
View File

@ -28,7 +28,7 @@ func (Pipe) String() string {
// Default sets the Pipes defaults. // Default sets the Pipes defaults.
func (Pipe) Default(ctx *context.Context) error { func (Pipe) Default(ctx *context.Context) error {
var ids = ids.New("signs") ids := ids.New("signs")
for i := range ctx.Config.Signs { for i := range ctx.Config.Signs {
cfg := &ctx.Config.Signs[i] cfg := &ctx.Config.Signs[i]
if cfg.Cmd == "" { if cfg.Cmd == "" {
@ -57,7 +57,7 @@ func (Pipe) Run(ctx *context.Context) error {
return pipe.ErrSkipSignEnabled return pipe.ErrSkipSignEnabled
} }
var g = semerrgroup.New(ctx.Parallelism) g := semerrgroup.New(ctx.Parallelism)
for i := range ctx.Config.Signs { for i := range ctx.Config.Signs {
cfg := ctx.Config.Signs[i] cfg := ctx.Config.Signs[i]
g.Go(func() error { g.Go(func() error {
@ -114,7 +114,7 @@ func signone(ctx *context.Context, cfg config.Sign, a *artifact.Artifact) (*arti
// nolint:prealloc // nolint:prealloc
var args []string var args []string
for _, a := range cfg.Args { for _, a := range cfg.Args {
var arg = expand(a, env) arg := expand(a, env)
arg, err := tmpl.New(ctx).WithEnv(env).Apply(arg) arg, err := tmpl.New(ctx).WithEnv(env).Apply(arg)
if err != nil { if err != nil {
return nil, fmt.Errorf("sign failed: %s: invalid template: %w", a, err) return nil, fmt.Errorf("sign failed: %s: invalid template: %w", a, err)

46
internal/pipe/snapcraft/snapcraft.go
View File

@ -74,9 +74,9 @@ func (Pipe) String() string {
// Default sets the pipe defaults. // Default sets the pipe defaults.
func (Pipe) Default(ctx *context.Context) error { func (Pipe) Default(ctx *context.Context) error {
var ids = ids.New("snapcrafts") ids := ids.New("snapcrafts")
for i := range ctx.Config.Snapcrafts { for i := range ctx.Config.Snapcrafts {
var snap = &ctx.Config.Snapcrafts[i] snap := &ctx.Config.Snapcrafts[i]
if snap.NameTemplate == "" { if snap.NameTemplate == "" {
snap.NameTemplate = defaultNameTemplate snap.NameTemplate = defaultNameTemplate
} }
@ -116,7 +116,7 @@ func doRun(ctx *context.Context, snap config.Snapcraft) error {
return ErrNoSnapcraft return ErrNoSnapcraft
} }
var g = semerrgroup.New(ctx.Parallelism) g := semerrgroup.New(ctx.Parallelism)
for platform, binaries := range ctx.Artifacts.Filter( for platform, binaries := range ctx.Artifacts.Filter(
artifact.And( artifact.And(
artifact.ByGoos("linux"), artifact.ByGoos("linux"),
@ -153,7 +153,7 @@ func (Pipe) Publish(ctx *context.Context) error {
return pipe.ErrSkipPublishEnabled return pipe.ErrSkipPublishEnabled
} }
snaps := ctx.Artifacts.Filter(artifact.ByType(artifact.PublishableSnapcraft)).List() snaps := ctx.Artifacts.Filter(artifact.ByType(artifact.PublishableSnapcraft)).List()
var g = semerrgroup.New(ctx.Parallelism) g := semerrgroup.New(ctx.Parallelism)
for _, snap := range snaps { for _, snap := range snaps {
snap := snap snap := snap
g.Go(func() error { g.Go(func() error {
@ -164,7 +164,7 @@ func (Pipe) Publish(ctx *context.Context) error {
} }
func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries []*artifact.Artifact) error { func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries []*artifact.Artifact) error {
var log = log.WithField("arch", arch) log := log.WithField("arch", arch)
folder, err := tmpl.New(ctx). folder, err := tmpl.New(ctx).
WithArtifact(binaries[0], snap.Replacements). WithArtifact(binaries[0], snap.Replacements).
Apply(snap.NameTemplate) Apply(snap.NameTemplate)
@ -173,11 +173,11 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
} }
// prime is the directory that then will be compressed to make the .snap package. // prime is the directory that then will be compressed to make the .snap package.
var folderDir = filepath.Join(ctx.Config.Dist, folder) folderDir := filepath.Join(ctx.Config.Dist, folder)
var primeDir = filepath.Join(folderDir, "prime") primeDir := filepath.Join(folderDir, "prime")
var metaDir = filepath.Join(primeDir, "meta") metaDir := filepath.Join(primeDir, "meta")
// #nosec // #nosec
if err = os.MkdirAll(metaDir, 0755); err != nil { if err = os.MkdirAll(metaDir, 0o755); err != nil {
return err return err
} }
@ -186,9 +186,9 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
file.Destination = file.Source file.Destination = file.Source
} }
if file.Mode == 0 { if file.Mode == 0 {
file.Mode = 0644 file.Mode = 0o644
} }
if err := os.MkdirAll(filepath.Join(primeDir, filepath.Dir(file.Destination)), 0755); err != nil { if err := os.MkdirAll(filepath.Join(primeDir, filepath.Dir(file.Destination)), 0o755); err != nil {
return fmt.Errorf("failed to link extra file '%s': %w", file.Source, err) return fmt.Errorf("failed to link extra file '%s': %w", file.Source, err)
} }
if err := link(file.Source, filepath.Join(primeDir, file.Destination), os.FileMode(file.Mode)); err != nil { if err := link(file.Source, filepath.Join(primeDir, file.Destination), os.FileMode(file.Mode)); err != nil {
@ -196,10 +196,10 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
} }
} }
var file = filepath.Join(primeDir, "meta", "snap.yaml") file := filepath.Join(primeDir, "meta", "snap.yaml")
log.WithField("file", file).Debug("creating snap metadata") log.WithField("file", file).Debug("creating snap metadata")
var metadata = &Metadata{ metadata := &Metadata{
Version: ctx.Version, Version: ctx.Version,
Summary: snap.Summary, Summary: snap.Summary,
Description: snap.Description, Description: snap.Description,
@ -235,7 +235,7 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
// if the user didn't specify any apps then // if the user didn't specify any apps then
// default to the main binary being the command: // default to the main binary being the command:
if len(snap.Apps) == 0 { if len(snap.Apps) == 0 {
var name = snap.Name name := snap.Name
if name == "" { if name == "" {
name = binaries[0].Name name = binaries[0].Name
} }
@ -254,7 +254,7 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
if err = os.Link(binary.Path, destBinaryPath); err != nil { if err = os.Link(binary.Path, destBinaryPath); err != nil {
return fmt.Errorf("failed to link binary: %w", err) return fmt.Errorf("failed to link binary: %w", err)
} }
if err := os.Chmod(destBinaryPath, 0555); err != nil { if err := os.Chmod(destBinaryPath, 0o555); err != nil {
return fmt.Errorf("failed to change binary permissions: %w", err) return fmt.Errorf("failed to change binary permissions: %w", err)
} }
} }
@ -280,7 +280,7 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
if config.Completer != "" { if config.Completer != "" {
destCompleterPath := filepath.Join(primeDir, config.Completer) destCompleterPath := filepath.Join(primeDir, config.Completer)
if err := os.MkdirAll(filepath.Dir(destCompleterPath), 0755); err != nil { if err := os.MkdirAll(filepath.Dir(destCompleterPath), 0o755); err != nil {
return fmt.Errorf("failed to create folder: %w", err) return fmt.Errorf("failed to create folder: %w", err)
} }
log.WithField("src", config.Completer). log.WithField("src", config.Completer).
@ -289,7 +289,7 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
if err := os.Link(config.Completer, destCompleterPath); err != nil { if err := os.Link(config.Completer, destCompleterPath); err != nil {
return fmt.Errorf("failed to link completer: %w", err) return fmt.Errorf("failed to link completer: %w", err)
} }
if err := os.Chmod(destCompleterPath, 0644); err != nil { if err := os.Chmod(destCompleterPath, 0o644); err != nil {
return fmt.Errorf("failed to change completer permissions: %w", err) return fmt.Errorf("failed to change completer permissions: %w", err)
} }
appMetadata.Completer = config.Completer appMetadata.Completer = config.Completer
@ -305,14 +305,14 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
} }
log.WithField("file", file).Debugf("writing metadata file") log.WithField("file", file).Debugf("writing metadata file")
if err = os.WriteFile(file, out, 0644); err != nil { //nolint: gosec if err = os.WriteFile(file, out, 0o644); err != nil { //nolint: gosec
return err return err
} }
var snapFile = filepath.Join(ctx.Config.Dist, folder+".snap") snapFile := filepath.Join(ctx.Config.Dist, folder+".snap")
log.WithField("snap", snapFile).Info("creating") log.WithField("snap", snapFile).Info("creating")
/* #nosec */ /* #nosec */
var cmd = exec.CommandContext(ctx, "snapcraft", "pack", primeDir, "--output", snapFile) cmd := exec.CommandContext(ctx, "snapcraft", "pack", primeDir, "--output", snapFile)
if out, err = cmd.CombinedOutput(); err != nil { if out, err = cmd.CombinedOutput(); err != nil {
return fmt.Errorf("failed to generate snap package: %s", string(out)) return fmt.Errorf("failed to generate snap package: %s", string(out))
} }
@ -333,11 +333,11 @@ func create(ctx *context.Context, snap config.Snapcraft, arch string, binaries [
const reviewWaitMsg = `Waiting for previous upload(s) to complete their review process.` const reviewWaitMsg = `Waiting for previous upload(s) to complete their review process.`
func push(ctx *context.Context, snap *artifact.Artifact) error { func push(ctx *context.Context, snap *artifact.Artifact) error {
var log = log.WithField("snap", snap.Name) log := log.WithField("snap", snap.Name)
log.Info("pushing snap") log.Info("pushing snap")
// TODO: customize --release based on snap.Grade? // TODO: customize --release based on snap.Grade?
/* #nosec */ /* #nosec */
var cmd = exec.CommandContext(ctx, "snapcraft", "upload", "--release=stable", snap.Path) cmd := exec.CommandContext(ctx, "snapcraft", "upload", "--release=stable", snap.Path)
if out, err := cmd.CombinedOutput(); err != nil { if out, err := cmd.CombinedOutput(); err != nil {
if strings.Contains(string(out), reviewWaitMsg) { if strings.Contains(string(out), reviewWaitMsg) {
log.Warn(reviewWaitMsg) log.Warn(reviewWaitMsg)
@ -361,7 +361,7 @@ func link(src, dest string, mode os.FileMode) error {
// - dest = "dist/linuxamd64/b" // - dest = "dist/linuxamd64/b"
// - path = "a/b/c.txt" // - path = "a/b/c.txt"
// So we join "a/b" with "c.txt" and use it as the destination. // So we join "a/b" with "c.txt" and use it as the destination.
var dst = filepath.Join(dest, strings.Replace(path, src, "", 1)) dst := filepath.Join(dest, strings.Replace(path, src, "", 1))
log.WithFields(log.Fields{ log.WithFields(log.Fields{
"src": path, "src": path,
"dst": dst, "dst": dst,

92
internal/pipe/snapcraft/snapcraft_test.go
View File

@ -31,7 +31,7 @@ func TestRunPipeMissingInfo(t *testing.T) {
pipe.Skip("no summary nor description were provided"): {}, pipe.Skip("no summary nor description were provided"): {},
} { } {
t.Run(fmt.Sprintf("testing if %v happens", eerr), func(t *testing.T) { t.Run(fmt.Sprintf("testing if %v happens", eerr), func(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
snap, snap,
@ -44,10 +44,10 @@ func TestRunPipeMissingInfo(t *testing.T) {
} }
func TestRunPipe(t *testing.T) { func TestRunPipe(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -84,10 +84,10 @@ func TestRunPipe(t *testing.T) {
} }
func TestRunPipeInvalidNameTemplate(t *testing.T) { func TestRunPipeInvalidNameTemplate(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "foo", ProjectName: "foo",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -106,10 +106,10 @@ func TestRunPipeInvalidNameTemplate(t *testing.T) {
} }
func TestRunPipeWithName(t *testing.T) { func TestRunPipeWithName(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "testprojectname", ProjectName: "testprojectname",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -140,10 +140,10 @@ func TestRunPipeWithName(t *testing.T) {
} }
func TestRunPipeMetadata(t *testing.T) { func TestRunPipeMetadata(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "testprojectname", ProjectName: "testprojectname",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -193,12 +193,12 @@ func TestRunPipeMetadata(t *testing.T) {
} }
func TestNoSnapcraftInPath(t *testing.T) { func TestNoSnapcraftInPath(t *testing.T) {
var path = os.Getenv("PATH") path := os.Getenv("PATH")
defer func() { defer func() {
require.NoError(t, os.Setenv("PATH", path)) require.NoError(t, os.Setenv("PATH", path))
}() }()
require.NoError(t, os.Setenv("PATH", "")) require.NoError(t, os.Setenv("PATH", ""))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
{ {
Summary: "dummy", Summary: "dummy",
@ -210,10 +210,10 @@ func TestNoSnapcraftInPath(t *testing.T) {
} }
func TestRunNoArguments(t *testing.T) { func TestRunNoArguments(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "testprojectname", ProjectName: "testprojectname",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -244,10 +244,10 @@ func TestRunNoArguments(t *testing.T) {
} }
func TestCompleter(t *testing.T) { func TestCompleter(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "testprojectname", ProjectName: "testprojectname",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -281,10 +281,10 @@ func TestCompleter(t *testing.T) {
} }
func TestCommand(t *testing.T) { func TestCommand(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "testprojectname", ProjectName: "testprojectname",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -316,10 +316,10 @@ func TestCommand(t *testing.T) {
} }
func TestExtraFile(t *testing.T) { func TestExtraFile(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "testprojectname", ProjectName: "testprojectname",
Dist: dist, Dist: dist,
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
@ -331,7 +331,7 @@ func TestExtraFile(t *testing.T) {
{ {
Source: "testdata/extra-file.txt", Source: "testdata/extra-file.txt",
Destination: "a/b/c/extra-file.txt", Destination: "a/b/c/extra-file.txt",
Mode: 0755, Mode: 0o755,
}, },
{ {
Source: "testdata/extra-file-2.txt", Source: "testdata/extra-file-2.txt",
@ -351,18 +351,18 @@ func TestExtraFile(t *testing.T) {
destFile, err := os.Stat(filepath.Join(dist, "foo_amd64", "prime", "a", "b", "c", "extra-file.txt")) destFile, err := os.Stat(filepath.Join(dist, "foo_amd64", "prime", "a", "b", "c", "extra-file.txt"))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, inode(srcFile), inode(destFile)) require.Equal(t, inode(srcFile), inode(destFile))
require.Equal(t, destFile.Mode(), os.FileMode(0755)) require.Equal(t, destFile.Mode(), os.FileMode(0o755))
srcFile, err = os.Stat("testdata/extra-file-2.txt") srcFile, err = os.Stat("testdata/extra-file-2.txt")
require.NoError(t, err) require.NoError(t, err)
destFileWithDefaults, err := os.Stat(filepath.Join(dist, "foo_amd64", "prime", "testdata", "extra-file-2.txt")) destFileWithDefaults, err := os.Stat(filepath.Join(dist, "foo_amd64", "prime", "testdata", "extra-file-2.txt"))
require.NoError(t, err) require.NoError(t, err)
require.Equal(t, destFileWithDefaults.Mode(), os.FileMode(0644)) require.Equal(t, destFileWithDefaults.Mode(), os.FileMode(0o644))
require.Equal(t, inode(srcFile), inode(destFileWithDefaults)) require.Equal(t, inode(srcFile), inode(destFileWithDefaults))
} }
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Builds: []config.Build{ Builds: []config.Build{
{ {
ID: "foo", ID: "foo",
@ -378,7 +378,7 @@ func TestDefault(t *testing.T) {
} }
func TestPublish(t *testing.T) { func TestPublish(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "mybin", Name: "mybin",
Path: "nope.snap", Path: "nope.snap",
@ -391,7 +391,7 @@ func TestPublish(t *testing.T) {
} }
func TestPublishSkip(t *testing.T) { func TestPublishSkip(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
ctx.SkipPublish = true ctx.SkipPublish = true
ctx.Artifacts.Add(&artifact.Artifact{ ctx.Artifacts.Add(&artifact.Artifact{
Name: "mybin", Name: "mybin",
@ -404,7 +404,7 @@ func TestPublishSkip(t *testing.T) {
} }
func TestDefaultSet(t *testing.T) { func TestDefaultSet(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
{ {
NameTemplate: "foo", NameTemplate: "foo",
@ -419,9 +419,9 @@ func addBinaries(t *testing.T, ctx *context.Context, name, dist string) {
t.Helper() t.Helper()
for _, goos := range []string{"linux", "darwin"} { for _, goos := range []string{"linux", "darwin"} {
for _, goarch := range []string{"amd64", "386", "arm6"} { for _, goarch := range []string{"amd64", "386", "arm6"} {
var folder = goos + goarch folder := goos + goarch
require.NoError(t, os.MkdirAll(filepath.Join(dist, folder), 0755)) require.NoError(t, os.MkdirAll(filepath.Join(dist, folder), 0o755))
var binPath = filepath.Join(dist, folder, name) binPath := filepath.Join(dist, folder, name)
f, err := os.Create(binPath) f, err := os.Create(binPath)
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, f.Close()) require.NoError(t, f.Close())
@ -440,7 +440,7 @@ func addBinaries(t *testing.T, ctx *context.Context, name, dist string) {
} }
func TestSeveralSnapssWithTheSameID(t *testing.T) { func TestSeveralSnapssWithTheSameID(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Snapcrafts: []config.Snapcraft{ Snapcrafts: []config.Snapcraft{
{ {

11
internal/pipe/snapshot/snapshot_test.go
View File

@ -12,8 +12,9 @@ import (
func TestStringer(t *testing.T) { func TestStringer(t *testing.T) {
require.NotEmpty(t, Pipe{}.String()) require.NotEmpty(t, Pipe{}.String())
} }
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Snapshot: config.Snapshot{}, Snapshot: config.Snapshot{},
}, },
@ -23,7 +24,7 @@ func TestDefault(t *testing.T) {
} }
func TestDefaultSet(t *testing.T) { func TestDefaultSet(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Snapshot: config.Snapshot{ Snapshot: config.Snapshot{
NameTemplate: "snap", NameTemplate: "snap",
@ -35,7 +36,7 @@ func TestDefaultSet(t *testing.T) {
} }
func TestSnapshotInvalidNametemplate(t *testing.T) { func TestSnapshotInvalidNametemplate(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Snapshot: config.Snapshot{ Snapshot: config.Snapshot{
NameTemplate: "{{.ShortCommit}{{{sss}}}", NameTemplate: "{{.ShortCommit}{{{sss}}}",
}, },
@ -45,7 +46,7 @@ func TestSnapshotInvalidNametemplate(t *testing.T) {
} }
func TestSnapshotEmptyFinalName(t *testing.T) { func TestSnapshotEmptyFinalName(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Snapshot: config.Snapshot{ Snapshot: config.Snapshot{
NameTemplate: "{{ .Commit }}", NameTemplate: "{{ .Commit }}",
}, },
@ -56,6 +57,6 @@ func TestSnapshotEmptyFinalName(t *testing.T) {
} }
func TestNotASnapshot(t *testing.T) { func TestNotASnapshot(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
testlib.AssertSkipped(t, Pipe{}.Run(ctx)) testlib.AssertSkipped(t, Pipe{}.Run(ctx))
} }

16
internal/pipe/sourcearchive/source_test.go
View File

@ -15,16 +15,16 @@ import (
func TestArchive(t *testing.T) { func TestArchive(t *testing.T) {
for _, format := range []string{"tar.gz", "tar", "zip"} { for _, format := range []string{"tar.gz", "tar", "zip"} {
t.Run(format, func(t *testing.T) { t.Run(format, func(t *testing.T) {
var tmp = testlib.Mktmp(t) tmp := testlib.Mktmp(t)
require.NoError(t, os.Mkdir("dist", 0744)) require.NoError(t, os.Mkdir("dist", 0o744))
testlib.GitInit(t) testlib.GitInit(t)
require.NoError(t, os.WriteFile("code.txt", []byte("not really code"), 0655)) require.NoError(t, os.WriteFile("code.txt", []byte("not really code"), 0o655))
require.NoError(t, os.WriteFile("README.md", []byte("# my dope fake project"), 0655)) require.NoError(t, os.WriteFile("README.md", []byte("# my dope fake project"), 0o655))
testlib.GitAdd(t) testlib.GitAdd(t)
testlib.GitCommit(t, "feat: first") testlib.GitCommit(t, "feat: first")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "foo", ProjectName: "foo",
Dist: "dist", Dist: "dist",
Source: config.Source{ Source: config.Source{
@ -38,7 +38,7 @@ func TestArchive(t *testing.T) {
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
require.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
var artifacts = ctx.Artifacts.List() artifacts := ctx.Artifacts.List()
require.Len(t, artifacts, 1) require.Len(t, artifacts, 1)
require.Equal(t, artifact.Artifact{ require.Equal(t, artifact.Artifact{
Type: artifact.UploadableSourceArchive, Type: artifact.UploadableSourceArchive,
@ -56,7 +56,7 @@ func TestArchive(t *testing.T) {
} }
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
var ctx = context.New(config.Project{}) ctx := context.New(config.Project{})
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
require.Equal(t, config.Source{ require.Equal(t, config.Source{
NameTemplate: "{{ .ProjectName }}-{{ .Version }}", NameTemplate: "{{ .ProjectName }}-{{ .Version }}",
@ -65,7 +65,7 @@ func TestDefault(t *testing.T) {
} }
func TestInvalidNameTemplate(t *testing.T) { func TestInvalidNameTemplate(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Source: config.Source{ Source: config.Source{
Enabled: true, Enabled: true,
NameTemplate: "{{ .foo }-asdda", NameTemplate: "{{ .foo }-asdda",

182
internal/pipe/upload/upload_test.go
View File

@ -36,18 +36,14 @@ func teardown() {
server.Close() server.Close()
} }
func testMethod(t *testing.T, r *http.Request, want string) { func requireMethodPut(t *testing.T, r *http.Request) {
t.Helper() t.Helper()
if got := r.Method; got != want { require.Equal(t, http.MethodPut, r.Method)
t.Errorf("Request method: %v, want %v", got, want)
}
} }
func testHeader(t *testing.T, r *http.Request, header, want string) { func requireHeader(t *testing.T, r *http.Request, header, want string) {
t.Helper() t.Helper()
if got := r.Header.Get(header); got != want { require.Equal(t, want, r.Header.Get(header))
t.Errorf("Header.Get(%q) returned %q, want %q", header, got, want)
}
} }
// TODO: improve all tests bellow by checking wether the mocked handlers // TODO: improve all tests bellow by checking wether the mocked handlers
@ -57,53 +53,53 @@ func TestRunPipe_ModeBinary(t *testing.T) {
setup() setup()
defer teardown() defer teardown()
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0o755))
var binPath = filepath.Join(dist, "mybin", "mybin") binPath := filepath.Join(dist, "mybin", "mybin")
d1 := []byte("hello\ngo\n") d1 := []byte("hello\ngo\n")
require.NoError(t, os.WriteFile(binPath, d1, 0666)) require.NoError(t, os.WriteFile(binPath, d1, 0o666))
// Dummy http server // Dummy http server
mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin") w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
}) })
mux.HandleFunc("/example-repo-local/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin") w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
}) })
mux.HandleFunc("/production-repo-remote/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/production-repo-remote/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "productionuser" with secret "productionuser-apikey" // Basic auth of user "productionuser" with secret "productionuser-apikey"
testHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5") requireHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5")
w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin") w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
}) })
mux.HandleFunc("/production-repo-remote/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/production-repo-remote/mybin/linux/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "productionuser" with secret "productionuser-apikey" // Basic auth of user "productionuser" with secret "productionuser-apikey"
testHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5") requireHeader(t, r, "Authorization", "Basic cHJvZHVjdGlvbnVzZXI6cHJvZHVjdGlvbnVzZXItYXBpa2V5")
w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin") w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
}) })
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -147,7 +143,7 @@ func TestRunPipe_ModeArchive(t *testing.T) {
setup() setup()
defer teardown() defer teardown()
var folder = t.TempDir() folder := t.TempDir()
tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz")) tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, tarfile.Close()) require.NoError(t, tarfile.Close())
@ -155,7 +151,7 @@ func TestRunPipe_ModeArchive(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, debfile.Close()) require.NoError(t, debfile.Close())
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "goreleaser", ProjectName: "goreleaser",
Dist: folder, Dist: folder,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -190,18 +186,18 @@ func TestRunPipe_ModeArchive(t *testing.T) {
// Dummy http server // Dummy http server
mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.tar.gz", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.tar.gz", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.tar.gz") w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.tar.gz")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
uploads.Store("targz", true) uploads.Store("targz", true)
}) })
mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.deb", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.deb", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.deb") w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.deb")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
@ -219,35 +215,35 @@ func TestRunPipe_ModeBinary_CustomArtifactName(t *testing.T) {
setup() setup()
defer teardown() defer teardown()
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0o755))
var binPath = filepath.Join(dist, "mybin", "mybin") binPath := filepath.Join(dist, "mybin", "mybin")
d1 := []byte("hello\ngo\n") d1 := []byte("hello\ngo\n")
require.NoError(t, os.WriteFile(binPath, d1, 0666)) require.NoError(t, os.WriteFile(binPath, d1, 0o666))
// Dummy http server // Dummy http server
mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin;deb.distribution=xenial") w.Header().Set("Location", "/production-repo-remote/mybin/linux/amd64/mybin;deb.distribution=xenial")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
}) })
mux.HandleFunc("/example-repo-local/mybin/linux/amd64/mybin;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/linux/amd64/mybin;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/example-repo-local/mybin/linux/amd64/mybin;deb.distribution=xenial") w.Header().Set("Location", "/example-repo-local/mybin/linux/amd64/mybin;deb.distribution=xenial")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
}) })
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -284,7 +280,7 @@ func TestRunPipe_ModeArchive_CustomArtifactName(t *testing.T) {
setup() setup()
defer teardown() defer teardown()
var folder = t.TempDir() folder := t.TempDir()
tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz")) tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, tarfile.Close()) require.NoError(t, tarfile.Close())
@ -292,7 +288,7 @@ func TestRunPipe_ModeArchive_CustomArtifactName(t *testing.T) {
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, debfile.Close()) require.NoError(t, debfile.Close())
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "goreleaser", ProjectName: "goreleaser",
Dist: folder, Dist: folder,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -328,18 +324,18 @@ func TestRunPipe_ModeArchive_CustomArtifactName(t *testing.T) {
// Dummy http server // Dummy http server
mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.tar.gz;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.tar.gz;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.tar.gz;deb.distribution=xenial") w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.tar.gz;deb.distribution=xenial")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
uploads.Store("targz", true) uploads.Store("targz", true)
}) })
mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.deb;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/goreleaser/1.0.0/bin.deb;deb.distribution=xenial", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.deb;deb.distribution=xenial") w.Header().Set("Location", "/example-repo-local/goreleaser/1.0.0/bin.deb;deb.distribution=xenial")
w.WriteHeader(http.StatusCreated) w.WriteHeader(http.StatusCreated)
@ -354,12 +350,12 @@ func TestRunPipe_ModeArchive_CustomArtifactName(t *testing.T) {
} }
func TestRunPipe_ArtifactoryDown(t *testing.T) { func TestRunPipe_ArtifactoryDown(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz")) tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz"))
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, tarfile.Close()) require.NoError(t, tarfile.Close())
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "goreleaser", ProjectName: "goreleaser",
Dist: folder, Dist: folder,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -387,11 +383,11 @@ func TestRunPipe_ArtifactoryDown(t *testing.T) {
} }
func TestRunPipe_TargetTemplateError(t *testing.T) { func TestRunPipe_TargetTemplateError(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
var binPath = filepath.Join(dist, "mybin", "mybin") binPath := filepath.Join(dist, "mybin", "mybin")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -418,7 +414,7 @@ func TestRunPipe_TargetTemplateError(t *testing.T) {
Goos: "darwin", Goos: "darwin",
Type: artifact.UploadableBinary, Type: artifact.UploadableBinary,
}) })
var err = Pipe{}.Publish(ctx) err := Pipe{}.Publish(ctx)
require.Error(t, err) require.Error(t, err)
require.Contains(t, err.Error(), `upload: error while building the target url: template: tmpl:1: unexpected "/" in operand`) require.Contains(t, err.Error(), `upload: error while building the target url: template: tmpl:1: unexpected "/" in operand`)
} }
@ -427,25 +423,25 @@ func TestRunPipe_BadCredentials(t *testing.T) {
setup() setup()
defer teardown() defer teardown()
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0o755))
var binPath = filepath.Join(dist, "mybin", "mybin") binPath := filepath.Join(dist, "mybin", "mybin")
d1 := []byte("hello\ngo\n") d1 := []byte("hello\ngo\n")
require.NoError(t, os.WriteFile(binPath, d1, 0666)) require.NoError(t, os.WriteFile(binPath, d1, 0o666))
// Dummy http server // Dummy http server
mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) { mux.HandleFunc("/example-repo-local/mybin/darwin/amd64/mybin", func(w http.ResponseWriter, r *http.Request) {
testMethod(t, r, http.MethodPut) requireMethodPut(t, r)
testHeader(t, r, "Content-Length", "9") requireHeader(t, r, "Content-Length", "9")
// Basic auth of user "deployuser" with secret "deployuser-secret" // Basic auth of user "deployuser" with secret "deployuser-secret"
testHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==") requireHeader(t, r, "Authorization", "Basic ZGVwbG95dXNlcjpkZXBsb3l1c2VyLXNlY3JldA==")
w.WriteHeader(http.StatusUnauthorized) w.WriteHeader(http.StatusUnauthorized)
}) })
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -472,13 +468,13 @@ func TestRunPipe_BadCredentials(t *testing.T) {
Type: artifact.UploadableBinary, Type: artifact.UploadableBinary,
}) })
var err = Pipe{}.Publish(ctx) err := Pipe{}.Publish(ctx)
require.Error(t, err) require.Error(t, err)
require.Contains(t, err.Error(), "Unauthorized") require.Contains(t, err.Error(), "Unauthorized")
} }
func TestRunPipe_FileNotFound(t *testing.T) { func TestRunPipe_FileNotFound(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: "archivetest/dist", Dist: "archivetest/dist",
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -509,15 +505,15 @@ func TestRunPipe_FileNotFound(t *testing.T) {
} }
func TestRunPipe_UnparsableTarget(t *testing.T) { func TestRunPipe_UnparsableTarget(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0o755))
var binPath = filepath.Join(dist, "mybin", "mybin") binPath := filepath.Join(dist, "mybin", "mybin")
d1 := []byte("hello\ngo\n") d1 := []byte("hello\ngo\n")
require.NoError(t, os.WriteFile(binPath, d1, 0666)) require.NoError(t, os.WriteFile(binPath, d1, 0o666))
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -548,7 +544,7 @@ func TestRunPipe_UnparsableTarget(t *testing.T) {
} }
func TestRunPipe_SkipWhenPublishFalse(t *testing.T) { func TestRunPipe_SkipWhenPublishFalse(t *testing.T) {
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
Uploads: []config.Upload{ Uploads: []config.Upload{
{ {
Name: "production", Name: "production",
@ -572,13 +568,13 @@ func TestRunPipe_SkipWhenPublishFalse(t *testing.T) {
} }
func TestRunPipe_DirUpload(t *testing.T) { func TestRunPipe_DirUpload(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
var dist = filepath.Join(folder, "dist") dist := filepath.Join(folder, "dist")
require.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0o755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0o755))
var binPath = filepath.Join(dist, "mybin") binPath := filepath.Join(dist, "mybin")
var ctx = context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "mybin", ProjectName: "mybin",
Dist: dist, Dist: dist,
Uploads: []config.Upload{ Uploads: []config.Upload{
@ -617,7 +613,7 @@ func TestNoPuts(t *testing.T) {
} }
func TestPutsWithoutTarget(t *testing.T) { func TestPutsWithoutTarget(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Env: map[string]string{ Env: map[string]string{
"UPLOAD_PRODUCTION_SECRET": "deployuser-secret", "UPLOAD_PRODUCTION_SECRET": "deployuser-secret",
}, },
@ -636,7 +632,7 @@ func TestPutsWithoutTarget(t *testing.T) {
} }
func TestPutsWithoutUsername(t *testing.T) { func TestPutsWithoutUsername(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Env: map[string]string{ Env: map[string]string{
"UPLOAD_PRODUCTION_SECRET": "deployuser-secret", "UPLOAD_PRODUCTION_SECRET": "deployuser-secret",
}, },
@ -680,7 +676,7 @@ func TestPutsWithoutSecret(t *testing.T) {
} }
func TestPutsWithInvalidMode(t *testing.T) { func TestPutsWithInvalidMode(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Env: map[string]string{ Env: map[string]string{
"UPLOAD_PRODUCTION_SECRET": "deployuser-secret", "UPLOAD_PRODUCTION_SECRET": "deployuser-secret",
}, },
@ -700,7 +696,7 @@ func TestPutsWithInvalidMode(t *testing.T) {
} }
func TestDefault(t *testing.T) { func TestDefault(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Uploads: []config.Upload{ Uploads: []config.Upload{
{ {
@ -713,13 +709,13 @@ func TestDefault(t *testing.T) {
} }
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
require.Len(t, ctx.Config.Uploads, 1) require.Len(t, ctx.Config.Uploads, 1)
var upload = ctx.Config.Uploads[0] upload := ctx.Config.Uploads[0]
require.Equal(t, "archive", upload.Mode) require.Equal(t, "archive", upload.Mode)
require.Equal(t, h.MethodPut, upload.Method) require.Equal(t, h.MethodPut, upload.Method)
} }
func TestDefaultNoPuts(t *testing.T) { func TestDefaultNoPuts(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Uploads: []config.Upload{}, Uploads: []config.Upload{},
}, },
@ -729,7 +725,7 @@ func TestDefaultNoPuts(t *testing.T) {
} }
func TestDefaultSet(t *testing.T) { func TestDefaultSet(t *testing.T) {
var ctx = &context.Context{ ctx := &context.Context{
Config: config.Project{ Config: config.Project{
Uploads: []config.Upload{ Uploads: []config.Upload{
{ {
@ -741,7 +737,7 @@ func TestDefaultSet(t *testing.T) {
} }
require.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
require.Len(t, ctx.Config.Uploads, 1) require.Len(t, ctx.Config.Uploads, 1)
var upload = ctx.Config.Uploads[0] upload := ctx.Config.Uploads[0]
require.Equal(t, "custom", upload.Mode) require.Equal(t, "custom", upload.Mode)
require.Equal(t, h.MethodPost, upload.Method) require.Equal(t, h.MethodPost, upload.Method)
} }

2
internal/semerrgroup/sem.go
View File

@ -89,7 +89,7 @@ type skipAwareGroup struct {
// Go execs runs `fn` and saves the result if no error has been encountered. // Go execs runs `fn` and saves the result if no error has been encountered.
func (s *skipAwareGroup) Go(fn func() error) { func (s *skipAwareGroup) Go(fn func() error) {
s.g.Go(func() error { s.g.Go(func() error {
var err = fn() err := fn()
// if the err is a skip, set it for later, but return nil for now so the // if the err is a skip, set it for later, but return nil for now so the
// the group proceeds. // the group proceeds.
if pipe.IsSkip(err) { if pipe.IsSkip(err) {

16
internal/semerrgroup/sem_test.go
View File

@ -11,7 +11,7 @@ import (
) )
func TestSemaphore(t *testing.T) { func TestSemaphore(t *testing.T) {
var g = New(4) g := New(4)
var lock sync.Mutex var lock sync.Mutex
var counter int var counter int
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
@ -28,9 +28,9 @@ func TestSemaphore(t *testing.T) {
} }
func TestSemaphoreOrder(t *testing.T) { func TestSemaphoreOrder(t *testing.T) {
var num = 10 num := 10
var g = New(1) g := New(1)
var output = []int{} output := []int{}
for i := 0; i < num; i++ { for i := 0; i < num; i++ {
i := i i := i
g.Go(func() error { g.Go(func() error {
@ -43,8 +43,8 @@ func TestSemaphoreOrder(t *testing.T) {
} }
func TestSemaphoreOrderError(t *testing.T) { func TestSemaphoreOrderError(t *testing.T) {
var g = New(1) g := New(1)
var output = []int{} output := []int{}
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
i := i i := i
g.Go(func() error { g.Go(func() error {
@ -57,7 +57,7 @@ func TestSemaphoreOrderError(t *testing.T) {
} }
func TestSemaphoreSkipAware(t *testing.T) { func TestSemaphoreSkipAware(t *testing.T) {
var g = NewSkipAware(New(1)) g := NewSkipAware(New(1))
var lock sync.Mutex var lock sync.Mutex
var counter int var counter int
for i := 0; i < 10; i++ { for i := 0; i < 10; i++ {
@ -74,7 +74,7 @@ func TestSemaphoreSkipAware(t *testing.T) {
} }
func TestSemaphoreSkipAndRealError(t *testing.T) { func TestSemaphoreSkipAndRealError(t *testing.T) {
var g = NewSkipAware(New(10)) g := NewSkipAware(New(10))
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
g.Go(func() error { g.Go(func() error {
time.Sleep(10 * time.Millisecond) time.Sleep(10 * time.Millisecond)

1
internal/tmpl/tmpl_test.go
View File

@ -13,6 +13,7 @@ import (
) )
func TestWithArtifact(t *testing.T) { func TestWithArtifact(t *testing.T) {
t.Parallel()
ctx := context.New(config.Project{ ctx := context.New(config.Project{
ProjectName: "proj", ProjectName: "proj",
}) })

6
pkg/archive/archive_test.go
View File

@ -8,18 +8,18 @@ import (
) )
func TestArchive(t *testing.T) { func TestArchive(t *testing.T) {
var folder = t.TempDir() folder := t.TempDir()
empty, err := os.Create(folder + "/empty.txt") empty, err := os.Create(folder + "/empty.txt")
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, empty.Close()) require.NoError(t, empty.Close())
require.NoError(t, os.Mkdir(folder+"/folder-inside", 0755)) require.NoError(t, os.Mkdir(folder+"/folder-inside", 0o755))
for _, format := range []string{"tar.gz", "zip", "gz", "tar.xz", "willbeatargzanyway"} { for _, format := range []string{"tar.gz", "zip", "gz", "tar.xz", "willbeatargzanyway"} {
format := format format := format
t.Run(format, func(t *testing.T) { t.Run(format, func(t *testing.T) {
file, err := os.Create(folder + "/folder." + format) file, err := os.Create(folder + "/folder." + format)
require.NoError(t, err) require.NoError(t, err)
var archive = New(file) archive := New(file)
t.Cleanup(func() { t.Cleanup(func() {
require.NoError(t, archive.Close()) require.NoError(t, archive.Close())
require.NoError(t, file.Close()) require.NoError(t, file.Close())

2
pkg/archive/gzip/gzip_test.go
View File

@ -11,7 +11,7 @@ import (
) )
func TestGzFile(t *testing.T) { func TestGzFile(t *testing.T) {
var tmp = t.TempDir() tmp := t.TempDir()
f, err := os.Create(filepath.Join(tmp, "test.gz")) f, err := os.Create(filepath.Join(tmp, "test.gz"))
require.NoError(t, err) require.NoError(t, err)
defer f.Close() // nolint: errcheck defer f.Close() // nolint: errcheck

4
pkg/archive/targz/targz_test.go
View File

@ -12,7 +12,7 @@ import (
) )
func TestTarGzFile(t *testing.T) { func TestTarGzFile(t *testing.T) {
var tmp = t.TempDir() tmp := t.TempDir()
f, err := os.Create(filepath.Join(tmp, "test.tar.gz")) f, err := os.Create(filepath.Join(tmp, "test.tar.gz"))
require.NoError(t, err) require.NoError(t, err)
defer f.Close() // nolint: errcheck defer f.Close() // nolint: errcheck
@ -55,7 +55,7 @@ func TestTarGzFile(t *testing.T) {
paths = append(paths, next.Name) paths = append(paths, next.Name)
t.Logf("%s: %v", next.Name, next.FileInfo().Mode()) t.Logf("%s: %v", next.Name, next.FileInfo().Mode())
if next.Name == "sub1/executable" { if next.Name == "sub1/executable" {
var ex = next.FileInfo().Mode() | 0111 ex := next.FileInfo().Mode() | 0o111
require.Equal(t, next.FileInfo().Mode().String(), ex.String()) require.Equal(t, next.FileInfo().Mode().String(), ex.String())
} }
} }

4
pkg/archive/tarxz/tarxz_test.go
View File

@ -12,7 +12,7 @@ import (
) )
func TestTarXzFile(t *testing.T) { func TestTarXzFile(t *testing.T) {
var tmp = t.TempDir() tmp := t.TempDir()
f, err := os.Create(filepath.Join(tmp, "test.tar.xz")) f, err := os.Create(filepath.Join(tmp, "test.tar.xz"))
require.NoError(t, err) require.NoError(t, err)
defer f.Close() // nolint: errcheck defer f.Close() // nolint: errcheck
@ -53,7 +53,7 @@ func TestTarXzFile(t *testing.T) {
paths = append(paths, next.Name) paths = append(paths, next.Name)
t.Logf("%s: %v", next.Name, next.FileInfo().Mode()) t.Logf("%s: %v", next.Name, next.FileInfo().Mode())
if next.Name == "sub1/executable" { if next.Name == "sub1/executable" {
var ex = next.FileInfo().Mode() | 0111 ex := next.FileInfo().Mode() | 0o111
require.Equal(t, next.FileInfo().Mode().String(), ex.String()) require.Equal(t, next.FileInfo().Mode().String(), ex.String())
} }
} }

6
pkg/archive/zip/zip_test.go
View File

@ -10,7 +10,7 @@ import (
) )
func TestZipFile(t *testing.T) { func TestZipFile(t *testing.T) {
var tmp = t.TempDir() tmp := t.TempDir()
f, err := os.Create(filepath.Join(tmp, "test.zip")) f, err := os.Create(filepath.Join(tmp, "test.zip"))
require.NoError(t, err) require.NoError(t, err)
defer f.Close() // nolint: errcheck defer f.Close() // nolint: errcheck
@ -40,12 +40,12 @@ func TestZipFile(t *testing.T) {
r, err := zip.NewReader(f, info.Size()) r, err := zip.NewReader(f, info.Size())
require.NoError(t, err) require.NoError(t, err)
var paths = make([]string, len(r.File)) paths := make([]string, len(r.File))
for i, zf := range r.File { for i, zf := range r.File {
paths[i] = zf.Name paths[i] = zf.Name
t.Logf("%s: %v", zf.Name, zf.Mode()) t.Logf("%s: %v", zf.Name, zf.Mode())
if zf.Name == "sub1/executable" { if zf.Name == "sub1/executable" {
var ex = zf.Mode() | 0111 ex := zf.Mode() | 0o111
require.Equal(t, zf.Mode().String(), ex.String()) require.Equal(t, zf.Mode().String(), ex.String())
} }
} }

3
pkg/build/build_test.go
View File

@ -13,12 +13,13 @@ type dummy struct{}
func (*dummy) WithDefaults(build config.Build) (config.Build, error) { func (*dummy) WithDefaults(build config.Build) (config.Build, error) {
return build, nil return build, nil
} }
func (*dummy) Build(ctx *context.Context, build config.Build, options Options) error { func (*dummy) Build(ctx *context.Context, build config.Build, options Options) error {
return nil return nil
} }
func TestRegisterAndGet(t *testing.T) { func TestRegisterAndGet(t *testing.T) {
var builder = &dummy{} builder := &dummy{}
Register("dummy", builder) Register("dummy", builder)
require.Equal(t, builder, For("dummy")) require.Equal(t, builder, For("dummy"))
} }

6
pkg/config/config_homebrew_dependency_test.go
View File

@ -9,7 +9,7 @@ import (
func TestUnmarshalHomebrewDependency(t *testing.T) { func TestUnmarshalHomebrewDependency(t *testing.T) {
t.Run("string arr", func(t *testing.T) { t.Run("string arr", func(t *testing.T) {
var conf = ` conf := `
brews: brews:
- name: foo - name: foo
dependencies: dependencies:
@ -30,7 +30,7 @@ brews:
}) })
t.Run("mixed", func(t *testing.T) { t.Run("mixed", func(t *testing.T) {
var conf = ` conf := `
brews: brews:
- name: foo - name: foo
dependencies: dependencies:
@ -56,7 +56,7 @@ brews:
}) })
t.Run("mixed", func(t *testing.T) { t.Run("mixed", func(t *testing.T) {
var conf = ` conf := `
brews: brews:
- name: foo - name: foo
dependencies: dependencies:

3
pkg/config/config_test.go
View File

@ -23,7 +23,7 @@ func TestEmptyRepoNameAndOwner(t *testing.T) {
} }
func TestLoadReader(t *testing.T) { func TestLoadReader(t *testing.T) {
var conf = ` conf := `
nfpms: nfpms:
- homepage: http://goreleaser.github.io - homepage: http://goreleaser.github.io
` `
@ -39,6 +39,7 @@ type errorReader struct{}
func (errorReader) Read(p []byte) (n int, err error) { func (errorReader) Read(p []byte) (n int, err error) {
return 1, fmt.Errorf("error") return 1, fmt.Errorf("error")
} }
func TestLoadBadReader(t *testing.T) { func TestLoadBadReader(t *testing.T) {
_, err := LoadReader(errorReader{}) _, err := LoadReader(errorReader{})
require.Error(t, err) require.Error(t, err)

2
pkg/context/context_test.go
View File

@ -12,7 +12,7 @@ import (
func TestNew(t *testing.T) { func TestNew(t *testing.T) {
require.NoError(t, os.Setenv("FOO", "NOT BAR")) require.NoError(t, os.Setenv("FOO", "NOT BAR"))
require.NoError(t, os.Setenv("BAR", "1")) require.NoError(t, os.Setenv("BAR", "1"))
var ctx = New(config.Project{ ctx := New(config.Project{
Env: []string{ Env: []string{
"FOO=BAR", "FOO=BAR",
}, },