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 }