wip: add tls support and further tidying up

examples/v3/consumer_test.go

@@ -5,8 +5,10 @@ package main
 
 import (
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net/http"
+	"net/url"
 	"strings"
 	"testing"
 
@@ -29,30 +31,38 @@ func TestConsumer(t *testing.T) {
 	mockProvider := &v3.MockProvider{
 		Consumer:             "MyConsumer",
 		Provider:             "MyProvider",
-		Host:                 "localhost",
+		Host:                 "127.0.0.1",
+		Port:                 8080,
 		LogLevel:             "TRACE",
 		SpecificationVersion: v3.V2,
+		TLS:                  true,
 	}
+
 	mockProvider.Setup()
-	defer mockProvider.Teardown()
 
 	// Pass in test case
 	var test = func(config v3.MockServerConfig) error {
-		u := fmt.Sprintf("http://localhost:%d/foobar", mockProvider.ServerPort)
-		req, err := http.NewRequest("GET", u, strings.NewReader(`{"name":"billy"}`))
+		client := &http.Client{
+			Transport: v3.GetTLSConfigForTLSMockServer(),
+		}
+		req := &http.Request{
+			Method: "POST",
+			URL: &url.URL{
+				Host:   fmt.Sprintf("localhost:%d", mockProvider.Port),
+				Scheme: "https",
+				Path:   "/foobar",
+			},
+			Body:   ioutil.NopCloser(strings.NewReader(`{"name":"billy"}`)),
+			Header: make(http.Header),
+		}
 
 		// NOTE: by default, request bodies are expected to be sent with a Content-Type
 		// of application/json. If you don't explicitly set the content-type, you
 		// will get a mismatch during Verification.
 		req.Header.Set("Content-Type", "application/json")
 		req.Header.Set("Authorization", "Bearer 1234")
 
-		if err != nil {
-			return err
-		}
-		if _, err = http.DefaultClient.Do(req); err != nil {
-			return err
-		}
+		_, err := client.Do(req)
 
 		return err
 	}
@@ -61,9 +71,9 @@ func TestConsumer(t *testing.T) {
 	mockProvider.
 		AddInteraction().
 		Given("User foo exists").
-		UponReceiving("A request to get foo").
+		UponReceiving("A request to do a foo").
 		WithRequest(v3.Request{
-			Method:  "GET",
+			Method:  "POST",
 			Path:    s("/foobar"),
 			Headers: v3.MapMatcher{"Content-Type": s("application/json"), "Authorization": s("Bearer 1234")},
 			Body: v3.MapMatcher{
@@ -73,16 +83,16 @@ func TestConsumer(t *testing.T) {
 		WillRespondWith(v3.Response{
 			Status:  200,
 			Headers: v3.MapMatcher{"Content-Type": s("application/json")},
-			Body:    v3.Match(&User{}),
-			// Body: v3.MapMatcher{
-			// 	"dateTime": v3.Regex("2020-01-01", "[0-9\\-]+"),
-			// 	"name":     s("FirstName"),
-			// 	"lastName": s("LastName"),
-			// },
+			// Body:    v3.Match(&User{}),
+			Body: v3.MapMatcher{
+				"dateTime": v3.Regex("2020-01-01", "[0-9\\-]+"),
+				"name":     s("FirstName"),
+				"lastName": s("LastName"),
+			},
 		})
 
-	// Verify
-	if err := mockProvider.Verify(test); err != nil {
+	// Execute pact test
+	if err := mockProvider.ExecuteTest(test); err != nil {
 		log.Fatalf("Error on Verify: %v", err)
 	}
 }

examples/v3/pacts/consumer-provider.json

@@ -0,0 +1,64 @@
+{
+  "consumer": {
+    "name": "consumer"
+  },
+  "interactions": [
+    {
+      "description": "A request to do a foo",
+      "providerState": "User foo exists",
+      "request": {
+        "body": {
+          "name": "billy"
+        },
+        "headers": {
+          "Authorization": "Bearer 1234",
+          "Content-Type": "application/json"
+        },
+        "matchingRules": {
+          "$.body.name": {
+            "match": "type"
+          }
+        },
+        "method": "POST",
+        "path": "/foobar"
+      },
+      "response": {
+        "body": {
+          "dateTime": "2020-01-01",
+          "lastName": "LastName",
+          "name": "FirstName"
+        },
+        "headers": {
+          "Content-Type": "application/json"
+        },
+        "matchingRules": {
+          "$.body.dateTime": {
+            "match": "regex",
+            "regex": "[0-9\\-]+"
+          },
+          "$.body.lastName": {
+            "match": "type"
+          },
+          "$.body.name": {
+            "match": "type"
+          }
+        },
+        "status": 200
+      }
+    }
+  ],
+  "metadata": {
+    "pactGo": {
+      "version": "v1.4.3"
+    },
+    "pactRust": {
+      "version": "0.6.3"
+    },
+    "pactSpecification": {
+      "version": "2.0.0"
+    }
+  },
+  "provider": {
+    "name": "provider"
+  }
+}

utils/port.go

@@ -12,7 +12,7 @@ import (
 // GetFreePort Gets an available port by asking the kernal for a random port
 // ready and available for use.
 func GetFreePort() (int, error) {
-	addr, err := net.ResolveTCPAddr("tcp", "localhost:0")
+	addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
 	if err != nil {
 		return 0, err
 	}