func TestMailer(t *testing.T) {
	g := Goblin(t)

	g.Describe("Mailer", func() {
		pwreset.CreateLogger(pwreset.NewContextForEnvironment("test"))

		g.It("should read the required credentials", func() {
			creds := pwreset.ReadCredentials()

			g.Assert(creds != nil).IsTrue()

			value, err := creds.Get()

			g.Assert(err == nil).IsTrue()
			g.Assert(len(value.AccessKeyID)).Equal(20)
			g.Assert(len(value.SecretAccessKey)).Equal(40)
		})

		g.It("should create a session from valid credentials", func() {
			creds := pwreset.ReadCredentials()
			svc := pwreset.CreateSession(creds)

			g.Assert(svc != nil).IsTrue()
			// fmt.Println("svc: ", svc.Client)
			g.Assert(svc.Client != nil).IsTrue()
		})
	})
}
func TestContext(t *testing.T) {
	g := Goblin(t)

	g.Describe("Context", func() {
		pwreset.CreateLogger(pwreset.NewContextForEnvironment("test"))

		g.It("should create a context struct", func() {
			ctx := new(pwreset.Context)

			g.Assert(ctx.GetShutdownPort()).Equal(0)
		})

		g.It("should create a context struct with defaults set", func() {
			ctx := pwreset.NewDefaultContext()

			g.Assert(ctx.GetShutdownPort()).Equal(3019)

			hash := ctx.ToMap()

			g.Assert(hash != nil)

			if value, ok := hash["webroot"]; ok {
				g.Assert(value).Equal("public")
			}

			g.Assert(hash["baseport"]).Equal(3011)
			g.Assert(hash["shutdownPort"]).Equal(3019)
			g.Assert(hash["serverCount"]).Equal(1)
			g.Assert(hash["timeout"]).Equal(int64(600))
		})

		g.It("should create context from args", func() {
			ctx := pwreset.ParseArgs()

			g.Assert(ctx.GetShutdownPort()).Equal(3019)

			hash := ctx.ToMap()

			g.Assert(hash["baseport"]).Equal(3011)
			g.Assert(hash["shutdownPort"]).Equal(3019)
			g.Assert(hash["serverCount"]).Equal(1)
			g.Assert(hash["timeout"]).Equal(int64(600))
		})

	})
}
func TestHandlers(t *testing.T) {
	g := Goblin(t)

	g.Describe("Handlers", func() {
		log := pwreset.CreateLogger(pwreset.NewContextForEnvironment("test"))

		g.It("should have a status handler that returns a json status blob", func() {
			mux := http.NewServeMux()
			mux.HandleFunc("/status", pwreset.StatusHandler)

			server := negroni.New()
			server.UseHandler(mux)

			request, err := http.NewRequest("GET", "http://test.com/status", nil)
			if err != nil {
				panic(err)
			}

			recorder := httptest.NewRecorder()

			server.ServeHTTP(recorder, request)
			// fmt.Println( recorder.Body.String() )
			log.Info("status response: %s", recorder.Body.String())

			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body != nil).IsTrue()

			wrapper := make(map[string]interface{})
			err = json.Unmarshal(recorder.Body.Bytes(), &wrapper)

			g.Assert(err == nil).IsTrue()
			status := wrapper["status"]
			g.Assert(status).Equal("ok")
		})

		g.It("should have a ping handler that returns pong", func() {
			mux := http.NewServeMux()
			mux.HandleFunc("/ping", pwreset.PingHandler)

			server := negroni.New()
			server.UseHandler(mux)

			request, err := http.NewRequest("GET", "http://test.com/ping", nil)
			if err != nil {
				panic(err)
			}

			recorder := httptest.NewRecorder()

			server.ServeHTTP(recorder, request)
			log.Info("status response: %s", recorder.Body.String())

			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body != nil).IsTrue()
			g.Assert(recorder.Body.String()).Equal("pong\r\n")
		})

		g.It("should have an index handler that returns not found if path is unknown", func() {
			mux := http.NewServeMux()
			mux.HandleFunc("/", pwreset.IndexHandler)

			server := negroni.New()
			server.UseHandler(mux)

			request, err := http.NewRequest("GET", "http://test.com/bad-request-path", nil)
			if err != nil {
				panic(err)
			}

			recorder := httptest.NewRecorder()

			server.ServeHTTP(recorder, request)
			log.Info("status response: %s", recorder.Body.String())

			g.Assert(recorder.Code).Equal(404)
			g.Assert(recorder.Body != nil).IsTrue()
			g.Assert(recorder.Body.String()).Equal("404 page not found\n")
		})

		g.It("should have a shutdown handler that rejects shudown requests with GET", func() {
			mux := http.NewServeMux()
			mux.HandleFunc("/shutdown", pwreset.ShutdownHandler)

			server := negroni.New()
			server.UseHandler(mux)

			request, err := http.NewRequest("GET", "http://test.com/shutdown", nil)
			if err != nil {
				panic(err)
			}

			recorder := httptest.NewRecorder()

			server.ServeHTTP(recorder, request)
			log.Info("status response: %s", recorder.Body.String())

			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body != nil).IsTrue()
			g.Assert(recorder.Body.String()).Equal("shutdown requested...\r\nshutdown request denied...\r\n")
		})

		g.It("should have a reset handler that rejects requests without key", func() {
			mux := http.NewServeMux()
			mux.HandleFunc("/login", pwreset.ResetHandler)

			server := negroni.New()
			server.UseHandler(mux)

			request, err := http.NewRequest("POST", "http://test.com/login", nil)
			if err != nil {
				panic(err)
			}

			recorder := httptest.NewRecorder()

			server.ServeHTTP(recorder, request)
			log.Info("status response: %s", recorder.Body.String())

			g.Assert(recorder.Code).Equal(404)
			g.Assert(recorder.Body != nil).IsTrue()
			g.Assert(recorder.Body.String()).Equal("404 page not found\n")
		})

	})
}
func TestMiddleware(t *testing.T) {
	g := Goblin(t)

	g.Describe("Middleware", func() {
		pwreset.CreateLogger(pwreset.NewContextForEnvironment("test"))

		g.It("should accept a https proto request", func() {
			msg := "write success to service"
			recorder := httptest.NewRecorder()

			proto := pwreset.NewProtoMiddleware("production")

			server := negroni.New()
			server.Use(proto)

			server.UseHandler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				// fmt.Println( req.Header.Get("X-Forwarded-Proto"))
				fmt.Fprintf(w, msg)
			}))

			request, err := http.NewRequest("GET", "https://bluelasso.com/mypage", nil)
			request.Header.Set("X-Forwarded-Proto", "https")

			g.Assert(err == nil).IsTrue()

			server.ServeHTTP(recorder, request)

			// fmt.Printf("%d - %s", recorder.Code, recorder.Body.String())
			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body.String()).Equal(msg)
		})

		g.It("should reject a non-https request", func() {
			msg := "write success to service"
			recorder := httptest.NewRecorder()

			proto := pwreset.NewProtoMiddleware("production")

			server := negroni.New()
			server.Use(proto)

			server.UseHandler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				// fmt.Println( req.Header.Get("X-Forwarded-Proto"))
				fmt.Fprintf(w, msg)
			}))

			request, err := http.NewRequest("GET", "https://bluelasso.com/mypage", nil)
			request.Header.Set("X-Forwarded-Proto", "http")

			g.Assert(err == nil).IsTrue()

			server.ServeHTTP(recorder, request)

			// fmt.Printf("%d - %s", recorder.Code, recorder.Body.String())
			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body.String() != msg)
		})

		g.It("should accept a non-https request for status", func() {
			msg := "write success to service for status"
			recorder := httptest.NewRecorder()

			proto := pwreset.NewProtoMiddleware("production")

			server := negroni.New()
			server.Use(proto)

			server.UseHandler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				// fmt.Println( req.Header.Get("X-Forwarded-Proto"))
				fmt.Fprintf(w, msg)
			}))

			request, err := http.NewRequest("GET", "https://bluelasso.com/status", nil)
			request.Header.Set("X-Forwarded-Proto", "http")

			g.Assert(err == nil).IsTrue()

			server.ServeHTTP(recorder, request)

			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body.String()).Equal(msg)
		})

		g.It("should accept a non-https request for ping", func() {
			msg := "write success to service for ping"
			recorder := httptest.NewRecorder()

			proto := pwreset.NewProtoMiddleware("production")

			server := negroni.New()
			server.Use(proto)

			server.UseHandler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				// fmt.Println( req.Header.Get("X-Forwarded-Proto"))
				fmt.Fprintf(w, msg)
			}))

			request, err := http.NewRequest("GET", "https://bluelasso.com/ping", nil)
			request.Header.Set("X-Forwarded-Proto", "http")

			g.Assert(err == nil).IsTrue()

			server.ServeHTTP(recorder, request)

			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body.String()).Equal(msg)
		})

		g.It("should accept a non-https request for non-production", func() {
			msg := "write success to service for non-production env"
			recorder := httptest.NewRecorder()

			proto := pwreset.NewProtoMiddleware("test")

			server := negroni.New()
			server.Use(proto)

			server.UseHandler(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
				// fmt.Println( req.Header.Get("X-Forwarded-Proto"))
				fmt.Fprintf(w, msg)
			}))

			request, err := http.NewRequest("GET", "https://bluelasso.com/anypage", nil)
			request.Header.Set("X-Forwarded-Proto", "http")

			g.Assert(err == nil).IsTrue()

			server.ServeHTTP(recorder, request)

			g.Assert(recorder.Code).Equal(200)
			g.Assert(recorder.Body.String()).Equal(msg)
		})
	})
}