CoCalc -- scanners

GitHub Repository: sundowndev/phoneinfoga
Path: blob/master/web/v2/api/handlers/scanners_test.go
⁹⁹⁴ views
1
package handlers_test
2

3
import (
4
	"bytes"
5
	"encoding/json"
6
	"errors"
7
	"fmt"
8
	"github.com/stretchr/testify/assert"
9
	"github.com/sundowndev/phoneinfoga/v2/lib/filter"
10
	"github.com/sundowndev/phoneinfoga/v2/lib/remote"
11
	"github.com/sundowndev/phoneinfoga/v2/mocks"
12
	"github.com/sundowndev/phoneinfoga/v2/test"
13
	"github.com/sundowndev/phoneinfoga/v2/web/v2/api"
14
	"github.com/sundowndev/phoneinfoga/v2/web/v2/api/handlers"
15
	"github.com/sundowndev/phoneinfoga/v2/web/v2/api/server"
16
	"net/http"
17
	"net/http/httptest"
18
	"testing"
19
)
20

21
func TestGetAllScanners(t *testing.T) {
22
	type expectedResponse struct {
23
		Code int
24
		Body interface{}
25
	}
26

27
	testcases := []struct {
28
		Name     string
29
		Expected expectedResponse
30
	}{
31
		{
32
			Name: "test getting all scanners",
33
			Expected: expectedResponse{
34
				Code: 200,
35
				Body: handlers.GetAllScannersResponse{
36
					Scanners: []handlers.Scanner{
37
						{
38
							Name:        "fakeScanner",
39
							Description: "fakeScanner description",
40
						},
41
					},
42
				},
43
			},
44
		},
45
	}
46

47
	for _, tt := range testcases {
48
		t.Run(tt.Name, func(t *testing.T) {
49
			fakeScanner := &mocks.Scanner{}
50
			fakeScanner.On("Name").Return("fakeScanner")
51
			fakeScanner.On("Description").Return("fakeScanner description")
52
			handlers.RemoteLibrary = remote.NewLibrary(filter.NewEngine())
53
			handlers.RemoteLibrary.AddScanner(fakeScanner)
54

55
			r := server.NewServer()
56

57
			req, err := http.NewRequest(http.MethodGet, "/v2/scanners", nil)
58
			if err != nil {
59
				t.Fatal(err)
60
			}
61
			w := httptest.NewRecorder()
62
			r.ServeHTTP(w, req)
63

64
			b, err := json.Marshal(tt.Expected.Body)
65
			if err != nil {
66
				t.Fatal(err)
67
			}
68

69
			assert.Equal(t, tt.Expected.Code, w.Code)
70
			assert.Equal(t, string(b), w.Body.String())
71
			fakeScanner.AssertExpectations(t)
72
		})
73
	}
74
}
75

76
func TestDryRunScanner(t *testing.T) {
77
	type expectedResponse struct {
78
		Code int
79
		Body interface{}
80
	}
81

82
	type params struct {
83
		Supplier string
84
	}
85

86
	testcases := []struct {
87
		Name     string
88
		Params   params
89
		Body     interface{}
90
		Expected expectedResponse
91
		Mocks    func(*mocks.Scanner)
92
	}{
93
		{
94
			Name:   "test dry running scanner",
95
			Params: params{Supplier: "fakeScanner"},
96
			Body:   handlers.DryRunScannerInput{Number: "14152229670"},
97
			Expected: expectedResponse{
98
				Code: 200,
99
				Body: handlers.DryRunScannerResponse{Success: true},
100
			},
101
			Mocks: func(s *mocks.Scanner) {
102
				s.On("Name").Return("fakeScanner")
103
				s.On("DryRun", *test.NewFakeUSNumber(), remote.ScannerOptions{}).Return(nil)
104
			},
105
		},
106
		{
107
			Name:   "test dry running scanner with options",
108
			Params: params{Supplier: "fakeScanner"},
109
			Body: handlers.DryRunScannerInput{
110
				Number:  "14152229670",
111
				Options: remote.ScannerOptions{"api_key": "secret"},
112
			},
113
			Expected: expectedResponse{
114
				Code: 200,
115
				Body: handlers.DryRunScannerResponse{Success: true},
116
			},
117
			Mocks: func(s *mocks.Scanner) {
118
				s.On("Name").Return("fakeScanner")
119
				s.On("DryRun", *test.NewFakeUSNumber(), remote.ScannerOptions{"api_key": "secret"}).Return(nil)
120
			},
121
		},
122
		{
123
			Name:   "test dry running scanner with empty options",
124
			Params: params{Supplier: "fakeScanner"},
125
			Body: handlers.DryRunScannerInput{
126
				Number:  "14152229670",
127
				Options: remote.ScannerOptions{},
128
			},
129
			Expected: expectedResponse{
130
				Code: 200,
131
				Body: handlers.DryRunScannerResponse{Success: true},
132
			},
133
			Mocks: func(s *mocks.Scanner) {
134
				s.On("Name").Return("fakeScanner")
135
				s.On("DryRun", *test.NewFakeUSNumber(), remote.ScannerOptions{}).Return(nil)
136
			},
137
		},
138
		{
139
			Name:   "test dry running scanner with error",
140
			Params: params{Supplier: "fakeScanner"},
141
			Body:   handlers.DryRunScannerInput{Number: "14152229670"},
142
			Expected: expectedResponse{
143
				Code: 400,
144
				Body: handlers.DryRunScannerResponse{Success: false, Error: "dummy error"},
145
			},
146
			Mocks: func(s *mocks.Scanner) {
147
				s.On("Name").Return("fakeScanner")
148
				s.On("DryRun", *test.NewFakeUSNumber(), make(remote.ScannerOptions)).Return(errors.New("dummy error"))
149
			},
150
		},
151
		{
152
			Name:   "test invalid number",
153
			Params: params{Supplier: "fakeScanner"},
154
			Body:   handlers.DryRunScannerInput{Number: "1.4152229670"},
155
			Expected: expectedResponse{
156
				Code: 400,
157
				Body: api.ErrorResponse{Error: "Invalid phone number: please provide an integer without any special chars"},
158
			},
159
			Mocks: func(s *mocks.Scanner) {
160
				s.On("Name").Return("fakeScanner")
161
			},
162
		},
163
		{
164
			Name:   "test scanner not found",
165
			Params: params{Supplier: "test"},
166
			Body:   handlers.DryRunScannerInput{Number: "14152229670"},
167
			Expected: expectedResponse{
168
				Code: 404,
169
				Body: api.ErrorResponse{Error: "Scanner not found"},
170
			},
171
			Mocks: func(s *mocks.Scanner) {
172
				s.On("Name").Return("fakeScanner")
173
			},
174
		},
175
		{
176
			Name:   "test invalid number",
177
			Params: params{Supplier: "fakeScanner"},
178
			Body:   handlers.DryRunScannerInput{Number: "222"},
179
			Expected: expectedResponse{
180
				Code: 400,
181
				Body: api.ErrorResponse{Error: "the string supplied is too short to be a phone number"},
182
			},
183
			Mocks: func(s *mocks.Scanner) {
184
				s.On("Name").Return("fakeScanner")
185
			},
186
		},
187
	}
188

189
	for _, tt := range testcases {
190
		t.Run(tt.Name, func(t *testing.T) {
191
			fakeScanner := &mocks.Scanner{}
192
			tt.Mocks(fakeScanner)
193
			handlers.RemoteLibrary = remote.NewLibrary(filter.NewEngine())
194
			handlers.RemoteLibrary.AddScanner(fakeScanner)
195

196
			data, err := json.Marshal(&tt.Body)
197
			if err != nil {
198
				t.Fatal(err)
199
			}
200

201
			req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("/v2/scanners/%s/dryrun", tt.Params.Supplier), bytes.NewReader(data))
202
			if err != nil {
203
				t.Fatal(err)
204
			}
205
			w := httptest.NewRecorder()
206
			server.NewServer().ServeHTTP(w, req)
207

208
			b, err := json.Marshal(tt.Expected.Body)
209
			if err != nil {
210
				t.Fatal(err)
211
			}
212

213
			assert.Equal(t, tt.Expected.Code, w.Code)
214
			assert.Equal(t, string(b), w.Body.String())
215
			fakeScanner.AssertExpectations(t)
216
		})
217
	}
218
}
219

220
func TestRunScanner(t *testing.T) {
221
	type FakeScannerResponse struct {
222
		Info string `json:"info"`
223
	}
224

225
	type expectedResponse struct {
226
		Code int
227
		Body interface{}
228
	}
229

230
	type params struct {
231
		Supplier string
232
	}
233

234
	testcases := []struct {
235
		Name     string
236
		Params   params
237
		Body     interface{}
238
		Expected expectedResponse
239
		Mocks    func(*mocks.Scanner)
240
	}{
241
		{
242
			Name:   "test running scanner",
243
			Params: params{Supplier: "fakeScanner"},
244
			Body:   handlers.RunScannerInput{Number: "14152229670"},
245
			Expected: expectedResponse{
246
				Code: 200,
247
				Body: handlers.RunScannerResponse{
248
					Result: FakeScannerResponse{Info: "test"},
249
				},
250
			},
251
			Mocks: func(s *mocks.Scanner) {
252
				s.On("Name").Return("fakeScanner")
253
				s.On("Run", *test.NewFakeUSNumber(), remote.ScannerOptions{}).Return(FakeScannerResponse{Info: "test"}, nil)
254
			},
255
		},
256
		{
257
			Name:   "test running scanner with error",
258
			Params: params{Supplier: "fakeScanner"},
259
			Body:   handlers.RunScannerInput{Number: "14152229670"},
260
			Expected: expectedResponse{
261
				Code: 500,
262
				Body: api.ErrorResponse{Error: "dummy error"},
263
			},
264
			Mocks: func(s *mocks.Scanner) {
265
				s.On("Name").Return("fakeScanner")
266
				s.On("Run", *test.NewFakeUSNumber(), remote.ScannerOptions{}).Return(nil, errors.New("dummy error"))
267
			},
268
		},
269
		{
270
			Name:   "test invalid number",
271
			Params: params{Supplier: "fakeScanner"},
272
			Body:   handlers.RunScannerInput{Number: "1.4152229670"},
273
			Expected: expectedResponse{
274
				Code: 400,
275
				Body: api.ErrorResponse{Error: "Invalid phone number: please provide an integer without any special chars"},
276
			},
277
			Mocks: func(s *mocks.Scanner) {
278
				s.On("Name").Return("fakeScanner")
279
			},
280
		},
281
		{
282
			Name:   "test scanner not found",
283
			Params: params{Supplier: "test"},
284
			Body:   handlers.RunScannerInput{Number: "14152229670"},
285
			Expected: expectedResponse{
286
				Code: 404,
287
				Body: api.ErrorResponse{Error: "Scanner not found"},
288
			},
289
			Mocks: func(s *mocks.Scanner) {
290
				s.On("Name").Return("fakeScanner")
291
			},
292
		},
293
		{
294
			Name:   "test invalid number",
295
			Params: params{Supplier: "fakeScanner"},
296
			Body:   handlers.RunScannerInput{Number: "222"},
297
			Expected: expectedResponse{
298
				Code: 400,
299
				Body: api.ErrorResponse{Error: "the string supplied is too short to be a phone number"},
300
			},
301
			Mocks: func(s *mocks.Scanner) {
302
				s.On("Name").Return("fakeScanner")
303
			},
304
		},
305
	}
306

307
	for _, tt := range testcases {
308
		t.Run(tt.Name, func(t *testing.T) {
309
			fakeScanner := &mocks.Scanner{}
310
			tt.Mocks(fakeScanner)
311
			handlers.RemoteLibrary = remote.NewLibrary(filter.NewEngine())
312
			handlers.RemoteLibrary.AddScanner(fakeScanner)
313

314
			data, err := json.Marshal(&tt.Body)
315
			if err != nil {
316
				t.Fatal(err)
317
			}
318

319
			req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("/v2/scanners/%s/run", tt.Params.Supplier), bytes.NewReader(data))
320
			if err != nil {
321
				t.Fatal(err)
322
			}
323
			w := httptest.NewRecorder()
324
			server.NewServer().ServeHTTP(w, req)
325

326
			b, err := json.Marshal(tt.Expected.Body)
327
			if err != nil {
328
				t.Fatal(err)
329
			}
330

331
			assert.Equal(t, tt.Expected.Code, w.Code)
332
			assert.Equal(t, string(b), w.Body.String())
333
			fakeScanner.AssertExpectations(t)
334
		})
335
	}
336
}
337

338
Product

Resources

Company
