// Run makes the HTTP request corresponding to the CreateBottleCommand command.
func (cmd *CreateBottleCommand) Run(c *client.Client, args []string) error {
var path string
if len(args) > 0 {
path = args[0]
} else {
path = "/bottles"
}
var payload client.CreateBottlePayload
if cmd.Payload != "" {
err := json.Unmarshal([]byte(cmd.Payload), &payload)
if err != nil {
return fmt.Errorf("failed to deserialize payload: %s", err)
}
}
logger := goa.NewLogger(log.New(os.Stderr, "", log.LstdFlags))
ctx := goa.WithLogger(context.Background(), logger)
resp, err := c.CreateBottle(ctx, path, &payload, cmd.ContentType)
if err != nil {
goa.LogError(ctx, "failed", "err", err)
return err
}
goaclient.HandleResponse(c.Client, resp, cmd.PrettyPrint)
return nil
}
// Service provide a general goa.Service used for testing purposes
func Service(logBuf *bytes.Buffer, respSetter ResponseSetterFunc) *goa.Service {
s := goa.New("test")
logger := log.New(logBuf, "", log.Ltime)
s.WithLogger(goa.NewLogger(logger))
s.Use(middleware.LogRequest(true))
s.Use(middleware.LogResponse())
newEncoder := func(io.Writer) goa.Encoder {
return respSetter
}
s.Decoder.Register(goa.NewJSONDecoder, "*/*")
s.Encoder.Register(newEncoder, "*/*")
return s
}
// StartAeOK runs the method Start of the given controller with the given parameters.
// It returns the response writer so it's possible to inspect the response headers.
// If ctx is nil then context.Background() is used.
// If service is nil then a default service is created.
func StartAeOK(t goatest.TInterface, ctx context.Context, service *goa.Service, ctrl app.AeController) http.ResponseWriter {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interface{}) { resp = r }
)
if service == nil {
service = goatest.Service(&logBuf, respSetter)
} else {
logger := log.New(&logBuf, "", log.Ltime)
service.WithLogger(goa.NewLogger(logger))
newEncoder := func(io.Writer) goa.Encoder { return respSetter }
service.Encoder = goa.NewHTTPEncoder() // Make sure the code ends up using this decoder
service.Encoder.Register(newEncoder, "*/*")
}
// Setup request context
rw := httptest.NewRecorder()
u := &url.URL{
Path: fmt.Sprintf("/_ah/start"),
}
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
panic("invalid test " + err.Error()) // bug
}
prms := url.Values{}
if ctx == nil {
ctx = context.Background()
}
goaCtx := goa.NewContext(goa.WithAction(ctx, "AeTest"), rw, req, prms)
startCtx, err := app.NewStartAeContext(goaCtx, service)
if err != nil {
panic("invalid test data " + err.Error()) // bug
}
// Perform action
err = ctrl.Start(startCtx)
// Validate response
if err != nil {
t.Fatalf("controller returned %s, logs:\n%s", err, logBuf.String())
}
if rw.Code != 200 {
t.Errorf("invalid response status code: got %+v, expected 200", rw.Code)
}
// Return results
return rw
}
// Run downloads files with given paths.
func (cmd *DownloadCommand) Run(c *client.Client, args []string) error {
var (
fnf func(context.Context, string) (int64, error)
fnd func(context.Context, string, string) (int64, error)
rpath = args[0]
outfile = cmd.OutFile
logger = goa.NewLogger(log.New(os.Stderr, "", log.LstdFlags))
ctx = goa.WithLogger(context.Background(), logger)
err error
)
if rpath[0] != '/' {
rpath = "/" + rpath
}
if rpath == "/swagger.json" {
fnf = c.DownloadSwaggerJSON
if outfile == "" {
outfile = "swagger.json"
}
goto found
}
if strings.HasPrefix(rpath, "/swagger-ui/") {
fnd = c.DownloadSwaggerUI
rpath = rpath[12:]
if outfile == "" {
_, outfile = path.Split(rpath)
}
goto found
}
return fmt.Errorf("don't know how to download %s", rpath)
found:
ctx = goa.WithLogContext(ctx, "file", outfile)
if fnf != nil {
_, err = fnf(ctx, outfile)
} else {
_, err = fnd(ctx, rpath, outfile)
}
if err != nil {
goa.LogError(ctx, "failed", "err", err)
return err
}
return nil
}
// Run makes the HTTP request corresponding to the ShowBottleCommand command.
func (cmd *ShowBottleCommand) Run(c *client.Client, args []string) error {
var path string
if len(args) > 0 {
path = args[0]
} else {
path = fmt.Sprintf("/bottles/%v", cmd.ID)
}
logger := goa.NewLogger(log.New(os.Stderr, "", log.LstdFlags))
ctx := goa.WithLogger(context.Background(), logger)
resp, err := c.ShowBottle(ctx, path)
if err != nil {
goa.LogError(ctx, "failed", "err", err)
return err
}
goaclient.HandleResponse(c.Client, resp, cmd.PrettyPrint)
return nil
}
// ShowBottleOK Show runs the method Show of the given controller with the given parameters.
// It returns the response writer so it's possible to inspect the response headers and the media type struct written to the response.
// If ctx is nil then context.Background() is used.
// If service is nil then a default service is created.
func ShowBottleOK(t *testing.T, ctx context.Context, service *goa.Service, ctrl app.BottleController, id int) (http.ResponseWriter, *app.Bottle) {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interface{}) { resp = r }
)
if service == nil {
service = goatest.Service(&logBuf, respSetter)
} else {
logger := log.New(&logBuf, "", log.Ltime)
service.WithLogger(goa.NewLogger(logger))
newEncoder := func(io.Writer) goa.Encoder { return respSetter }
service.Encoder = goa.NewHTTPEncoder() // Make sure the code ends up using this decoder
service.Encoder.Register(newEncoder, "*/*")
}
// Setup request context
rw := httptest.NewRecorder()
u := &url.URL{
Path: fmt.Sprintf("/bottles/%v", id),
}
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
panic("invalid test " + err.Error()) // bug
}
prms := url.Values{}
prms["id"] = []string{fmt.Sprintf("%v", id)}
if ctx == nil {
ctx = context.Background()
}
goaCtx := goa.NewContext(goa.WithAction(ctx, "BottleTest"), rw, req, prms)
showCtx, err := app.NewShowBottleContext(goaCtx, service)
if err != nil {
panic("invalid test data " + err.Error()) // bug
}
// Perform action
err = ctrl.Show(showCtx)
// Validate response
if err != nil {
t.Fatalf("controller returned %s, logs:\n%s", err, logBuf.String())
}
if rw.Code != 200 {
t.Errorf("invalid response status code: got %+v, expected 200", rw.Code)
}
var mt *app.Bottle
if resp != nil {
var ok bool
mt, ok = resp.(*app.Bottle)
if !ok {
t.Errorf("invalid response media: got %+v, expected instance of app.Bottle", resp)
}
err = mt.Validate()
if err != nil {
t.Errorf("invalid response media type: %s", err)
}
}
// Return results
return rw, mt
}
// CreateBottleCreated Create runs the method Create of the given controller with the given parameters and payload.
// It returns the response writer so it's possible to inspect the response headers.
// If ctx is nil then context.Background() is used.
// If service is nil then a default service is created.
func CreateBottleCreated(t *testing.T, ctx context.Context, service *goa.Service, ctrl app.BottleController, payload *app.CreateBottlePayload) http.ResponseWriter {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interface{}) { resp = r }
)
if service == nil {
service = goatest.Service(&logBuf, respSetter)
} else {
logger := log.New(&logBuf, "", log.Ltime)
service.WithLogger(goa.NewLogger(logger))
newEncoder := func(io.Writer) goa.Encoder { return respSetter }
service.Encoder = goa.NewHTTPEncoder() // Make sure the code ends up using this decoder
service.Encoder.Register(newEncoder, "*/*")
}
// Validate payload
err := payload.Validate()
if err != nil {
e, ok := err.(*goa.Error)
if !ok {
panic(err) // bug
}
if e.Status != 201 {
t.Errorf("unexpected payload validation error: %+v", e)
}
return nil
}
// Setup request context
rw := httptest.NewRecorder()
u := &url.URL{
Path: fmt.Sprintf("/bottles"),
}
req, err := http.NewRequest("POST", u.String(), nil)
if err != nil {
panic("invalid test " + err.Error()) // bug
}
prms := url.Values{}
if ctx == nil {
ctx = context.Background()
}
goaCtx := goa.NewContext(goa.WithAction(ctx, "BottleTest"), rw, req, prms)
createCtx, err := app.NewCreateBottleContext(goaCtx, service)
if err != nil {
panic("invalid test data " + err.Error()) // bug
}
createCtx.Payload = payload
// Perform action
err = ctrl.Create(createCtx)
// Validate response
if err != nil {
t.Fatalf("controller returned %s, logs:\n%s", err, logBuf.String())
}
if rw.Code != 201 {
t.Errorf("invalid response status code: got %+v, expected 201", rw.Code)
}
// Return results
return rw
}
It("doesn't log and doesn't crash", func() {
Ω(func() { goa.LogError(context.Background(), "foo", "bar") }).ShouldNot(Panic())
})
})
})
var _ = Describe("LogAdapter", func() {
Context("with a valid Log", func() {
var logger goa.LogAdapter
const msg = "message"
data := []interface{}{"data", "foo"}
var out bytes.Buffer
BeforeEach(func() {
stdlogger := log.New(&out, "", log.LstdFlags)
logger = goa.NewLogger(stdlogger)
})
It("Info logs", func() {
logger.Info(msg, data...)
Ω(out.String()).Should(ContainSubstring(msg + " data=foo"))
})
It("Error logs", func() {
logger.Error(msg, data...)
Ω(out.String()).Should(ContainSubstring(msg + " data=foo"))
})
})
})