Docs and race test

Author: kalverra

parrot/Makefile

@@ -1,8 +1,8 @@
 # Default test log level (can be overridden)
-TEST_LOG_LEVEL ?= ""
+PARROT_TEST_LOG_LEVEL ?= ""
 
 # Pass TEST_LOG_LEVEL as a flag to go test
-TEST_ARGS ?= -testLogLevel=$(TEST_LOG_LEVEL)
+TEST_ARGS ?= -testLogLevel=$(PARROT_TEST_LOG_LEVEL)
 
 .PHONY: lint
 lint:

parrot/README.md

@@ -2,83 +2,18 @@
 
 A simple, high-performing mockserver that can dynamically build new routes with customized responses, parroting back whatever you tell it to.
 
-## Use
-
-Call the `/register` endpoint to define a route.
-
-### Curl
-
-```sh
-curl -X POST http://localhost:8080/register -d '{
-  "method": "GET",
-  "path": "/hello",
-  "response": "{\"message\": \"Hello, world!\"}",
-  "status_code": 200,
-  "content_type": "application/json"
-}' -H "Content-Type: application/json"
-```
-
-### Go and [Resty](https://github.com/go-resty/resty)
-
-```go
-client := resty.New()
-
-route := map[string]any{
-    "method":      "GET",
-    "path":        "/hello",
-    "response":    "{\"message\":\"Hello, world!\"}",
-    "status_code": 200,
-    "content_type": "application/json",
-}
-
-resp, _ := client.R().
-    SetHeader("Content-Type", "application/json").
-    SetBody(route).
-    Post("http://localhost:8080/register")
-```
-
-You can now call your endpoint and receive the JSON response back.
-
-```sh
-curl -X GET http://localhost:8080/hello -H "Content-Type: application/json"
-# {"message":"Hello, world!"}
-```
-
-## Configure
-
-Config is through environment variables.
-
-| **Environment Variable** | **Description**                                                | **Default Value** |
-| ------------------------ | -------------------------------------------------------------- | ----------------- |
-| `LOG_LEVEL`              | Controls the logging level (`debug`, `info`, `warn`, `error`). | `debug`           |
-| `SAVE_FILE`              | Path to the file where routes are saved and loaded.            | `save.json`       |
-
 ## Run
 
 ```sh
-go run .
+go run ./cmd
+go run ./cmd -h # See all config options 
 ```
 
 ## Test
 
 ```sh
-go test -cover -race ./...
-```
-
-## Benchmark
-
-```sh
-LOG_LEVEL=disabled go test -bench=. -benchmem -run=^$
-```
-
-Benchmark run on an Apple M3 Max.
-
-```sh
-goos: darwin
-goarch: arm64
-pkg: github.com/smartcontractkit/chainlink-testing-framework/parrotserver
-BenchmarkRegisterRoute-14    	  604978	      1967 ns/op	    6263 B/op	      29 allocs/op
-BenchmarkRouteResponse-14    	16561670	        70.62 ns/op	      80 B/op	       1 allocs/op
-BenchmarkSaveRoutes-14       	    1245	    956784 ns/op	  636042 B/op	    2014 allocs/op
-BenchmarkLoadRoutes-14       	    1020	   1185990 ns/op	  348919 B/op	    9020 allocs/op
+make test
+make test PARROT_TEST_LOG_LEVEL=trace # Set log level for tests
+make test_race # Test with -race flag enabled
+make bench # Benchmark
 ```

parrot/cmd/main.go

@@ -22,8 +22,8 @@ func main() {
 	)
 
 	rootCmd := &cobra.Command{
-		Use:   "parrotserver",
-		Short: "a server that can set and parrrot back dynamic requests",
+		Use:   "parrot",
+		Short: "A server that can register and parrot back dynamic requests",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			options := []parrot.ServerOption{parrot.WithPort(port)}
 			logLevel := zerolog.InfoLevel

parrot/parrot_examples_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/smartcontractkit/chainlink-testing-framework/parrot"
 )
 
-func ExampleServer_Register() {
+func ExampleServer() {
 	p, err := parrot.Wake()
 	if err != nil {
 		panic(err)

parrot/parrot_test.go

@@ -1,6 +1,7 @@
 package parrot
 
 import (
+	"encoding/json"
 	"flag"
 	"fmt"
 	"io"
@@ -76,14 +77,20 @@ func TestRegisteredRoute(t *testing.T) {
 			ResponseStatusCode:  201,
 			ResponseContentType: "text/plain",
 		},
+		{
+			Method:              http.MethodGet,
+			Path:                "/json",
+			ResponseBody:        map[string]any{"message": "Squawk"},
+			ResponseStatusCode:  200,
+			ResponseContentType: "application/json",
+		},
 	}
 
-	for _, r := range routes {
-		route := r
+	for _, route := range routes {
 		t.Run(route.Method+":"+route.Path, func(t *testing.T) {
 			t.Parallel()
 
-			err = p.Register(route)
+			err := p.Register(route)
 			require.NoError(t, err, "error registering route")
 
 			resp, err := p.Call(route.Method, route.Path)
@@ -93,7 +100,13 @@ func TestRegisteredRoute(t *testing.T) {
 			assert.Equal(t, resp.StatusCode, route.ResponseStatusCode)
 			assert.Equal(t, resp.Header.Get("Content-Type"), route.ResponseContentType)
 			body, _ := io.ReadAll(resp.Body)
-			assert.Equal(t, route.RawResponseBody, string(body))
+			if route.ResponseBody != nil {
+				jsonBody, err := json.Marshal(route.ResponseBody)
+				require.NoError(t, err)
+				assert.JSONEq(t, string(jsonBody), string(body))
+			} else {
+				assert.Equal(t, route.RawResponseBody, string(body))
+			}
 			resp.Body.Close()
 		})
 	}
@@ -113,6 +126,39 @@ func TestUnregisteredRoute(t *testing.T) {
 	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
 }
 
+func TestUnregister(t *testing.T) {
+	t.Parallel()
+
+	p, err := Wake(WithLogLevel(testLogLevel))
+	require.NoError(t, err, "error waking parrot")
+
+	route := &Route{
+		Method:              http.MethodPost,
+		Path:                "/hello",
+		RawResponseBody:     "Squawk",
+		ResponseStatusCode:  200,
+		ResponseContentType: "text/plain",
+	}
+
+	err = p.Register(route)
+	require.NoError(t, err, "error registering route")
+
+	resp, err := p.Call(route.Method, route.Path)
+	require.NoError(t, err, "error calling parrot")
+
+	assert.Equal(t, resp.StatusCode, route.ResponseStatusCode)
+	assert.Equal(t, resp.Header.Get("Content-Type"), route.ResponseContentType)
+	body, _ := io.ReadAll(resp.Body)
+	assert.Equal(t, route.RawResponseBody, string(body))
+	resp.Body.Close()
+
+	p.Unregister(route.Method, route.Path)
+
+	resp, err = p.Call(route.Method, route.Path)
+	require.NoError(t, err, "error calling parrot")
+	assert.Equal(t, http.StatusNotFound, resp.StatusCode)
+}
+
 func TestSaveLoad(t *testing.T) {
 	t.Parallel()