client_test.TestShouldNotRepeatTheSameRequestTwice - Code Metrics - Inspection of "Adding configurable requests cache" - stefanoj3/dirstalk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( b9ce7a...fa5039 )

by Stefano

created 2019-08-04 06:24 UTC

client_test.TestShouldNotRepeatTheSameRequestTwice A

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

Complexity

Conditions

Size

Total Lines	33
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	25
nop	1
dl	0
loc	33
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 * 50)
		}),
	)
	defer testServer.Close()

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

	res, err := c.Get(testServer.URL)
	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,
		u,
	)
	assert.NoError(t, err)

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

	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)

	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,
		u,
	)
	assert.NoError(t, err)

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

	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()

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

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

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

	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,
		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,
		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)
	assert.Equal(t, http.StatusOK, res.StatusCode)

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

	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 * 50)
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			nil,
31			)
32			assert.NoError(t, err)
33
34			res, err := c.Get(testServer.URL)
35			assert.Error(t, err)
36			assert.Nil(t, res)
37
38			assert.Contains(t, err.Error(), "Client.Timeout")
39			}
40
41			func TestShouldForwardProvidedCookiesWhenUsingJar(t *testing.T) {
42			const (
43			serverCookieName = "server_cookie_name"
44			serverCookieValue = "server_cookie_value"
45			)
46
47			testServer, serverAssertion := test.NewServerWithAssertion(
48			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
49			http.SetCookie(
50			w,
51			&http.Cookie{
52			Name: serverCookieName,
53			Value: serverCookieValue,
54			Expires: time.Now().AddDate(0, 1, 0),
55			},
56			)
57			}),
58			)
59			defer testServer.Close()
60
61			u, err := url.Parse(testServer.URL)
62			assert.NoError(t, err)
63
64			cookies := []*http.Cookie{
65			{
66			Name: "a_cookie_name",
67			Value: "a_cookie_value",
68			},
69			}
70
71			c, err := client.NewClientFromConfig(
72			100,
73			nil,
74			"",
75			true,
76			cookies,
77			map[string]string{},
78			false,
79			u,
80			)
81			assert.NoError(t, err)
82
83			res, err := c.Get(testServer.URL)
84			assert.NoError(t, err)
85			assert.NotNil(t, res)
86
87			assert.Equal(t, 1, serverAssertion.Len())
88
89			serverAssertion.At(0, func(r http.Request) {
90			assert.Equal(t, 1, len(r.Cookies()))
91
92			assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
93			assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
94			assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
95			})
96
97			res, err = c.Get(testServer.URL)
98			assert.NoError(t, err)
99			assert.NotNil(t, res)
100
101			assert.Equal(t, 2, serverAssertion.Len())
102
103			serverAssertion.At(1, func(r http.Request) {
104			assert.Equal(t, 2, len(r.Cookies()))
105
106			assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
107			assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
108			assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
109
110			assert.Equal(t, r.Cookies()[1].Name, serverCookieName)
111			assert.Equal(t, r.Cookies()[1].Value, serverCookieValue)
112			})
113			}
114
115			func TestShouldForwardCookiesWhenJarIsDisabled(t *testing.T) {
116			testServer, serverAssertion := test.NewServerWithAssertion(
117			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
118			)
119			defer testServer.Close()
120
121			u, err := url.Parse(testServer.URL)
122			assert.NoError(t, err)
123
124			cookies := []*http.Cookie{
125			{
126			Name: "a_cookie_name",
127			Value: "a_cookie_value",
128			},
129			}
130
131			c, err := client.NewClientFromConfig(
132			100,
133			nil,
134			"",
135			false,
136			cookies,
137			map[string]string{},
138			true,
139			u,
140			)
141			assert.NoError(t, err)
142
143			res, err := c.Get(testServer.URL)
144			assert.NoError(t, err)
145			assert.NotNil(t, res)
146
147			assert.Equal(t, 1, serverAssertion.Len())
148
149			serverAssertion.At(0, func(r http.Request) {
150			assert.Equal(t, 1, len(r.Cookies()))
151
152			assert.Equal(t, r.Cookies()[0].Name, cookies[0].Name)
153			assert.Equal(t, r.Cookies()[0].Value, cookies[0].Value)
154			assert.Equal(t, r.Cookies()[0].Expires, cookies[0].Expires)
155			})
156			}
157
158			func TestShouldForwardProvidedHeader(t *testing.T) {
159			const (
160			headerName = "my_header_name"
161			headerValue = "my_header_value_123"
162			)
163			testServer, serverAssertion := test.NewServerWithAssertion(
164			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
165			)
166			defer testServer.Close()
167
168			u, err := url.Parse(testServer.URL)
169			assert.NoError(t, err)
170
171			c, err := client.NewClientFromConfig(
172			100,
173			nil,
174			"",
175			false,
176			nil,
177			map[string]string{headerName: headerValue},
178			true,
179			u,
180			)
181			assert.NoError(t, err)
182
183			res, err := c.Get(testServer.URL)
184			assert.NoError(t, err)
185			assert.NotNil(t, res)
186
187			assert.Equal(t, 1, serverAssertion.Len())
188
189			serverAssertion.At(0, func(r http.Request) {
190			assert.Equal(t, headerValue, r.Header.Get(headerName))
191
192			})
193			}
194
195			func TestShouldFailToCreateAClientWithInvalidSocks5Url(t *testing.T) {
196			u := url.URL{Scheme: "potatoscheme"}
197
198			c, err := client.NewClientFromConfig(
199			100,
200			&u,
201			"",
202			false,
203			nil,
204			map[string]string{},
205			true,
206			nil,
207			)
208			assert.Nil(t, c)
209			assert.Error(t, err)
210
211			assert.Contains(t, err.Error(), "unknown scheme")
212			}
213
214			func TestShouldNotRepeatTheSameRequestTwice(t *testing.T) {
215			testServer, serverAssertion := test.NewServerWithAssertion(
216			http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {}),
217			)
218			defer testServer.Close()
219
220			u, err := url.Parse(testServer.URL)
221			assert.NoError(t, err)
222
223			c, err := client.NewClientFromConfig(
224			100,
225			nil,
226			"",
227			false,
228			nil,
229			nil,
230			true,
231			u,
232			)
233			assert.NoError(t, err)
234
235			req, err := http.NewRequest(http.MethodGet, u.String(), nil)
236			assert.NoError(t, err)
237
238			res, err := c.Do(req)
239			assert.NoError(t, err)
240			assert.Equal(t, http.StatusOK, res.StatusCode)
241
242			res, err = c.Do(req)
243			assert.Contains(t, err.Error(), client.ErrRequestRedundant.Error())
244			assert.Nil(t, res)
245
246			assert.Equal(t, 1, serverAssertion.Len())
247			}
248

stefanoj3 / dirstalk

Push — master ( b9ce7a...fa5039 )

client_test.TestShouldNotRepeatTheSameRequestTwice A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like