github.com/marianogappa/goreleaser@v0.26.2-0.20170715090149-96acd0a9fc46/pipeline/brew/brew_test.go (about)

     1  package brew
     2  
     3  import (
     4  	"bytes"
     5  	"io/ioutil"
     6  	"os"
     7  	"path/filepath"
     8  	"testing"
     9  
    10  	"github.com/goreleaser/goreleaser/config"
    11  	"github.com/goreleaser/goreleaser/context"
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func TestDescription(t *testing.T) {
    16  	assert.NotEmpty(t, Pipe{}.Description())
    17  }
    18  
    19  func TestNameWithDash(t *testing.T) {
    20  	assert.Equal(t, formulaNameFor("some-binary"), "SomeBinary")
    21  }
    22  
    23  func TestNameWithUnderline(t *testing.T) {
    24  	assert.Equal(t, formulaNameFor("some_binary"), "SomeBinary")
    25  }
    26  
    27  func TestSimpleName(t *testing.T) {
    28  	assert.Equal(t, formulaNameFor("binary"), "Binary")
    29  }
    30  
    31  var defaultTemplateData = templateData{
    32  	Desc:     "Some desc",
    33  	Homepage: "https://google.com",
    34  	Name:     "Test",
    35  	Repo: config.Repo{
    36  		Owner: "caarlos0",
    37  		Name:  "test",
    38  	},
    39  	Tag:     "v0.1.3",
    40  	Version: "0.1.3",
    41  	File:    "test_Darwin_x86_64.tar.gz",
    42  	SHA256:  "1633f61598ab0791e213135923624eb342196b3494909c91899bcd0560f84c68",
    43  }
    44  
    45  func assertDefaultTemplateData(t *testing.T, formulae string) {
    46  	assert := assert.New(t)
    47  	assert.Contains(formulae, "class Test < Formula")
    48  	assert.Contains(formulae, "homepage \"https://google.com\"")
    49  	assert.Contains(formulae, "url \"https://github.com/caarlos0/test/releases/download/v0.1.3/test_Darwin_x86_64.tar.gz\"")
    50  	assert.Contains(formulae, "sha256 \"1633f61598ab0791e213135923624eb342196b3494909c91899bcd0560f84c68\"")
    51  	assert.Contains(formulae, "version \"0.1.3\"")
    52  }
    53  
    54  func TestFullFormulae(t *testing.T) {
    55  	assert := assert.New(t)
    56  	data := defaultTemplateData
    57  	data.Caveats = "Here are some caveats"
    58  	data.Dependencies = []string{"gtk", "git"}
    59  	data.Conflicts = []string{"conflicting_dep"}
    60  	data.Plist = "it works"
    61  	data.Install = []string{"custom install script", "another install script"}
    62  	out, err := doBuildFormula(data)
    63  	assert.NoError(err)
    64  	formulae := out.String()
    65  	assertDefaultTemplateData(t, formulae)
    66  	assert.Contains(formulae, "def caveats")
    67  	assert.Contains(formulae, "Here are some caveats")
    68  	assert.Contains(formulae, "depends_on \"gtk\"")
    69  	assert.Contains(formulae, "depends_on \"git\"")
    70  	assert.Contains(formulae, "conflicts_with \"conflicting_dep\"")
    71  	assert.Contains(formulae, "custom install script")
    72  	assert.Contains(formulae, "another install script")
    73  	assert.Contains(formulae, "def plist;")
    74  }
    75  
    76  func TestFormulaeSimple(t *testing.T) {
    77  	assert := assert.New(t)
    78  	out, err := doBuildFormula(defaultTemplateData)
    79  	assert.NoError(err)
    80  	formulae := out.String()
    81  	assertDefaultTemplateData(t, formulae)
    82  	assert.NotContains(formulae, "def caveats")
    83  	assert.NotContains(formulae, "depends_on")
    84  	assert.NotContains(formulae, "def plist;")
    85  }
    86  
    87  func TestRunPipe(t *testing.T) {
    88  	assert := assert.New(t)
    89  	folder, err := ioutil.TempDir("", "goreleasertest")
    90  	assert.NoError(err)
    91  	var ctx = &context.Context{
    92  		Config: config.Project{
    93  			Dist: folder,
    94  			Archive: config.Archive{
    95  				Format: "tar.gz",
    96  			},
    97  			Brew: config.Homebrew{
    98  				GitHub: config.Repo{
    99  					Owner: "test",
   100  					Name:  "test",
   101  				},
   102  			},
   103  		},
   104  		Folders: map[string]string{
   105  			"darwinamd64": "bin",
   106  		},
   107  		Publish: true,
   108  	}
   109  	client := &DummyClient{}
   110  	assert.Error(doRun(ctx, client))
   111  	assert.False(client.CreatedFile)
   112  
   113  	_, err = os.Create(filepath.Join(folder, "bin.tar.gz"))
   114  	assert.NoError(err)
   115  	assert.NoError(doRun(ctx, client))
   116  	assert.True(client.CreatedFile)
   117  }
   118  
   119  func TestRunPipeFormatOverride(t *testing.T) {
   120  	assert := assert.New(t)
   121  	folder, err := ioutil.TempDir("", "goreleasertest")
   122  	assert.NoError(err)
   123  	_, err = os.Create(filepath.Join(folder, "bin.zip"))
   124  	assert.NoError(err)
   125  	var ctx = &context.Context{
   126  		Config: config.Project{
   127  			Dist: folder,
   128  			Archive: config.Archive{
   129  				Format: "tar.gz",
   130  				FormatOverrides: []config.FormatOverride{
   131  					{
   132  						Format: "zip",
   133  						Goos:   "darwin",
   134  					},
   135  				},
   136  			},
   137  			Brew: config.Homebrew{
   138  				GitHub: config.Repo{
   139  					Owner: "test",
   140  					Name:  "test",
   141  				},
   142  			},
   143  		},
   144  		Folders: map[string]string{
   145  			"darwinamd64": "bin",
   146  		},
   147  		Publish: true,
   148  	}
   149  	client := &DummyClient{}
   150  	assert.NoError(doRun(ctx, client))
   151  	assert.True(client.CreatedFile)
   152  	assert.Contains(client.Content, "bin.zip")
   153  }
   154  
   155  func TestRunPipeNoDarwin64Build(t *testing.T) {
   156  	assert := assert.New(t)
   157  	var ctx = &context.Context{
   158  		Config: config.Project{
   159  			Archive: config.Archive{
   160  				Format: "tar.gz",
   161  			},
   162  			Brew: config.Homebrew{
   163  				GitHub: config.Repo{
   164  					Owner: "test",
   165  					Name:  "test",
   166  				},
   167  			},
   168  		},
   169  		Publish: true,
   170  	}
   171  	client := &DummyClient{}
   172  	assert.Equal(ErrNoDarwin64Build, doRun(ctx, client))
   173  	assert.False(client.CreatedFile)
   174  }
   175  
   176  func TestRunPipeBrewNotSetup(t *testing.T) {
   177  	assert := assert.New(t)
   178  	var ctx = &context.Context{
   179  		Config:  config.Project{},
   180  		Publish: true,
   181  	}
   182  	client := &DummyClient{}
   183  	assert.NoError(doRun(ctx, client))
   184  	assert.False(client.CreatedFile)
   185  }
   186  
   187  func TestRunPipeBinaryRelease(t *testing.T) {
   188  	assert := assert.New(t)
   189  	var ctx = &context.Context{
   190  		Publish: true,
   191  		Config: config.Project{
   192  			Archive: config.Archive{
   193  				Format: "binary",
   194  			},
   195  			Brew: config.Homebrew{
   196  				GitHub: config.Repo{
   197  					Owner: "test",
   198  					Name:  "test",
   199  				},
   200  			},
   201  		},
   202  		Folders: map[string]string{
   203  			"darwinamd64": "bin",
   204  		},
   205  	}
   206  	client := &DummyClient{}
   207  	assert.NoError(doRun(ctx, client))
   208  	assert.False(client.CreatedFile)
   209  }
   210  
   211  func TestRunPipeNoPublish(t *testing.T) {
   212  	assert := assert.New(t)
   213  	var ctx = &context.Context{
   214  		Publish: false,
   215  	}
   216  	client := &DummyClient{}
   217  	assert.NoError(doRun(ctx, client))
   218  	assert.False(client.CreatedFile)
   219  }
   220  
   221  func TestRunPipeDraftRelease(t *testing.T) {
   222  	assert := assert.New(t)
   223  	var ctx = &context.Context{
   224  		Publish: true,
   225  		Config: config.Project{
   226  			Release: config.Release{
   227  				Draft: true,
   228  			},
   229  			Brew: config.Homebrew{
   230  				GitHub: config.Repo{
   231  					Owner: "test",
   232  					Name:  "test",
   233  				},
   234  			},
   235  		},
   236  	}
   237  	client := &DummyClient{}
   238  	assert.NoError(doRun(ctx, client))
   239  	assert.False(client.CreatedFile)
   240  }
   241  
   242  func TestRunPipeFormatBinary(t *testing.T) {
   243  	assert := assert.New(t)
   244  	var ctx = &context.Context{
   245  		Config: config.Project{
   246  			Archive: config.Archive{
   247  				Format: "binary",
   248  			},
   249  		},
   250  	}
   251  	client := &DummyClient{}
   252  	assert.NoError(doRun(ctx, client))
   253  	assert.False(client.CreatedFile)
   254  }
   255  
   256  type DummyClient struct {
   257  	CreatedFile bool
   258  	Content     string
   259  }
   260  
   261  func (client *DummyClient) CreateRelease(ctx *context.Context, body string) (releaseID int, err error) {
   262  	return
   263  }
   264  
   265  func (client *DummyClient) CreateFile(ctx *context.Context, content bytes.Buffer, path string) (err error) {
   266  	client.CreatedFile = true
   267  	bts, _ := ioutil.ReadAll(&content)
   268  	client.Content = string(bts)
   269  	return
   270  }
   271  
   272  func (client *DummyClient) Upload(ctx *context.Context, releaseID int, name string, file *os.File) (err error) {
   273  	return
   274  }