func configureAPI(api *operations.TaskTrackerAPI) http.Handler {
// configure the api here
api.ServeError = errors.ServeError
api.JSONConsumer = runtime.JSONConsumer()
api.MulitpartformConsumer = runtime.DiscardConsumer
api.JSONProducer = runtime.JSONProducer()
api.APIKeyAuth = func(token string) (interface{}, error) {
return nil, errors.NotImplemented("api key auth (api_key) token from query has not yet been implemented")
}
api.TokenHeaderAuth = func(token string) (interface{}, error) {
return nil, errors.NotImplemented("api key auth (token_header) X-Token from header has not yet been implemented")
}
api.TasksAddCommentToTaskHandler = tasks.AddCommentToTaskHandlerFunc(func(params tasks.AddCommentToTaskParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation tasks.AddCommentToTask has not yet been implemented")
})
api.TasksCreateTaskHandler = tasks.CreateTaskHandlerFunc(func(params tasks.CreateTaskParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation tasks.CreateTask has not yet been implemented")
})
api.TasksDeleteTaskHandler = tasks.DeleteTaskHandlerFunc(func(params tasks.DeleteTaskParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation tasks.DeleteTask has not yet been implemented")
})
api.TasksGetTaskCommentsHandler = tasks.GetTaskCommentsHandlerFunc(func(params tasks.GetTaskCommentsParams) middleware.Responder {
return middleware.NotImplemented("operation tasks.GetTaskComments has not yet been implemented")
})
api.TasksGetTaskDetailsHandler = tasks.GetTaskDetailsHandlerFunc(func(params tasks.GetTaskDetailsParams) middleware.Responder {
return middleware.NotImplemented("operation tasks.GetTaskDetails has not yet been implemented")
})
api.TasksListTasksHandler = tasks.ListTasksHandlerFunc(func(params tasks.ListTasksParams) middleware.Responder {
return middleware.NotImplemented("operation tasks.ListTasks has not yet been implemented")
})
api.TasksUpdateTaskHandler = tasks.UpdateTaskHandlerFunc(func(params tasks.UpdateTaskParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation tasks.UpdateTask has not yet been implemented")
})
api.TasksUploadTaskFileHandler = tasks.UploadTaskFileHandlerFunc(func(params tasks.UploadTaskFileParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation tasks.UploadTaskFile has not yet been implemented")
})
api.ServerShutdown = func() {}
return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}
// New creates a new default runtime for a swagger api runtime.Client
func New(host, basePath string, schemes []string) *Runtime {
var rt Runtime
rt.DefaultMediaType = runtime.JSONMime
// TODO: actually infer this stuff from the spec
rt.Consumers = map[string]runtime.Consumer{
runtime.JSONMime: runtime.JSONConsumer(),
runtime.XMLMime: runtime.XMLConsumer(),
runtime.TextMime: runtime.TextConsumer(),
}
rt.Producers = map[string]runtime.Producer{
runtime.JSONMime: runtime.JSONProducer(),
runtime.XMLMime: runtime.XMLProducer(),
runtime.TextMime: runtime.TextProducer(),
}
rt.Transport = http.DefaultTransport
rt.Jar = nil
rt.Host = host
rt.BasePath = basePath
rt.Context = context.Background()
rt.clientOnce = new(sync.Once)
if !strings.HasPrefix(rt.BasePath, "/") {
rt.BasePath = "/" + rt.BasePath
}
rt.Debug = os.Getenv("DEBUG") == "1"
if len(schemes) > 0 {
rt.schemes = schemes
}
return &rt
}
func configureAPI(api *operations.TodoListAPI) http.Handler {
// configure the api here
api.ServeError = errors.ServeError
api.JSONConsumer = runtime.JSONConsumer()
api.JSONProducer = runtime.JSONProducer()
api.KeyAuth = func(token string) (interface{}, error) {
return nil, errors.NotImplemented("api key auth (key) x-petstore-token from header has not yet been implemented")
}
api.TodosAddOneHandler = todos.AddOneHandlerFunc(func(params todos.AddOneParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation todos.AddOne has not yet been implemented")
})
api.TodosDestroyOneHandler = todos.DestroyOneHandlerFunc(func(params todos.DestroyOneParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation todos.DestroyOne has not yet been implemented")
})
api.TodosFindHandler = todos.FindHandlerFunc(func(params todos.FindParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation todos.Find has not yet been implemented")
})
api.TodosUpdateOneHandler = todos.UpdateOneHandlerFunc(func(params todos.UpdateOneParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation todos.UpdateOne has not yet been implemented")
})
api.ServerShutdown = func() {}
return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}
// WithJSONDefaults loads the json defaults for this api
func (d *API) WithJSONDefaults() *API {
d.DefaultConsumes = runtime.JSONMime
d.DefaultProduces = runtime.JSONMime
d.consumers[runtime.JSONMime] = runtime.JSONConsumer()
d.producers[runtime.JSONMime] = runtime.JSONProducer()
return d
}
func configureAPI(api *operations.TodoListAPI) http.Handler {
// configure the api here
api.ServeError = errors.ServeError
api.JSONConsumer = runtime.JSONConsumer()
api.JSONProducer = runtime.JSONProducer()
api.TodosAddOneHandler = todos.AddOneHandlerFunc(func(params todos.AddOneParams) middleware.Responder {
return middleware.NotImplemented("operation todos.AddOne has not yet been implemented")
})
api.TodosDestroyOneHandler = todos.DestroyOneHandlerFunc(func(params todos.DestroyOneParams) middleware.Responder {
return middleware.NotImplemented("operation todos.DestroyOne has not yet been implemented")
})
api.TodosFindTodosHandler = todos.FindTodosHandlerFunc(func(params todos.FindTodosParams) middleware.Responder {
return middleware.NotImplemented("operation todos.FindTodos has not yet been implemented")
})
api.TodosUpdateOneHandler = todos.UpdateOneHandlerFunc(func(params todos.UpdateOneParams) middleware.Responder {
return middleware.NotImplemented("operation todos.UpdateOne has not yet been implemented")
})
api.ServerShutdown = func() {}
return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}
func configureAPI(api *operations.AttendListAPI) http.Handler {
// configure the api here
api.ServeError = errors.ServeError
api.JSONConsumer = httpkit.JSONConsumer()
api.JSONProducer = httpkit.JSONProducer()
api.EventsDeleteEventByIDHandler = events.DeleteEventByIDHandlerFunc(func(params events.DeleteEventByIDParams) middleware.Responder {
return middleware.NotImplemented("operation events.DeleteEventByID has not yet been implemented")
})
api.EventsGetEventByIDHandler = events.GetEventByIDHandlerFunc(func(params events.GetEventByIDParams) middleware.Responder {
return middleware.NotImplemented("operation events.GetEventByID has not yet been implemented")
})
api.EventsGetEventsHandler = events.GetEventsHandlerFunc(func() middleware.Responder {
return middleware.NotImplemented("operation events.GetEvents has not yet been implemented")
})
api.EventsPostEventHandler = events.PostEventHandlerFunc(func(params events.PostEventParams) middleware.Responder {
return middleware.NotImplemented("operation events.PostEvent has not yet been implemented")
})
api.EventsPutEventByIDHandler = events.PutEventByIDHandlerFunc(func(params events.PutEventByIDParams) middleware.Responder {
return middleware.NotImplemented("operation events.PutEventByID has not yet been implemented")
})
api.ServerShutdown = func() {}
return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}
func TestContentType_Issue264(t *testing.T) {
swspec, err := loads.Spec("../fixtures/bugs/264/swagger.yml")
if assert.NoError(t, err) {
api := untyped.NewAPI(swspec)
api.RegisterConsumer("application/json", runtime.JSONConsumer())
api.RegisterProducer("application/json", runtime.JSONProducer())
api.RegisterOperation("delete", "/key/{id}", new(stubOperationHandler))
handler := Serve(swspec, api)
request, _ := http.NewRequest("DELETE", "/key/1", nil)
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, request)
assert.Equal(t, 200, recorder.Code)
}
}
func configureAPI(api *operations.TodoListAPI) http.Handler {
// configure the api here
api.ServeError = errors.ServeError
api.JSONConsumer = httpkit.JSONConsumer()
api.JSONProducer = httpkit.JSONProducer()
api.TodosAddOneHandler = todos.AddOneHandlerFunc(func(params todos.AddOneParams) middleware.Responder {
if err := addItem(params.Body); err != nil {
return todos.NewAddOneDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
}
return todos.NewAddOneCreated().WithPayload(params.Body)
})
api.TodosDestroyOneHandler = todos.DestroyOneHandlerFunc(func(params todos.DestroyOneParams) middleware.Responder {
if err := deleteItem(params.ID); err != nil {
return todos.NewDestroyOneDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
}
return todos.NewDestroyOneNoContent()
})
api.TodosFindTodosHandler = todos.FindTodosHandlerFunc(func(params todos.FindTodosParams) middleware.Responder {
mergedParams := todos.NewFindTodosParams()
mergedParams.Since = swag.Int64(0)
if params.Since != nil {
mergedParams.Since = params.Since
}
if params.Limit != nil {
mergedParams.Limit = params.Limit
}
return todos.NewFindTodosOK().WithPayload(allItems(*mergedParams.Since, *mergedParams.Limit))
})
api.TodosUpdateOneHandler = todos.UpdateOneHandlerFunc(func(params todos.UpdateOneParams) middleware.Responder {
if err := updateItem(params.ID, params.Body); err != nil {
return todos.NewUpdateOneDefault(500).WithPayload(&models.Error{Code: 500, Message: swag.String(err.Error())})
}
return todos.NewUpdateOneOK().WithPayload(params.Body)
})
api.ServerShutdown = func() {}
return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}
// NewAPI creates the default untyped API
func NewAPI(spec *loads.Document) *API {
var an *analysis.Spec
if spec != nil && spec.Spec() != nil {
an = analysis.New(spec.Spec())
}
return &API{
spec: spec,
analyzer: an,
DefaultProduces: runtime.JSONMime,
DefaultConsumes: runtime.JSONMime,
consumers: map[string]runtime.Consumer{
runtime.JSONMime: runtime.JSONConsumer(),
},
producers: map[string]runtime.Producer{
runtime.JSONMime: runtime.JSONProducer(),
},
authenticators: make(map[string]runtime.Authenticator),
operations: make(map[string]map[string]runtime.OperationHandler),
ServeError: errors.ServeError,
Models: make(map[string]func() interface{}),
formats: strfmt.NewFormats(),
}
}
"encoding/json"
"encoding/xml"
"io/ioutil"
"mime"
"mime/multipart"
"os"
"path/filepath"
"testing"
"github.com/go-openapi/runtime"
"github.com/go-openapi/strfmt"
"github.com/stretchr/testify/assert"
)
var testProducers = map[string]runtime.Producer{
runtime.JSONMime: runtime.JSONProducer(),
runtime.XMLMime: runtime.XMLProducer(),
runtime.TextMime: runtime.TextProducer(),
}
func TestBuildRequest_SetHeaders(t *testing.T) {
r, _ := newRequest("GET", "/flats/{id}/", nil)
// single value
r.SetHeaderParam("X-Rate-Limit", "500")
assert.Equal(t, "500", r.header.Get("X-Rate-Limit"))
r.SetHeaderParam("X-Rate-Limit", "400")
assert.Equal(t, "400", r.header.Get("X-Rate-Limit"))
// multi value
r.SetHeaderParam("X-Accepts", "json", "xml", "yaml")
assert.EqualValues(t, []string{"json", "xml", "yaml"}, r.header["X-Accepts"])
// RegisterProducer registers a producer for a media type
func (d *API) RegisterProducer(mediaType string, handler runtime.Producer) {
if d.producers == nil {
d.producers = map[string]runtime.Producer{runtime.JSONMime: runtime.JSONProducer()}
}
d.producers[strings.ToLower(mediaType)] = handler
}
func configureAPI(api *operations.PetstoreAPI) http.Handler {
// configure the api here
api.ServeError = errors.ServeError
api.XMLConsumer = runtime.XMLConsumer()
api.UrlformConsumer = runtime.DiscardConsumer
api.JSONConsumer = runtime.JSONConsumer()
api.XMLProducer = runtime.XMLProducer()
api.JSONProducer = runtime.JSONProducer()
api.APIKeyAuth = func(token string) (interface{}, error) {
return nil, errors.NotImplemented("api key auth (api_key) api_key from header has not yet been implemented")
}
api.PetstoreAuthAuth = func(token string, scopes []string) (interface{}, error) {
return nil, errors.NotImplemented("oauth2 bearer auth (petstore_auth) has not yet been implemented")
}
api.PetAddPetHandler = pet.AddPetHandlerFunc(func(params pet.AddPetParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.AddPet has not yet been implemented")
})
api.UserCreateUserHandler = user.CreateUserHandlerFunc(func(params user.CreateUserParams) middleware.Responder {
return middleware.NotImplemented("operation user.CreateUser has not yet been implemented")
})
api.UserCreateUsersWithArrayInputHandler = user.CreateUsersWithArrayInputHandlerFunc(func(params user.CreateUsersWithArrayInputParams) middleware.Responder {
return middleware.NotImplemented("operation user.CreateUsersWithArrayInput has not yet been implemented")
})
api.UserCreateUsersWithListInputHandler = user.CreateUsersWithListInputHandlerFunc(func(params user.CreateUsersWithListInputParams) middleware.Responder {
return middleware.NotImplemented("operation user.CreateUsersWithListInput has not yet been implemented")
})
api.StoreDeleteOrderHandler = store.DeleteOrderHandlerFunc(func(params store.DeleteOrderParams) middleware.Responder {
return middleware.NotImplemented("operation store.DeleteOrder has not yet been implemented")
})
api.PetDeletePetHandler = pet.DeletePetHandlerFunc(func(params pet.DeletePetParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.DeletePet has not yet been implemented")
})
api.UserDeleteUserHandler = user.DeleteUserHandlerFunc(func(params user.DeleteUserParams) middleware.Responder {
return middleware.NotImplemented("operation user.DeleteUser has not yet been implemented")
})
api.PetFindPetsByStatusHandler = pet.FindPetsByStatusHandlerFunc(func(params pet.FindPetsByStatusParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.FindPetsByStatus has not yet been implemented")
})
api.PetFindPetsByTagsHandler = pet.FindPetsByTagsHandlerFunc(func(params pet.FindPetsByTagsParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.FindPetsByTags has not yet been implemented")
})
api.StoreGetOrderByIDHandler = store.GetOrderByIDHandlerFunc(func(params store.GetOrderByIDParams) middleware.Responder {
return middleware.NotImplemented("operation store.GetOrderByID has not yet been implemented")
})
api.PetGetPetByIDHandler = pet.GetPetByIDHandlerFunc(func(params pet.GetPetByIDParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.GetPetByID has not yet been implemented")
})
api.UserGetUserByNameHandler = user.GetUserByNameHandlerFunc(func(params user.GetUserByNameParams) middleware.Responder {
return middleware.NotImplemented("operation user.GetUserByName has not yet been implemented")
})
api.UserLoginUserHandler = user.LoginUserHandlerFunc(func(params user.LoginUserParams) middleware.Responder {
return middleware.NotImplemented("operation user.LoginUser has not yet been implemented")
})
api.UserLogoutUserHandler = user.LogoutUserHandlerFunc(func() middleware.Responder {
return middleware.NotImplemented("operation user.LogoutUser has not yet been implemented")
})
api.StorePlaceOrderHandler = store.PlaceOrderHandlerFunc(func(params store.PlaceOrderParams) middleware.Responder {
return middleware.NotImplemented("operation store.PlaceOrder has not yet been implemented")
})
api.PetUpdatePetHandler = pet.UpdatePetHandlerFunc(func(params pet.UpdatePetParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.UpdatePet has not yet been implemented")
})
api.PetUpdatePetWithFormHandler = pet.UpdatePetWithFormHandlerFunc(func(params pet.UpdatePetWithFormParams, principal interface{}) middleware.Responder {
return middleware.NotImplemented("operation pet.UpdatePetWithForm has not yet been implemented")
})
api.UserUpdateUserHandler = user.UpdateUserHandlerFunc(func(params user.UpdateUserParams) middleware.Responder {
return middleware.NotImplemented("operation user.UpdateUser has not yet been implemented")
})
api.ServerShutdown = func() {}
return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}
