client_test.TestShouldForwardProvidedHeader - Code Metrics - Inspection of "Adding headers support" - stefanoj3/dirstalk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#41)

by Stefano

created 2019-06-10 08:53 UTC

client_test.TestShouldForwardProvidedHeader A

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

Complexity

Conditions

Size

Total Lines	32
Code Lines	24

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	24
nop	1
dl	0
loc	32
rs	9.304
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,
		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{},
		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{},
		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},
		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{},
		nil,
	)
	assert.Nil(t, c)
	assert.Error(t, err)

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


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

stefanoj3 / dirstalk

Pull Request — master (#41)

client_test.TestShouldForwardProvidedHeader A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like