simpify code, update README

Author: giefferre

README.md

@@ -16,7 +16,8 @@ func main() {
 	client := gojsonrpc.NewClient("http://mock.rpcservice.url")
 
 	// you can optionally set a HTTP proxy for the connection
-	client.SetHTTPProxy("http://proxy.url:3128")
+	proxyURL, _ := "http://proxy.url:3128"
+	client.SetHTTPProxy(proxyURL)
 
 	// you can also optionally set the connection timeout
 	client.SetTimeout(120)

client.go

@@ -13,35 +13,36 @@ import (
 
 // Client executes JSON RPC calls to remote servers.
 type Client struct {
-	URL string
-
-	timeout    int
-	proxyURL   string
+	serverURL  string
 	httpClient *http.Client
 }
 
 // NewClient returns a newly istantiated Client pointing to the given url.
 func NewClient(url string) *Client {
-	client := &Client{
-		URL:      url,
-		timeout:  defaultTimeout,
-		proxyURL: "",
+	httpClient := &http.Client{
+		Timeout: time.Duration(time.Duration(defaultTimeout) * time.Second),
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: true,
+			},
+			Proxy: http.ProxyFromEnvironment,
+		},
 	}
-	client.setHTTPClient()
 
-	return client
+	return &Client{
+		serverURL:  url,
+		httpClient: httpClient,
+	}
 }
 
 // SetTimeout sets the client timeout to the given value.
 func (c *Client) SetTimeout(timeout int) {
-	c.timeout = timeout
-	c.setHTTPClient()
+	c.httpClient.Timeout = time.Duration(timeout) * time.Second
 }
 
-// SetHTTPProxy tells the client to use the given httpProxyURL as proxy address.
-func (c *Client) SetHTTPProxy(httpProxyURL string) {
-	c.proxyURL = httpProxyURL
-	c.setHTTPClient()
+// SetHTTPProxyURL tells the client to use the given proxyURL as proxy address.
+func (c *Client) SetHTTPProxyURL(proxyURL *url.URL) {
+	c.httpClient.Transport.(*http.Transport).Proxy = http.ProxyURL(proxyURL)
 }
 
 // Run executes the given method having the given params setting the response
@@ -92,30 +93,10 @@ func (c *Client) Notify(method string, params interface{}) error {
 	return nil
 }
 
-func (c *Client) setHTTPClient() {
-	transport := &http.Transport{
-		TLSClientConfig: &tls.Config{
-			InsecureSkipVerify: true,
-		},
-		Proxy: http.ProxyFromEnvironment,
-	}
-
-	if parsedProxyURL, err := url.Parse(c.proxyURL); c.proxyURL != "" && err == nil {
-		transport.Proxy = http.ProxyURL(parsedProxyURL)
-	}
-
-	newHTTPClient := &http.Client{
-		Timeout:   time.Duration(time.Duration(c.timeout) * time.Second),
-		Transport: transport,
-	}
-
-	c.httpClient = newHTTPClient
-}
-
 func (c *Client) sendJSONRequest(jsonRequest []byte) ([]byte, error) {
 	var jsonResponse []byte
 
-	httpRequest, err := http.NewRequest("POST", c.URL, strings.NewReader(string(jsonRequest)))
+	httpRequest, err := http.NewRequest("POST", c.serverURL, strings.NewReader(string(jsonRequest)))
 	httpRequest.Header.Set("Content-Type", "application/json")
 	httpRequest.Header.Set("Content-Length", "")
 	httpRequest.Header.Set("Accept", "application/json")

client_test.go

@@ -1,45 +1,30 @@
 package gojsonrpc
 
 import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
 	"testing"
-	"time"
 )
 
-func TestThatNewClientReturnsTheExpectedClient(t *testing.T) {
-	mockURL := "http://mock.url"
+func TestThatSetHTTPProxyURLSetsAnHTTPProxyInClient(t *testing.T) {
+	proxyCalled := false
 
-	sut := NewClient(mockURL)
+	mockProxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		proxyCalled = true
+	}))
 
-	if sut.timeout != defaultTimeout ||
-		sut.proxyURL != "" ||
-		sut.httpClient.Timeout != time.Duration(defaultTimeout)*time.Second {
-		t.Fatal("expected Client was not received.")
-	}
-}
-
-func TestThatSetTimeoutSucceeds(t *testing.T) {
-	mockURL := "http://mock.url"
-	mockTimeout := 123
+	mockRPCServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	}))
 
-	sut := NewClient(mockURL)
-	sut.SetTimeout(mockTimeout)
-
-	if sut.timeout != 123 ||
-		sut.proxyURL != "" ||
-		sut.httpClient.Timeout != time.Duration(123)*time.Second {
-		t.Fatal("expected Client was not received.")
-	}
-}
+	sut := NewClient(mockRPCServer.URL)
 
-func TestThatSetProxySucceeds(t *testing.T) {
-	mockURL := "http://mock.url"
-	mockProxyURL := "http://proxy.url:1234"
+	mockHTTPProxyURL, _ := url.Parse(mockProxy.URL)
 
-	sut := NewClient(mockURL)
-	sut.SetHTTPProxy(mockProxyURL)
+	sut.SetHTTPProxyURL(mockHTTPProxyURL)
+	_ = sut.Notify("SometMethod", nil)
 
-	if sut.timeout != defaultTimeout ||
-		sut.proxyURL != mockProxyURL {
-		t.Fatal("expected Client was not received.")
+	if !proxyCalled {
+		t.Fatal("expected proxy was not called")
 	}
 }