Merge pull request #1 from walkerus/priority-scenarios

Added priority and scenarios

Author: walkerus

README.md

@@ -2,28 +2,62 @@
 [![Actions Status](https://github.com/walkerus/go-wiremock/workflows/build/badge.svg)](https://github.com/walkerus/go-wiremock/actions?query=workflow%3Abuild)
 [![Go Report Card](https://goreportcard.com/badge/github.com/walkerus/go-wiremock)](https://goreportcard.com/report/github.com/walkerus/go-wiremock)
 
-A simple package for stub http resource using [WireMock admin](http://wiremock.org/docs/api/)
-
-## Install
-```go get https://github.com/walkerus/go-wiremock```
+The simple package to stub HTTP resource using [WireMock admin](http://wiremock.org/docs/api/)
 
 ## Usage
 ```
 docker run -it --rm -p 8080:8080 rodolpheche/wiremock
 ```
 ```go
-wiremockClient := NewClient("http://0.0.0.0:8080")
-defer wiremockClient.Reset()
-wiremockClient.StubFor(Post(URLPathEqualTo("/example")).
-		WithQueryParam("firstName", EqualTo("Jhon")).
-		WithQueryParam("lastName", NotMatching("Black")).
-		WithBodyPattern(EqualToJson(`{"meta": "information"}`)).
-		WithHeader("x-session", Matching("^\\S+fingerprint\\S+$")).
+package main
+
+import (
+    "testing"
+    "github.com/walkerus/go-wiremock"
+)
+
+func TestSome(t *testing.T) {
+    wiremockClient := wiremock.NewClient("http://0.0.0.0:8080")
+    defer wiremockClient.Reset()
+    
+    // stubbing POST http://0.0.0.0:8080/example
+    wiremockClient.StubFor(wiremock.Post(wiremock.URLPathEqualTo("/example")).
+            WithQueryParam("firstName", wiremock.EqualTo("Jhon")).
+            WithQueryParam("lastName", wiremock.NotMatching("Black")).
+            WithBodyPattern(wiremock.EqualToJson(`{"meta": "information"}`)).
+            WithHeader("x-session", wiremock.Matching("^\\S+fingerprint\\S+$")).
+            WillReturn(
+                `{"code": 400, "detail": "detail"}`,
+                map[string]string{"Content-Type": "application/json"},
+                400,
+            ).
+            AtPriority(1))
+
+    // scenario
+    defer wiremockClient.ResetAllScenarios()
+    wiremockClient.StubFor(wiremock.Get(wiremock.URLPathEqualTo("/status")).
 		WillReturn(
-			`{"code": 400, "detail": "detail"}`,
+			`{"status": null}`,
 			map[string]string{"Content-Type": "application/json"},
-			400,
-		))
+			200,
+		).
+		InScenario("Set status").
+        WhenScenarioStateIs(wiremock.ScenarioStateStarted))
+
+    wiremockClient.StubFor(wiremock.Post(wiremock.URLPathEqualTo("/state")).
+            WithBodyPattern(wiremock.EqualToJson(`{"status": "started"}`)).
+            InScenario("Set status").
+            WillSetStateTo("Status started"))
+
+    wiremockClient.StubFor(wiremock.Get(wiremock.URLPathEqualTo("/status")).
+            WillReturn(
+                `{"status": "started"}`,
+                map[string]string{"Content-Type": "application/json"},
+                200,
+            ).
+            InScenario("Set status").
+            WhenScenarioStateIs("Status started"))
 
-// testing code...
+    //testing code...
+}
 ```

client.go

@@ -8,7 +8,10 @@ import (
 	"net/http"
 )
 
-const wiremockAdminURN = "__admin/mappings"
+const (
+	wiremockAdminURN         = "__admin"
+	wiremockAdminMappingsURN = "__admin/mappings"
+)
 
 // A Client implements requests to the wiremock server
 type Client struct {
@@ -27,10 +30,11 @@ func (c *Client) StubFor(stubRule *StubRule) error {
 		return fmt.Errorf("build stub request error: %s", err.Error())
 	}
 
-	res, err := http.Post(fmt.Sprintf("%s/%s", c.url, wiremockAdminURN), "application/json", bytes.NewBuffer(requestBody))
+	res, err := http.Post(fmt.Sprintf("%s/%s", c.url, wiremockAdminMappingsURN), "application/json", bytes.NewBuffer(requestBody))
 	if err != nil {
 		return fmt.Errorf("stub request error: %s", err.Error())
 	}
+	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusCreated {
 		bodyBytes, err := ioutil.ReadAll(res.Body)
@@ -46,7 +50,7 @@ func (c *Client) StubFor(stubRule *StubRule) error {
 
 // Clear deletes all stub mappings.
 func (c *Client) Clear() error {
-	req, err := http.NewRequest(http.MethodDelete, fmt.Sprintf("%s/%s", c.url, wiremockAdminURN), nil)
+	req, err := http.NewRequest(http.MethodDelete, fmt.Sprintf("%s/%s", c.url, wiremockAdminMappingsURN), nil)
 	if err != nil {
 		return fmt.Errorf("build cleare request error: %s", err.Error())
 	}
@@ -55,6 +59,7 @@ func (c *Client) Clear() error {
 	if err != nil {
 		return fmt.Errorf("clear request error: %s", err.Error())
 	}
+	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusOK {
 		return fmt.Errorf("bad response status: %d", res.StatusCode)
@@ -65,10 +70,31 @@ func (c *Client) Clear() error {
 
 // Reset restores stub mappings to the defaults defined back in the backing store.
 func (c *Client) Reset() error {
-	res, err := http.Post(fmt.Sprintf("%s/%s/reset", c.url, wiremockAdminURN), "application/json", nil)
+	res, err := http.Post(fmt.Sprintf("%s/%s/reset", c.url, wiremockAdminMappingsURN), "application/json", nil)
 	if err != nil {
 		return fmt.Errorf("reset request error: %s", err.Error())
 	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusOK {
+		bodyBytes, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return fmt.Errorf("read response error: %s", err.Error())
+		}
+
+		return fmt.Errorf("bad response status: %d, response: %s", res.StatusCode, string(bodyBytes))
+	}
+
+	return nil
+}
+
+// ResetAllScenarios resets back to start of the state of all configured scenarios.
+func (c *Client) ResetAllScenarios() error {
+	res, err := http.Post(fmt.Sprintf("%s/%s/scenarios/reset", c.url, wiremockAdminURN), "application/json", nil)
+	if err != nil {
+		return fmt.Errorf("reset all scenarios request error: %s", err.Error())
+	}
+	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusOK {
 		bodyBytes, err := ioutil.ReadAll(res.Body)

client_test.go

@@ -28,10 +28,14 @@ func TestStubRule_ToJson(t *testing.T) {
 			`{"code": 400, "detail": "detail"}`,
 			map[string]string{"Content-Type": "application/json"},
 			400,
-		)
+		).
+		AtPriority(1).
+		InScenario("Scenario").
+		WhenScenarioStateIs("Started").
+		WillSetStateTo("Stopped")
 
-	expectedRequestBody = `{"request":` +
-		`{"bodyPatterns":[{"equalToJson":"{\"meta\": \"information\"}"},{"contains":"information"}],` +
+	expectedRequestBody = `{"priority":1,"scenarioName":"Scenario","requiredScenarioState":"Started","newScenarioState":"Stopped",` +
+		`"request":{"bodyPatterns":[{"equalToJson":"{\"meta\": \"information\"}"},{"contains":"information"}],` +
 		`"cookies":{"session":{"equalToXml":"\u003cxml\u003e"}},` +
 		`"headers":{"x-session":{"matches":"^\\S+@\\S+$"}},` +
 		`"method":"POST","queryParameters":{"firstName":{"equalTo":"Jhon"},"lastName":{"doesNotMatch":"Black"}},"urlPath":"/example"},` +

stub_rule.go

@@ -5,6 +5,8 @@ import (
 	"net/http"
 )
 
+const ScenarioStateStarted = "Started"
+
 // ParamMatcherInterface is pair ParamMatchingStrategy and string matched value
 type ParamMatcherInterface interface {
 	Strategy() ParamMatchingStrategy
@@ -34,17 +36,31 @@ type response struct {
 
 // StubRule is struct of http request body to WireMock
 type StubRule struct {
-	request  request
-	response response
+	request               request
+	response              response
+	priority              *int64
+	scenarioName          *string
+	requiredScenarioState *string
+	newScenarioState      *string
+}
+
+// NewStubRule returns a new *StubRule.
+func NewStubRule(method string, urlMatcher URLMatcher) *StubRule {
+	return &StubRule{
+		request: request{
+			urlMatcher: urlMatcher,
+			method:     method,
+		},
+		response: response{
+			status: http.StatusOK,
+		},
+	}
 }
 
 // WithQueryParam adds query param and returns *StubRule
 func (s *StubRule) WithQueryParam(param string, matcher ParamMatcherInterface) *StubRule {
 	if s.request.queryParams == nil {
-		s.request.queryParams = map[string]ParamMatcherInterface{
-			param: matcher,
-		}
-		return s
+		s.request.queryParams = map[string]ParamMatcherInterface{}
 	}
 
 	s.request.queryParams[param] = matcher
@@ -54,10 +70,7 @@ func (s *StubRule) WithQueryParam(param string, matcher ParamMatcherInterface) *
 // WithHeader adds header to Headers and returns *StubRule
 func (s *StubRule) WithHeader(header string, matcher ParamMatcherInterface) *StubRule {
 	if s.request.headers == nil {
-		s.request.headers = map[string]ParamMatcherInterface{
-			header: matcher,
-		}
-		return s
+		s.request.headers = map[string]ParamMatcherInterface{}
 	}
 
 	s.request.headers[header] = matcher
@@ -67,10 +80,7 @@ func (s *StubRule) WithHeader(header string, matcher ParamMatcherInterface) *Stu
 // WithCookie adds cookie and returns *StubRule
 func (s *StubRule) WithCookie(cookie string, matcher ParamMatcherInterface) *StubRule {
 	if s.request.cookies == nil {
-		s.request.cookies = map[string]ParamMatcherInterface{
-			cookie: matcher,
-		}
-		return s
+		s.request.cookies = map[string]ParamMatcherInterface{}
 	}
 
 	s.request.cookies[cookie] = matcher
@@ -91,17 +101,28 @@ func (s *StubRule) WillReturn(body string, headers map[string]string, status int
 	return s
 }
 
-// NewStubRule returns a new *StubRule.
-func NewStubRule(method string, urlMatcher URLMatcher) *StubRule {
-	return &StubRule{
-		request: request{
-			urlMatcher: urlMatcher,
-			method:     method,
-		},
-		response: response{
-			status: http.StatusOK,
-		},
-	}
+// AtPriority sets priority and returns *StubRule
+func (s *StubRule) AtPriority(priority int64) *StubRule {
+	s.priority = &priority
+	return s
+}
+
+// InScenario sets scenarioName and returns *StubRule
+func (s *StubRule) InScenario(scenarioName string) *StubRule {
+	s.scenarioName = &scenarioName
+	return s
+}
+
+// WhenScenarioStateIs sets requiredScenarioState and returns *StubRule
+func (s *StubRule) WhenScenarioStateIs(scenarioState string) *StubRule {
+	s.requiredScenarioState = &scenarioState
+	return s
+}
+
+// WillSetStateTo sets newScenarioState and returns *StubRule
+func (s *StubRule) WillSetStateTo(scenarioState string) *StubRule {
+	s.newScenarioState = &scenarioState
+	return s
 }
 
 // Post returns *StubRule for POST method.
@@ -124,15 +145,24 @@ func Put(urlMatchingPair URLMatcher) *StubRule {
 	return NewStubRule(http.MethodPut, urlMatchingPair)
 }
 
+//MarshalJSON makes json body for http request
 func (s *StubRule) MarshalJSON() ([]byte, error) {
 	jsonStubRule := struct {
-		Request  map[string]interface{} `json:"request"`
-		Response struct {
+		Priority                      *int64                 `json:"priority,omitempty"`
+		ScenarioName                  *string                `json:"scenarioName,omitempty"`
+		RequiredScenarioScenarioState *string                `json:"requiredScenarioState,omitempty"`
+		NewScenarioState              *string                `json:"newScenarioState,omitempty"`
+		Request                       map[string]interface{} `json:"request"`
+		Response                      struct {
 			Body    string            `json:"body,omitempty"`
 			Headers map[string]string `json:"headers,omitempty"`
 			Status  int64             `json:"status,omitempty"`
 		} `json:"response"`
 	}{}
+	jsonStubRule.Priority = s.priority
+	jsonStubRule.ScenarioName = s.scenarioName
+	jsonStubRule.RequiredScenarioScenarioState = s.requiredScenarioState
+	jsonStubRule.NewScenarioState = s.newScenarioState
 	jsonStubRule.Response.Body = s.response.body
 	jsonStubRule.Response.Headers = s.response.headers
 	jsonStubRule.Response.Status = s.response.status