feat(Responsefile): implement Responsefile for multiple responses

Author: jamescun

README.md

@@ -21,7 +21,7 @@ brew install jamescun/formulas/httplog
 ## Usage
 
 ```
-httplog v1.0.2
+httplog v1.0.3
 
 httplog is a command line tool that launches a local HTTP server that logs all
 requests it receives, replying with a canned response.
@@ -38,6 +38,8 @@ Options:
                                 to all requests (default 200)
   --response-header <X=Y>       configure one or more headers to be sent in the
                                 response, may be specified more than once
+  --responses       <file>      configure multiple responses using a
+                                Responsefile (recommended)
   --json                        log all requests as JSON rather than human
                                 readable text
   --tls-self-cert               enable TLS with a self-signed certificate
@@ -66,3 +68,9 @@ Hello World
 ```
 
 If you would prefer JSON output, rather than human-readable text, use the `--json` option.
+
+## Responsefile
+
+A Responsefile is a YAML file that configures HTTPLog with multiple canned responses, as well as defaults and error handling.
+
+See [Responsefile.example](Responsefile.example) for an example Responsefile.

Responsefile.example

@@ -0,0 +1,23 @@
+responses:
+- method: GET
+  path: /foo/bar
+  status: 200
+  headers:
+    "Content-Type": [ "application/json" ]
+  body: >-
+    {"foo": "bar"}
+
+
+notFound:
+  status: 404
+  headers:
+    "Content-Type": [ "application/json" ]
+  body: >-
+    {"error":{"code": "NOT_FOUND"}}
+
+methodNotAllowed:
+  status: 405
+  headers:
+    "Content-Type": [ "application/json" ]
+  body: >-
+    {"error":{"code": "METHOD_NOT_ALLOWED"}}

go.mod

@@ -2,4 +2,8 @@ module github.com/jamescun/httplog
 
 go 1.19
 
-require github.com/spf13/pflag v1.0.5
+require (
+	github.com/go-chi/chi/v5 v5.0.10
+	github.com/spf13/pflag v1.0.5
+	gopkg.in/yaml.v3 v3.0.1
+)

go.sum

@@ -1,2 +1,8 @@
+github.com/go-chi/chi/v5 v5.0.10 h1:rLz5avzKpjqxrYwXNfmjkrYYXOyLJd37pz53UFHC6vk=
+github.com/go-chi/chi/v5 v5.0.10/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

httplog/server.go

@@ -10,17 +10,9 @@ import (
 )
 
 type Server struct {
-	// ResponseCode is the HTTP Status Code sent in response to all requests,
-	// if not set, HTTP 200 is used.
-	ResponseCode int
-
-	// ResponseBody is the contents sent in response to all requests, if not
-	// set, no response body is used.
-	ResponseBody []byte
-
-	// ResponseHEaders are additional HTTP headers to be sent in response to
-	// all requests.
-	ResponseHeaders http.Header
+	// Handler is the HTTP Handler executed for all requests. If not
+	// configured, an HTTP 200 will be sent in response to all requests.
+	Handler http.Handler
 
 	requests chan *Request
 }
@@ -66,20 +58,10 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	s.requests <- req
 
-	if len(s.ResponseHeaders) > 0 {
-		for key, values := range s.ResponseHeaders {
-			for _, value := range values {
-				r.Header.Set(key, value)
-			}
-		}
-	}
-
-	if s.ResponseCode > 0 {
-		w.WriteHeader(s.ResponseCode)
-	}
-
-	if len(s.ResponseBody) > 0 {
-		w.Write(s.ResponseBody)
+	if s.Handler != nil {
+		s.Handler.ServeHTTP(w, r)
+	} else {
+		w.WriteHeader(http.StatusOK)
 	}
 }
 

main.go

@@ -16,6 +16,7 @@ import (
 	"github.com/spf13/pflag"
 
 	"github.com/jamescun/httplog/httplog"
+	"github.com/jamescun/httplog/responses"
 )
 
 // Version is the semantic release version of this build of httplog.
@@ -26,6 +27,7 @@ var (
 	responseBody   = pflag.String("response", "", "configure the canned body sent in response to all requests")
 	responseCode   = pflag.Int("response-code", 200, "configure the HTTP status code sent in response requests")
 	responseHeader = pflag.StringArray("response-header", nil, "configure one or more headers to be sent in the response")
+	responseFile   = pflag.String("responses", "", "ponfigure multiple responses using a Responsefile")
 	logJSON        = pflag.Bool("json", false, "log all requests as JSON rather than human readable text")
 	tlsSelfCert    = pflag.Bool("tls-self-cert", false, "enable TLS with a self-signed certificate")
 )
@@ -47,6 +49,8 @@ Options:
                                 to all requests (default 200)
   --response-header <X=Y>       configure one or more headers to be sent in the
                                 response, may be specified more than once
+  --responses       <file>      configure multiple responses using a
+                                Responsefile (recommended)
   --json                        log all requests as JSON rather than human
                                 readable text
   --tls-self-cert               enable TLS with a self-signed certificate
@@ -58,13 +62,24 @@ func main() {
 
 	srv := httplog.NewServer(128)
 
-	srv.ResponseCode = *responseCode
+	if *responseFile != "" {
+		file, err := responses.ReadFile(*responseFile)
+		if err != nil {
+			exitError(2, "could not read Responsefile: %s", err)
+		}
 
-	if *responseBody != "" {
-		srv.ResponseBody = []byte(*responseBody)
-	}
+		srv.Handler = file.Handler()
+	} else {
+		r := &responses.File{
+			NotFound: &responses.Response{
+				Status:  *responseCode,
+				Headers: httplog.ParseHeaders(*responseHeader),
+				Body:    *responseBody,
+			},
+		}
 
-	srv.ResponseHeaders = httplog.ParseHeaders(*responseHeader)
+		srv.Handler = r.Handler()
+	}
 
 	if *logJSON {
 		go httplog.JSONLogger(os.Stdout, srv.Requests())

responses/responses.go

@@ -0,0 +1,129 @@
+package responses
+
+import (
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/go-chi/chi/v5"
+	"gopkg.in/yaml.v3"
+)
+
+type File struct {
+	// Responses are all the pre-defined responses that HTTPLog will be
+	// configured to reply to. If none match the request, Default will be used.
+	Responses []*Response `yaml:"responses"`
+
+	// Headers are HTTP Headers that are to be sent in response to all
+	// requests.
+	Headers http.Header `yaml:"headers"`
+
+	// NotFound is the default response sent by HTTPLog when no Response was
+	// matched for a request.
+	NotFound *Response `yaml:"notFound"`
+
+	// MethodNotAllowed is the default response sent by HTTPLog when a Response
+	// was matched but not for the method of the request.
+	MethodNotAllowed *Response `yaml:"methodNotAllowed"`
+}
+
+// ReadFile reads and unmarshals a Responsefile from a YAML file on disk.
+func ReadFile(path string) (*File, error) {
+	file, err := os.OpenFile(path, os.O_RDONLY, 0)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	var cfg File
+
+	err = yaml.NewDecoder(file).Decode(&cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cfg, nil
+}
+
+// Handler builds the response routes configured on File into a HTTP router.
+func (f *File) Handler() http.Handler {
+	r := chi.NewRouter()
+
+	if len(f.Headers) > 0 {
+		r.Use(func(next http.Handler) http.Handler {
+			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				for key, values := range f.Headers {
+					for _, value := range values {
+						w.Header().Set(key, value)
+					}
+				}
+
+				next.ServeHTTP(w, r)
+			})
+		})
+	}
+
+	if f.NotFound != nil {
+		r.NotFound(f.NotFound.handlerFunc())
+	}
+
+	if f.MethodNotAllowed != nil {
+		r.MethodNotAllowed(f.MethodNotAllowed.handlerFunc())
+	}
+
+	for _, response := range f.Responses {
+		if response.Method != "" {
+			r.Method(response.Method, response.Path, response.handlerFunc())
+		} else {
+			r.Handle(response.Path, response.handlerFunc())
+		}
+	}
+
+	return r
+}
+
+type Response struct {
+	// Method is the HTTP Method verb to match this request, or all requests if
+	// not configured.
+	Method string `yaml:"method"`
+
+	// Path is the URL Path where this response/ will be made available by
+	// HTTPLog. Internally, HTTPLog uses the Chi router, which supports
+	// parameters and regular expressions. Parameters are currently unused.
+	Path string `yaml:"path"`
+
+	// Status is the HTTP Status Code returned by this Response, or HTTP 200
+	// if not configured.
+	Status int `yaml:"status"`
+
+	// Headers are HTTP Headers that are sent in response to this request only.
+	Headers http.Header `yaml:"headers"`
+
+	// Body is the contents of the response body.
+	Body string `yaml:"body"`
+
+	// File is like Body, except reads from a file path.
+	File string `yaml:"file"`
+}
+
+func (res *Response) handlerFunc() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		for key, values := range res.Headers {
+			for _, value := range values {
+				w.Header().Set(key, value)
+			}
+		}
+
+		if res.Status > 0 {
+			w.WriteHeader(res.Status)
+		} else {
+			w.WriteHeader(http.StatusOK)
+		}
+
+		if res.Body != "" {
+			io.WriteString(w, res.Body)
+		} else if res.File != "" {
+			http.ServeFile(w, r, res.File)
+		}
+	}
+}