Consolidate test doubles

- Migrate various mocks of core namespaces to shared version in `fakes` pkg
- Err on the side of making test doubles less sophisticated
- Don't pull over mocks of namespaces that are only used in example code

pkg/geth/blockchain.go

@@ -12,13 +12,13 @@ import (
 )
 
 type BlockChain struct {
-	client          core.Client
+	client          core.EthClient
 	blockConverter  vulcCommon.BlockConverter
 	headerConverter vulcCommon.HeaderConverter
 	node            core.Node
 }
 
-func NewBlockChain(client core.Client, node core.Node, converter vulcCommon.TransactionConverter) *BlockChain {
+func NewBlockChain(client core.EthClient, node core.Node, converter vulcCommon.TransactionConverter) *BlockChain {
 	return &BlockChain{
 		client:          client,
 		blockConverter:  vulcCommon.NewBlockConverter(converter),

pkg/geth/blockchain_test.go

@@ -19,7 +19,7 @@ import (
 var _ = Describe("Geth blockchain", func() {
 	Describe("getting a block", func() {
 		It("fetches block from client", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			mockClient.SetBlockByNumberReturnBlock(types.NewBlockWithHeader(&types.Header{}))
 			node := vulcCore.Node{}
 			blockChain := geth.NewBlockChain(mockClient, node, cold_db.NewColdDbTransactionConverter())
@@ -32,7 +32,7 @@ var _ = Describe("Geth blockchain", func() {
 		})
 
 		It("returns err if client returns err", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			mockClient.SetBlockByNumberErr(fakes.FakeError)
 			node := vulcCore.Node{}
 			blockChain := geth.NewBlockChain(mockClient, node, cold_db.NewColdDbTransactionConverter())
@@ -46,7 +46,7 @@ var _ = Describe("Geth blockchain", func() {
 
 	Describe("getting a header", func() {
 		It("fetches header from client", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			blockNumber := int64(100)
 			mockClient.SetHeaderByNumberReturnHeader(&types.Header{Number: big.NewInt(blockNumber)})
 			node := vulcCore.Node{}
@@ -59,7 +59,7 @@ var _ = Describe("Geth blockchain", func() {
 		})
 
 		It("returns err if client returns err", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			mockClient.SetHeaderByNumberErr(fakes.FakeError)
 			node := vulcCore.Node{}
 			blockChain := geth.NewBlockChain(mockClient, node, cold_db.NewColdDbTransactionConverter())
@@ -73,7 +73,7 @@ var _ = Describe("Geth blockchain", func() {
 
 	Describe("getting logs", func() {
 		It("fetches logs from client", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			mockClient.SetFilterLogsReturnLogs([]types.Log{{}})
 			node := vulcCore.Node{}
 			blockChain := geth.NewBlockChain(mockClient, node, cold_db.NewColdDbTransactionConverter())
@@ -93,7 +93,7 @@ var _ = Describe("Geth blockchain", func() {
 		})
 
 		It("returns err if client returns err", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			mockClient.SetFilterLogsErr(fakes.FakeError)
 			node := vulcCore.Node{}
 			blockChain := geth.NewBlockChain(mockClient, node, cold_db.NewColdDbTransactionConverter())
@@ -110,7 +110,7 @@ var _ = Describe("Geth blockchain", func() {
 
 	Describe("getting the most recent block number", func() {
 		It("fetches latest header from client", func() {
-			mockClient := fakes.NewMockClient()
+			mockClient := fakes.NewMockEthClient()
 			blockNumber := int64(100)
 			mockClient.SetHeaderByNumberReturnHeader(&types.Header{Number: big.NewInt(blockNumber)})
 			node := vulcCore.Node{}

pkg/geth/client/client.go

@@ -1,33 +0,0 @@
-package client
-
-import (
-	"context"
-	"github.com/ethereum/go-ethereum"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient"
-	"math/big"
-)
-
-type Client struct {
-	client *ethclient.Client
-}
-
-func NewClient(client *ethclient.Client) Client {
-	return Client{client: client}
-}
-
-func (client Client) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
-	return client.client.BlockByNumber(ctx, number)
-}
-
-func (client Client) CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
-	return client.client.CallContract(ctx, msg, blockNumber)
-}
-
-func (client Client) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
-	return client.client.FilterLogs(ctx, q)
-}
-
-func (client Client) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
-	return client.client.HeaderByNumber(ctx, number)
-}

pkg/geth/client/eth_client.go

@@ -0,0 +1,42 @@
+package client
+
+import (
+	"context"
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/ethclient"
+	"math/big"
+)
+
+type EthClient struct {
+	client *ethclient.Client
+}
+
+func NewEthClient(client *ethclient.Client) EthClient {
+	return EthClient{client: client}
+}
+
+func (client EthClient) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
+	return client.client.BlockByNumber(ctx, number)
+}
+
+func (client EthClient) CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
+	return client.client.CallContract(ctx, msg, blockNumber)
+}
+
+func (client EthClient) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
+	return client.client.FilterLogs(ctx, q)
+}
+
+func (client EthClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
+	return client.client.HeaderByNumber(ctx, number)
+}
+
+func (client EthClient) TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error) {
+	return client.client.TransactionSender(ctx, tx, block, index)
+}
+
+func (client EthClient) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
+	return client.client.TransactionReceipt(ctx, txHash)
+}

pkg/geth/client/rpc_client.go

@@ -0,0 +1,30 @@
+package client
+
+import (
+	"context"
+	"github.com/ethereum/go-ethereum/rpc"
+)
+
+type RpcClient struct {
+	client  *rpc.Client
+	ipcPath string
+}
+
+func NewRpcClient(client *rpc.Client, ipcPath string) RpcClient {
+	return RpcClient{
+		client:  client,
+		ipcPath: ipcPath,
+	}
+}
+
+func (client RpcClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
+	return client.client.CallContext(ctx, result, method, args)
+}
+
+func (client RpcClient) IpcPath() string {
+	return client.ipcPath
+}
+
+func (client RpcClient) SupportedModules() (map[string]string, error) {
+	return client.client.SupportedModules()
+}

pkg/geth/converters/common/block_converter_test.go

@@ -1,8 +1,6 @@
 package common_test
 
 import (
-	"context"
-	"fmt"
 	"io/ioutil"
 	"log"
 	"math/big"
@@ -14,57 +12,11 @@ import (
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 
+	"github.com/vulcanize/vulcanizedb/pkg/fakes"
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/geth/converters/common"
 	"github.com/vulcanize/vulcanizedb/pkg/geth/converters/rpc"
 )
 
-type FakeGethClient struct {
-	receipts map[string]*types.Receipt
-	err      error
-}
-
-type TransActionReceiptError struct{}
-
-func (tarErr TransActionReceiptError) Error() string {
-	return fmt.Sprintf("transaction receipt error")
-}
-
-type TransactionSenderError struct{}
-
-func (tasErr TransactionSenderError) Error() string {
-	return fmt.Sprintf("transaction sender error")
-}
-
-func NewFakeClient(err error) *FakeGethClient {
-	return &FakeGethClient{
-		receipts: make(map[string]*types.Receipt),
-		err:      err,
-	}
-}
-
-func (client *FakeGethClient) AddReceipts(receipts []*types.Receipt) {
-	for _, receipt := range receipts {
-		client.receipts[receipt.TxHash.Hex()] = receipt
-	}
-}
-
-func (client *FakeGethClient) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
-	if err, ok := client.err.(TransActionReceiptError); ok {
-		return &types.Receipt{}, err
-	}
-	if gasUsed, ok := client.receipts[txHash.Hex()]; ok {
-		return gasUsed, nil
-	}
-	return &types.Receipt{GasUsed: uint64(0)}, nil
-}
-
-func (client *FakeGethClient) TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error) {
-	if err, ok := client.err.(TransactionSenderError); ok {
-		return common.Address{}, err
-	}
-	return common.HexToAddress("0x123"), nil
-}
-
 var _ = Describe("Conversion of GethBlock to core.Block", func() {
 
 	It("converts basic Block metadata", func() {
@@ -90,7 +42,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 			UncleHash:  common.Hash{128},
 		}
 		block := types.NewBlock(&header, []*types.Transaction{}, []*types.Header{}, []*types.Receipt{})
-		client := &FakeGethClient{}
+		client := fakes.NewMockEthClient()
 		transactionConverter := rpc.NewRpcTransactionConverter(client)
 		blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
@@ -132,8 +84,8 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 			}
 			receipts := []*types.Receipt{&receipt}
 
-			client := NewFakeClient(nil)
-			client.AddReceipts(receipts)
+			client := fakes.NewMockEthClient()
+			client.SetTransactionReceipts(receipts)
 
 			number := int64(1071819)
 			header := types.Header{
@@ -176,8 +128,8 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 			}
 			block := types.NewBlock(&header, transactions, uncles, receipts)
 
-			client := NewFakeClient(nil)
-			client.AddReceipts(receipts)
+			client := fakes.NewMockEthClient()
+			client.SetTransactionReceipts(receipts)
 			transactionConverter := rpc.NewRpcTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
@@ -225,8 +177,8 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 			var uncles []*types.Header
 			block := types.NewBlock(&header, transactions, uncles, receipts)
 
-			client := NewFakeClient(nil)
-			client.AddReceipts(receipts)
+			client := fakes.NewMockEthClient()
+			client.SetTransactionReceipts(receipts)
 			transactionConverter := rpc.NewRpcTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
@@ -241,7 +193,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 		It("is empty", func() {
 			header := types.Header{}
 			block := types.NewBlock(&header, []*types.Transaction{}, []*types.Header{}, []*types.Receipt{})
-			client := &FakeGethClient{}
+			client := fakes.NewMockEthClient()
 			transactionConverter := rpc.NewRpcTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
@@ -270,8 +222,8 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 				TxHash:            gethTransaction.Hash(),
 			}
 
-			client := NewFakeClient(nil)
-			client.AddReceipts([]*types.Receipt{gethReceipt})
+			client := fakes.NewMockEthClient()
+			client.SetTransactionReceipts([]*types.Receipt{gethReceipt})
 
 			header := types.Header{}
 			block := types.NewBlock(
@@ -317,8 +269,8 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 				ContractAddress:   common.HexToAddress("0x1023342345"),
 			}
 
-			client := NewFakeClient(nil)
-			client.AddReceipts([]*types.Receipt{gethReceipt})
+			client := fakes.NewMockEthClient()
+			client.SetTransactionReceipts([]*types.Receipt{gethReceipt})
 
 			block := types.NewBlock(
 				&types.Header{},
@@ -373,25 +325,25 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 		})
 
 		It("returns an error when transaction sender call fails", func() {
-			client := NewFakeClient(TransactionSenderError{})
-			client.AddReceipts([]*types.Receipt{})
+			client := fakes.NewMockEthClient()
+			client.SetTransactionSenderErr(fakes.FakeError)
 			transactionConverter := rpc.NewRpcTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			_, err := blockConverter.ToCoreBlock(block)
 
-			Expect(err).To(Equal(TransactionSenderError{}))
+			Expect(err).To(MatchError(fakes.FakeError))
 		})
 
 		It("returns an error when transaction receipt call fails", func() {
-			client := NewFakeClient(TransActionReceiptError{})
-			client.AddReceipts([]*types.Receipt{})
+			client := fakes.NewMockEthClient()
+			client.SetTransactionReceiptErr(fakes.FakeError)
 			transactionConverter := rpc.NewRpcTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			_, err := blockConverter.ToCoreBlock(block)
 
-			Expect(err).To(Equal(TransActionReceiptError{}))
+			Expect(err).To(MatchError(fakes.FakeError))
 		})
 	})
 

pkg/geth/converters/rpc/transaction_converter.go

@@ -14,16 +14,11 @@ import (
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/geth/converters/common"
 )
 
-type Client interface {
-	TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error)
-	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
-}
-
 type RpcTransactionConverter struct {
-	client Client
+	client core.EthClient
 }
 
-func NewRpcTransactionConverter(client Client) *RpcTransactionConverter {
+func NewRpcTransactionConverter(client core.EthClient) *RpcTransactionConverter {
 	return &RpcTransactionConverter{client: client}
 }
 
@@ -42,7 +37,7 @@ func (rtc *RpcTransactionConverter) ConvertTransactionsToCore(gethBlock *types.B
 				return err
 			}
 			coreTransaction := transToCoreTrans(transaction, &from)
-			coreTransaction, err = appendReceiptToTransaction(rtc.client, coreTransaction)
+			coreTransaction, err = rtc.appendReceiptToTransaction(coreTransaction)
 			if err != nil {
 				log.Println("receipt: ", err)
 				return err
@@ -58,8 +53,8 @@ func (rtc *RpcTransactionConverter) ConvertTransactionsToCore(gethBlock *types.B
 	return coreTransactions, nil
 }
 
-func appendReceiptToTransaction(client Client, transaction core.Transaction) (core.Transaction, error) {
-	gethReceipt, err := client.TransactionReceipt(context.Background(), common.HexToHash(transaction.Hash))
+func (rtc *RpcTransactionConverter) appendReceiptToTransaction(transaction core.Transaction) (core.Transaction, error) {
+	gethReceipt, err := rtc.client.TransactionReceipt(context.Background(), common.HexToHash(transaction.Hash))
 	if err != nil {
 		return transaction, err
 	}

pkg/geth/node/node.go

@@ -7,69 +7,38 @@ import (
 
 	"regexp"
 
-	"strings"
-
 	"log"
 
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/p2p"
 	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"strings"
 )
 
-type PropertiesReader interface {
+type IPropertiesReader interface {
 	NodeInfo() (id string, name string)
 	NetworkId() float64
 	GenesisBlock() string
 }
 
-type ClientWrapper struct {
-	ContextCaller
-	IPCPath string
-}
-
-type ContextCaller interface {
-	CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
-	SupportedModules() (map[string]string, error)
+type PropertiesReader struct {
+	client core.RpcClient
 }
 
 type ParityClient struct {
-	ClientWrapper
+	PropertiesReader
 }
 
 type GethClient struct {
-	ClientWrapper
+	PropertiesReader
 }
 
 type InfuraClient struct {
-	ClientWrapper
+	PropertiesReader
 }
 
-func (clientWrapper ClientWrapper) NodeType() core.NodeType {
-	if strings.Contains(clientWrapper.IPCPath, "infura") {
-		return core.INFURA
-	}
-	modules, _ := clientWrapper.SupportedModules()
-	if _, ok := modules["admin"]; ok {
-		return core.GETH
-	}
-	return core.PARITY
-}
-
-func makePropertiesReader(wrapper ClientWrapper) PropertiesReader {
-	switch wrapper.NodeType() {
-	case core.GETH:
-		return GethClient{ClientWrapper: wrapper}
-	case core.PARITY:
-		return ParityClient{ClientWrapper: wrapper}
-	case core.INFURA:
-		return InfuraClient{ClientWrapper: wrapper}
-	default:
-		return wrapper
-	}
-}
-
-func MakeNode(wrapper ClientWrapper) core.Node {
-	pr := makePropertiesReader(wrapper)
+func MakeNode(rpcClient core.RpcClient) core.Node {
+	pr := makePropertiesReader(rpcClient)
 	id, name := pr.NodeInfo()
 	return core.Node{
 		GenesisBlock: pr.GenesisBlock(),
@@ -79,9 +48,33 @@ func MakeNode(wrapper ClientWrapper) core.Node {
 	}
 }
 
-func (client ClientWrapper) NetworkId() float64 {
+func makePropertiesReader(client core.RpcClient) IPropertiesReader {
+	switch getNodeType(client) {
+	case core.GETH:
+		return GethClient{PropertiesReader: PropertiesReader{client: client}}
+	case core.PARITY:
+		return ParityClient{PropertiesReader: PropertiesReader{client: client}}
+	case core.INFURA:
+		return InfuraClient{PropertiesReader: PropertiesReader{client: client}}
+	default:
+		return PropertiesReader{client: client}
+	}
+}
+
+func getNodeType(client core.RpcClient) core.NodeType {
+	if strings.Contains(client.IpcPath(), "infura") {
+		return core.INFURA
+	}
+	modules, _ := client.SupportedModules()
+	if _, ok := modules["admin"]; ok {
+		return core.GETH
+	}
+	return core.PARITY
+}
+
+func (reader PropertiesReader) NetworkId() float64 {
 	var version string
-	err := client.CallContext(context.Background(), &version, "net_version")
+	err := reader.client.CallContext(context.Background(), &version, "net_version")
 	if err != nil {
 		log.Println(err)
 	}
@@ -89,17 +82,17 @@ func (client ClientWrapper) NetworkId() float64 {
 	return networkId
 }
 
-func (client ClientWrapper) GenesisBlock() string {
+func (reader PropertiesReader) GenesisBlock() string {
 	var header *types.Header
 	blockZero := "0x0"
 	includeTransactions := false
-	client.CallContext(context.Background(), &header, "eth_getBlockByNumber", blockZero, includeTransactions)
+	reader.client.CallContext(context.Background(), &header, "eth_getBlockByNumber", blockZero, includeTransactions)
 	return header.Hash().Hex()
 }
 
-func (client ClientWrapper) NodeInfo() (string, string) {
+func (reader PropertiesReader) NodeInfo() (string, string) {
 	var info p2p.NodeInfo
-	client.CallContext(context.Background(), &info, "admin_nodeInfo")
+	reader.client.CallContext(context.Background(), &info, "admin_nodeInfo")
 	return info.ID, info.Name
 }
 
@@ -115,14 +108,14 @@ func (client InfuraClient) NodeInfo() (string, string) {
 
 func (client ParityClient) parityNodeInfo() string {
 	var nodeInfo core.ParityNodeInfo
-	client.CallContext(context.Background(), &nodeInfo, "parity_versionInfo")
+	client.client.CallContext(context.Background(), &nodeInfo, "parity_versionInfo")
 	return nodeInfo.String()
 }
 
 func (client ParityClient) parityID() string {
 	var enodeId = regexp.MustCompile(`^enode://(.+)@.+$`)
 	var enodeURL string
-	client.CallContext(context.Background(), &enodeURL, "parity_enode")
+	client.client.CallContext(context.Background(), &enodeURL, "parity_enode")
 	enode := enodeId.FindStringSubmatch(enodeURL)
 	if len(enode) < 2 {
 		return ""

pkg/geth/node/node_test.go

@@ -3,66 +3,15 @@ package node_test
 import (
 	"encoding/json"
 
-	"context"
-
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/p2p"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/fakes"
 	"github.com/vulcanize/vulcanizedb/pkg/geth/node"
 )
 
-type MockContextCaller struct {
-	nodeType core.NodeType
-}
-
 var EmpytHeaderHash = "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347"
 
-func (MockContextCaller) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
-	switch method {
-	case "admin_nodeInfo":
-		if p, ok := result.(*p2p.NodeInfo); ok {
-			p.ID = "enode://GethNode@172.17.0.1:30303"
-			p.Name = "Geth/v1.7"
-		}
-	case "eth_getBlockByNumber":
-		if p, ok := result.(*types.Header); ok {
-			*p = types.Header{}
-		}
-
-	case "parity_versionInfo":
-		if p, ok := result.(*core.ParityNodeInfo); ok {
-			*p = core.ParityNodeInfo{
-				Track: "",
-				ParityVersion: core.ParityVersion{
-					Major: 1,
-					Minor: 2,
-					Patch: 3,
-				},
-				Hash: "",
-			}
-		}
-	case "parity_enode":
-		if p, ok := result.(*string); ok {
-			*p = "enode://ParityNode@172.17.0.1:30303"
-		}
-	case "net_version":
-		if p, ok := result.(*string); ok {
-			*p = "1234"
-		}
-	}
-	return nil
-}
-
-func (mcc MockContextCaller) SupportedModules() (map[string]string, error) {
-	result := make(map[string]string)
-	if mcc.nodeType == core.GETH {
-		result["admin"] = "ok"
-	}
-	return result, nil
-}
-
 var _ = Describe("Parity Node Info", func() {
 
 	It("verifies parity_versionInfo can be unmarshalled into ParityNodeInfo", func() {
@@ -99,39 +48,38 @@ var _ = Describe("Parity Node Info", func() {
 	})
 
 	It("returns the genesis block for any client", func() {
-		mcc := MockContextCaller{}
-		cw := node.ClientWrapper{ContextCaller: mcc}
-		n := node.MakeNode(cw)
+		client := fakes.NewMockRpcClient()
+		n := node.MakeNode(client)
 		Expect(n.GenesisBlock).To(Equal(EmpytHeaderHash))
 	})
 
 	It("returns the network id for any client", func() {
-		mcc := MockContextCaller{}
-		cw := node.ClientWrapper{ContextCaller: mcc}
-		n := node.MakeNode(cw)
+		client := fakes.NewMockRpcClient()
+		n := node.MakeNode(client)
 		Expect(n.NetworkID).To(Equal(float64(1234)))
 	})
 
 	It("returns parity ID and client name for parity node", func() {
-		mcc := MockContextCaller{core.PARITY}
-		cw := node.ClientWrapper{ContextCaller: mcc}
-		n := node.MakeNode(cw)
+		client := fakes.NewMockRpcClient()
+		client.SetNodeType(core.PARITY)
+		n := node.MakeNode(client)
 		Expect(n.ID).To(Equal("ParityNode"))
 		Expect(n.ClientName).To(Equal("Parity/v1.2.3/"))
 	})
 
 	It("returns geth ID and client name for geth node", func() {
-		mcc := MockContextCaller{core.GETH}
-		cw := node.ClientWrapper{ContextCaller: mcc}
-		n := node.MakeNode(cw)
+		client := fakes.NewMockRpcClient()
+		client.SetNodeType(core.GETH)
+		n := node.MakeNode(client)
 		Expect(n.ID).To(Equal("enode://GethNode@172.17.0.1:30303"))
 		Expect(n.ClientName).To(Equal("Geth/v1.7"))
 	})
 
 	It("returns infura ID and client name for infura node", func() {
-		mcc := MockContextCaller{core.INFURA}
-		cw := node.ClientWrapper{ContextCaller: mcc, IPCPath: "https://mainnet.infura.io/123"}
-		n := node.MakeNode(cw)
+		client := fakes.NewMockRpcClient()
+		client.SetNodeType(core.INFURA)
+		client.SetIpcPath("infura/path")
+		n := node.MakeNode(client)
 		Expect(n.ID).To(Equal("infura"))
 		Expect(n.ClientName).To(Equal("infura"))
 	})