Merge pull request #2065 from mslipper/feat/caching-itests

go/proxyd: Add additional itests for cache, changeset

.changeset/moody-bottles-decide.md

+---
+'@eth-optimism/proxyd': minor
+---
+
+Add caching for block-dependent RPCs

.github/workflows/proxyd.yml

@@ -6,6 +6,8 @@ on:
       - 'master'
       - 'develop'
   pull_request:
+    paths:
+      - 'go/proxyd/**'
   workflow_dispatch:
 
 defaults:
@@ -13,7 +15,9 @@ defaults:
     working-directory: ./go/proxyd
 
 jobs:
-  test:
+  tests:
+    runs-on: ubuntu-latest
+
     steps:
     - name: Install Go
       uses: actions/setup-go@v2

go/proxyd/integration_tests/caching_test.go

@@ -16,12 +16,14 @@ func TestCaching(t *testing.T) {
 	require.NoError(t, err)
 	defer redis.Close()
 
-	backend := NewMockBackend(RPCResponseHandler(map[string]string{
+	hdlr := NewRPCResponseHandler(map[string]string{
 		"eth_chainId":          "0x420",
 		"net_version":          "0x1234",
 		"eth_blockNumber":      "0x64",
 		"eth_getBlockByNumber": "dummy_block",
-	}))
+		"eth_call":             "dummy_call",
+	})
+	backend := NewMockBackend(hdlr)
 	defer backend.Close()
 
 	require.NoError(t, os.Setenv("GOOD_BACKEND_RPC_URL", backend.URL()))
@@ -36,19 +38,22 @@ func TestCaching(t *testing.T) {
 	time.Sleep(1500 * time.Millisecond)
 
 	tests := []struct {
-		method   string
-		params   []interface{}
-		response string
+		method       string
+		params       []interface{}
+		response     string
+		backendCalls int
 	}{
 		{
 			"eth_chainId",
 			nil,
 			"{\"jsonrpc\": \"2.0\", \"result\": \"0x420\", \"id\": 999}",
+			1,
 		},
 		{
 			"net_version",
 			nil,
 			"{\"jsonrpc\": \"2.0\", \"result\": \"0x1234\", \"id\": 999}",
+			1,
 		},
 		{
 			"eth_getBlockByNumber",
@@ -57,23 +62,79 @@ func TestCaching(t *testing.T) {
 				true,
 			},
 			"{\"jsonrpc\": \"2.0\", \"result\": \"dummy_block\", \"id\": 999}",
+			1,
+		},
+		{
+			"eth_call",
+			[]interface{}{
+				struct {
+					To string `json:"to"`
+				}{
+					"0x1234",
+				},
+				"0x60",
+			},
+			"{\"id\":999,\"jsonrpc\":\"2.0\",\"result\":\"dummy_call\"}",
+			1,
+		},
+		{
+			"eth_blockNumber",
+			nil,
+			"{\"id\":999,\"jsonrpc\":\"2.0\",\"result\":\"0x64\"}",
+			0,
+		},
+		{
+			"eth_call",
+			[]interface{}{
+				struct {
+					To string `json:"to"`
+				}{
+					"0x1234",
+				},
+				"latest",
+			},
+			"{\"id\":999,\"jsonrpc\":\"2.0\",\"result\":\"dummy_call\"}",
+			2,
+		},
+		{
+			"eth_call",
+			[]interface{}{
+				struct {
+					To string `json:"to"`
+				}{
+					"0x1234",
+				},
+				"pending",
+			},
+			"{\"id\":999,\"jsonrpc\":\"2.0\",\"result\":\"dummy_call\"}",
+			2,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.method, func(t *testing.T) {
-			_, _, err := client.SendRPC(tt.method, tt.params)
+			resRaw, _, err := client.SendRPC(tt.method, tt.params)
 			require.NoError(t, err)
-			res, _, err := client.SendRPC(tt.method, tt.params)
+			resCache, _, err := client.SendRPC(tt.method, tt.params)
 			require.NoError(t, err)
-			RequireEqualJSON(t, []byte(tt.response), res)
-			var count int
-			for _, req := range backend.Requests() {
-				if bytes.Contains(req.Body, []byte(tt.method)) {
-					count++
-				}
-			}
-			require.Equal(t, 1, count)
+			RequireEqualJSON(t, []byte(tt.response), resCache)
+			RequireEqualJSON(t, resRaw, resCache)
+			require.Equal(t, tt.backendCalls, countRequests(backend, tt.method))
 			backend.Reset()
 		})
 	}
+
+	hdlr.SetResponse("eth_blockNumber", "0x100")
+	time.Sleep(1500 * time.Millisecond)
+	resRaw, _, err := client.SendRPC("eth_blockNumber", nil)
+	RequireEqualJSON(t, []byte("{\"id\":999,\"jsonrpc\":\"2.0\",\"result\":\"0x100\"}"), resRaw)
+}
+
+func countRequests(backend *MockBackend, name string) int {
+	var count int
+	for _, req := range backend.Requests() {
+		if bytes.Contains(req.Body, []byte(name)) {
+			count++
+		}
+	}
+	return count
 }

go/proxyd/integration_tests/mock_backend_test.go

@@ -31,31 +31,48 @@ func SingleResponseHandler(code int, response string) http.HandlerFunc {
 	}
 }
 
-func RPCResponseHandler(rpcResponses map[string]string) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		body, err := ioutil.ReadAll(r.Body)
-		if err != nil {
-			panic(err)
-		}
-		req, err := proxyd.ParseRPCReq(body)
-		if err != nil {
-			panic(err)
-		}
-		res := rpcResponses[req.Method]
-		if res == "" {
-			w.WriteHeader(400)
-			return
-		}
-
-		out := &proxyd.RPCRes{
-			JSONRPC: proxyd.JSONRPCVersion,
-			Result:  res,
-			ID:      req.ID,
-		}
-		enc := json.NewEncoder(w)
-		if err := enc.Encode(out); err != nil {
-			panic(err)
-		}
+type RPCResponseHandler struct {
+	mtx          sync.RWMutex
+	rpcResponses map[string]string
+}
+
+func NewRPCResponseHandler(rpcResponses map[string]string) *RPCResponseHandler {
+	return &RPCResponseHandler{
+		rpcResponses: rpcResponses,
+	}
+}
+
+func (h *RPCResponseHandler) SetResponse(method, response string) {
+	h.mtx.Lock()
+	defer h.mtx.Unlock()
+	h.rpcResponses[method] = response
+}
+
+func (h *RPCResponseHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	body, err := ioutil.ReadAll(r.Body)
+	if err != nil {
+		panic(err)
+	}
+	req, err := proxyd.ParseRPCReq(body)
+	if err != nil {
+		panic(err)
+	}
+	h.mtx.RLock()
+	res := h.rpcResponses[req.Method]
+	h.mtx.RUnlock()
+	if res == "" {
+		w.WriteHeader(400)
+		return
+	}
+
+	out := &proxyd.RPCRes{
+		JSONRPC: proxyd.JSONRPCVersion,
+		Result:  res,
+		ID:      req.ID,
+	}
+	enc := json.NewEncoder(w)
+	if err := enc.Encode(out); err != nil {
+		panic(err)
 	}
 }
 

go/proxyd/integration_tests/testdata/caching.toml

@@ -25,3 +25,5 @@ backends = ["good"]
 eth_chainId = "main"
 net_version = "main"
 eth_getBlockByNumber = "main"
+eth_blockNumber = "main"
+eth_call = "main"

go/proxyd/rpc_test.go

@@ -7,10 +7,10 @@ import (
 )
 
 func TestRPCResJSON(t *testing.T) {
-	tests := []struct{
+	tests := []struct {
 		name string
-		in *RPCRes
-		out string
+		in   *RPCRes
+		out  string
 	}{
 		{
 			"string result",
@@ -25,12 +25,12 @@ func TestRPCResJSON(t *testing.T) {
 			"object result",
 			&RPCRes{
 				JSONRPC: JSONRPCVersion,
-				Result:  struct{
+				Result: struct {
 					Str string `json:"str"`
 				}{
 					"test",
 				},
-				ID:      []byte("123"),
+				ID: []byte("123"),
 			},
 			`{"jsonrpc":"2.0","result":{"str":"test"},"id":123}`,
 		},
@@ -48,10 +48,10 @@ func TestRPCResJSON(t *testing.T) {
 			&RPCRes{
 				JSONRPC: JSONRPCVersion,
 				Error: &RPCErr{
-					Code:          1234,
-					Message:       "test err",
+					Code:    1234,
+					Message: "test err",
 				},
-				ID:      []byte("123"),
+				ID: []byte("123"),
 			},
 			`{"jsonrpc":"2.0","error":{"code":1234,"message":"test err"},"id":123}`,
 		},
@@ -72,4 +72,4 @@ func TestRPCResJSON(t *testing.T) {
 			require.Equal(t, tt.out, string(out))
 		})
 	}
-}
+}
\ No newline at end of file