func TestHandlerGetItem(t *testing.T) { s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Payload: map[string]interface{}{"id": "1"}}, {ID: "2", Payload: map[string]interface{}{"id": "2"}}, {ID: "3", Payload: map[string]interface{}{"id": "3"}}, }) index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, s, resource.DefaultConf) r, _ := http.NewRequest("GET", "/test/2", nil) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, } status, headers, body := itemGet(context.TODO(), r, rm) assert.Equal(t, http.StatusOK, status) assert.Nil(t, headers) if assert.IsType(t, body, &resource.Item{}) { i := body.(*resource.Item) assert.Equal(t, "2", i.ID) } }
func TestHandlerDeleteItemInvalidFilter(t *testing.T) { index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, nil, resource.DefaultConf) r, _ := http.NewRequest("DELETE", "/test/2", nil) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, Params: url.Values{ "filter": []string{"invalid"}, }, } status, headers, body := itemDelete(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Invalid `filter` parameter: must be valid JSON", err.Message) } }
func TestHandlerGetItemInvalidIfModifiedSince(t *testing.T) { s := mem.NewHandler() now := time.Now() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Updated: now, Payload: map[string]interface{}{"id": "1"}}, {ID: "2", Updated: now, Payload: map[string]interface{}{"id": "2"}}, {ID: "3", Updated: now, Payload: map[string]interface{}{"id": "3"}}, }) index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, s, resource.DefaultConf) r, _ := http.NewRequest("GET", "/test/2", nil) r.Header.Set("If-Modified-Since", "invalid date") rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, } status, headers, body := itemGet(context.TODO(), r, rm) assert.Equal(t, http.StatusBadRequest, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, http.StatusBadRequest, err.Code) assert.Equal(t, "Invalid If-Modified-Since header", err.Message) } }
func TestHandlerGetItemInvalidLookupSort(t *testing.T) { index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, nil, resource.DefaultConf) r, _ := http.NewRequest("GET", "/test", nil) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "1", Resource: test, }, }, Params: url.Values{ "sort": []string{"invalid"}, }, } status, headers, body := itemGet(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Invalid `sort` paramter: invalid sort field: invalid", err.Message) } }
func TestHandlerGetItemModifiedDontMatch(t *testing.T) { s := mem.NewHandler() now := time.Now() yesterday := now.Add(-24 * time.Hour) s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Updated: now, Payload: map[string]interface{}{"id": "1"}}, {ID: "2", Updated: now, Payload: map[string]interface{}{"id": "2"}}, {ID: "3", Updated: now, Payload: map[string]interface{}{"id": "3"}}, }) index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, s, resource.DefaultConf) r, _ := http.NewRequest("GET", "/test/2", nil) r.Header.Set("If-Modified-Since", yesterday.Format(time.RFC1123)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, } status, headers, body := itemGet(context.TODO(), r, rm) assert.Equal(t, http.StatusOK, status) assert.Nil(t, headers) if assert.IsType(t, body, &resource.Item{}) { i := body.(*resource.Item) assert.Equal(t, "2", i.ID) } }
func TestHandlerGetItemEtagMatch(t *testing.T) { s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", ETag: "a", Payload: map[string]interface{}{"id": "1"}}, {ID: "2", ETag: "a", Payload: map[string]interface{}{"id": "2"}}, {ID: "3", ETag: "a", Payload: map[string]interface{}{"id": "3"}}, }) index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, s, resource.DefaultConf) r, _ := http.NewRequest("GET", "/test/2", nil) r.Header.Set("If-None-Match", "a") rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, } status, headers, body := itemGet(context.TODO(), r, rm) assert.Equal(t, http.StatusNotModified, status) assert.Nil(t, headers) assert.Nil(t, body) }
func main() { index := resource.NewIndex() users := index.Bind("users", resource.New(models.UserSchema, mem.NewHandler(), resource.Conf{ AllowedModes: resource.ReadWrite, PaginationDefaultLimit: 50, })) models.SetAuthUserResource(users) index.Bind("auth", resource.New(models.AuthSchema, mem.NewHandler(), resource.Conf{ AllowedModes: []resource.Mode{resource.Create}, })) api, err := rest.NewHandler(index) if err != nil { log.Fatal(err) } http.Handle("/", api) if err := http.ListenAndServe(":8080", nil); err != nil { log.Fatal(err) } }
func TestHandlerDeleteItemEtag(t *testing.T) { s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", ETag: "a", Payload: map[string]interface{}{"id": "1"}}, }) index := resource.NewIndex() test := index.Bind("test", schema.Schema{ Fields: schema.Fields{"foo": {Filterable: true}}, }, s, resource.DefaultConf) r, _ := http.NewRequest("DELETE", "/test/2", nil) r.Header.Set("If-Match", "a") rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "1", Resource: test, }, }, } status, headers, body := itemDelete(context.TODO(), r, rm) assert.Equal(t, http.StatusNoContent, status) assert.Nil(t, headers) assert.Nil(t, body) l, err := s.Find(context.TODO(), resource.NewLookup(), 1, -1) assert.NoError(t, err) assert.Len(t, l.Items, 0) }
func TestHandlerPostListWithReferenceNoRouter(t *testing.T) { s := mem.NewHandler() index := resource.NewIndex() index.Bind("foo", schema.Schema{Fields: schema.Fields{"id": {}}}, s, resource.DefaultConf) bar := index.Bind("bar", schema.Schema{Fields: schema.Fields{ "id": {}, "foo": {Validator: &schema.Reference{Path: "foo"}}, }}, s, resource.DefaultConf) r, _ := http.NewRequest("POST", "/bar", bytes.NewBufferString(`{"id": "1", "foo": "nonexisting"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "bar", Resource: bar, }, }, } status, _, body := listPost(context.TODO(), r, rm) assert.Equal(t, http.StatusInternalServerError, status) if assert.IsType(t, &Error{}, body) { err := body.(*Error) assert.Equal(t, http.StatusInternalServerError, err.Code) assert.Equal(t, "Router not available in context", err.Message) } }
func TestNewHandler(t *testing.T) { i := resource.NewIndex() h, err := NewHandler(i) assert.NoError(t, err) assert.Equal(t, DefaultResponseSender{}, h.ResponseSender) assert.Equal(t, i, h.index) }
func TestHandlerPatchItemReplaceInvalidModifiedSinceDate(t *testing.T) { index := resource.NewIndex() s := mem.NewHandler() now := time.Now() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Updated: now, Payload: map[string]interface{}{"id": "1"}}, }) test := index.Bind("test", schema.Schema{Fields: schema.Fields{"id": {}}}, s, resource.DefaultConf) r, _ := http.NewRequest("PATCH", "/test/1", bytes.NewBufferString(`{"id": "1"}`)) r.Header.Set("If-Unmodified-Since", "invalid date") rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "1", Resource: test, }, }, } status, _, body := itemPatch(context.TODO(), r, rm) assert.Equal(t, http.StatusBadRequest, status) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, http.StatusBadRequest, err.Code) assert.Equal(t, "Invalid If-Unmodified-Since header", err.Message) } }
func TestHandlerPatchItemNoStorage(t *testing.T) { index := resource.NewIndex() test := index.Bind("test", schema.Schema{Fields: schema.Fields{"id": {}}}, nil, resource.Conf{ AllowedModes: []resource.Mode{resource.Replace}, }) r, _ := http.NewRequest("PATCH", "/test/1", bytes.NewBufferString(`{}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "1", Resource: test, }, }, } status, headers, body := itemPatch(context.TODO(), r, rm) assert.Equal(t, http.StatusNotImplemented, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, http.StatusNotImplemented, err.Code) assert.Equal(t, "No Storage Defined", err.Message) } }
func main() { // Create a REST API resource index index := resource.NewIndex() // Add a resource on /users[/:user_id] users := index.Bind("users", user, mem.NewHandler(), resource.Conf{ // We allow all REST methods // (rest.ReadWrite is a shortcut for []resource.Mode{resource.Create, resource.Read, resource.Update, resource.Delete, resource,List}) AllowedModes: resource.ReadWrite, }) // Bind a sub resource on /users/:user_id/posts[/:post_id] // and reference the user on each post using the "user" field of the posts resource. posts := users.Bind("posts", "user", post, mem.NewHandler(), resource.Conf{ // Posts can only be read, created and deleted, not updated AllowedModes: []resource.Mode{resource.Read, resource.List, resource.Create, resource.Delete}, }) // Add a friendly alias to public posts // (equivalent to /users/:user_id/posts?filter={"published":true}) posts.Alias("public", url.Values{"filter": []string{"{\"published\":true}"}}) // Create API HTTP handler for the resource graph api, err := rest.NewHandler(index) if err != nil { log.Fatalf("Invalid API configuration: %s", err) } c := alice.New() // Add close notifier handler so context is cancelled when the client closes // the connection // c.Append(xhandler.CloseHandler) // Add timeout handler // c.Append(xhandler.TimeoutHandler(2 * time.Second)) // Install a logger (see https://github.com/rs/xlog) c = c.Append(xlog.NewHandler(xlog.Config{})) resource.LoggerLevel = resource.LogLevelDebug resource.Logger = func(ctx context.Context, level resource.LogLevel, msg string, fields map[string]interface{}) { xlog.FromContext(ctx).OutputF(xlog.Level(level), 2, msg, fields) } // Log API access c = c.Append(xaccess.NewHandler()) // Add CORS support with passthrough option on so rest-layer can still // handle OPTIONS method c = c.Append(cors.New(cors.Options{OptionsPassthrough: true}).Handler) // Bind the API under /api/ path http.Handle("/api/", http.StripPrefix("/api/", c.Then(api))) // Serve it log.Print("Serving API on http://localhost:8080") if err := http.ListenAndServe(":8080", nil); err != nil { log.Fatal(err) } }
func TestHandlerPatchItemCannotChangeID(t *testing.T) { index := resource.NewIndex() s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Payload: map[string]interface{}{"id": "1"}}, }) test := index.Bind("test", schema.Schema{Fields: schema.Fields{"id": {}}}, s, resource.DefaultConf) r, _ := http.NewRequest("PATCH", "/test/1", bytes.NewBufferString(`{"id": "2"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "1", Resource: test, }, }, } status, headers, body := itemPatch(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Cannot change document ID", err.Message) } }
func Example() { session, err := mgo.Dial("") if err != nil { log.Fatalf("Can't connect to MongoDB: %s", err) } db := "test_rest_layer" index := resource.NewIndex() users := index.Bind("users", user, mongo.NewHandler(session, db, "users"), resource.Conf{ AllowedModes: resource.ReadWrite, }) users.Bind("posts", "user", post, mongo.NewHandler(session, db, "posts"), resource.Conf{ AllowedModes: resource.ReadWrite, }) api, err := rest.NewHandler(index) if err != nil { log.Fatalf("Invalid API configuration: %s", err) } http.Handle("/", cors.New(cors.Options{OptionsPassthrough: true}).Handler(api)) log.Print("Serving API on http://localhost:8080") if err := http.ListenAndServe(":8080", nil); err != nil { log.Fatal(err) } }
func TestHandlerPatchItemFound(t *testing.T) { index := resource.NewIndex() s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Payload: map[string]interface{}{"id": "1", "foo": "bar"}}, {ID: "2", Payload: map[string]interface{}{"id": "2", "foo": "bar"}}, {ID: "3", Payload: map[string]interface{}{"id": "3", "foo": "bar"}}, }) test := index.Bind("test", schema.Schema{Fields: schema.Fields{ "id": {}, "foo": {}, }}, s, resource.DefaultConf) r, _ := http.NewRequest("PATCH", "/test/2", bytes.NewBufferString(`{"id": "2", "foo": "baz"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, } status, headers, body := itemPatch(context.TODO(), r, rm) assert.Equal(t, http.StatusOK, status) assert.Nil(t, headers) if assert.IsType(t, body, &resource.Item{}) { i := body.(*resource.Item) assert.Equal(t, "2", i.ID) assert.Equal(t, map[string]interface{}{"id": "2", "foo": "baz"}, i.Payload) } }
func TestHandlerPostListWithReference(t *testing.T) { s := mem.NewHandler() s.Insert(context.Background(), []*resource.Item{{ID: "ref", Payload: map[string]interface{}{"id": "ref"}}}) index := resource.NewIndex() index.Bind("foo", schema.Schema{Fields: schema.Fields{"id": {}}}, s, resource.DefaultConf) bar := index.Bind("bar", schema.Schema{Fields: schema.Fields{ "id": {}, "foo": {Validator: &schema.Reference{Path: "foo"}}, }}, s, resource.DefaultConf) r, _ := http.NewRequest("POST", "/bar", bytes.NewBufferString(`{"id": "1", "foo": "ref"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "bar", Resource: bar, }, }, } ctx := contextWithIndex(context.Background(), index) status, _, body := listPost(ctx, r, rm) assert.Equal(t, http.StatusCreated, status) if assert.IsType(t, &resource.Item{}, body) { item := body.(*resource.Item) assert.Equal(t, "1", item.ID) } }
func TestHandlerPostListWithSubSchemaReferenceNotFound(t *testing.T) { s := mem.NewHandler() s.Insert(context.Background(), []*resource.Item{{ID: "ref", Payload: map[string]interface{}{"id": "ref"}}}) index := resource.NewIndex() index.Bind("foo", schema.Schema{Fields: schema.Fields{"id": {}}}, s, resource.DefaultConf) bar := index.Bind("bar", schema.Schema{Fields: schema.Fields{ "id": {}, "sub": { Schema: &schema.Schema{ Fields: schema.Fields{ "foo": {Validator: &schema.Reference{Path: "foo"}}, }, }, }, }}, s, resource.DefaultConf) r, _ := http.NewRequest("POST", "/bar", bytes.NewBufferString(`{"id": "1", "sub": {"foo": "notfound"}}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "bar", Resource: bar, }, }, } ctx := contextWithIndex(context.Background(), index) status, _, body := listPost(ctx, r, rm) assert.Equal(t, http.StatusNotFound, status) if assert.IsType(t, &Error{}, body) { err := body.(*Error) assert.Equal(t, http.StatusNotFound, err.Code) assert.Equal(t, "Resource reference not found for field `foo'", err.Message) } }
func TestHandlerGetListInvalidPage(t *testing.T) { index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, nil, resource.DefaultConf) r, _ := http.NewRequest("GET", "/test", nil) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Resource: test, }, }, Params: url.Values{ "page": []string{"invalid"}, }, } status, headers, body := listGet(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Invalid `page` parameter", err.Message) } rm.Params.Set("page", "-1") status, headers, body = listGet(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Invalid `page` parameter", err.Message) } }
func TestHandlerPostListWithReferenceOtherError(t *testing.T) { s := mem.NewHandler() index := resource.NewIndex() index.Bind("foo", schema.Schema{Fields: schema.Fields{"id": {}}}, nil, resource.DefaultConf) bar := index.Bind("bar", schema.Schema{Fields: schema.Fields{ "id": {}, "foo": {Validator: &schema.Reference{Path: "foo"}}, }}, s, resource.DefaultConf) r, _ := http.NewRequest("POST", "/bar", bytes.NewBufferString(`{"id": "1", "foo": "1"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "bar", Resource: bar, }, }, } ctx := contextWithIndex(context.Background(), index) status, _, body := listPost(ctx, r, rm) assert.Equal(t, http.StatusInternalServerError, status) if assert.IsType(t, &Error{}, body) { err := body.(*Error) assert.Equal(t, http.StatusInternalServerError, err.Code) assert.Equal(t, "Error fetching resource reference for field `foo': No Storage Defined", err.Message) } }
func TestHandlerPostListNew(t *testing.T) { index := resource.NewIndex() s := mem.NewHandler() test := index.Bind("test", schema.Schema{Fields: schema.Fields{ "id": {}, "foo": {}, }}, s, resource.DefaultConf) r, _ := http.NewRequest("POST", "/test", bytes.NewBufferString(`{"id": "2", "foo": "baz"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Resource: test, }, }, } status, headers, body := listPost(context.TODO(), r, rm) assert.Equal(t, http.StatusCreated, status) assert.Equal(t, http.Header{"Content-Location": []string{"/test/2"}}, headers) if assert.IsType(t, body, &resource.Item{}) { i := body.(*resource.Item) assert.Equal(t, "2", i.ID) assert.Equal(t, map[string]interface{}{"id": "2", "foo": "baz"}, i.Payload) } }
func TestHandlerPutItemReplaceModeNotAllowed(t *testing.T) { index := resource.NewIndex() s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Payload: map[string]interface{}{"id": "1"}}, }) test := index.Bind("test", schema.Schema{Fields: schema.Fields{"id": {}}}, s, resource.Conf{ AllowedModes: []resource.Mode{resource.Create}, }) r, _ := http.NewRequest("PUT", "/test/1", bytes.NewBufferString(`{}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "1", Resource: test, }, }, } status, headers, body := itemPut(context.TODO(), r, rm) assert.Equal(t, http.StatusMethodNotAllowed, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, http.StatusMethodNotAllowed, err.Code) assert.Equal(t, "Invalid method", err.Message) } }
func TestHandlerPutItemInvalidField(t *testing.T) { index := resource.NewIndex() test := index.Bind("test", schema.Schema{Fields: schema.Fields{"id": {}}}, mem.NewHandler(), resource.DefaultConf) r, _ := http.NewRequest("PUT", "/test/2", bytes.NewBufferString(`{"foo": "baz"}`)) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, } status, headers, body := itemPut(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Document contains error(s)", err.Message) assert.Equal(t, map[string][]interface{}{ "foo": []interface{}{"invalid field"}}, err.Issues) } }
func TestHandlerPatchItemInvalidLookupFields(t *testing.T) { index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, nil, resource.DefaultConf) r, _ := http.NewRequest("PATCH", "/test/2", bytes.NewBufferString("{}")) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Field: "id", Value: "2", Resource: test, }, }, Params: url.Values{ "fields": []string{"invalid"}, }, } status, headers, body := itemPatch(context.TODO(), r, rm) assert.Equal(t, 422, status) assert.Nil(t, headers) if assert.IsType(t, body, &Error{}) { err := body.(*Error) assert.Equal(t, 422, err.Code) assert.Equal(t, "Invalid `fields` paramter: invalid: unknown field", err.Message) } }
func TestHandlerDeleteList(t *testing.T) { s := mem.NewHandler() s.Insert(context.TODO(), []*resource.Item{ {ID: "1", Payload: map[string]interface{}{}}, {ID: "2", Payload: map[string]interface{}{}}, {ID: "3", Payload: map[string]interface{}{}}, {ID: "4", Payload: map[string]interface{}{}}, {ID: "5", Payload: map[string]interface{}{}}, }) index := resource.NewIndex() test := index.Bind("test", schema.Schema{}, s, resource.DefaultConf) r, _ := http.NewRequest("DELETE", "/test", bytes.NewBufferString("{}")) rm := &RouteMatch{ ResourcePath: []*ResourcePathComponent{ &ResourcePathComponent{ Name: "test", Resource: test, }, }, } status, headers, body := listDelete(context.TODO(), r, rm) assert.Equal(t, http.StatusNoContent, status) assert.Equal(t, http.Header{"X-Total": []string{"5"}}, headers) assert.Nil(t, body) l, err := s.Find(context.TODO(), resource.NewLookup(), 1, -1) assert.NoError(t, err) assert.Len(t, l.Items, 0) }
func TestHandlerServeHTTPNotFound(t *testing.T) { h, _ := NewHandler(resource.NewIndex()) w := httptest.NewRecorder() r, _ := http.NewRequest("GET", "/", nil) h.ServeHTTP(w, r) assert.Equal(t, 404, w.Code) b, _ := ioutil.ReadAll(w.Body) assert.Equal(t, "{\"code\":404,\"message\":\"Resource Not Found\"}", string(b)) }
func TestHandlerServeHTTPNotFound(t *testing.T) { h, _ := NewHandler(resource.NewIndex()) w := newRecorder() defer w.Close() u, _ := url.ParseRequestURI("/") h.ServeHTTP(w, &http.Request{Method: "GET", URL: u}) assert.Equal(t, 404, w.Code) b, _ := ioutil.ReadAll(w.Body) assert.Equal(t, "{\"code\":404,\"message\":\"Resource Not Found\"}", string(b)) }
func TestHandlerServeHTTPInvalidTimeout(t *testing.T) { h, _ := NewHandler(resource.NewIndex()) w := newRecorder() defer w.Close() u, _ := url.ParseRequestURI("/?timeout=invalid") h.ServeHTTP(w, &http.Request{Method: "GET", URL: u}) assert.Equal(t, 422, w.Code) b, _ := ioutil.ReadAll(w.Body) assert.Equal(t, "{\"code\":422,\"message\":\"Cannot parse timeout parameter: time: invalid duration invalid\"}", string(b)) }
func TestHandlerGetContext(t *testing.T) { var c context.Context var err *Error h, _ := NewHandler(resource.NewIndex()) w := newRecorder() defer w.Close() c, err = h.getContext(w, &http.Request{URL: &url.URL{}}) assert.Nil(t, err) _, ok := c.Deadline() assert.False(t, ok) }
func TestHandlerServeHTTPGetNotFoundItem(t *testing.T) { i := resource.NewIndex() i.Bind("foo", schema.Schema{}, mem.NewHandler(), resource.DefaultConf) h, _ := NewHandler(i) w := httptest.NewRecorder() r, _ := http.NewRequest("GET", "/foo/1", nil) h.ServeHTTP(w, r) assert.Equal(t, 404, w.Code) b, _ := ioutil.ReadAll(w.Body) assert.Equal(t, "{\"code\":404,\"message\":\"Not Found\"}", string(b)) }