client_test.TestShouldBeAbleToSkipSSLCertificatesCheck - Code Metrics - Inspection of "Adding flag to skip SSL certificate check" - stefanoj3/dirstalk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 938cbd...107211 )

by Stefano

created 2019-11-22 06:19 UTC

SkipSSLCertificatesCheck A

↳ Parent: pkg/scan/client/client_test.go

Complexity

Conditions

Size

Total Lines	36
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	25
nop	1
dl	0
loc	36
rs	9.28
c	0
b	0
f	0

package client_test

import (
	"net/http"
	"net/url"
	"testing"
	"time"

	"github.com/stefanoj3/dirstalk/pkg/common/test"
	"github.com/stefanoj3/dirstalk/pkg/scan/client"
	"github.com/stretchr/testify/assert"
)

func TestWhenRemoteIsTooSlowClientShouldTimeout(t *testing.T) {
	testServer, _ := test.NewServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			time.Sleep(time.Millisecond * 100)
		}),
	)
	defer testServer.Close()

	c, err := client.NewClientFromConfig(
		10,
		nil,
		"",
		false,
		nil,
		nil,
		true,
		false,
		nil,
	)
	assert.NoError(t, err)

	res, err := c.Get(testServer.URL) //nolint
	assert.Error(t, err)
	assert.Nil(t, res)

	assert.Contains(t, err.Error(), "Client.Timeout")
}

func TestShouldForwardProvidedCookiesWhenUsingJar(t *testing.T) {
	const (
		serverCookieName  = "server_cookie_name"
		serverCookieValue = "server_cookie_value"
	)

	testServer, serverAssertion := test.NewServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			http.SetCookie(
				w,
				&http.Cookie{
					Name:    serverCookieName,
					Value:   serverCookieValue,
					Expires: time.Now().AddDate(0, 1, 0),
				},
			)
		}),
	)
	defer testServer.Close()

	u, err := url.Parse(testServer.URL)
	assert.NoError(t, err)

	cookies := []*http.Cookie{
		{
			Name:  "a_cookie_name",
			Value: "a_cookie_value",
		},
	}

	c, err := client.NewClientFromConfig(
		100,
		nil,
		"",
		true,
		cookies,
		map[string]string{},
		false,
		false,
		u,
	)
	assert.NoError(t, err)

	res, err := c.Get(testServer.URL)
	assert.NoError(t, err)
	assert.NotNil(t, res)

	defer res.Body.Close() //nolint:errcheck

	assert.Equal(t, 1, serverAssertion.Len())

	serverAssertion.At(0, func(r http.Request) {
		assert.Equal(t, 1, len(r.Cookies()))

		assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
		assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
		assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
	})

	res, err = c.Get(testServer.URL)
	assert.NoError(t, err)
	assert.NotNil(t, res)

	defer res.Body.Close() //nolint:errcheck

	assert.Equal(t, 2, serverAssertion.Len())

	serverAssertion.At(1, func(r http.Request) {
		assert.Equal(t, 2, len(r.Cookies()))

		assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
		assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
		assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)

		assert.Equal(t, r.Cookies()[1].Name, serverCookieName)
		assert.Equal(t, r.Cookies()[1].Value, serverCookieValue)
	})
}

func TestShouldForwardCookiesWhenJarIsDisabled(t *testing.T) {
	testServer, serverAssertion := test.NewServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
	)
	defer testServer.Close()

	u, err := url.Parse(testServer.URL)
	assert.NoError(t, err)

	cookies := []*http.Cookie{
		{
			Name:  "a_cookie_name",
			Value: "a_cookie_value",
		},
	}

	c, err := client.NewClientFromConfig(
		100,
		nil,
		"",
		false,
		cookies,
		map[string]string{},
		true,
		false,
		u,
	)
	assert.NoError(t, err)

	res, err := c.Get(testServer.URL)
	assert.NoError(t, err)
	assert.NotNil(t, res)

	defer res.Body.Close() //nolint:errcheck

	assert.Equal(t, 1, serverAssertion.Len())

	serverAssertion.At(0, func(r http.Request) {
		assert.Equal(t, 1, len(r.Cookies()))

		assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
		assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
		assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
	})
}

func TestShouldForwardProvidedHeader(t *testing.T) {
	const (
		headerName  = "my_header_name"
		headerValue = "my_header_value_123"
	)

	testServer, serverAssertion := test.NewServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
	)
	defer testServer.Close() //nolint:errcheck

	u, err := url.Parse(testServer.URL)
	assert.NoError(t, err)

	c, err := client.NewClientFromConfig(
		100,
		nil,
		"",
		false,
		nil,
		map[string]string{headerName: headerValue},
		true,
		false,
		u,
	)
	assert.NoError(t, err)

	res, err := c.Get(testServer.URL)
	assert.NoError(t, err)
	assert.NotNil(t, res)

	defer res.Body.Close() //nolint:errcheck

	assert.Equal(t, 1, serverAssertion.Len())

	serverAssertion.At(0, func(r http.Request) {
		assert.Equal(t, headerValue, r.Header.Get(headerName))
	})
}

func TestShouldFailToCreateAClientWithInvalidSocks5Url(t *testing.T) {
	u := url.URL{Scheme: "potatoscheme"}

	c, err := client.NewClientFromConfig(
		100,
		&u,
		"",
		false,
		nil,
		map[string]string{},
		true,
		false,
		nil,
	)
	assert.Nil(t, c)
	assert.Error(t, err)

	assert.Contains(t, err.Error(), "unknown scheme")
}

func TestShouldNotRepeatTheSameRequestTwice(t *testing.T) {
	testServer, serverAssertion := test.NewServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
	)
	defer testServer.Close()

	u, err := url.Parse(testServer.URL)
	assert.NoError(t, err)

	c, err := client.NewClientFromConfig(
		100,
		nil,
		"",
		false,
		nil,
		nil,
		true,
		false,
		u,
	)
	assert.NoError(t, err)

	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	assert.NoError(t, err)

	res, err := c.Do(req)
	assert.NoError(t, err)

	res.Body.Close() //nolint:errcheck,gosec

	assert.Equal(t, http.StatusOK, res.StatusCode)

	res, err = c.Do(req) //nolint
	assert.Contains(t, err.Error(), client.ErrRequestRedundant.Error())
	assert.Nil(t, res)

	assert.Equal(t, 1, serverAssertion.Len())
}

func TestShouldFailToCommunicateWithServerHavingInvalidSSLCertificates(t *testing.T) {
	testServer, serverAssertion := test.NewTSLServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
	)
	defer testServer.Close()

	u, err := url.Parse(testServer.URL)
	assert.NoError(t, err)

	c, err := client.NewClientFromConfig(
		1500,
		nil,
		"",
		false,
		nil,
		nil,
		true,
		false,
		u,
	)
	assert.NoError(t, err)

	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	assert.NoError(t, err)

	res, err := c.Do(req) //nolint:bodyclose
	assert.Error(t, err)
	assert.Nil(t, res)

	assert.Contains(t, err.Error(), "certificate signed by unknown authority")

	// the request should NOT hit the handler
	assert.Equal(t, 0, serverAssertion.Len())
}

func TestShouldBeAbleToSkipSSLCertificatesCheck(t *testing.T) {
	testServer, serverAssertion := test.NewTSLServerWithAssertion(
		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			w.WriteHeader(http.StatusNoContent)
		}),
	)
	defer testServer.Close()

	u, err := url.Parse(testServer.URL)
	assert.NoError(t, err)

	c, err := client.NewClientFromConfig(
		1500,
		nil,
		"",
		false,
		nil,
		nil,
		true,
		true,
		u,
	)
	assert.NoError(t, err)

	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
	assert.NoError(t, err)

	res, err := c.Do(req)
	assert.NoError(t, err)

	res.Body.Close() //nolint:errcheck,gosec

	assert.Equal(t, http.StatusNoContent, res.StatusCode)

	// the request should hit the handler
	assert.Equal(t, 1, serverAssertion.Len())
}


1			package client_test
2
3			import (
4			"net/http"
5			"net/url"
6			"testing"
7			"time"
8
9			"github.com/stefanoj3/dirstalk/pkg/common/test"
10			"github.com/stefanoj3/dirstalk/pkg/scan/client"
11			"github.com/stretchr/testify/assert"
12			)
13
14			func TestWhenRemoteIsTooSlowClientShouldTimeout(t *testing.T) {
15			testServer, _ := test.NewServerWithAssertion(
16			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
17			time.Sleep(time.Millisecond * 100)
18			}),
19			)
20			defer testServer.Close()
21
22			c, err := client.NewClientFromConfig(
23			10,
24			nil,
25			"",
26			false,
27			nil,
28			nil,
29			true,
30			false,
31			nil,
32			)
33			assert.NoError(t, err)
34
35			res, err := c.Get(testServer.URL) //nolint
36			assert.Error(t, err)
37			assert.Nil(t, res)
38
39			assert.Contains(t, err.Error(), "Client.Timeout")
40			}
41
42			func TestShouldForwardProvidedCookiesWhenUsingJar(t *testing.T) {
43			const (
44			serverCookieName = "server_cookie_name"
45			serverCookieValue = "server_cookie_value"
46			)
47
48			testServer, serverAssertion := test.NewServerWithAssertion(
49			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
50			http.SetCookie(
51			w,
52			&http.Cookie{
53			Name: serverCookieName,
54			Value: serverCookieValue,
55			Expires: time.Now().AddDate(0, 1, 0),
56			},
57			)
58			}),
59			)
60			defer testServer.Close()
61
62			u, err := url.Parse(testServer.URL)
63			assert.NoError(t, err)
64
65			cookies := []*http.Cookie{
66			{
67			Name: "a_cookie_name",
68			Value: "a_cookie_value",
69			},
70			}
71
72			c, err := client.NewClientFromConfig(
73			100,
74			nil,
75			"",
76			true,
77			cookies,
78			map[string]string{},
79			false,
80			false,
81			u,
82			)
83			assert.NoError(t, err)
84
85			res, err := c.Get(testServer.URL)
86			assert.NoError(t, err)
87			assert.NotNil(t, res)
88
89			defer res.Body.Close() //nolint:errcheck
90
91			assert.Equal(t, 1, serverAssertion.Len())
92
93			serverAssertion.At(0, func(r http.Request) {
94			assert.Equal(t, 1, len(r.Cookies()))
95
96			assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
97			assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
98			assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
99			})
100
101			res, err = c.Get(testServer.URL)
102			assert.NoError(t, err)
103			assert.NotNil(t, res)
104
105			defer res.Body.Close() //nolint:errcheck
106
107			assert.Equal(t, 2, serverAssertion.Len())
108
109			serverAssertion.At(1, func(r http.Request) {
110			assert.Equal(t, 2, len(r.Cookies()))
111
112			assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
113			assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
114			assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
115
116			assert.Equal(t, r.Cookies()[1].Name, serverCookieName)
117			assert.Equal(t, r.Cookies()[1].Value, serverCookieValue)
118			})
119			}
120
121			func TestShouldForwardCookiesWhenJarIsDisabled(t *testing.T) {
122			testServer, serverAssertion := test.NewServerWithAssertion(
123			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
124			)
125			defer testServer.Close()
126
127			u, err := url.Parse(testServer.URL)
128			assert.NoError(t, err)
129
130			cookies := []*http.Cookie{
131			{
132			Name: "a_cookie_name",
133			Value: "a_cookie_value",
134			},
135			}
136
137			c, err := client.NewClientFromConfig(
138			100,
139			nil,
140			"",
141			false,
142			cookies,
143			map[string]string{},
144			true,
145			false,
146			u,
147			)
148			assert.NoError(t, err)
149
150			res, err := c.Get(testServer.URL)
151			assert.NoError(t, err)
152			assert.NotNil(t, res)
153
154			defer res.Body.Close() //nolint:errcheck
155
156			assert.Equal(t, 1, serverAssertion.Len())
157
158			serverAssertion.At(0, func(r http.Request) {
159			assert.Equal(t, 1, len(r.Cookies()))
160
161			assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
162			assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
163			assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
164			})
165			}
166
167			func TestShouldForwardProvidedHeader(t *testing.T) {
168			const (
169			headerName = "my_header_name"
170			headerValue = "my_header_value_123"
171			)
172
173			testServer, serverAssertion := test.NewServerWithAssertion(
174			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
175			)
176			defer testServer.Close() //nolint:errcheck
177
178			u, err := url.Parse(testServer.URL)
179			assert.NoError(t, err)
180
181			c, err := client.NewClientFromConfig(
182			100,
183			nil,
184			"",
185			false,
186			nil,
187			map[string]string{headerName: headerValue},
188			true,
189			false,
190			u,
191			)
192			assert.NoError(t, err)
193
194			res, err := c.Get(testServer.URL)
195			assert.NoError(t, err)
196			assert.NotNil(t, res)
197
198			defer res.Body.Close() //nolint:errcheck
199
200			assert.Equal(t, 1, serverAssertion.Len())
201
202			serverAssertion.At(0, func(r http.Request) {
203			assert.Equal(t, headerValue, r.Header.Get(headerName))
204			})
205			}
206
207			func TestShouldFailToCreateAClientWithInvalidSocks5Url(t *testing.T) {
208			u := url.URL{Scheme: "potatoscheme"}
209
210			c, err := client.NewClientFromConfig(
211			100,
212			&u,
213			"",
214			false,
215			nil,
216			map[string]string{},
217			true,
218			false,
219			nil,
220			)
221			assert.Nil(t, c)
222			assert.Error(t, err)
223
224			assert.Contains(t, err.Error(), "unknown scheme")
225			}
226
227			func TestShouldNotRepeatTheSameRequestTwice(t *testing.T) {
228			testServer, serverAssertion := test.NewServerWithAssertion(
229			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
230			)
231			defer testServer.Close()
232
233			u, err := url.Parse(testServer.URL)
234			assert.NoError(t, err)
235
236			c, err := client.NewClientFromConfig(
237			100,
238			nil,
239			"",
240			false,
241			nil,
242			nil,
243			true,
244			false,
245			u,
246			)
247			assert.NoError(t, err)
248
249			req, err := http.NewRequest(http.MethodGet, u.String(), nil)
250			assert.NoError(t, err)
251
252			res, err := c.Do(req)
253			assert.NoError(t, err)
254
255			res.Body.Close() //nolint:errcheck,gosec
256
257			assert.Equal(t, http.StatusOK, res.StatusCode)
258
259			res, err = c.Do(req) //nolint
260			assert.Contains(t, err.Error(), client.ErrRequestRedundant.Error())
261			assert.Nil(t, res)
262
263			assert.Equal(t, 1, serverAssertion.Len())
264			}
265
266			func TestShouldFailToCommunicateWithServerHavingInvalidSSLCertificates(t *testing.T) {
267			testServer, serverAssertion := test.NewTSLServerWithAssertion(
268			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
269			)
270			defer testServer.Close()
271
272			u, err := url.Parse(testServer.URL)
273			assert.NoError(t, err)
274
275			c, err := client.NewClientFromConfig(
276			1500,
277			nil,
278			"",
279			false,
280			nil,
281			nil,
282			true,
283			false,
284			u,
285			)
286			assert.NoError(t, err)
287
288			req, err := http.NewRequest(http.MethodGet, u.String(), nil)
289			assert.NoError(t, err)
290
291			res, err := c.Do(req) //nolint:bodyclose
292			assert.Error(t, err)
293			assert.Nil(t, res)
294
295			assert.Contains(t, err.Error(), "certificate signed by unknown authority")
296
297			// the request should NOT hit the handler
298			assert.Equal(t, 0, serverAssertion.Len())
299			}
300
301			func TestShouldBeAbleToSkipSSLCertificatesCheck(t *testing.T) {
302			testServer, serverAssertion := test.NewTSLServerWithAssertion(
303			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
304			w.WriteHeader(http.StatusNoContent)
305			}),
306			)
307			defer testServer.Close()
308
309			u, err := url.Parse(testServer.URL)
310			assert.NoError(t, err)
311
312			c, err := client.NewClientFromConfig(
313			1500,
314			nil,
315			"",
316			false,
317			nil,
318			nil,
319			true,
320			true,
321			u,
322			)
323			assert.NoError(t, err)
324
325			req, err := http.NewRequest(http.MethodGet, u.String(), nil)
326			assert.NoError(t, err)
327
328			res, err := c.Do(req)
329			assert.NoError(t, err)
330
331			res.Body.Close() //nolint:errcheck,gosec
332
333			assert.Equal(t, http.StatusNoContent, res.StatusCode)
334
335			// the request should hit the handler
336			assert.Equal(t, 1, serverAssertion.Len())
337			}
338

stefanoj3 / dirstalk

Push — master ( 938cbd...107211 )

SkipSSLCertificatesCheck A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like