func TestAuthenticateRequest(t *testing.T) {
success := make(chan struct{})
contextMapper := api.NewRequestContextMapper()
auth, err := NewRequestAuthenticator(
contextMapper,
authenticator.RequestFunc(func(req *http.Request) (user.Info, bool, error) {
return &user.DefaultInfo{Name: "user"}, true, nil
}),
http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {
t.Errorf("unexpected call to failed")
}),
http.HandlerFunc(func(_ http.ResponseWriter, req *http.Request) {
ctx, ok := contextMapper.Get(req)
if ctx == nil || !ok {
t.Errorf("no context stored on contextMapper: %#v", contextMapper)
}
user, ok := api.UserFrom(ctx)
if user == nil || !ok {
t.Errorf("no user stored in context: %#v", ctx)
}
close(success)
}),
)
auth.ServeHTTP(httptest.NewRecorder(), &http.Request{})
<-success
empty, err := api.IsEmpty(contextMapper)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !empty {
t.Fatalf("contextMapper should have no stored requests: %v", contextMapper)
}
}
func TestCommitContainer(t *testing.T) {
var called bool
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "container not found", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.Write([]byte(`{"Id":"596069db4bf5"}`))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
opts := dclient.CommitContainerOptions{
Container: "abcdef",
}
image, err := cluster.CommitContainer(opts)
if err != nil {
t.Fatal(err)
}
if image.ID != "596069db4bf5" {
t.Errorf("CommitContainer: the image container is %s, expected: '596069db4bf5'", image.ID)
}
if !called {
t.Error("CommitContainer: Did not call the remote HTTP API")
}
}
// Issue 12344
func TestNilBody(t *testing.T) {
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("hi"))
}))
defer backend.Close()
frontend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
backURL, _ := url.Parse(backend.URL)
rp := NewSingleHostReverseProxy(backURL)
r := req(t, "GET / HTTP/1.0\r\n\r\n")
r.Body = nil // this accidentally worked in Go 1.4 and below, so keep it working
rp.ServeHTTP(w, r)
}))
defer frontend.Close()
res, err := http.Get(frontend.URL)
if err != nil {
t.Fatal(err)
}
defer res.Body.Close()
slurp, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatal(err)
}
if string(slurp) != "hi" {
t.Errorf("Got %q; want %q", slurp, "hi")
}
}
func TestWaitContainerNotFound(t *testing.T) {
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
id := "abc123"
expected := -1
status, err := cluster.WaitContainer(id)
if err == nil {
t.Errorf("WaitContainer(%q): unexpected <nil> error", id)
}
if status != expected {
t.Errorf("WaitContainer(%q): Wrong status. Want %d. Got %d.", id, expected, status)
}
}
func TestAttachToContainer(t *testing.T) {
var called bool
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "container not found", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.Write([]byte("something happened"))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
opts := dclient.AttachToContainerOptions{
Container: "abcdef",
OutputStream: &safe.Buffer{},
Logs: true,
Stdout: true,
}
err = cluster.AttachToContainer(opts)
if err != nil {
t.Errorf("AttachToContainer: unexpected error. Want <nil>. Got %#v.", err)
}
if !called {
t.Error("AttachToContainer: Did not call the remote HTTP API")
}
}
func TestCreateContainer(t *testing.T) {
body := `{"Id":"e90302"}`
handler := []bool{false, false}
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handler[0] = true
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(body))
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handler[1] = true
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(body))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
config := docker.Config{Memory: 67108864}
nodeID, container, err := cluster.CreateContainer(&config)
if err != nil {
t.Fatal(err)
}
if nodeID != "handler0" {
t.Errorf("CreateContainer: wrong node ID. Want %q. Got %q.", "handler0", nodeID)
}
if container.ID != "e90302" {
t.Errorf("CreateContainer: wrong container ID. Want %q. Got %q.", "e90302", container.ID)
}
}
func TestRestartContainerWithStorage(t *testing.T) {
var called bool
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("ok"))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
id := "abc123"
storage := mapStorage{cMap: map[string]string{id: "handler1"}}
cluster.SetStorage(&storage)
err = cluster.RestartContainer(id, 10)
if err != nil {
t.Fatal(err)
}
if called {
t.Errorf("RestartContainer(%q): should not call the node server", id)
}
}
func TestCotacao(t *testing.T) {
Convey("Ao executar o comando cotação", t, func() {
cmd := &bot.Cmd{}
Convey("Deve responder com a cotação do dólar e euro", func() {
ts := httptest.NewServer(
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, expectedJSON)
}))
defer ts.Close()
url = ts.URL
c, err := cotacao(cmd)
So(err, ShouldBeNil)
So(c, ShouldEqual, "Dólar: 2.2430 (+0.36), Euro: 2.9018 (-1.21)")
})
Convey("Quando o webservice retornar algo inválido deve retornar erro", func() {
ts := httptest.NewServer(
http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "invalid")
}))
defer ts.Close()
url = ts.URL
_, err := cotacao(cmd)
So(err, ShouldNotBeNil)
})
})
}
func main() {
rand.Seed(time.Now().Unix())
var port string
if len(os.Args) < 2 {
port = "80"
} else {
port = os.Args[1]
}
log.Printf("Port number to listen on = %s\n", port)
http.Handle("/status/", http.HandlerFunc(status.Status))
http.Handle("/logon", http.HandlerFunc(config.CloudLogon))
http.Handle("/getMachine", http.HandlerFunc(config.GetMachineAccount))
http.Handle("/connect", http.HandlerFunc(config.Connect))
http.Handle("/dmcConfig", http.HandlerFunc(config.DmcConfig))
http.Handle("/getBearerForMachine", http.HandlerFunc(config.GetBearerForMachine))
http.Handle("/getRealToken", http.HandlerFunc(config.GetRealToken))
//debug related items - intended to aid in standalone, test environment
http.Handle("/config/", http.HandlerFunc(config.Config))
http.Handle("/logmeon", http.HandlerFunc(config.LogMeOn))
http.Handle("/token", http.HandlerFunc(config.Token))
chan1 := make(chan bool)
go httpListener(port, chan1)
go httpTlsListener(chan1)
select {
case <-chan1:
log.Printf("\n\nDetected context done\n\n")
}
log.Printf("goodbye\n")
}
// layerDispatcher uses the request context to build a layerHandler.
func layerDispatcher(ctx *Context, r *http.Request) http.Handler {
dgst, err := getDigest(ctx)
if err != nil {
if err == errDigestNotAvailable {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusNotFound)
ctx.Errors.Push(v2.ErrorCodeDigestInvalid, err)
})
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ctx.Errors.Push(v2.ErrorCodeDigestInvalid, err)
})
}
layerHandler := &layerHandler{
Context: ctx,
Digest: dgst,
}
return handlers.MethodHandler{
"GET": http.HandlerFunc(layerHandler.GetLayer),
"HEAD": http.HandlerFunc(layerHandler.GetLayer),
}
}
func TestBuilder(t *testing.T) {
rv := ""
builder := &Builder{}
builder.UseHandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rv += "a"
})
builder.Use(func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rv += "b"
next.ServeHTTP(w, r)
rv += "c"
})
})
builder.UseHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rv += "X"
}))
builder.UseHandlerFunc(func(w http.ResponseWriter, r *http.Request) {
rv += "d"
})
recorder := httptest.NewRecorder()
builder.ServeHTTP(recorder, (*http.Request)(nil))
expected := "abXdc"
if rv != expected {
t.Errorf("have %q want %q", rv, expected)
}
}
// TODO: more tests on redirect
func TestRedirectPolicyFunc(t *testing.T) {
redirectSuccess := false
redirectFuncGetCalled := false
tsRedirect := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
redirectSuccess = true
}))
defer tsRedirect.Close()
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, tsRedirect.URL, http.StatusMovedPermanently)
}))
defer ts.Close()
New().
Get(ts.URL).
RedirectPolicy(func(req Request, via []Request) error {
redirectFuncGetCalled = true
return nil
}).End()
if !redirectSuccess {
t.Errorf("Expected reaching another redirect url not original one")
}
if !redirectFuncGetCalled {
t.Errorf("Expected redirect policy func to get called")
}
}
func TestPatRoutingMethodNotAllowed(t *testing.T) {
p := New()
var ok bool
p.Post("/foo/:name", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ok = true
}))
p.Put("/foo/:name", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ok = true
}))
r := httptest.NewRecorder()
p.ServeHTTP(r, newRequest("GET", "/foo/keith", nil))
if ok {
t.Fatal("handler called when it should have not been allowed")
}
if r.Code != http.StatusMethodNotAllowed {
t.Fatalf("got status %d; expected %d", r.Code, http.StatusMethodNotAllowed)
}
got := strings.Split(r.Header().Get("Allow"), ", ")
sort.Strings(got)
want := []string{"POST", "PUT"}
if !reflect.DeepEqual(got, want) {
t.Fatalf("got Allow header %v; want %v", got, want)
}
}
func TestPatImplicitRedirect(t *testing.T) {
p := New()
p.Get("/foo/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
r := newRequest("GET", "/foo", nil)
res := httptest.NewRecorder()
p.ServeHTTP(res, r)
if res.Code != 301 {
t.Errorf("expected Code 301, was %d", res.Code)
}
if loc := res.Header().Get("Location"); loc != "/foo/" {
t.Errorf("expected %q, got %q", "/foo/", loc)
}
p = New()
p.Get("/foo", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
p.Get("/foo/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}))
r = newRequest("GET", "/foo", nil)
res = httptest.NewRecorder()
res.Code = 200
p.ServeHTTP(res, r)
if res.Code != 200 {
t.Errorf("expected Code 200, was %d", res.Code)
}
}
func TestInspectContainer(t *testing.T) {
body := `{"Id":"e90302","Path":"date","Args":[]}`
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(body))
}))
defer server2.Close()
server3 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server3.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
Node{ID: "handler2", Address: server3.URL},
)
if err != nil {
t.Fatal(err)
}
id := "e90302"
container, err := cluster.InspectContainer(id)
if err != nil {
t.Fatal(err)
}
if container.ID != id {
t.Errorf("InspectContainer(%q): Wrong ID. Want %q. Got %q.", id, id, container.ID)
}
if container.Path != "date" {
t.Errorf("InspectContainer(%q): Wrong Path. Want %q. Got %q.", id, "date", container.Path)
}
}
func (server *MockServer) run(t *testing.T) {
httpServer := &http.Server{
Addr: HTTP_ADDR,
Handler: http.HandlerFunc(server.handle),
}
httpsServer := &http.Server{
Addr: HTTPS_ADDR,
Handler: http.HandlerFunc(server.handle),
}
go func() {
t.Logf("About to start mock HTTP at: %s", httpServer.Addr)
err := httpServer.ListenAndServe()
if err != nil {
t.Errorf("Unable to start HTTP server: %s", err)
}
}()
go func() {
t.Logf("About to start mock HTTPS at: %s", httpsServer.Addr)
err := httpsServer.ListenAndServeTLS(server.certContext.ServerCertFile, server.certContext.PKFile)
if err != nil {
t.Errorf("Unable to start HTTP server: %s", err)
}
}()
}
func TestInspectContainerNoSuchContainer(t *testing.T) {
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
id := "e90302"
container, err := cluster.InspectContainer(id)
if container != nil {
t.Errorf("InspectContainer(%q): Expected <nil> container, got %#v.", id, container)
}
expected := &dclient.NoSuchContainer{ID: id}
if !reflect.DeepEqual(err, expected) {
t.Errorf("InspectContainer(%q): Wrong error. Want %#v. Got %#v.", id, expected, err)
}
}
func SetupTaskRouter(pool db.DBPool, prefix string, writeToFile bool, middleware RestMiddleware) *pat.PatternServeMux {
router := pat.New()
taskServices := SetupTasks(pool)
router.Get(prefix+"addresses", middleware(taskServices.getAllAddresses))
router.Get(prefix+"addresses/:address/requests",
middleware(taskServices.getRequestsForAddress))
router.Get(prefix+"addresses/:address/requests/:requestid/tasks",
middleware(taskServices.getTaskKeysForRequests))
router.Get(prefix+"addresses/:address/requests/:requestid/taskgraph",
middleware(taskServices.getTaskGraphForRequest))
router.Get(prefix+"task/:taskKey", middleware(taskServices.getTaskByKey))
router.Get(prefix+"tasks/:taskid",
middleware(taskServices.getTaskKeysForTask))
if writeToFile {
//router.HandleFunc(prefix, middleware(taskServices.addTaskToFile)).Methods("POST")
router.Post(prefix, middleware(taskServices.addTaskToFile))
} else {
router.Post(prefix, http.HandlerFunc(taskServices.addTask))
}
router.Post(prefix, http.HandlerFunc(taskServices.addTask))
router.Get(prefix, middleware(taskServices.getAllTasks))
return router
}
func TestRestartContainer(t *testing.T) {
var called bool
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
w.Write([]byte("ok"))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
id := "abc123"
err = cluster.RestartContainer(id, 10)
if err != nil {
t.Fatal(err)
}
if !called {
t.Errorf("RestartContainer(%q, 10): Did not call node HTTP server", id)
}
}
func main() {
// Create cookie store
Store = sessions.NewCookieStore([]byte("This is super screen..."))
Store.Options = &sessions.Options{
//Domain: "localhost", // Chrome doesn't work with localhost domain
Path: "/",
MaxAge: 3600 * 8, // 8 hours
HttpOnly: true,
}
// Default handler
h := http.HandlerFunc(routeLogin)
// Prevents CSRF
cs := csrfbanana.New(h, Store, SessionName)
// Set error page for CSRF
cs.FailureHandler(http.HandlerFunc(routeInvalidToken))
// Generate a new token after each check (also prevents double submits)
cs.ClearAfterUsage(true)
// Exclude /static/ from tokens (even though we don't have a static file handler...)
cs.ExcludeRegexPaths([]string{"/static(.*)"})
// Optional - set the token length
csrfbanana.TokenLength = 32
// Optional - set the token name used in the forms
csrfbanana.TokenName = "token"
fmt.Println("Listening on http://localhost:80/")
http.ListenAndServe(":8080", cs)
}
func TestCreateContainerWithStorage(t *testing.T) {
body := `{"Id":"e90302"}`
handler := []bool{false, false}
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handler[0] = true
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(body))
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handler[1] = true
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(body))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
var storage mapStorage
cluster.SetStorage(&storage)
config := docker.Config{Memory: 67108864}
_, _, err = cluster.CreateContainer(&config)
if err != nil {
t.Fatal(err)
}
expected := map[string]string{"e90302": "handler0"}
if storage.cMap["e90302"] != "handler0" {
t.Errorf("Cluster.CreateContainer() with storage: wrong data. Want %#v. Got %#v.", expected, storage.cMap)
}
}
func NewSignatureTest() *SignatureTest {
opts := NewOptions()
opts.CookieSecret = "cookie secret"
opts.ClientID = "client ID"
opts.ClientSecret = "client secret"
opts.EmailDomains = []string{"acm.org"}
authenticator := &SignatureAuthenticator{}
upstream := httptest.NewServer(
http.HandlerFunc(authenticator.Authenticate))
upstream_url, _ := url.Parse(upstream.URL)
opts.Upstreams = append(opts.Upstreams, upstream.URL)
providerHandler := func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(`{"access_token": "my_auth_token"}`))
}
provider := httptest.NewServer(http.HandlerFunc(providerHandler))
provider_url, _ := url.Parse(provider.URL)
opts.provider = NewTestProvider(provider_url, "*****@*****.**")
return &SignatureTest{
opts,
upstream,
upstream_url.Host,
provider,
make(http.Header),
httptest.NewRecorder(),
authenticator,
}
}
func TestWaitContainerWithStorage(t *testing.T) {
var called bool
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
body := `{"StatusCode":34}`
w.Write([]byte(body))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
id := "abc123"
storage := mapStorage{cMap: map[string]string{id: "handler1"}}
cluster.SetStorage(&storage)
expected := 34
status, err := cluster.WaitContainer(id)
if err != nil {
t.Fatal(err)
}
if status != expected {
t.Errorf("WaitContainer(%q): Wrong status. Want %d. Got %d.", id, expected, status)
}
if called {
t.Errorf("WaitContainer(%q): should not call the all node servers.", id)
}
}
func router() *httprouter.Router {
r := httprouter.New()
// Set 404 handler
r.NotFound = http.HandlerFunc(controller.Error404)
// Serve static files, no directory browsing
r.GET("/static/*filepath", hr.HandlerFunc(controller.Static))
// Home page
r.GET("/", hr.Handler(http.HandlerFunc(controller.Index)))
//r.GET("/", hr.HandlerFunc(controller.Index))
// Login
r.GET("/login", hr.HandlerFunc(controller.LoginGET))
r.POST("/login", hr.HandlerFunc(controller.LoginPOST))
r.GET("/logout", hr.HandlerFunc(controller.Logout))
// Register
r.GET("/register", hr.HandlerFunc(controller.RegisterGET))
r.POST("/register", hr.HandlerFunc(controller.RegisterPOST))
// About
r.GET("/about", hr.HandlerFunc(controller.AboutGET))
// Enable Pprof
r.GET("/debug/pprof/*pprof", pprofhandler.Handler)
return r
}
func TestAttachToContainerWithStorage(t *testing.T) {
var called bool
server1 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
called = true
http.Error(w, "No such container", http.StatusNotFound)
}))
defer server1.Close()
server2 := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("ok"))
}))
defer server2.Close()
cluster, err := New(nil,
Node{ID: "handler0", Address: server1.URL},
Node{ID: "handler1", Address: server2.URL},
)
if err != nil {
t.Fatal(err)
}
id := "abcdef"
storage := mapStorage{cMap: map[string]string{id: "handler1"}}
cluster.SetStorage(&storage)
opts := dclient.AttachToContainerOptions{
Container: id,
OutputStream: &safe.Buffer{},
Logs: true,
Stdout: true,
}
err = cluster.AttachToContainer(opts)
if err != nil {
t.Fatal(err)
}
if called {
t.Error("AttachToContainer(): should not call the node server")
}
}
func TestAuthenticateRequestError(t *testing.T) {
failed := make(chan struct{})
contextMapper := genericapirequest.NewRequestContextMapper()
auth := WithAuthentication(
http.HandlerFunc(func(_ http.ResponseWriter, req *http.Request) {
t.Errorf("unexpected call to handler")
}),
contextMapper,
authenticator.RequestFunc(func(req *http.Request) (user.Info, bool, error) {
return nil, false, errors.New("failure")
}),
http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {
close(failed)
}),
)
auth.ServeHTTP(httptest.NewRecorder(), &http.Request{})
<-failed
empty, err := genericapirequest.IsEmpty(contextMapper)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !empty {
t.Fatalf("contextMapper should have no stored requests: %v", contextMapper)
}
}
func main() {
header := "-------------------------------------------------------------------------------\n RRDA (RRDA REST DNS API) 1.01 (c) by Frederic Cambus 2012-2014\n-------------------------------------------------------------------------------"
host := flag.String("host", "127.0.0.1", "Set the server host")
port := flag.String("port", "8080", "Set the server port")
flag.Usage = func() {
fmt.Println(header)
fmt.Println("\nUSAGE :")
flag.PrintDefaults()
}
flag.Parse()
fmt.Println(header)
fmt.Println("\nListening on :", *host+":"+*port)
m := pat.New()
m.Get("/:server/x/:ip", http.HandlerFunc(ptr))
m.Get("/:server/:domain/:querytype", http.HandlerFunc(query))
if err := http.ListenAndServe(*host+":"+*port, m); err != nil {
fmt.Println("\nERROR :", err)
os.Exit(1)
}
}
func Test_HTTPClient_Check(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
res.WriteHeader(http.StatusOK)
if req.URL.Path == "/api/functions.json" {
res.Write([]byte(functionsListJSON))
}
}))
defer server.Close()
successClient := NewHTTPClient(server.URL)
err := successClient.Check()
if err != nil {
t.Errorf("Check() failed: got %s, expected nil", err.Error())
}
failServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
res.WriteHeader(http.StatusNotFound)
}))
defer failServer.Close()
failClient := NewHTTPClient(failServer.URL)
err = failClient.Check()
if err == nil {
t.Errorf("Check() failed: got nil error, expected an error")
}
}
func init() {
http.Handle("/debug/pprof/", http.HandlerFunc(Index))
http.Handle("/debug/pprof/cmdline", http.HandlerFunc(Cmdline))
http.Handle("/debug/pprof/profile", http.HandlerFunc(Profile))
http.Handle("/debug/pprof/symbol", http.HandlerFunc(Symbol))
http.Handle("/debug/pprof/trace", http.HandlerFunc(Trace))
}
func TestPatRoutingMethodNotAllowed(t *testing.T) {
p := New()
var ok bool
p.Post("/foo/:name", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ok = true
}))
p.Put("/foo/:name", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
ok = true
}))
r, err := http.NewRequest("GET", "/foo/keith", nil)
if err != nil {
t.Fatal(err)
}
rr := httptest.NewRecorder()
p.ServeHTTP(rr, r)
assert.T(t, !ok)
assert.Equal(t, http.StatusMethodNotAllowed, rr.Code)
allowed := strings.Split(rr.Header().Get("Allow"), ", ")
sort.Strings(allowed)
assert.Equal(t, allowed, []string{"POST", "PUT"})
}