added multiple responses per endpoint

Author: schigh

README.md

@@ -1,5 +1,4 @@
 [![Build Status](https://travis-ci.org/schigh/fony.svg?branch=master)](https://travis-ci.org/schigh/fony)
-
 [![Go Report Card](https://goreportcard.com/badge/github.com/schigh/fony)](https://goreportcard.com/report/github.com/schigh/fony)
 
 # fony
@@ -17,46 +16,44 @@ Create a json file with a list of your endpoints like so:
     {
       "url": "/foo/bar",
       "verb": "GET",
-      "response_payload": {
-        "foo": "bar",
-        "fizz": "buzz"
-      },
-      "response_code": 200
-    },
-    {
-      "url": "/herp/derp",
-      "verb": "POST",
-      "response_payload": [
+      "responses": [
+        {
+          "headers": {
+            "X-Herp": "DDDERP"
+          },
+          "payload": {
+            "foo": "bar",
+            "fizz": "buzz"
+          },
+          "status_code": 200
+        },
         {
-          "duck": 1,
-          "cow": true,
-          "pig": null
+          "headers": {
+            "X-Herp": "HHHERP"
+          },
+          "payload": {
+            "foo": "bark",
+            "fizz": "moo"
+          },
+          "status_code": 201
         }
-      ],
-      "response_code": 200
-    },
-    {
-      "url": "/i/am/a/teapot",
-      "verb": "GET",
-      "response_payload": {},
-      "response_code": 418
+      ]
     }
   ]
 }
 ```
 
+For each endpoint, the url and verb are required.  There must also be at least one response per endpoint as well.
+
+If you have multiple responses for the same endpoint, you can specify which one to return in the headers of your request.  To do this, set a header called `X-Fony-Index` to the index of the response you wish to return. If you pass an index out of range, the response at index `0` will be returned.
+
 Use `docker-compose` to run the `fony` command.  Be sure to set the `GOBIN` environment variable to `/go/bin`.
 See the `docker-compose.yml` file in this repository for an example.
 
 ## Things that need done
 - All the tests
 
-## Known bugs
-Headers are not parsing properly at the moment
-
-## Future enhancements
-Right now there can only be one call per endpoint/http verb combo.
-We need to be able to allow multiple responses for each endpoint/http verb.
-
-One proposed solution would be push a list of response payloads to the endpoint, and return them sequentially.
-I will revisit this if the need arises.
+## Caveats
+This project is meant to run in a Docker container.  The necessary go dependencies will be installed when the Dockerfile is built.  If you want to run this program locally, you will need to install the following dependencies via `go get`:
+- `github.com/sirupsen/logrus`
+- `goji.io`

fony.go

@@ -8,31 +8,40 @@ import (
 	"net/http"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	log "github.com/sirupsen/logrus"
 	"goji.io"
 	"goji.io/pat"
 )
 
-// PhonyEndpoint represents a single endpoint served by fony
-type PhonyEndpoint struct {
-	URL             string            `json:"url"`
-	Verb            string            `json:"verb"`
-	ResponseHeaders map[string]string `json:"response_headers"`
-	ResponsePayload interface{}       `json:"response_payload"`
-	ResponseCode    int               `json:"response_code"`
+// FonyResponse contains the data returned in a specific response
+type FonyResponse struct {
+	Headers    map[string]string `json:"headers"`
+	Payload    interface{}       `json:"payload"`
+	StatusCode int               `json:"status_code"`
 }
 
-// PhonySuite encloses the suite of endpoints served by fony
-type PhonySuite struct {
+// FonyEndpoint represents a single endpoint served by fony
+type FonyEndpoint struct {
+	URL       string         `json:"url"`
+	Verb      string         `json:"verb"`
+	Responses []FonyResponse `json:"responses"`
+}
+
+// FonySuite encloses the suite of endpoints served by fony
+type FonySuite struct {
 	GlobalHeaders map[string]string `json:"global_headers"`
-	Endpoints     []*PhonyEndpoint  `json:"endpoints"`
+	Endpoints     []FonyEndpoint    `json:"endpoints"`
 }
 
 // patFunction is an alias to pat http verb functions
 type patFunction func(url string) *pat.Pattern
 
+// FonyPayloadIndexHeader is the index of the payload we wish to see for a given endpoint
+const FonyPayloadIndexHeader = "X-Fony-Index"
+
 var (
 	suiteFile string
 )
@@ -41,7 +50,8 @@ func init() {
 	flag.StringVar(&suiteFile, "f", "./suite.json", "Absolute path to the fony suite file")
 }
 
-func setup() (*PhonySuite, bool) {
+// setup prepares the suite for service
+func setup() (*FonySuite, bool) {
 	flag.Parse()
 
 	fileInfo, err := os.Stat(suiteFile)
@@ -60,7 +70,7 @@ func setup() (*PhonySuite, bool) {
 		return nil, false
 	}
 
-	suite := &PhonySuite{}
+	suite := &FonySuite{}
 	ext := filepath.Ext(suiteFile)
 	switch ext {
 	case ".json":
@@ -76,19 +86,8 @@ func setup() (*PhonySuite, bool) {
 	return suite, true
 }
 
-func register(suite *PhonySuite) (*goji.Mux, bool) {
-	mux := goji.NewMux()
-	for _, ep := range suite.Endpoints {
-		if err := processEndpoint(ep, mux, suite.GlobalHeaders); err != nil {
-			log.Errorf("Error registering endpoint %s: %+v", ep.URL, err)
-			return nil, false
-		}
-	}
-
-	return mux, true
-}
-
-func getPatFunction(ep *PhonyEndpoint) (patFunction, error) {
+// getPatFunction will get the appropriate pat function based on HTTP verb
+func getPatFunction(ep FonyEndpoint) (patFunction, error) {
 	verb := strings.ToUpper(ep.Verb)
 	switch verb {
 	case "GET":
@@ -110,34 +109,90 @@ func getPatFunction(ep *PhonyEndpoint) (patFunction, error) {
 	return nil, fmt.Errorf("unknown HTTP method: %s", verb)
 }
 
-func processEndpoint(ep *PhonyEndpoint, mux *goji.Mux, globals map[string]string) error {
+func errOut(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "text/plain")
+	w.WriteHeader(500)
+	w.Write([]byte("Fony failed to process this endpoint.  Check your logs to find the root cause"))
+}
+
+// processEndpoint will set each endpoint and handler in the muxxer
+func processEndpoint(ep FonyEndpoint, mux *goji.Mux, globals map[string]string) error {
 	f, err := getPatFunction(ep)
 	if err != nil {
 		return err
 	}
 
 	mux.HandleFunc(f(ep.URL), func(w http.ResponseWriter, r *http.Request) {
+		// by default, all responses return this header.  It can be overwritten in the global
+		// headers or the endpoint-specific header
 		w.Header().Set("Content-Type", "application/json")
 		for k := range globals {
 			w.Header().Set(k, globals[k])
 		}
-		for k := range ep.ResponseHeaders {
-			w.Header().Set(k, ep.ResponseHeaders[k])
+
+		// get the index header if set
+		var index uint64
+		indexHeader := r.Header.Get(FonyPayloadIndexHeader)
+		if indexHeader != "" {
+			index, err = strconv.ParseUint(indexHeader, 10, 8)
+			if err != nil {
+				log.Errorf("header index parse error: %+v", err)
+				errOut(w)
+				return
+			}
 		}
 
-		data, err := json.Marshal(ep.ResponsePayload)
-		if err != nil {
-			log.Errorf("Payload marshal error: %+v", err)
+		var response *FonyResponse
+		numResponses := len(ep.Responses)
+
+		if numResponses > int(index) {
+			response = &ep.Responses[index]
+		} else if numResponses > 0 {
+			response = &ep.Responses[0]
+		} else {
+			// there must be at least one response
+			log.Error("There must be at least one response per endpoint")
+			errOut(w)
 			return
 		}
 
-		w.WriteHeader(ep.ResponseCode)
+		// specific endpoint headers will override globals if set
+		for k := range response.Headers {
+			w.Header().Set(k, response.Headers[k])
+		}
+
+		var data []byte
+		if response.Payload != nil {
+			data, err = json.Marshal(response.Payload)
+			if err != nil {
+				log.Errorf("payload marshal error: %+v", err)
+				return
+			}
+		}
+
+		if response.StatusCode == 0 {
+			response.StatusCode = 200
+		}
+		w.WriteHeader(response.StatusCode)
 		w.Write(data)
 	})
 
 	return nil
 }
 
+// register will register each endpoint in the muxxer
+func register(suite *FonySuite) (*goji.Mux, bool) {
+	mux := goji.NewMux()
+	for _, ep := range suite.Endpoints {
+		if err := processEndpoint(ep, mux, suite.GlobalHeaders); err != nil {
+			log.Errorf("Error registering endpoint %s: %+v", ep.URL, err)
+			return nil, false
+		}
+	}
+
+	return mux, true
+}
+
 func main() {
 	suite, ok := setup()
 	if !ok {

sample/sample.json

@@ -6,29 +6,57 @@
     {
       "url": "/foo/bar",
       "verb": "GET",
-      "response_payload": {
-        "foo": "bar",
-        "fizz": "buzz"
-      },
-      "response_code": 200
+      "responses": [
+        {
+          "headers": {
+            "X-Herp": "DDDERP"
+          },
+          "payload": {
+            "foo": "bar",
+            "fizz": "buzz"
+          },
+          "status_code": 200
+        },
+        {
+          "headers": {
+            "X-Herp": "HHHERP"
+          },
+          "payload": {
+            "foo": "bark",
+            "fizz": "moo"
+          },
+          "status_code": 201
+        }
+      ]
     },
     {
       "url": "/herp/derp",
       "verb": "POST",
-      "response_payload": [
+      "responses": [
         {
-          "duck": 1,
-          "cow": true,
-          "pig": null
+          "headers": {
+            "X-Fony": "override"
+          },
+          "payload": [
+            {
+              "duck": 1,
+              "cow": true,
+              "pig": null
+            }
+          ],
+          "status_code": 200
         }
-      ],
-      "response_code": 200
+      ]
     },
     {
       "url": "/i/am/a/teapot",
       "verb": "GET",
-      "response_payload": {},
-      "response_code": 418
+      "responses": [
+        {
+          "payload": null,
+          "status_code": 418
+        }
+      ]
     }
   ]
 }