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"}) }