Skip to content

armgit / fider

Public Imported from GitHub
0

Open platform to collect and prioritize feedback

some retrofit

goenningb62cb12c2cd6
diff --git a/app/handlers/identity_test.go b/app/handlers/identity_test.go
index 4d7f57208..e230072b6 100644
--- a/app/handlers/identity_test.go
+++ b/app/handlers/identity_test.go
@@ -26,7 +26,6 @@ func TestLoginHandler(t *testing.T) {
RegisterTestingT(t)
server := mock.NewServer()
- server.Context.Set("__CTX_AUTH_ENDPOINT", "http://login.test.canherayou.com:3000")
code, response := server.ExecuteRaw(oauthHandlers.Login(oauth.FacebookProvider))
Expect(code).To(Equal(http.StatusTemporaryRedirect))
diff --git a/app/middlewares/cache_test.go b/app/middlewares/cache_test.go
index c36717481..dd3156a7e 100644
--- a/app/middlewares/cache_test.go
+++ b/app/middlewares/cache_test.go
@@ -2,29 +2,25 @@ package middlewares_test
import (
"net/http"
- "net/http/httptest"
"testing"
"github.com/WeCanHearYou/wechy/app/middlewares"
- "github.com/WeCanHearYou/wechy/app/mock"
+ "github.com/WeCanHearYou/wechy/app/mock2"
"github.com/WeCanHearYou/wechy/app/pkg/web"
- "github.com/labstack/echo"
. "github.com/onsi/gomega"
)
func TestCache(t *testing.T) {
RegisterTestingT(t)
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
-
- mw := middlewares.OneYearCache()
- mw(func(c web.Context) error {
+ server := mock2.NewServer()
+ server.Use(middlewares.OneYearCache())
+ handler := func(c web.Context) error {
return c.NoContent(http.StatusOK)
- })(c)
+ }
+
+ status, response := server.Execute(handler)
- Expect(rec.Code).To(Equal(http.StatusOK))
- Expect(rec.Header().Get("Cache-Control")).To(Equal("public, max-age=30672000"))
+ Expect(status).To(Equal(http.StatusOK))
+ Expect(response.Header().Get("Cache-Control")).To(Equal("public, max-age=30672000"))
}
diff --git a/app/middlewares/domain.go b/app/middlewares/domain.go
index bc9454226..e85f7d252 100644
--- a/app/middlewares/domain.go
+++ b/app/middlewares/domain.go
@@ -68,7 +68,7 @@ func MultiTenant(tenants storage.Tenant) web.MiddlewareFunc {
func HostChecker(baseURL string) web.MiddlewareFunc {
return func(next web.HandlerFunc) web.HandlerFunc {
return func(c web.Context) error {
- u, err := url.Parse(baseURL)
+ u, err := url.Parse("http://" + baseURL)
if err != nil {
return c.Failure(err)
}
diff --git a/app/middlewares/domain_test.go b/app/middlewares/domain_test.go
index c44ec2e15..bfeb02f68 100644
--- a/app/middlewares/domain_test.go
+++ b/app/middlewares/domain_test.go
@@ -2,15 +2,13 @@ package middlewares_test
import (
"net/http"
- "net/http/httptest"
"testing"
"github.com/WeCanHearYou/wechy/app/middlewares"
- "github.com/WeCanHearYou/wechy/app/mock"
+ "github.com/WeCanHearYou/wechy/app/mock2"
"github.com/WeCanHearYou/wechy/app/models"
"github.com/WeCanHearYou/wechy/app/pkg/web"
"github.com/WeCanHearYou/wechy/app/storage/inmemory"
- "github.com/labstack/echo"
. "github.com/onsi/gomega"
)
@@ -45,19 +43,16 @@ func TestMultiTenant(t *testing.T) {
for _, testCase := range testCases {
for _, host := range testCase.hosts {
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
- c.Request().Host = host
+ server := mock2.NewServer()
+ server.Context.Request().Host = host
- mw := middlewares.MultiTenant(tenants)
- mw(func(c web.Context) error {
+ server.Use(middlewares.MultiTenant(tenants))
+ status, response := server.Execute(func(c web.Context) error {
return c.String(http.StatusOK, c.Tenant().Name)
- })(c)
+ })
- Expect(rec.Code).To(Equal(http.StatusOK))
- Expect(rec.Body.String()).To(Equal(testCase.expected))
+ Expect(status).To(Equal(http.StatusOK))
+ Expect(response.Body.String()).To(Equal(testCase.expected))
}
}
}
@@ -65,94 +60,80 @@ func TestMultiTenant(t *testing.T) {
func TestMultiTenant_AuthDomain(t *testing.T) {
RegisterTestingT(t)
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
- c.Request().Host = "login.test.canhearyou.com"
+ tenants := &inmemory.TenantStorage{}
+ server := mock2.NewServer()
+ server.Context.Request().Host = "login.test.canhearyou.com"
- mw := middlewares.MultiTenant(&inmemory.TenantStorage{})
- mw(func(c web.Context) error {
+ server.Use(middlewares.MultiTenant(tenants))
+ status, _ := server.Execute(func(c web.Context) error {
if c.Tenant() == nil {
return c.NoContent(http.StatusOK)
}
return c.NoContent(http.StatusInternalServerError)
- })(c)
+ })
- Expect(rec.Code).To(Equal(http.StatusOK))
+ Expect(status).To(Equal(http.StatusOK))
}
func TestMultiTenant_UnknownDomain(t *testing.T) {
RegisterTestingT(t)
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
- c.Request().Host = "somedomain.com"
+ tenants := &inmemory.TenantStorage{}
+ server := mock2.NewServer()
+ server.Context.Request().Host = "somedomain.com"
- mw := middlewares.MultiTenant(&inmemory.TenantStorage{})
- mw(func(c web.Context) error {
+ server.Use(middlewares.MultiTenant(tenants))
+ status, _ := server.Execute(func(c web.Context) error {
return c.String(http.StatusOK, c.Tenant().Name)
- })(c)
+ })
- Expect(rec.Code).To(Equal(http.StatusNotFound))
+ Expect(status).To(Equal(http.StatusNotFound))
}
func TestSingleTenant(t *testing.T) {
RegisterTestingT(t)
tenants := &inmemory.TenantStorage{}
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
- c.Request().Host = "somedomain.com"
-
- mw := middlewares.SingleTenant(tenants)
- mw(func(c web.Context) error {
+ server := mock2.NewServer()
+ server.Context.Request().Host = "somedomain.com"
+
+ server.Use(middlewares.SingleTenant(tenants))
+ status, _ := server.Execute(func(c web.Context) error {
return c.NoContent(http.StatusOK)
- })(c)
+ })
tenant, err := tenants.First()
- Expect(rec.Code).To(Equal(http.StatusOK))
+ Expect(status).To(Equal(http.StatusOK))
Expect(err).To(BeNil())
Expect(tenant.Name).To(Equal("Default"))
Expect(tenant.Subdomain).To(Equal("default"))
- Expect(c.Get("__CTX_TENANT")).To(Equal(tenant))
+ Expect(server.Context.Tenant()).To(Equal(tenant))
}
func TestHostChecker(t *testing.T) {
RegisterTestingT(t)
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
- c.Request().Host = "login.test.canhearyou.com"
+ server := mock2.NewServer()
+ server.Context.Request().Host = "login.test.canhearyou.com"
- mw := middlewares.HostChecker("http://login.test.canhearyou.com")
- mw(func(c web.Context) error {
+ server.Use(middlewares.HostChecker("login.test.canhearyou.com"))
+ status, _ := server.Execute(func(c web.Context) error {
return c.NoContent(http.StatusOK)
- })(c)
+ })
- Expect(rec.Code).To(Equal(http.StatusOK))
+ Expect(status).To(Equal(http.StatusOK))
}
func TestHostChecker_DifferentHost(t *testing.T) {
RegisterTestingT(t)
- server := mock.NewServer()
- req, _ := http.NewRequest(echo.GET, "/", nil)
- rec := httptest.NewRecorder()
- c := server.NewContext(req, rec)
- c.Request().Host = "orange.test.canhearyou.com"
-
- mw := middlewares.HostChecker("login.test.canhearyou.com")
- mw(web.HandlerFunc(func(c web.Context) error {
+ server := mock2.NewServer()
+ server.Context.Request().Host = "orange.test.canhearyou.com"
+ server.Use(middlewares.HostChecker("login.test.canhearyou.com"))
+ status, _ := server.Execute(func(c web.Context) error {
return c.NoContent(http.StatusOK)
- }))(c)
+ })
- Expect(rec.Code).To(Equal(http.StatusBadRequest))
+ Expect(status).To(Equal(http.StatusBadRequest))
}
diff --git a/app/middlewares/noop.go b/app/middlewares/noop.go
new file mode 100644
index 000000000..a1ef32032
--- /dev/null
+++ b/app/middlewares/noop.go
@@ -0,0 +1,12 @@
+package middlewares
+
+import "github.com/WeCanHearYou/wechy/app/pkg/web"
+
+// Noop does nothing
+func Noop() web.MiddlewareFunc {
+ return func(next web.HandlerFunc) web.HandlerFunc {
+ return func(c web.Context) error {
+ return next(c)
+ }
+ }
+}
diff --git a/app/mock/server.go b/app/mock/server.go
index f33c27668..b784058eb 100644
--- a/app/mock/server.go
+++ b/app/mock/server.go
@@ -7,8 +7,6 @@ import (
"strings"
- "fmt"
-
"github.com/WeCanHearYou/wechy/app/models"
"github.com/WeCanHearYou/wechy/app/pkg/web"
"github.com/jmoiron/jsonq"
@@ -17,7 +15,7 @@ import (
// Server is a HTTP server wrapper for testing purpose
type Server struct {
- engine *echo.Echo
+ engine *web.Engine
handler echo.HandlerFunc
Context web.Context
recorder *httptest.ResponseRecorder
@@ -25,12 +23,8 @@ type Server struct {
// NewServer creates a new test server
func NewServer() *Server {
- engine := echo.New()
- engine.Renderer = web.NewHTMLRenderer(&models.AppSettings{}, engine.Logger)
- engine.HTTPErrorHandler = func(e error, c echo.Context) {
- fmt.Println(e)
- c.NoContent(e.(*echo.HTTPError).Code)
- }
+ settings := &models.AppSettings{}
+ engine := web.New(settings)
request, _ := http.NewRequest(echo.GET, "/", nil)
recorder := httptest.NewRecorder()
@@ -45,15 +39,14 @@ func NewServer() *Server {
// NewContext creates a new HTTP context
func (s *Server) NewContext(req *http.Request, w http.ResponseWriter) web.Context {
- c := s.engine.NewContext(req, w)
- return web.Context{Context: c}
+ return s.engine.NewContext(req, w)
}
// Execute given handler and return response as JSON
func (s *Server) Execute(handler web.HandlerFunc) (int, *jsonq.JsonQuery) {
ctx := web.Context{Context: s.Context}
if err := handler(ctx); err != nil {
- s.engine.HTTPErrorHandler(err, ctx)
+ s.engine.HandleError(err, ctx)
}
return parseJSONBody(s)
@@ -68,7 +61,7 @@ func (s *Server) ExecutePost(handler web.HandlerFunc, body string) (int, *jsonq.
ctx.SetRequest(req)
if err := handler(ctx); err != nil {
- s.engine.HTTPErrorHandler(err, ctx)
+ s.engine.HandleError(err, ctx)
}
return parseJSONBody(s)
}
@@ -88,9 +81,8 @@ func parseJSONBody(s *Server) (int, *jsonq.JsonQuery) {
// ExecuteRaw executes given handler and return raw response
func (s *Server) ExecuteRaw(handler web.HandlerFunc) (int, *http.Response) {
- ctx := web.Context{Context: s.Context}
- if err := handler(ctx); err != nil {
- s.engine.HTTPErrorHandler(err, ctx)
+ if err := handler(s.Context); err != nil {
+ s.engine.HandleError(err, s.Context)
}
return s.recorder.Code, s.recorder.Result()
diff --git a/app/mock2/server.go b/app/mock2/server.go
new file mode 100644
index 000000000..3a585fd2e
--- /dev/null
+++ b/app/mock2/server.go
@@ -0,0 +1,51 @@
+package mock2
+
+import (
+ "net/http"
+ "net/http/httptest"
+
+ "github.com/WeCanHearYou/wechy/app/middlewares"
+ "github.com/WeCanHearYou/wechy/app/models"
+ "github.com/WeCanHearYou/wechy/app/pkg/web"
+ "github.com/labstack/echo"
+)
+
+// Server is a HTTP server wrapper for testing purpose
+type Server struct {
+ engine *web.Engine
+ handler echo.HandlerFunc
+ Context web.Context
+ recorder *httptest.ResponseRecorder
+ middleware web.MiddlewareFunc
+}
+
+// NewServer creates a new test server
+func NewServer() *Server {
+ settings := &models.AppSettings{}
+ engine := web.New(settings)
+
+ request, _ := http.NewRequest(echo.GET, "/", nil)
+ recorder := httptest.NewRecorder()
+ context := engine.NewContext(request, recorder)
+
+ return &Server{
+ engine: engine,
+ recorder: recorder,
+ Context: web.Context{Context: context},
+ middleware: middlewares.Noop(),
+ }
+}
+
+// Use adds a new middleware to pipeline
+func (s *Server) Use(middleware web.MiddlewareFunc) {
+ s.middleware = middleware
+}
+
+// Execute given handler and return response
+func (s *Server) Execute(handler web.HandlerFunc) (int, *httptest.ResponseRecorder) {
+ if err := s.middleware(handler)(s.Context); err != nil {
+ s.engine.HandleError(err, s.Context)
+ }
+
+ return s.recorder.Code, s.recorder
+}
diff --git a/app/pkg/web/engine.go b/app/pkg/web/engine.go
index 799a3db04..6c983f6d6 100644
--- a/app/pkg/web/engine.go
+++ b/app/pkg/web/engine.go
@@ -39,11 +39,27 @@ type Group struct {
group *echo.Group
}
+//NewContext creates and return a new context
+func (e *Engine) NewContext(req *http.Request, w http.ResponseWriter) Context {
+ context := e.router.NewContext(req, w)
+ return Context{Context: context}
+}
+
//Group creates a new router group with prefix and optional group-level middleware
func (e *Engine) Group(preffix string) *Group {
return &Group{group: e.router.Group(preffix)}
}
+//HandleError redirect error to router
+func (e *Engine) HandleError(err error, ctx Context) {
+ e.router.HTTPErrorHandler(err, ctx)
+}
+
+//Use add middleware to routes within the main Engine
+func (e *Engine) Use(middleware MiddlewareFunc) {
+ e.router.Use(wrapMiddleware(middleware))
+}
+
//Use add middleware to sub-routes within the Group
func (g *Group) Use(middleware MiddlewareFunc) {
g.group.Use(wrapMiddleware(middleware))