Calculate file paths(schema and body) based on imposter path

Author: aperezg

.gitignore

@@ -15,4 +15,4 @@ imposters
 schemas
 
 !test/testdata/imposters/
-!test/testdata/schemas/
+!test/testdata/imposters/schemas/

CHANGELOG.md

@@ -17,4 +17,7 @@
 
 ## v0.2.1 (2019/04/25)
 
-* Allow imposter's matching by request schema
+* Allow imposter's matching by request schema
+* Dynamic responses based on regex endpoint or request schema
+* Calculate files directory(body and schema) based on imposters path
+* Update REAMDE.md with resolved features and new future features

handler.go

@@ -72,7 +72,8 @@ func writeBody(imposter Imposter, w http.ResponseWriter) {
 	wb := []byte(imposter.Response.Body)
 
 	if imposter.Response.BodyFile != nil {
-		wb = fetchBodyFromFile(*imposter.Response.BodyFile)
+		bodyFile := imposter.CalculateFilePath(*imposter.Response.BodyFile)
+		wb = fetchBodyFromFile(bodyFile)
 	}
 	w.Write(wb)
 }

handler_test.go

@@ -23,9 +23,9 @@ func TestImposterHandler(t *testing.T) {
 	var headers = make(http.Header)
 	headers.Add("Content-Type", "application/json")
 
-	schemaFile := "test/testdata/schemas/create_gopher_request.json"
-	bodyFile := "test/testdata/responses/create_gopher_response.json"
-	bodyFileFake := "test/testdata/responses/create_gopher_response_fail.json"
+	schemaFile := "test/testdata/imposters/schemas/create_gopher_request.json"
+	bodyFile := "test/testdata/imposters/responses/create_gopher_response.json"
+	bodyFileFake := "test/testdata/imposters/responses/create_gopher_response_fail.json"
 	body := `{"test":true}`
 
 	validRequest := Request{
@@ -123,7 +123,7 @@ func TestInvalidHeaders(t *testing.T) {
 		  }
 		}
 	  }`)
-	schemaFile := "test/testdata/schemas/create_gopher_request.json"
+	schemaFile := "test/testdata/imposters/schemas/create_gopher_request.json"
 	var expectedHeaders = make(http.Header)
 	expectedHeaders.Add("Content-Type", "application/json")
 	expectedHeaders.Add("Authorization", "Bearer gopher")

imposter.go

@@ -1,13 +1,22 @@
 package killgrave
 
-import "net/http"
+import (
+	"net/http"
+	"path"
+)
 
 // Imposter define an imposter structure
 type Imposter struct {
+	BasePath string
 	Request  Request  `json:"request"`
 	Response Response `json:"response"`
 }
 
+// CalculateFilePath calculate file path based on basePath of imposter directory
+func (i *Imposter) CalculateFilePath(filePath string) string {
+	return path.Join(i.BasePath, filePath)
+}
+
 // Request represent the structure of real request
 type Request struct {
 	Method     string       `json:"method"`
@@ -18,8 +27,8 @@ type Request struct {
 
 // Response represent the structure of real response
 type Response struct {
-	Status      int     `json:"status"`
-	Body        string  `json:"body"`
-	BodyFile    *string `json:"bodyFile"`
-	Headers    *http.Header `json:"headers"`
+	Status   int          `json:"status"`
+	Body     string       `json:"body"`
+	BodyFile *string      `json:"bodyFile"`
+	Headers  *http.Header `json:"headers"`
 }

route_matchers.go

@@ -17,9 +17,11 @@ func MatcherBySchema(imposter Imposter) mux.MatcherFunc {
 		err := validateSchema(imposter, req)
 
 		// TODO: inject the logger
-		log.Println(err)
-
-		return err == nil
+		if err != nil {
+			log.Println(err)
+			return false
+		}
+		return true
 	}
 }
 
@@ -35,7 +37,7 @@ func validateSchema(imposter Imposter, req *http.Request) error {
 		req.Body = ioutil.NopCloser(bytes.NewBuffer(b))
 	}()
 
-	schemaFile := *imposter.Request.SchemaFile
+	schemaFile := imposter.CalculateFilePath(*imposter.Request.SchemaFile)
 	if _, err := os.Stat(schemaFile); os.IsNotExist(err) {
 		return errors.Wrapf(err, "the schema file %s not found", schemaFile)
 	}

route_matchers_test.go

@@ -12,9 +12,9 @@ func TestMatcherBySchema(t *testing.T) {
 	bodyA := ioutil.NopCloser(bytes.NewReader([]byte("{\"type\": \"gopher\"}")))
 	bodyB := ioutil.NopCloser(bytes.NewReader([]byte("{\"type\": \"cat\"}")))
 
-	schemaGopherFile := "test/testdata/schemas/type_gopher.json"
-	schemaCatFile := "test/testdata/schemas/type_cat.json"
-	schemeFailFile := "test/testdata/schemas/type_gopher_fail.json"
+	schemaGopherFile := "test/testdata/imposters/schemas/type_gopher.json"
+	schemaCatFile := "test/testdata/imposters/schemas/type_cat.json"
+	schemeFailFile := "test/testdata/imposters/schemas/type_gopher_fail.json"
 
 	requestWithoutSchema := Request{
 		Method:     "POST",

server.go

@@ -40,6 +40,10 @@ func (s *Server) buildImposters() error {
 	files, _ := ioutil.ReadDir(s.impostersPath)
 
 	for _, f := range files {
+		if f.IsDir() {
+			continue
+		}
+
 		var imposter Imposter
 		if err := s.buildImposter(f.Name(), &imposter); err != nil {
 			return err
@@ -65,5 +69,7 @@ func (s *Server) buildImposter(imposterFileName string, imposter *Imposter) erro
 	if err := json.Unmarshal(bytes, imposter); err != nil {
 		return malformattedImposterError(fmt.Sprintf("error while unmarshall imposter file %s", f))
 	}
+	imposter.BasePath = s.impostersPath
+
 	return nil
 }

server_test.go

@@ -13,7 +13,7 @@ func TestRunServer(t *testing.T) {
 		err    error
 	}{
 		{"imposter directory not found", NewServer("failImposterPath", nil), invalidDirectoryError("error")},
-		{"malformatted json", NewServer("test/testdata/malformatted", nil), malformattedImposterError("error")},
+		{"malformatted json", NewServer("test/testdata/malformatted_imposters", nil), malformattedImposterError("error")},
 		{"valid imposter", NewServer("test/testdata/imposters", mux.NewRouter()), nil},
 	}