mirror of
https://github.com/goreleaser/goreleaser.git
synced 2024-12-31 01:53:50 +02:00
253 lines
7.0 KiB
Go
253 lines
7.0 KiB
Go
package http
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
h "net/http"
|
|
"net/http/httptest"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/goreleaser/goreleaser/config"
|
|
"github.com/goreleaser/goreleaser/context"
|
|
"github.com/goreleaser/goreleaser/internal/artifact"
|
|
)
|
|
|
|
var (
|
|
mux *h.ServeMux
|
|
srv *httptest.Server
|
|
)
|
|
|
|
func setup() {
|
|
mux = h.NewServeMux()
|
|
srv = httptest.NewServer(mux)
|
|
}
|
|
|
|
func teardown() {
|
|
srv.Close()
|
|
}
|
|
|
|
func TestDefaults(t *testing.T) {
|
|
type args struct {
|
|
puts []config.Put
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
wantErr bool
|
|
wantMode string
|
|
}{
|
|
{"set default", args{[]config.Put{{Name: "a", Target: "http://"}}}, false, ModeArchive},
|
|
{"keep value", args{[]config.Put{{Name: "a", Target: "http://...", Mode: ModeBinary}}}, false, ModeBinary},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if err := Defaults(tt.args.puts); (err != nil) != tt.wantErr {
|
|
t.Errorf("Defaults() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
if tt.wantMode != tt.args.puts[0].Mode {
|
|
t.Errorf("Incorrect Defaults() mode %q , wanted %q", tt.args.puts[0].Mode, tt.wantMode)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckConfig(t *testing.T) {
|
|
ctx := context.New(config.Project{ProjectName: "blah"})
|
|
ctx.Env["TEST_A_SECRET"] = "x"
|
|
type args struct {
|
|
ctx *context.Context
|
|
upload *config.Put
|
|
kind string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
wantErr bool
|
|
}{
|
|
{"ok", args{ctx, &config.Put{Name: "a", Target: "http://blabla", Username: "pepe", Mode: ModeArchive}, "test"}, false},
|
|
{"secret missing", args{ctx, &config.Put{Name: "b", Target: "http://blabla", Username: "pepe", Mode: ModeArchive}, "test"}, true},
|
|
{"target missing", args{ctx, &config.Put{Name: "a", Username: "pepe", Mode: ModeArchive}, "test"}, true},
|
|
{"username missing", args{ctx, &config.Put{Name: "a", Target: "http://blabla", Mode: ModeArchive}, "test"}, true},
|
|
{"name missing", args{ctx, &config.Put{Target: "http://blabla", Username: "pepe", Mode: ModeArchive}, "test"}, true},
|
|
{"mode missing", args{ctx, &config.Put{Name: "a", Target: "http://blabla", Username: "pepe"}, "test"}, true},
|
|
{"mode invalid", args{ctx, &config.Put{Name: "a", Target: "http://blabla", Username: "pepe", Mode: "blabla"}, "test"}, true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if err := CheckConfig(tt.args.ctx, tt.args.upload, tt.args.kind); (err != nil) != tt.wantErr {
|
|
t.Errorf("CheckConfig() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func count(r io.Reader) (int64, error) {
|
|
var (
|
|
c int64
|
|
b int64
|
|
err error
|
|
buf = make([]byte, 16)
|
|
)
|
|
for b >= 0 && err == nil {
|
|
b, err := r.Read(buf)
|
|
if err != nil {
|
|
return c, err
|
|
}
|
|
c = c + int64(b)
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
type check struct {
|
|
path string
|
|
user string
|
|
pass string
|
|
content []byte
|
|
}
|
|
|
|
func checks(checks ...check) func(rs []*h.Request) error {
|
|
return func(rs []*h.Request) error {
|
|
if len(rs) != len(checks) {
|
|
return errors.New("expectations mismatch requests")
|
|
}
|
|
for _, r := range rs {
|
|
found := false
|
|
for _, c := range checks {
|
|
if c.path == r.RequestURI {
|
|
found = true
|
|
err := doCheck(c, r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
return errors.Errorf("check not found for request %+v", r)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
}
|
|
|
|
func doCheck(c check, r *h.Request) error {
|
|
contentLength := int64(len(c.content))
|
|
if r.ContentLength != contentLength {
|
|
return errors.Errorf("request content-length header value %v unexpected, wanted %v", r.ContentLength, contentLength)
|
|
}
|
|
bs, err := ioutil.ReadAll(r.Body)
|
|
if err != nil {
|
|
return errors.Errorf("reading request body: %v", err)
|
|
}
|
|
if !bytes.Equal(bs, c.content) {
|
|
return errors.New("content does not match")
|
|
}
|
|
if int64(len(bs)) != contentLength {
|
|
return errors.Errorf("request content length %v unexpected, wanted %v", int64(len(bs)), contentLength)
|
|
}
|
|
if r.RequestURI != c.path {
|
|
return errors.Errorf("bad request uri %q, expecting %q", r.RequestURI, c.path)
|
|
}
|
|
if u, p, ok := r.BasicAuth(); !ok || u != c.user || p != c.pass {
|
|
return errors.Errorf("bad basic auth credentials: %s/%s", u, p)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestUpload(t *testing.T) {
|
|
setup()
|
|
defer teardown()
|
|
content := []byte("blah!")
|
|
requests := []*h.Request{}
|
|
var m sync.Mutex
|
|
mux.Handle("/", h.HandlerFunc(func(w h.ResponseWriter, r *h.Request) {
|
|
bs, err := ioutil.ReadAll(r.Body)
|
|
if err != nil {
|
|
w.WriteHeader(h.StatusInternalServerError)
|
|
fmt.Fprintf(w, "reading request body: %v", err)
|
|
return
|
|
}
|
|
r.Body = ioutil.NopCloser(bytes.NewReader(bs))
|
|
m.Lock()
|
|
requests = append(requests, r)
|
|
m.Unlock()
|
|
w.WriteHeader(h.StatusCreated)
|
|
w.Header().Set("Location", r.URL.RequestURI())
|
|
}))
|
|
assetOpen = func(k string, a *artifact.Artifact) (*asset, error) {
|
|
return &asset{
|
|
ReadCloser: ioutil.NopCloser(bytes.NewReader(content)),
|
|
Size: int64(len(content)),
|
|
}, nil
|
|
}
|
|
defer assetOpenReset()
|
|
var is2xx ResponseChecker = func(r *h.Response) (string, error) {
|
|
if r.StatusCode/100 == 2 {
|
|
return r.Header.Get("Location"), nil
|
|
}
|
|
return "", errors.Errorf("unexpected http status code: %v", r.StatusCode)
|
|
}
|
|
ctx := context.New(config.Project{ProjectName: "blah"})
|
|
ctx.Env["TEST_A_SECRET"] = "x"
|
|
ctx.Version = "2.1.0"
|
|
ctx.Artifacts = artifact.New()
|
|
for _, a := range []struct {
|
|
ext string
|
|
typ artifact.Type
|
|
}{
|
|
{"---", artifact.DockerImage},
|
|
{"deb", artifact.LinuxPackage},
|
|
{"bin", artifact.Binary},
|
|
{"tar", artifact.UploadableArchive},
|
|
{"ubi", artifact.UploadableBinary},
|
|
{"sum", artifact.Checksum},
|
|
{"sig", artifact.Signature},
|
|
} {
|
|
ctx.Artifacts.Add(artifact.Artifact{Name: "a." + a.ext, Path: "/a/a." + a.ext, Type: a.typ})
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
ctx *context.Context
|
|
wantErr bool
|
|
put config.Put
|
|
check func(r []*h.Request) error
|
|
}{
|
|
{"archive", ctx, false,
|
|
config.Put{Mode: ModeArchive, Name: "a", Target: srv.URL + "/{{.ProjectName}}/{{.Version}}/", Username: "u1"},
|
|
checks(
|
|
check{"/blah/2.1.0/a.deb", "u1", "x", content},
|
|
check{"/blah/2.1.0/a.tar", "u1", "x", content},
|
|
),
|
|
},
|
|
{"binary", ctx, false,
|
|
config.Put{Mode: ModeBinary, Name: "a", Target: srv.URL + "/{{.ProjectName}}/{{.Version}}/", Username: "u2"},
|
|
checks(check{"/blah/2.1.0/a.ubi", "u2", "x", content}),
|
|
},
|
|
{"archive-with-checksum-and-signature", ctx, false,
|
|
config.Put{Mode: ModeArchive, Name: "a", Target: srv.URL + "/{{.ProjectName}}/{{.Version}}/", Username: "u3", Checksum: true, Signature: true},
|
|
checks(
|
|
check{"/blah/2.1.0/a.deb", "u3", "x", content},
|
|
check{"/blah/2.1.0/a.tar", "u3", "x", content},
|
|
check{"/blah/2.1.0/a.sum", "u3", "x", content},
|
|
check{"/blah/2.1.0/a.sig", "u3", "x", content},
|
|
),
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
requests = nil
|
|
if err := Upload(tt.ctx, []config.Put{tt.put}, "test", is2xx); (err != nil) != tt.wantErr {
|
|
t.Errorf("Upload() error = %v, wantErr %v", err, tt.wantErr)
|
|
}
|
|
if err := tt.check(requests); err != nil {
|
|
t.Errorf("Upload() request invalid. Error: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|