github.com/client9/goreleaser@v0.17.4-0.20170511023544-27e4b028926d/pipeline/release/release_test.go (about)

     1  package release
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"io/ioutil"
     7  	"os"
     8  	"path/filepath"
     9  	"testing"
    10  
    11  	"github.com/goreleaser/goreleaser/config"
    12  	"github.com/goreleaser/goreleaser/context"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  func TestPipeDescription(t *testing.T) {
    17  	assert.NotEmpty(t, Pipe{}.Description())
    18  }
    19  
    20  func TestRunPipe(t *testing.T) {
    21  	var assert = assert.New(t)
    22  	folder, err := ioutil.TempDir("", "goreleasertest")
    23  	assert.NoError(err)
    24  	tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz"))
    25  	assert.NoError(err)
    26  	debfile, err := os.Create(filepath.Join(folder, "bin.deb"))
    27  	assert.NoError(err)
    28  	var ctx = &context.Context{
    29  		Git: context.GitInfo{
    30  			CurrentTag: "v1.0.0",
    31  		},
    32  		Config: config.Project{
    33  			Dist: folder,
    34  			Release: config.Release{
    35  				GitHub: config.Repo{
    36  					Owner: "test",
    37  					Name:  "test",
    38  				},
    39  			},
    40  		},
    41  		Publish: true,
    42  	}
    43  	ctx.AddArtifact(tarfile.Name())
    44  	ctx.AddArtifact(debfile.Name())
    45  	client := &DummyClient{}
    46  	assert.NoError(doRun(ctx, client))
    47  	assert.True(client.CreatedRelease)
    48  	assert.True(client.UploadedFile)
    49  }
    50  
    51  func TestRunPipeReleaseCreationFailed(t *testing.T) {
    52  	var assert = assert.New(t)
    53  	var ctx = &context.Context{
    54  		Git: context.GitInfo{
    55  			CurrentTag: "v1.0.0",
    56  		},
    57  		Config: config.Project{
    58  			Release: config.Release{
    59  				GitHub: config.Repo{
    60  					Owner: "test",
    61  					Name:  "test",
    62  				},
    63  			},
    64  		},
    65  		Publish: true,
    66  	}
    67  	client := &DummyClient{
    68  		FailToCreateRelease: true,
    69  	}
    70  	assert.Error(doRun(ctx, client))
    71  	assert.False(client.CreatedRelease)
    72  	assert.False(client.UploadedFile)
    73  }
    74  
    75  func TestRunPipeWithFileThatDontExist(t *testing.T) {
    76  	var assert = assert.New(t)
    77  	var ctx = &context.Context{
    78  		Git: context.GitInfo{
    79  			CurrentTag: "v1.0.0",
    80  		},
    81  		Config: config.Project{
    82  			Release: config.Release{
    83  				GitHub: config.Repo{
    84  					Owner: "test",
    85  					Name:  "test",
    86  				},
    87  			},
    88  		},
    89  		Publish: true,
    90  	}
    91  	ctx.AddArtifact("this-file-wont-exist-hopefully")
    92  	client := &DummyClient{}
    93  	assert.Error(doRun(ctx, client))
    94  	assert.True(client.CreatedRelease)
    95  	assert.False(client.UploadedFile)
    96  }
    97  
    98  func TestRunPipeUploadFailure(t *testing.T) {
    99  	var assert = assert.New(t)
   100  	folder, err := ioutil.TempDir("", "goreleasertest")
   101  	assert.NoError(err)
   102  	tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz"))
   103  	assert.NoError(err)
   104  	var ctx = &context.Context{
   105  		Git: context.GitInfo{
   106  			CurrentTag: "v1.0.0",
   107  		},
   108  		Config: config.Project{
   109  			Dist: folder,
   110  			Release: config.Release{
   111  				GitHub: config.Repo{
   112  					Owner: "test",
   113  					Name:  "test",
   114  				},
   115  			},
   116  		},
   117  		Publish: true,
   118  	}
   119  	ctx.AddArtifact(tarfile.Name())
   120  	client := &DummyClient{
   121  		FailToUpload: true,
   122  	}
   123  	assert.Error(doRun(ctx, client))
   124  	assert.True(client.CreatedRelease)
   125  	assert.False(client.UploadedFile)
   126  }
   127  
   128  func TestSkipPublish(t *testing.T) {
   129  	var assert = assert.New(t)
   130  	var ctx = &context.Context{
   131  		Publish: false,
   132  	}
   133  	client := &DummyClient{}
   134  	assert.NoError(doRun(ctx, client))
   135  	assert.False(client.CreatedRelease)
   136  	assert.False(client.UploadedFile)
   137  }
   138  
   139  type DummyClient struct {
   140  	FailToCreateRelease bool
   141  	FailToUpload        bool
   142  	CreatedRelease      bool
   143  	UploadedFile        bool
   144  }
   145  
   146  func (client *DummyClient) CreateRelease(ctx *context.Context, body string) (releaseID int, err error) {
   147  	if client.FailToCreateRelease {
   148  		return 0, errors.New("release failed")
   149  	}
   150  	client.CreatedRelease = true
   151  	return
   152  }
   153  
   154  func (client *DummyClient) CreateFile(ctx *context.Context, content bytes.Buffer, path string) (err error) {
   155  	return
   156  }
   157  
   158  func (client *DummyClient) Upload(ctx *context.Context, releaseID int, name string, file *os.File) (err error) {
   159  	if client.FailToUpload {
   160  		return errors.New("upload failed")
   161  	}
   162  	client.UploadedFile = true
   163  	return
   164  }