go/goreleaser
1
0
Fork 0
mirror of https://github.com/goreleaser/goreleaser.git synced 2025-10-30 23:58:09 +02:00
Code Issues Releases Activity

test: fixed

Browse Source
This commit is contained in:
Carlos Alexandro Becker
2018-11-11 18:17:44 -02:00
committed by Carlos Alexandro Becker
parent 8867356965
commit 7a6de727dd
2 changed files with 106 additions and 101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -26,10 +26,11 @@ const (
defaultBinaryNameTemplate = "{{ .Binary }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}" defaultBinaryNameTemplate = "{{ .Binary }}_{{ .Version }}_{{ .Os }}_{{ .Arch }}{{ if .Arm }}v{{ .Arm }}{{ end }}"
) )
// nolint: gochecknoglobals
var lock sync.Mutex
// Pipe for archive // Pipe for archive
type Pipe struct { type Pipe struct{}
lock sync.Mutex
}
func (Pipe) String() string { func (Pipe) String() string {
return "archives" return "archives"
@@ -63,7 +64,7 @@ func (Pipe) Default(ctx *context.Context) error {
} }
// Run the pipe // Run the pipe
func (p Pipe) Run(ctx *context.Context) error { func (Pipe) Run(ctx *context.Context) error {
var g errgroup.Group // TODO: use semerrgroup here var g errgroup.Group // TODO: use semerrgroup here
var filtered = ctx.Artifacts.Filter(artifact.ByType(artifact.Binary)) var filtered = ctx.Artifacts.Filter(artifact.ByType(artifact.Binary))
for group, artifacts := range filtered.GroupByPlatform() { for group, artifacts := range filtered.GroupByPlatform() {
@@ -73,13 +74,13 @@ func (p Pipe) Run(ctx *context.Context) error {
if packageFormat(ctx, artifacts[0].Goos) == "binary" { if packageFormat(ctx, artifacts[0].Goos) == "binary" {
return skip(ctx, artifacts) return skip(ctx, artifacts)
} }
return p.create(ctx, artifacts) return create(ctx, artifacts)
}) })
} }
return g.Wait() return g.Wait()
} }
func (p Pipe) create(ctx *context.Context, binaries []artifact.Artifact) error { func create(ctx *context.Context, binaries []artifact.Artifact) error {
var format = packageFormat(ctx, binaries[0].Goos) var format = packageFormat(ctx, binaries[0].Goos)
folder, err := tmpl.New(ctx). folder, err := tmpl.New(ctx).
WithArtifact(binaries[0], ctx.Config.Archive.Replacements). WithArtifact(binaries[0], ctx.Config.Archive.Replacements).
@@ -88,15 +89,17 @@ func (p Pipe) create(ctx *context.Context, binaries []artifact.Artifact) error {
return err return err
} }
archivePath := filepath.Join(ctx.Config.Dist, folder+"."+format) archivePath := filepath.Join(ctx.Config.Dist, folder+"."+format)
p.lock.Lock() lock.Lock()
if _, err := os.Stat(archivePath); !os.IsNotExist(err) { if _, err := os.Stat(archivePath); !os.IsNotExist(err) {
lock.Unlock()
return fmt.Errorf("archive named %s already exists. Check your archive name template", archivePath) return fmt.Errorf("archive named %s already exists. Check your archive name template", archivePath)
} }
archiveFile, err := os.Create(archivePath) archiveFile, err := os.Create(archivePath)
if err != nil { if err != nil {
lock.Unlock()
return fmt.Errorf("failed to create directory %s: %s", archivePath, err.Error()) return fmt.Errorf("failed to create directory %s: %s", archivePath, err.Error())
} }
p.lock.Unlock() lock.Unlock()
defer archiveFile.Close() // nolint: errcheck defer archiveFile.Close() // nolint: errcheck
var log = log.WithField("archive", archivePath) var log = log.WithField("archive", archivePath)
log.Info("creating") log.Info("creating")

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

@@ -13,32 +13,31 @@ import (
"github.com/goreleaser/goreleaser/internal/testlib" "github.com/goreleaser/goreleaser/internal/testlib"
"github.com/goreleaser/goreleaser/pkg/config" "github.com/goreleaser/goreleaser/pkg/config"
"github.com/goreleaser/goreleaser/pkg/context" "github.com/goreleaser/goreleaser/pkg/context"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
) )
func TestDescription(t *testing.T) { func TestDescription(t *testing.T) {
assert.NotEmpty(t, Pipe{}.String()) require.NotEmpty(t, Pipe{}.String())
} }
func TestRunPipe(t *testing.T) { func TestRunPipe(t *testing.T) {
folder, back := testlib.Mktmp(t) folder, back := testlib.Mktmp(t)
defer back() defer back()
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
assert.NoError(t, err)
_, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe"))
assert.NoError(t, err)
_, err = os.Create(filepath.Join(folder, "README.md"))
assert.NoError(t, err)
assert.NoError(t, os.MkdirAll(filepath.Join(folder, "foo", "bar", "foobar"), 0755))
_, err = os.Create(filepath.Join(filepath.Join(folder, "foo", "bar", "foobar", "blah.txt")))
assert.NoError(t, err)
for _, format := range []string{"tar.gz", "zip"} { for _, format := range []string{"tar.gz", "zip"} {
t.Run("Archive format "+format, func(tt *testing.T) { t.Run("Archive format "+format, func(tt *testing.T) {
var dist = filepath.Join(folder, format+"_dist")
require.NoError(t, os.Mkdir(dist, 0755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
require.NoError(t, err)
_, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe"))
require.NoError(t, err)
_, err = os.Create(filepath.Join(folder, "README.md"))
require.NoError(t, err)
require.NoError(t, os.MkdirAll(filepath.Join(folder, "foo", "bar", "foobar"), 0755))
_, err = os.Create(filepath.Join(filepath.Join(folder, "foo", "bar", "foobar", "blah.txt")))
require.NoError(t, err)
var ctx = context.New( var ctx = context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
@@ -82,37 +81,41 @@ func TestRunPipe(t *testing.T) {
ctx.Version = "0.0.1" ctx.Version = "0.0.1"
ctx.Git.CurrentTag = "v0.0.1" ctx.Git.CurrentTag = "v0.0.1"
ctx.Config.Archive.Format = format ctx.Config.Archive.Format = format
assert.NoError(tt, Pipe{}.Run(ctx)) require.NoError(tt, Pipe{}.Run(ctx))
var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)) var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive))
require.Len(tt, archives.List(), 2) require.Len(tt, archives.List(), 2)
darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0] darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0]
windows := archives.Filter(artifact.ByGoos("windows")).List()[0] windows := archives.Filter(artifact.ByGoos("windows")).List()[0]
assert.Equal(tt, "foobar_0.0.1_darwin_amd64."+format, darwin.Name) require.Equal(tt, "foobar_0.0.1_darwin_amd64."+format, darwin.Name)
assert.Equal(tt, "foobar_0.0.1_windows_amd64.zip", windows.Name) require.Equal(tt, "foobar_0.0.1_windows_amd64.zip", windows.Name)
if format == "tar.gz" {
// Check archive contents
require.Equal(
t,
[]string{
"README.md",
"foo/bar",
"foo/bar/foobar",
"foo/bar/foobar/blah.txt",
"mybin",
},
tarFiles(t, filepath.Join(dist, "foobar_0.0.1_darwin_amd64.tar.gz")),
)
}
if format == "zip" {
require.Equal(
t,
[]string{
"README.md",
"foo/bar/foobar/blah.txt",
"mybin.exe",
},
zipFiles(t, filepath.Join(dist, "foobar_0.0.1_windows_amd64.zip")),
)
}
}) })
} }
// Check archive contents
assert.Equal(
t,
[]string{
"README.md",
"foo/bar",
"foo/bar/foobar",
"foo/bar/foobar/blah.txt",
"mybin",
},
tarFiles(t, filepath.Join(dist, "foobar_0.0.1_darwin_amd64.tar.gz")),
)
assert.Equal(
t,
[]string{
"README.md",
"foo/bar/foobar/blah.txt",
"mybin.exe",
},
zipFiles(t, filepath.Join(dist, "foobar_0.0.1_windows_amd64.zip")),
)
} }
func zipFiles(t *testing.T, path string) []string { func zipFiles(t *testing.T, path string) []string {
@@ -153,15 +156,15 @@ func TestRunPipeBinary(t *testing.T) {
folder, back := testlib.Mktmp(t) folder, back := testlib.Mktmp(t)
defer back() defer back()
var dist = filepath.Join(folder, "dist") var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
assert.NoError(t, err) require.NoError(t, err)
_, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) _, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe"))
assert.NoError(t, err) require.NoError(t, err)
_, err = os.Create(filepath.Join(folder, "README.md")) _, err = os.Create(filepath.Join(folder, "README.md"))
assert.NoError(t, err) require.NoError(t, err)
var ctx = context.New( var ctx = context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
@@ -194,13 +197,13 @@ func TestRunPipeBinary(t *testing.T) {
"Ext": ".exe", "Ext": ".exe",
}, },
}) })
assert.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
var binaries = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary)) var 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]
assert.Equal(t, "mybin_0.0.1_darwin_amd64", darwin.Name) require.Equal(t, "mybin_0.0.1_darwin_amd64", darwin.Name)
assert.Equal(t, "mybin_0.0.1_windows_amd64.exe", windows.Name) require.Equal(t, "mybin_0.0.1_windows_amd64.exe", windows.Name)
assert.Len(t, binaries.List(), 2) require.Len(t, binaries.List(), 2)
} }
func TestRunPipeDistRemoved(t *testing.T) { func TestRunPipeDistRemoved(t *testing.T) {
@@ -225,17 +228,17 @@ func TestRunPipeDistRemoved(t *testing.T) {
"Extension": ".exe", "Extension": ".exe",
}, },
}) })
assert.EqualError(t, Pipe{}.Run(ctx), `failed to create directory /path/nope/nope.zip: open /path/nope/nope.zip: no such file or directory`) require.EqualError(t, Pipe{}.Run(ctx), `failed to create directory /path/nope/nope.zip: open /path/nope/nope.zip: no such file or directory`)
} }
func TestRunPipeInvalidGlob(t *testing.T) { func TestRunPipeInvalidGlob(t *testing.T) {
folder, back := testlib.Mktmp(t) folder, back := testlib.Mktmp(t)
defer back() defer back()
var dist = filepath.Join(folder, "dist") var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
assert.NoError(t, err) require.NoError(t, err)
var ctx = context.New( var ctx = context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
@@ -259,19 +262,19 @@ func TestRunPipeInvalidGlob(t *testing.T) {
"Binary": "mybin", "Binary": "mybin",
}, },
}) })
assert.EqualError(t, Pipe{}.Run(ctx), `failed to find files to archive: globbing failed for pattern [x-]: file does not exist`) require.EqualError(t, Pipe{}.Run(ctx), `failed to find files to archive: globbing failed for pattern [x-]: file does not exist`)
} }
func TestRunPipeWrap(t *testing.T) { func TestRunPipeWrap(t *testing.T) {
folder, back := testlib.Mktmp(t) folder, back := testlib.Mktmp(t)
defer back() defer back()
var dist = filepath.Join(folder, "dist") var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
assert.NoError(t, err) require.NoError(t, err)
_, err = os.Create(filepath.Join(folder, "README.md")) _, err = os.Create(filepath.Join(folder, "README.md"))
assert.NoError(t, err) require.NoError(t, err)
var ctx = context.New( var ctx = context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,
@@ -296,23 +299,23 @@ func TestRunPipeWrap(t *testing.T) {
"Binary": "mybin", "Binary": "mybin",
}, },
}) })
assert.NoError(t, Pipe{}.Run(ctx)) require.NoError(t, Pipe{}.Run(ctx))
// Check archive contents // Check archive contents
f, err := os.Open(filepath.Join(dist, "foo.tar.gz")) f, err := os.Open(filepath.Join(dist, "foo.tar.gz"))
assert.NoError(t, err) require.NoError(t, err)
defer func() { assert.NoError(t, f.Close()) }() defer func() { require.NoError(t, f.Close()) }()
gr, err := gzip.NewReader(f) gr, err := gzip.NewReader(f)
assert.NoError(t, err) require.NoError(t, err)
defer func() { assert.NoError(t, gr.Close()) }() defer func() { require.NoError(t, gr.Close()) }()
r := tar.NewReader(gr) r := tar.NewReader(gr)
for _, n := range []string{"README.md", "mybin"} { for _, n := range []string{"README.md", "mybin"} {
h, err := r.Next() h, err := r.Next()
if err == io.EOF { if err == io.EOF {
break break
} }
assert.NoError(t, err) require.NoError(t, err)
assert.Equal(t, filepath.Join("foo", n), h.Name) require.Equal(t, filepath.Join("foo", n), h.Name)
} }
} }
@@ -322,10 +325,10 @@ func TestDefault(t *testing.T) {
Archive: config.Archive{}, Archive: config.Archive{},
}, },
} }
assert.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
assert.NotEmpty(t, ctx.Config.Archive.NameTemplate) require.NotEmpty(t, ctx.Config.Archive.NameTemplate)
assert.Equal(t, "tar.gz", ctx.Config.Archive.Format) require.Equal(t, "tar.gz", ctx.Config.Archive.Format)
assert.NotEmpty(t, ctx.Config.Archive.Files) require.NotEmpty(t, ctx.Config.Archive.Files)
} }
func TestDefaultSet(t *testing.T) { func TestDefaultSet(t *testing.T) {
@@ -340,10 +343,10 @@ func TestDefaultSet(t *testing.T) {
}, },
}, },
} }
assert.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
assert.Equal(t, "foo", ctx.Config.Archive.NameTemplate) require.Equal(t, "foo", ctx.Config.Archive.NameTemplate)
assert.Equal(t, "zip", ctx.Config.Archive.Format) require.Equal(t, "zip", ctx.Config.Archive.Format)
assert.Equal(t, "foo", ctx.Config.Archive.Files[0]) require.Equal(t, "foo", ctx.Config.Archive.Files[0])
} }
func TestDefaultFormatBinary(t *testing.T) { func TestDefaultFormatBinary(t *testing.T) {
@@ -354,8 +357,8 @@ func TestDefaultFormatBinary(t *testing.T) {
}, },
}, },
} }
assert.NoError(t, Pipe{}.Default(ctx)) require.NoError(t, Pipe{}.Default(ctx))
assert.Equal(t, defaultBinaryNameTemplate, ctx.Config.Archive.NameTemplate) require.Equal(t, defaultBinaryNameTemplate, ctx.Config.Archive.NameTemplate)
} }
func TestFormatFor(t *testing.T) { func TestFormatFor(t *testing.T) {
@@ -372,23 +375,23 @@ func TestFormatFor(t *testing.T) {
}, },
}, },
} }
assert.Equal(t, "zip", packageFormat(ctx, "windows")) require.Equal(t, "zip", packageFormat(ctx, "windows"))
assert.Equal(t, "tar.gz", packageFormat(ctx, "linux")) require.Equal(t, "tar.gz", packageFormat(ctx, "linux"))
} }
func TestBinaryOverride(t *testing.T) { func TestBinaryOverride(t *testing.T) {
folder, back := testlib.Mktmp(t) folder, back := testlib.Mktmp(t)
defer back() defer back()
var dist = filepath.Join(folder, "dist") var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
assert.NoError(t, err) require.NoError(t, err)
_, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) _, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe"))
assert.NoError(t, err) require.NoError(t, err)
_, err = os.Create(filepath.Join(folder, "README.md")) _, err = os.Create(filepath.Join(folder, "README.md"))
assert.NoError(t, err) require.NoError(t, err)
for _, format := range []string{"tar.gz", "zip"} { for _, format := range []string{"tar.gz", "zip"} {
t.Run("Archive format "+format, func(tt *testing.T) { t.Run("Archive format "+format, func(tt *testing.T) {
var ctx = context.New( var ctx = context.New(
@@ -434,15 +437,14 @@ func TestBinaryOverride(t *testing.T) {
ctx.Version = "0.0.1" ctx.Version = "0.0.1"
ctx.Config.Archive.Format = format ctx.Config.Archive.Format = format
assert.NoError(tt, Pipe{}.Run(ctx)) require.NoError(tt, Pipe{}.Run(ctx))
var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive)) var archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableArchive))
darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0] darwin := archives.Filter(artifact.ByGoos("darwin")).List()[0]
assert.Equal(tt, "foobar_0.0.1_darwin_amd64."+format, darwin.Name) require.Equal(tt, "foobar_0.0.1_darwin_amd64."+format, darwin.Name)
archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary)) archives = ctx.Artifacts.Filter(artifact.ByType(artifact.UploadableBinary))
windows := archives.Filter(artifact.ByGoos("windows")).List()[0] windows := archives.Filter(artifact.ByGoos("windows")).List()[0]
assert.Equal(tt, "foobar_0.0.1_windows_amd64.exe", windows.Name) require.Equal(tt, "foobar_0.0.1_windows_amd64.exe", windows.Name)
}) })
} }
} }
@@ -451,13 +453,13 @@ func TestRunPipeSameArchiveFilename(t *testing.T) {
folder, back := testlib.Mktmp(t) folder, back := testlib.Mktmp(t)
defer back() defer back()
var dist = filepath.Join(folder, "dist") var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755)) require.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "darwinamd64"), 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755)) require.NoError(t, os.Mkdir(filepath.Join(dist, "windowsamd64"), 0755))
_, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin")) _, err := os.Create(filepath.Join(dist, "darwinamd64", "mybin"))
assert.NoError(t, err) require.NoError(t, err)
_, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe")) _, err = os.Create(filepath.Join(dist, "windowsamd64", "mybin.exe"))
assert.NoError(t, err) require.NoError(t, err)
var ctx = context.New( var ctx = context.New(
config.Project{ config.Project{
Dist: dist, Dist: dist,