github.com/marianogappa/goreleaser@v0.26.2-0.20170715090149-96acd0a9fc46/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  	assert.Contains(client.UploadedFileNames, "bin.deb")
    50  	assert.Contains(client.UploadedFileNames, "bin.tar.gz")
    51  }
    52  
    53  func TestRunPipeReleaseCreationFailed(t *testing.T) {
    54  	var assert = assert.New(t)
    55  	var ctx = &context.Context{
    56  		Git: context.GitInfo{
    57  			CurrentTag: "v1.0.0",
    58  		},
    59  		Config: config.Project{
    60  			Release: config.Release{
    61  				GitHub: config.Repo{
    62  					Owner: "test",
    63  					Name:  "test",
    64  				},
    65  			},
    66  		},
    67  		Publish: true,
    68  	}
    69  	client := &DummyClient{
    70  		FailToCreateRelease: true,
    71  	}
    72  	assert.Error(doRun(ctx, client))
    73  	assert.False(client.CreatedRelease)
    74  	assert.False(client.UploadedFile)
    75  }
    76  
    77  func TestRunPipeWithFileThatDontExist(t *testing.T) {
    78  	var assert = assert.New(t)
    79  	var ctx = &context.Context{
    80  		Git: context.GitInfo{
    81  			CurrentTag: "v1.0.0",
    82  		},
    83  		Config: config.Project{
    84  			Release: config.Release{
    85  				GitHub: config.Repo{
    86  					Owner: "test",
    87  					Name:  "test",
    88  				},
    89  			},
    90  		},
    91  		Publish: true,
    92  	}
    93  	ctx.AddArtifact("this-file-wont-exist-hopefully")
    94  	client := &DummyClient{}
    95  	assert.Error(doRun(ctx, client))
    96  	assert.True(client.CreatedRelease)
    97  	assert.False(client.UploadedFile)
    98  }
    99  
   100  func TestRunPipeUploadFailure(t *testing.T) {
   101  	var assert = assert.New(t)
   102  	folder, err := ioutil.TempDir("", "goreleasertest")
   103  	assert.NoError(err)
   104  	tarfile, err := os.Create(filepath.Join(folder, "bin.tar.gz"))
   105  	assert.NoError(err)
   106  	var ctx = &context.Context{
   107  		Git: context.GitInfo{
   108  			CurrentTag: "v1.0.0",
   109  		},
   110  		Config: config.Project{
   111  			Dist: folder,
   112  			Release: config.Release{
   113  				GitHub: config.Repo{
   114  					Owner: "test",
   115  					Name:  "test",
   116  				},
   117  			},
   118  		},
   119  		Publish: true,
   120  	}
   121  	ctx.AddArtifact(tarfile.Name())
   122  	client := &DummyClient{
   123  		FailToUpload: true,
   124  	}
   125  	assert.Error(doRun(ctx, client))
   126  	assert.True(client.CreatedRelease)
   127  	assert.False(client.UploadedFile)
   128  }
   129  
   130  func TestSkipPublish(t *testing.T) {
   131  	var assert = assert.New(t)
   132  	var ctx = &context.Context{
   133  		Publish: false,
   134  	}
   135  	client := &DummyClient{}
   136  	assert.NoError(doRun(ctx, client))
   137  	assert.False(client.CreatedRelease)
   138  	assert.False(client.UploadedFile)
   139  }
   140  
   141  type DummyClient struct {
   142  	FailToCreateRelease bool
   143  	FailToUpload        bool
   144  	CreatedRelease      bool
   145  	UploadedFile        bool
   146  	UploadedFileNames   []string
   147  }
   148  
   149  func (client *DummyClient) CreateRelease(ctx *context.Context, body string) (releaseID int, err error) {
   150  	if client.FailToCreateRelease {
   151  		return 0, errors.New("release failed")
   152  	}
   153  	client.CreatedRelease = true
   154  	return
   155  }
   156  
   157  func (client *DummyClient) CreateFile(ctx *context.Context, content bytes.Buffer, path string) (err error) {
   158  	return
   159  }
   160  
   161  func (client *DummyClient) Upload(ctx *context.Context, releaseID int, name string, file *os.File) (err error) {
   162  	if client.FailToUpload {
   163  		return errors.New("upload failed")
   164  	}
   165  	client.UploadedFile = true
   166  	client.UploadedFileNames = append(client.UploadedFileNames, name)
   167  	return
   168  }