func (s *S) TestAppLockMiddlewareOnLockedApp(c *check.C) {
oldDuration := lockWaitDuration
lockWaitDuration = 1 * time.Second
defer func() { lockWaitDuration = oldDuration }()
myApp := app.App{
Name: "my-app",
Lock: app.AppLock{
Locked: true,
Reason: "/app/my-app/deploy",
Owner: "someone",
AcquireDate: time.Date(2048, time.November, 10, 10, 0, 0, 0, time.UTC),
},
}
err := s.conn.Apps().Insert(myApp)
c.Assert(err, check.IsNil)
defer s.conn.Apps().Remove(bson.M{"name": myApp.Name})
recorder := httptest.NewRecorder()
request, err := http.NewRequest("POST", "/?:app=my-app", nil)
c.Assert(err, check.IsNil)
h, log := doHandler()
m := &appLockMiddleware{}
m.ServeHTTP(recorder, request, h)
c.Assert(log.called, check.Equals, false)
httpErr := context.GetRequestError(request).(*errors.HTTP)
c.Assert(httpErr.Code, check.Equals, http.StatusConflict)
c.Assert(httpErr.Message, check.Matches, "App locked by someone, running /app/my-app/deploy. Acquired in 2048-11-10.*")
}
func (s *S) TestAppLockMiddlewareReturns404IfNotApp(c *check.C) {
recorder := httptest.NewRecorder()
request, err := http.NewRequest("POST", "/?:app=abc", nil)
c.Assert(err, check.IsNil)
h, log := doHandler()
m := &appLockMiddleware{}
m.ServeHTTP(recorder, request, h)
c.Assert(log.called, check.Equals, false)
httpErr := context.GetRequestError(request).(*errors.HTTP)
c.Assert(httpErr.Code, check.Equals, http.StatusNotFound)
c.Assert(httpErr.Message, check.Equals, "App not found.")
request, err = http.NewRequest("POST", "/?:appname=abc", nil)
c.Assert(err, check.IsNil)
m.ServeHTTP(recorder, request, h)
c.Assert(log.called, check.Equals, false)
httpErr = context.GetRequestError(request).(*errors.HTTP)
c.Assert(httpErr.Code, check.Equals, http.StatusNotFound)
c.Assert(httpErr.Message, check.Equals, "App not found.")
}
func (s *S) TestContextClearerMiddleware(c *check.C) {
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/", nil)
c.Assert(err, check.IsNil)
context.AddRequestError(request, fmt.Errorf("Some Error"))
h, log := doHandler()
contextClearerMiddleware(recorder, request, h)
c.Assert(log.called, check.Equals, true)
contErr := context.GetRequestError(request)
c.Assert(contErr, check.IsNil)
}
func (s *S) TestAuthTokenMiddlewareUserTokenAppNotFound(c *check.C) {
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/?:app=something", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
h, log := doHandler()
authTokenMiddleware(recorder, request, h)
c.Assert(log.called, check.Equals, false)
err = context.GetRequestError(request)
c.Assert(err, check.NotNil)
e, ok := err.(*errors.HTTP)
c.Assert(ok, check.Equals, true)
c.Assert(e.Code, check.Equals, http.StatusNotFound)
}
func errorHandlingMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
next(w, r)
err := context.GetRequestError(r)
if err != nil {
code := http.StatusInternalServerError
if e, ok := err.(*errors.HTTP); ok {
code = e.Code
}
flushing, ok := w.(*io.FlushingWriter)
if ok && flushing.Wrote() {
fmt.Fprintln(w, err)
} else {
http.Error(w, err.Error(), code)
}
log.Errorf("failure running HTTP request %s %s (%d): %s", r.Method, r.URL.Path, code, err)
}
}
func (s *S) TestAuthTokenMiddlewareUserTokenNoAccessToTheApp(c *check.C) {
a := app.App{Name: "something"}
err := s.conn.Apps().Insert(a)
c.Assert(err, check.IsNil)
defer s.conn.Apps().Remove(bson.M{"name": a.Name})
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/?:app=something", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+s.token.GetValue())
h, log := doHandler()
authTokenMiddleware(recorder, request, h)
c.Assert(log.called, check.Equals, false)
err = context.GetRequestError(request)
c.Assert(err, check.NotNil)
e, ok := err.(*errors.HTTP)
c.Assert(ok, check.Equals, true)
c.Assert(e.Code, check.Equals, http.StatusForbidden)
}
func (s *S) TestAuthTokenMiddlewareWithIncorrectAppToken(c *check.C) {
token, err := nativeScheme.AppLogin("xyz")
c.Assert(err, check.IsNil)
defer s.conn.Tokens().Remove(bson.M{"token": token.GetValue()})
recorder := httptest.NewRecorder()
request, err := http.NewRequest("GET", "/?:app=abc", nil)
c.Assert(err, check.IsNil)
request.Header.Set("Authorization", "bearer "+token.GetValue())
h, log := doHandler()
authTokenMiddleware(recorder, request, h)
t := context.GetAuthToken(request)
c.Assert(t, check.IsNil)
c.Assert(log.called, check.Equals, false)
err = context.GetRequestError(request)
c.Assert(err, check.NotNil)
e, ok := err.(*errors.HTTP)
c.Assert(ok, check.Equals, true)
c.Assert(e.Code, check.Equals, http.StatusForbidden)
}
func errorHandlingMiddleware(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
next(w, r)
err := context.GetRequestError(r)
if err != nil {
code := http.StatusInternalServerError
if e, ok := err.(*tsuruErrors.HTTP); ok {
code = e.Code
}
flushing, ok := w.(*io.FlushingWriter)
if ok && flushing.Wrote() {
if w.Header().Get("Content-Type") == "application/x-json-stream" {
data, marshalErr := json.Marshal(io.SimpleJsonMessage{Error: err.Error()})
if marshalErr == nil {
w.Write(append(data, "\n"...))
}
} else {
fmt.Fprintln(w, err)
}
} else {
http.Error(w, err.Error(), code)
}
log.Errorf("failure running HTTP request %s %s (%d): %s", r.Method, r.URL.Path, code, err)
}
}