increase test coverage

Author: wwwdata

api.go

@@ -702,7 +702,7 @@ func (res *resource) handleReplaceRelation(c APIContexter, w http.ResponseWriter
 		editObj = response.Result()
 	}
 
-	err = jsonapi.UnmarshalRelationshipsData(editObj, relation.Name, data)
+	err = processRelationshipsData(data, relation.Name, editObj)
 	if err != nil {
 		return err
 	}
@@ -1101,3 +1101,57 @@ func handleError(err error, w http.ResponseWriter, r *http.Request, marshalers m
 
 	writeResult(w, []byte(marshaler.MarshalError(err)), http.StatusInternalServerError, contentType)
 }
+
+func processRelationshipsData(data interface{}, linkName string, target interface{}) error {
+	hasOne, ok := data.(map[string]interface{})
+	if ok {
+		hasOneID, ok := hasOne["id"].(string)
+		if !ok {
+			return fmt.Errorf("data object must have a field id for %s", linkName)
+		}
+
+		target, ok := target.(jsonapi.UnmarshalToOneRelations)
+		if !ok {
+			return errors.New("target struct must implement interface UnmarshalToOneRelations")
+		}
+
+		target.SetToOneReferenceID(linkName, hasOneID)
+	} else if data == nil {
+		// this means that a to-one relationship must be deleted
+		target, ok := target.(jsonapi.UnmarshalToOneRelations)
+		if !ok {
+			return errors.New("target struct must implement interface UnmarshalToOneRelations")
+		}
+
+		target.SetToOneReferenceID(linkName, "")
+	} else {
+		hasMany, ok := data.([]interface{})
+		if !ok {
+			return fmt.Errorf("invalid data object or array, must be an object with \"id\" and \"type\" field for %s", linkName)
+		}
+
+		target, ok := target.(jsonapi.UnmarshalToManyRelations)
+		if !ok {
+			return errors.New("target struct must implement interface UnmarshalToManyRelations")
+		}
+
+		hasManyIDs := []string{}
+
+		for _, entry := range hasMany {
+			data, ok := entry.(map[string]interface{})
+			if !ok {
+				return fmt.Errorf("entry in data array must be an object for %s", linkName)
+			}
+			dataID, ok := data["id"].(string)
+			if !ok {
+				return fmt.Errorf("all data objects must have a field id for %s", linkName)
+			}
+
+			hasManyIDs = append(hasManyIDs, dataID)
+		}
+
+		target.SetToManyReferenceIDs(linkName, hasManyIDs)
+	}
+
+	return nil
+}

api_public.go

@@ -59,23 +59,6 @@ func (api *API) UseMiddleware(middleware ...HandlerFunc) {
 	api.middlewares = append(api.middlewares, middleware...)
 }
 
-// SetRedirectTrailingSlash enables 307 redirects on urls ending with /
-// when disabled, an URL ending with / will 404
-// this will and should work only if using the default router
-// DEPRECATED
-func (api *API) SetRedirectTrailingSlash(enabled bool) {
-	if api.router == nil {
-		panic("router must not be nil")
-	}
-
-	httpRouter, ok := api.router.(*routing.HTTPRouter)
-	if !ok {
-		panic("can not set redirectTrailingSlashes if not using the internal httpRouter")
-	}
-
-	httpRouter.SetRedirectTrailingSlash(enabled)
-}
-
 // NewAPIWithMarshalling does the same as NewAPIWithBaseURL with the addition
 // of a set of marshalers that provide a way to interact with clients that
 // use a serialization format other than JSON. The marshalers map is indexed

api_test.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/manyminds/api2go/jsonapi"
+	"github.com/manyminds/api2go/routing"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"gopkg.in/guregu/null.v2"
@@ -620,6 +621,10 @@ var _ = Describe("RestHandler", func() {
 			rec = httptest.NewRecorder()
 		})
 
+		It("Router() returns a HTTPRouter instance", func() {
+			Expect(api.Router()).To(BeAssignableToTypeOf(&routing.HTTPRouter{}))
+		})
+
 		It("GETs collections", func() {
 			req, err := http.NewRequest("GET", "/v1/posts", nil)
 			Expect(err).To(BeNil())
@@ -758,7 +763,8 @@ var _ = Describe("RestHandler", func() {
 			reqBody := strings.NewReader(`{"data": [{"title": "New Post", "type": "posts"}]}`)
 			req, err := http.NewRequest("POST", "/v1/posts/", reqBody)
 			Expect(err).To(BeNil())
-			api.SetRedirectTrailingSlash(true)
+			router := api.Router().(*routing.HTTPRouter)
+			router.SetRedirectTrailingSlash(true)
 			api.Handler().ServeHTTP(rec, req)
 			Expect(rec.Code).To(Equal(http.StatusTemporaryRedirect))
 		})
@@ -775,7 +781,8 @@ var _ = Describe("RestHandler", func() {
 			reqBody := strings.NewReader(`{"data": [{"title": "New Post", "type": "posts"}]}`)
 			req, err := http.NewRequest("POST", "/v1/posts/", reqBody)
 			Expect(err).To(BeNil())
-			api.SetRedirectTrailingSlash(false)
+			router := api.Router().(*routing.HTTPRouter)
+			router.SetRedirectTrailingSlash(false)
 			api.Handler().ServeHTTP(rec, req)
 			Expect(rec.Code).To(Equal(http.StatusNotFound))
 		})

context.go

@@ -1,8 +1,9 @@
 package api2go
 
 import (
-	"golang.org/x/net/context"
 	"time"
+
+	"golang.org/x/net/context"
 )
 
 // APIContextAllocatorFunc to allow custom context implementations
@@ -72,7 +73,7 @@ var _ APIContexter = &APIContext{}
 // ContextQueryParams fetches the QueryParams if Set
 func ContextQueryParams(c *APIContext) map[string][]string {
 	qp, ok := c.Get("QueryParams")
-	if ok == true {
+	if ok == false {
 		qp = make(map[string][]string)
 		c.Set("QueryParams", qp)
 	}

context_test.go

@@ -1,14 +1,20 @@
 package api2go
 
 import (
+	"time"
+
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
 var _ = Describe("Context", func() {
-	Context("Set", func() {
-		c := &APIContext{}
+	var c *APIContext
+
+	BeforeEach(func() {
+		c = &APIContext{}
+	})
 
+	Context("Set", func() {
 		It("sets key", func() {
 			c.Set("test", 1)
 			_, ok := c.keys["test"]
@@ -17,28 +23,76 @@ var _ = Describe("Context", func() {
 	})
 
 	Context("Get", func() {
-		c := &APIContext{}
-		c.Set("test", 2)
+		BeforeEach(func() {
+			c.Set("test", 2)
+		})
 
 		It("gets key", func() {
 			key, ok := c.Get("test")
 			Expect(ok).To(BeTrue())
 			Expect(key.(int)).To(Equal(2))
 		})
+
 		It("not okay if key does not exist", func() {
 			key, ok := c.Get("nope")
 			Expect(ok).To(BeFalse())
 			Expect(key).To(BeNil())
 		})
 	})
+
 	Context("Reset", func() {
-		c := &APIContext{}
-		c.Set("test", 3)
+		BeforeEach(func() {
+			c.Set("test", 3)
+		})
 
 		It("reset removes keys", func() {
 			c.Reset()
 			_, ok := c.Get("test")
 			Expect(ok).To(BeFalse())
 		})
 	})
+
+	Context("Not yet implemented", func() {
+		It("Deadline", func() {
+			deadline, ok := c.Deadline()
+			Expect(deadline).To(Equal(time.Time{}))
+			Expect(ok).To(Equal(false))
+		})
+
+		It("Done", func() {
+			var chanel <-chan struct{}
+			Expect(c.Done()).To(Equal(chanel))
+		})
+
+		It("Err", func() {
+			Expect(c.Err()).To(BeNil())
+		})
+	})
+
+	Context("Value", func() {
+		It("Value returns a set value", func() {
+			c.Set("foo", "bar")
+			Expect(c.Value("foo")).To(Equal("bar"))
+		})
+
+		It("Returns nil if key was not a string", func() {
+			Expect(c.Value(1337)).To(BeNil())
+		})
+
+	})
+
+	Context("ContextQueryParams", func() {
+		It("returns them if set", func() {
+			queryParams := map[string][]string{
+				"foo": {"bar"},
+			}
+
+			c.Set("QueryParams", queryParams)
+			Expect(ContextQueryParams(c)).To(Equal(queryParams))
+		})
+
+		It("sets empty ones if not set", func() {
+			Expect(ContextQueryParams(c)).To(Equal(map[string][]string{}))
+		})
+	})
 })

error.go

@@ -29,11 +29,6 @@ type Error struct {
 	Meta   interface{}  `json:"meta,omitempty"`
 }
 
-// GetID returns the ID
-func (e Error) GetID() string {
-	return e.ID
-}
-
 // ErrorLinks is used to provide an About URL that leads to
 // further details about the particular occurrence of the problem.
 //

error_test.go

@@ -2,11 +2,25 @@ package api2go
 
 import (
 	"errors"
+	"net/http"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
+type ErrorMarshaler struct{}
+
+func (e ErrorMarshaler) Marshal(i interface{}) ([]byte, error) {
+	return []byte{}, errors.New("this will always fail")
+}
+func (e ErrorMarshaler) Unmarshal(data []byte, i interface{}) error {
+	return nil
+}
+
+func (e ErrorMarshaler) MarshalError(error) string {
+	return ""
+}
+
 var _ = Describe("Errors test", func() {
 	Context("validate error logic", func() {
 		It("can create array tree", func() {
@@ -85,5 +99,13 @@ var _ = Describe("Errors test", func() {
 			expected := `{"errors":[{"id":"001","status":"500","code":"001","title":"Title must not be empty","detail":"Never occures in real life","meta":{"creator":"api2go"}}]}`
 			Expect(result).To(Equal(expected))
 		})
+
+		It("logs a Marshal error and returns an empty json array", func() {
+			Expect(
+				marshalHTTPError(
+					NewHTTPError(nil, "test", http.StatusInternalServerError),
+					ErrorMarshaler{}),
+			).To(Equal("{}"))
+		})
 	})
 })

jsonapi/data_structs_test.go

@@ -98,6 +98,31 @@ var _ = Describe("JSONAPI Struct tests", func() {
 		})
 	})
 
+	It("return an error for invalid relationship data format", func() {
+		sampleJSON := `
+		{
+			"data": [
+			{
+				"type": "test",
+				"id": "1",
+				"attributes": {"foo": "bar"},
+				"relationships": {
+					"comments": {
+						"data": "foo"
+					}
+				}
+			}
+			]
+		}
+		`
+
+		target := Document{}
+
+		err := json.Unmarshal([]byte(sampleJSON), &target)
+		Expect(err).To(HaveOccurred())
+		Expect(err.Error()).To(Equal("Invalid json for relationship data array/object"))
+	})
+
 	It("creates an empty slice for empty to-many relationships and nil for empty toOne", func() {
 		sampleJSON := `
 			{

jsonapi/fixtures_test.go

@@ -421,3 +421,39 @@ func (i PrefixServerInformation) GetBaseURL() string {
 func (i PrefixServerInformation) GetPrefix() string {
 	return prefix
 }
+
+type NoRelationshipPosts struct{}
+
+func (n NoRelationshipPosts) GetID() string {
+	return "someID"
+}
+
+func (n *NoRelationshipPosts) SetID(ID string) error {
+	return nil
+}
+
+func (n NoRelationshipPosts) GetName() string {
+	return "posts"
+}
+
+type ErrorRelationshipPosts struct{}
+
+func (e ErrorRelationshipPosts) GetID() string {
+	return "errorID"
+}
+
+func (e *ErrorRelationshipPosts) SetID(ID string) error {
+	return nil
+}
+
+func (e ErrorRelationshipPosts) GetName() string {
+	return "posts"
+}
+
+func (e ErrorRelationshipPosts) SetToOneReferenceID(name, ID string) error {
+	return errors.New("this never works")
+}
+
+func (e ErrorRelationshipPosts) SetToManyReferenceIDs(name string, IDs []string) error {
+	return errors.New("this also never works")
+}

jsonapi/helpers_test.go

@@ -12,5 +12,15 @@ var _ = Describe("StringHelpers", func() {
 			Expect(Pluralize("posts")).To(Equal("posts"))
 			Expect(Pluralize("category")).To(Equal("categories"))
 		})
+
+		Context("Jsonify", func() {
+			It("handles empty strings", func() {
+				Expect(Jsonify("")).To(Equal(""))
+			})
+
+			It("uses common initialisms", func() {
+				Expect(Jsonify("RAM")).To(Equal("ram"))
+			})
+		})
 	})
 })