func Test_SessionsDeleteValue(t *testing.T) { n := negroni.Classic() store := cookiestore.New([]byte("secret123")) n.Use(sessions.Sessions("my_session", store)) mux := http.NewServeMux() mux.HandleFunc("/testsession", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) session.Set("hello", "world") session.Delete("hello") fmt.Fprintf(w, "OK") }) mux.HandleFunc("/show", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) if session.Get("hello") == "world" { t.Error("Session value deleting failed") } fmt.Fprintf(w, "OK") }) n.UseHandler(mux) res := httptest.NewRecorder() req, _ := http.NewRequest("GET", "/testsession", nil) n.ServeHTTP(res, req) res2 := httptest.NewRecorder() req2, _ := http.NewRequest("GET", "/show", nil) req2.Header.Set("Cookie", res.Header().Get("Set-Cookie")) n.ServeHTTP(res2, req2) }
func TestRecoveryMiddlewareHandlesPanic(t *testing.T) { var ( router = mux.NewRouter() app = negroni.Classic() r *http.Request err error match *mux.RouteMatch ) // Add a test GET route without a middleware routes.AddRoutes([]routes.Route{ routes.Route{ Name: "panic_route", Method: "GET", Pattern: "/panic", HandlerFunc: func(w http.ResponseWriter, r *http.Request) { panic("oh no") }, }, }, router.PathPrefix("/foo").Subrouter()) // Test the foobar_route r, err = http.NewRequest("GET", "http://1.2.3.4/foo/panic", nil) assert.NoError(t, err, "Request setup should not get an error") // Test the route matches expected name match = new(mux.RouteMatch) router.Match(r, match) assert.Equal(t, "panic_route", match.Route.GetName()) // Test that panic does not crash the app app.UseHandler(router) app.ServeHTTP(httptest.NewRecorder(), r) }
func Test_LoginRequired(t *testing.T) { recorder := httptest.NewRecorder() n := negroni.Classic() n.Use(sessions.Sessions("my_session", cookiestore.New([]byte("secret123")))) n.Use(Google(&Config{ ClientID: "foo", ClientSecret: "foo", RedirectURL: "foo", })) n.Use(LoginRequired()) mux := http.NewServeMux() mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { fmt.Fprintf(w, "OK") }) n.UseHandler(mux) r, _ := http.NewRequest("GET", "/", nil) n.ServeHTTP(recorder, r) if recorder.Code != 302 { t.Errorf("Not being redirected to the auth page although user is not logged in. %d\n", recorder.Code) } }
func Test_LogoutOnAccessTokenExpiration(t *testing.T) { recorder := httptest.NewRecorder() s := cookiestore.New([]byte("secret123")) n := negroni.Classic() n.Use(sessions.Sessions("my_session", s)) n.Use(Google(&Config{ ClientID: "foo", ClientSecret: "foo", RedirectURL: "foo", })) mux := http.NewServeMux() mux.HandleFunc("/addtoken", func(w http.ResponseWriter, req *http.Request) { SetToken(req, "dummy token") fmt.Fprintf(w, "OK") }) mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { tok := GetToken(req) if tok != nil { t.Errorf("User not logged out although access token is expired. %v\n", tok) } }) n.UseHandler(mux) addtoken, _ := http.NewRequest("GET", "/addtoken", nil) index, _ := http.NewRequest("GET", "/", nil) n.ServeHTTP(recorder, addtoken) n.ServeHTTP(recorder, index) }
func main() { router := mux.NewRouter() router.HandleFunc("/", index) n := negroni.Classic() n.UseHandler(router) n.Run(":8080") }
func main() { mux := http.NewServeMux() mux.HandleFunc("/", index) // The classic function probides built-in middleware functions // for Recovery, Logging and serving Static files under the // "public" directory n := negroni.Classic() n.UseHandler(mux) n.Run(":8080") }
func NewRouter() http.Handler { n := negroni.Classic() router := &fakeRouter{mux: mux.NewRouter()} controller := &controller{persistorCreator: models.NewPersistor} router.mux.HandleFunc("/near", controller.nearHandler).Methods("POST") router.mux.HandleFunc("/store", controller.storeHandler).Methods("POST") router.mux.HandleFunc("/recent/{id}", controller.recentStrokes).Methods("GET") n.Use(router) return n }
func Test_Flashes(t *testing.T) { n := negroni.Classic() store := cookiestore.New([]byte("secret123")) n.Use(sessions.Sessions("my_session", store)) mux := http.NewServeMux() mux.HandleFunc("/set", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) session.AddFlash("hello world") fmt.Fprintf(w, "OK") }) mux.HandleFunc("/show", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) l := len(session.Flashes()) if l != 1 { t.Error("Flashes count does not equal 1. Equals ", l) } fmt.Fprintf(w, "OK") }) mux.HandleFunc("/showagain", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) l := len(session.Flashes()) if l != 0 { t.Error("flashes count is not 0 after reading. Equals ", l) } fmt.Fprintf(w, "OK") }) n.UseHandler(mux) res := httptest.NewRecorder() req, _ := http.NewRequest("GET", "/set", nil) n.ServeHTTP(res, req) res2 := httptest.NewRecorder() req2, _ := http.NewRequest("GET", "/show", nil) req2.Header.Set("Cookie", res.Header().Get("Set-Cookie")) n.ServeHTTP(res2, req2) res3 := httptest.NewRecorder() req3, _ := http.NewRequest("GET", "/showagain", nil) req3.Header.Set("Cookie", res2.Header().Get("Set-Cookie")) n.ServeHTTP(res3, req3) }
func main() { flag.StringVar(&masterConnection, "master", "redis-master:6379", "The connection string to the Redis master as <hostname/ip>:<port>") flag.StringVar(&slaveConnection, "slave", "redis-slave:6379", "The connection string to the Redis slave as <hostname/ip>:<port>") flag.StringVar(&masterPassword, "master-password", "", "The password used to connect to the master") flag.StringVar(&slavePassword, "slave-password", "", "The password used to connect to the slave") flag.IntVar(&healthCheckTime, "health-check", 15, "Period to check all connections") flag.BoolVar(&showVersion, "version", false, "Shows the version") flag.Parse() if showVersion { log.Printf("Version: %s\n", appVersion) return } // Iniitialize metrics healthCheckTimer := time.NewTicker(time.Duration(healthCheckTime) * time.Second) quit := make(chan struct{}) go func() { for { select { case <-healthCheckTimer.C: log.Println("Called Health check") getHealthStatus() case <-quit: healthCheckTimer.Stop() return } } }() r := mux.NewRouter() r.Path("/read/{key}").Methods("GET").HandlerFunc(readTodoHandler) r.Path("/insert/{key}/{value}").Methods("GET").HandlerFunc(insertTodoHandler) r.Path("/delete/{key}/{value}").Methods("GET").HandlerFunc(deleteTodoHandler) r.Path("/health").Methods("GET").HandlerFunc(healthCheckHandler) r.Path("/metrics").Methods("GET").Handler(prometheus.Handler()) r.Path("/whoami").Methods("GET").HandlerFunc(whoAmIHandler) r.Path("/version").Methods("GET").HandlerFunc(versionHandler) n := negroni.Classic() n.UseHandler(r) http.ListenAndServe(":3000", n) ch := make(chan os.Signal) signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM) log.Println(<-ch) close(quit) }
func Test_Options(t *testing.T) { n := negroni.Classic() store := cookiestore.New([]byte("secret123")) store.Options(sessions.Options{ Domain: "negroni-sessions.goincremental.com", }) n.Use(sessions.Sessions("my_session", store)) mux := http.NewServeMux() mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) session.Set("hello", "world") session.Options(sessions.Options{ Path: "/foo/bar/bat", }) fmt.Fprintf(w, "OK") }) mux.HandleFunc("/foo", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) session.Set("hello", "world") fmt.Fprintf(w, "OK") }) n.UseHandler(mux) res := httptest.NewRecorder() req, _ := http.NewRequest("GET", "/", nil) n.ServeHTTP(res, req) res2 := httptest.NewRecorder() req2, _ := http.NewRequest("GET", "/foo", nil) n.ServeHTTP(res2, req2) s := strings.Split(res.Header().Get("Set-Cookie"), ";") if s[1] != " Path=/foo/bar/bat" { t.Error("Error writing path with options:", s[1]) } s = strings.Split(res2.Header().Get("Set-Cookie"), ";") if s[1] != " Domain=negroni-sessions.goincremental.com" { t.Error("Error writing domain with options:", s[1]) } }
func Test_SessionsClear(t *testing.T) { n := negroni.Classic() data := map[string]string{ "hello": "world", "foo": "bar", "apples": "oranges", } store := cookiestore.New([]byte("secret123")) n.Use(sessions.Sessions("my_session", store)) mux := http.NewServeMux() mux.HandleFunc("/testsession", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) for k, v := range data { session.Set(k, v) } session.Clear() fmt.Fprintf(w, "OK") }) mux.HandleFunc("/show", func(w http.ResponseWriter, req *http.Request) { session := sessions.GetSession(req) for k, v := range data { if session.Get(k) == v { t.Fatal("Session clear failed") } } fmt.Fprintf(w, "OK") }) n.UseHandler(mux) res := httptest.NewRecorder() req, _ := http.NewRequest("GET", "/testsession", nil) n.ServeHTTP(res, req) res2 := httptest.NewRecorder() req2, _ := http.NewRequest("GET", "/show", nil) req2.Header.Set("Cookie", res.Header().Get("Set-Cookie")) n.ServeHTTP(res2, req2) }
func RunFunc() { r := render.New() mux, store := InitServerMux(r) n := negroni.Classic() n.Use(negroni.HandlerFunc(CookieMiddleware(store))) n.Use(negroni.HandlerFunc(RecoveryErr())) timeourHandler := http.TimeoutHandler(context.ClearHandler(mux), time.Duration(3*time.Second), timeoutErrMessage) n.UseHandler(timeourHandler) //All the middlerware we used l := log.New(os.Stdout, "[negroni] ", 0) l.Printf("listening on :80") server := http.Server{Addr: ":80", Handler: n} server.SetKeepAlivesEnabled(true) go MainMonitor() InitSchoolDB() InitCourseMap() InitSchoolStructs() l.Fatal(server.ListenAndServe()) }
func Test_Logout(t *testing.T) { recorder := httptest.NewRecorder() s := cookiestore.New([]byte("secret123")) n := negroni.Classic() n.Use(sessions.Sessions("my_session", s)) n.Use(Google(&Config{ ClientID: "foo", ClientSecret: "foo", RedirectURL: "foo", })) mux := http.NewServeMux() mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) { SetToken(req, "dummy token") fmt.Fprintf(w, "OK") }) mux.HandleFunc("/get", func(w http.ResponseWriter, req *http.Request) { tok := GetToken(req) if tok != nil { t.Errorf("User credentials are still kept in the session.") } fmt.Fprintf(w, "OK") }) n.UseHandler(mux) logout, _ := http.NewRequest("GET", "/logout", nil) index, _ := http.NewRequest("GET", "/", nil) n.ServeHTTP(httptest.NewRecorder(), index) n.ServeHTTP(recorder, logout) if recorder.Code != 302 { t.Errorf("Not being redirected to the next page.") } }
func NewServer(sh chan bool) { serverOnce.Do(func() { shutdownCh = sh flag.Parse() go hub.run() r := mux.NewRouter() var buffer bytes.Buffer buffer.WriteString(":") buffer.WriteString(core.NewConfig().HttpConfig.Port) jwtMiddleware := jwtmiddleware.New(jwtmiddleware.Options{ ValidationKeyGetter: func(token *jwt.Token) (interface{}, error) { return []byte(core.NewConfig().JWTConfig.Secret), nil }, Debug: true, Extractor: jwtmiddleware.FromFirst(jwtmiddleware.FromAuthHeader, func(r *http.Request) (string, error) { c, err := r.Cookie("Authentication") if err != nil { return "", err } authHeaderParts := strings.Split(c.Value, " ") if len(authHeaderParts) != 2 || strings.ToLower(authHeaderParts[0]) != "bearer" { return "", fmt.Errorf("Authorization header format must be Bearer {token}") } return authHeaderParts[1], nil }), SigningMethod: jwt.SigningMethodHS256, }) n := negroni.Classic() for _, v := range routes { if v.auth { r.Handle(v.path, negroni.New( negroni.HandlerFunc(jwtMiddleware.HandlerWithNext), negroni.Wrap(http.HandlerFunc(v.handleFunc)), )).Methods(v.method) } else { r.HandleFunc(v.path, v.handleFunc).Methods(v.method) } } n.UseHandler(r) server = &graceful.Server{ Timeout: 10 * time.Second, Server: &http.Server{ Addr: buffer.String(), Handler: n, }, BeforeShutdown: func() bool { log.Println("bye") return true }, } err := server.ListenAndServe() if err != nil { log.Fatal("ListenAndServe: ", err) } }) }