It("returns the middleware", func() {
Ω(fmt.Sprintf("%#v", middleware)).Should(Equal(fmt.Sprintf("%#v", goa.Middleware(goaMiddlewareFunc))))
Ω(mErr).ShouldNot(HaveOccurred())
})
})
Context("with a context", func() {
var ctx *goa.Context
BeforeEach(func() {
req, err := http.NewRequest("GET", "/goo", nil)
Ω(err).ShouldNot(HaveOccurred())
rw := new(TestResponseWriter)
params := url.Values{"foo": []string{"bar"}}
ctx = goa.NewContext(nil, req, rw, params, nil)
Ω(ctx.ResponseStatus()).Should(Equal(0))
})
Context("using a goa handler", func() {
BeforeEach(func() {
var goaHandler goa.Handler = func(ctx *goa.Context) error {
ctx.JSON(200, "ok")
return nil
}
input = goaHandler
})
It("wraps it in a middleware", func() {
Ω(mErr).ShouldNot(HaveOccurred())
h := func(ctx *goa.Context) error { return nil }
Ω(middleware(h)(ctx)).ShouldNot(HaveOccurred())
Describe("Request", func() {
It("returns nil if not initialized", func() {
Ω(ctx.Request()).Should(BeNil())
})
})
Describe("Header", func() {
It("returns nil if not initialized", func() {
Ω(ctx.Header()).Should(BeNil())
})
})
Describe("ResponseStatus", func() {
It("returns 0 if not initialized", func() {
Ω(ctx.ResponseStatus()).Should(Equal(0))
})
})
Describe("ResponseLength", func() {
It("returns 0 if not initialized", func() {
Ω(ctx.ResponseLength()).Should(Equal(0))
})
})
Describe("Get", func() {
It(`returns "", false if not initialized`, func() {
p := ctx.Get("foo")
Ω(p).Should(Equal(""))
})
})
token = jwtg.New(jwtg.SigningMethodHS256)
token.Claims["exp"] = time.Now().Add(time.Hour * 24).Unix()
token.Claims["random"] = "42"
tokenString, err = token.SignedString(signingKey)
Ω(err).ShouldNot(HaveOccurred())
})
It("requires a jwt token be present", func() {
h := func(ctx *goa.Context) error {
ctx.Respond(200, "ok")
return nil
}
jw := jwt.Middleware(spec)(h)
Ω(jw(ctx)).ShouldNot(HaveOccurred())
Ω(ctx.ResponseStatus()).Should(Equal(http.StatusUnauthorized))
})
It("returns the jwt token that was sent as a header", func() {
req.Header.Set("Authorization", "bearer "+tokenString)
h := func(ctx *goa.Context) error {
ctx.Respond(200, "ok")
return nil
}
jw := jwt.Middleware(spec)(h)
Ω(jw(ctx)).ShouldNot(HaveOccurred())
Ω(ctx.ResponseStatus()).Should(Equal(http.StatusOK))
tok, err := jwtg.Parse(tokenString, validFunc)
Ω(err).ShouldNot(HaveOccurred())
handler = new(testHandler)
logger := log15.New("test", "test")
logger.SetHandler(handler)
ctx.Logger = logger
})
It("encodes response using gzip", func() {
h := func(ctx *goa.Context) error {
ctx.Write([]byte("gzip me!"))
ctx.WriteHeader(http.StatusOK)
return nil
}
t := gzm.Middleware(gzip.BestCompression)(h)
err := t(ctx)
Ω(err).ShouldNot(HaveOccurred())
Ω(ctx.ResponseStatus()).Should(Equal(http.StatusOK))
gzr, err := gzip.NewReader(bytes.NewReader(rw.Body))
Ω(err).ShouldNot(HaveOccurred())
buf := bytes.NewBuffer(nil)
io.Copy(buf, gzr)
Ω(err).ShouldNot(HaveOccurred())
Ω(buf.String()).Should(Equal("gzip me!"))
})
})
type testHandler struct {
Records []*log15.Record
}
provisioningContext.InstanceId = "some-instance-id"
provisioningContext.OrganizationId = "org-1"
provisioningContext.SpaceId = "space-1"
provisioningContext.ServiceId = "service-1"
provisioningContext.PlanId = "plan-1"
})
Context("when all goes ok", func() {
BeforeEach(func() {
err := provisioningController.Create(provisioningContext)
Expect(err).ToNot(HaveOccurred())
})
It("responds with 201", func() {
Expect(goaContext.ResponseStatus()).To(Equal(201))
})
It("sends the correct message to the state", func() {
recordedInstance := state.AddInstanceArgsForCall(0)
Expect(recordedInstance.ID).To(Equal("some-instance-id"))
Expect(recordedInstance.OrganizationID).To(Equal("org-1"))
Expect(recordedInstance.SpaceID).To(Equal("space-1"))
Expect(recordedInstance.ServiceID).To(Equal("service-1"))
Expect(recordedInstance.PlanID).To(Equal("plan-1"))
})
})
Context("when the instance id already exists", func() {
BeforeEach(func() {
state.InstanceExistsReturns(true)
Ω(mErr).ShouldNot(HaveOccurred())
})
})
Context("with a context", func() {
var service goa.Service
var ctx *goa.Context
BeforeEach(func() {
service = goa.New("test")
req, err := http.NewRequest("GET", "/goo", nil)
Ω(err).ShouldNot(HaveOccurred())
rw := new(TestResponseWriter)
params := url.Values{"foo": []string{"bar"}}
ctx = goa.NewContext(nil, service, req, rw, params)
Ω(ctx.ResponseStatus()).Should(Equal(0))
})
Context("using a goa handler", func() {
BeforeEach(func() {
var goaHandler goa.Handler = func(ctx *goa.Context) error {
ctx.Respond(200, "ok")
return nil
}
input = goaHandler
})
It("wraps it in a middleware", func() {
Ω(mErr).ShouldNot(HaveOccurred())
h := func(ctx *goa.Context) error { return nil }
Ω(middleware(h)(ctx)).ShouldNot(HaveOccurred())