Skip to content

Commit 74f55c3

Browse files
morremeyermorremeyer
authored
refactor: remove unnecessary parameters from test helpers (#401)
1 parent 3e702fd commit 74f55c3

File tree

13 files changed

+615
-597
lines changed

13 files changed

+615
-597
lines changed

‎pkg/controllers/account_test.go‎

Lines changed: 49 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -13,21 +13,21 @@ import (
1313
"github.com/stretchr/testify/assert"
1414
)
1515

16-
func (suite *TestSuiteStandard) createTestAccount(t *testing.T, c models.AccountCreate, expectedStatus ...int) controllers.AccountResponse {
16+
func (suite *TestSuiteStandard) createTestAccount(c models.AccountCreate, expectedStatus ...int) controllers.AccountResponse {
1717
if c.BudgetID == uuid.Nil {
18-
c.BudgetID = suite.createTestBudget(t, models.BudgetCreate{Name: "Testing budget"}).Data.ID
18+
c.BudgetID = suite.createTestBudget(models.BudgetCreate{Name: "Testing budget"}).Data.ID
1919
}
2020

2121
// Default to 200 OK as expected status
2222
if len(expectedStatus) == 0 {
2323
expectedStatus = append(expectedStatus, http.StatusCreated)
2424
}
2525

26-
r := test.Request(suite.controller, t, http.MethodPost, "http://example.com/v1/accounts", c)
27-
test.AssertHTTPStatus(t, &r, expectedStatus...)
26+
r := test.Request(suite.controller, suite.T(), http.MethodPost, "http://example.com/v1/accounts", c)
27+
suite.assertHTTPStatus(&r, expectedStatus...)
2828

2929
var a controllers.AccountResponse
30-
test.DecodeResponse(t, &r, &a)
30+
suite.decodeResponse(&r, &a)
3131

3232
return a
3333
}
@@ -36,7 +36,7 @@ func (suite *TestSuiteStandard) TestAccounts() {
3636
suite.CloseDB()
3737

3838
recorder := test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts", "")
39-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusInternalServerError)
39+
suite.assertHTTPStatus(&recorder, http.StatusInternalServerError)
4040
assert.Contains(suite.T(), test.DecodeError(suite.T(), recorder.Body.Bytes()), "There is a problem with the database connection")
4141
}
4242

@@ -48,51 +48,51 @@ func (suite *TestSuiteStandard) TestOptionsAccount() {
4848
recorder = test.Request(suite.controller, suite.T(), http.MethodOptions, "http://example.com/v1/accounts/NotParseableAsUUID", "")
4949
assert.Equal(suite.T(), http.StatusBadRequest, recorder.Code, "Request ID %s", recorder.Header().Get("x-request-id"))
5050

51-
path = suite.createTestAccount(suite.T(), models.AccountCreate{}).Data.Links.Self
51+
path = suite.createTestAccount(models.AccountCreate{}).Data.Links.Self
5252
recorder = test.Request(suite.controller, suite.T(), http.MethodOptions, path, "")
5353
assert.Equal(suite.T(), http.StatusNoContent, recorder.Code, "Request ID %s", recorder.Header().Get("x-request-id"))
5454
}
5555

5656
func (suite *TestSuiteStandard) TestGetAccounts() {
57-
_ = suite.createTestAccount(suite.T(), models.AccountCreate{})
57+
_ = suite.createTestAccount(models.AccountCreate{})
5858

5959
var response controllers.AccountListResponse
6060
recorder := test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts", "")
61-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusOK)
62-
test.DecodeResponse(suite.T(), &recorder, &response)
61+
suite.assertHTTPStatus(&recorder, http.StatusOK)
62+
suite.decodeResponse(&recorder, &response)
6363

6464
assert.Len(suite.T(), response.Data, 1)
6565
}
6666

6767
func (suite *TestSuiteStandard) TestGetAccountsInvalidQuery() {
6868
recorder := test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts?onBudget=NotABoolean", "")
69-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusBadRequest)
69+
suite.assertHTTPStatus(&recorder, http.StatusBadRequest)
7070

7171
recorder = test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts?budget=8593-not-a-uuid", "")
72-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusBadRequest)
72+
suite.assertHTTPStatus(&recorder, http.StatusBadRequest)
7373
}
7474

7575
func (suite *TestSuiteStandard) TestGetAccountsFilter() {
76-
b1 := suite.createTestBudget(suite.T(), models.BudgetCreate{})
77-
b2 := suite.createTestBudget(suite.T(), models.BudgetCreate{})
76+
b1 := suite.createTestBudget(models.BudgetCreate{})
77+
b2 := suite.createTestBudget(models.BudgetCreate{})
7878

79-
a1 := suite.createTestAccount(suite.T(), models.AccountCreate{
79+
a1 := suite.createTestAccount(models.AccountCreate{
8080
Name: "Exact Account Match",
8181
Note: "This is a specific note",
8282
BudgetID: b1.Data.ID,
8383
OnBudget: true,
8484
External: false,
8585
})
8686

87-
a2 := suite.createTestAccount(suite.T(), models.AccountCreate{
87+
a2 := suite.createTestAccount(models.AccountCreate{
8888
Name: "External Account Filter",
8989
Note: "This is a specific note",
9090
BudgetID: b2.Data.ID,
9191
OnBudget: true,
9292
External: true,
9393
})
9494

95-
a3 := suite.createTestAccount(suite.T(), models.AccountCreate{
95+
a3 := suite.createTestAccount(models.AccountCreate{
9696
Name: "External Account Filter",
9797
Note: "A different note",
9898
BudgetID: b1.Data.ID,
@@ -119,8 +119,8 @@ func (suite *TestSuiteStandard) TestGetAccountsFilter() {
119119
suite.T().Run(tt.name, func(t *testing.T) {
120120
var re controllers.BudgetListResponse
121121
r := test.Request(suite.controller, t, http.MethodGet, fmt.Sprintf("/v1/accounts?%s", tt.query), "")
122-
test.AssertHTTPStatus(t, &r, http.StatusOK)
123-
test.DecodeResponse(t, &r, &re)
122+
suite.assertHTTPStatus(&r, http.StatusOK)
123+
suite.decodeResponse(&r, &re)
124124

125125
var accountNames []string
126126
for _, d := range re.Data {
@@ -141,67 +141,67 @@ func (suite *TestSuiteStandard) TestGetAccountsFilter() {
141141

142142
func (suite *TestSuiteStandard) TestNoAccountNotFound() {
143143
recorder := test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts/39633f90-3d9f-4b1e-ac24-c341c432a6e3", "")
144-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusNotFound)
144+
suite.assertHTTPStatus(&recorder, http.StatusNotFound)
145145
}
146146

147147
func (suite *TestSuiteStandard) TestAccountInvalidIDs() {
148148
/*
149149
* GET
150150
*/
151151
r := test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts/-56", "")
152-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
152+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
153153

154154
r = test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts/notANumber", "")
155-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
155+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
156156

157157
r = test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts/23", "")
158-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
158+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
159159

160160
/*
161161
* PATCH
162162
*/
163163
r = test.Request(suite.controller, suite.T(), http.MethodPatch, "http://example.com/v1/accounts/-274", "")
164-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
164+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
165165

166166
r = test.Request(suite.controller, suite.T(), http.MethodPatch, "http://example.com/v1/accounts/stringRandom", "")
167-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
167+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
168168

169169
/*
170170
* DELETE
171171
*/
172172
r = test.Request(suite.controller, suite.T(), http.MethodDelete, "http://example.com/v1/accounts/-274", "")
173-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
173+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
174174

175175
r = test.Request(suite.controller, suite.T(), http.MethodDelete, "http://example.com/v1/accounts/stringRandom", "")
176-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
176+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
177177
}
178178

179179
func (suite *TestSuiteStandard) TestCreateAccount() {
180-
_ = suite.createTestAccount(suite.T(), models.AccountCreate{Name: "Test account for creation"})
180+
_ = suite.createTestAccount(models.AccountCreate{Name: "Test account for creation"})
181181
}
182182

183183
func (suite *TestSuiteStandard) TestCreateAccountNoBudget() {
184184
r := test.Request(suite.controller, suite.T(), http.MethodPost, "http://example.com/v1/accounts", models.Account{})
185-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
185+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
186186
}
187187

188188
func (suite *TestSuiteStandard) TestCreateBrokenAccount() {
189189
recorder := test.Request(suite.controller, suite.T(), http.MethodPost, "http://example.com/v1/accounts", `{ "createdAt": "New Account", "note": "More tests for accounts to ensure less brokenness something" }`)
190-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusBadRequest)
190+
suite.assertHTTPStatus(&recorder, http.StatusBadRequest)
191191
}
192192

193193
func (suite *TestSuiteStandard) TestCreateAccountNoBody() {
194194
recorder := test.Request(suite.controller, suite.T(), http.MethodPost, "http://example.com/v1/accounts", "")
195-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusBadRequest)
195+
suite.assertHTTPStatus(&recorder, http.StatusBadRequest)
196196
}
197197

198198
func (suite *TestSuiteStandard) TestCreateAccountNonExistingBudget() {
199199
recorder := test.Request(suite.controller, suite.T(), http.MethodPost, "http://example.com/v1/accounts", models.AccountCreate{BudgetID: uuid.New()})
200-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusNotFound)
200+
suite.assertHTTPStatus(&recorder, http.StatusNotFound)
201201
}
202202

203203
func (suite *TestSuiteStandard) TestGetAccount() {
204-
a := suite.createTestAccount(suite.T(), models.AccountCreate{})
204+
a := suite.createTestAccount(models.AccountCreate{})
205205

206206
r := test.Request(suite.controller, suite.T(), http.MethodGet, a.Data.Links.Self, "")
207207
assert.Equal(suite.T(), http.StatusOK, r.Code)
@@ -213,74 +213,74 @@ func (suite *TestSuiteStandard) TestGetAccountTransactionsNonExistingAccount() {
213213
}
214214

215215
func (suite *TestSuiteStandard) TestUpdateAccount() {
216-
a := suite.createTestAccount(suite.T(), models.AccountCreate{Name: "Original name", OnBudget: true})
216+
a := suite.createTestAccount(models.AccountCreate{Name: "Original name", OnBudget: true})
217217

218218
r := test.Request(suite.controller, suite.T(), http.MethodPatch, a.Data.Links.Self, map[string]any{
219219
"name": "Updated new account for testing",
220220
"note": "",
221221
"onBudget": false,
222222
})
223-
test.AssertHTTPStatus(suite.T(), &r, http.StatusOK)
223+
suite.assertHTTPStatus(&r, http.StatusOK)
224224

225225
var u controllers.AccountResponse
226-
test.DecodeResponse(suite.T(), &r, &u)
226+
suite.decodeResponse(&r, &u)
227227

228228
assert.Equal(suite.T(), "Updated new account for testing", u.Data.Name)
229229
assert.Equal(suite.T(), "", u.Data.Note)
230230
assert.Equal(suite.T(), false, u.Data.OnBudget)
231231
}
232232

233233
func (suite *TestSuiteStandard) TestUpdateAccountBrokenJSON() {
234-
a := suite.createTestAccount(suite.T(), models.AccountCreate{
234+
a := suite.createTestAccount(models.AccountCreate{
235235
Name: "New Account",
236236
Note: "More tests something something",
237237
})
238238

239239
r := test.Request(suite.controller, suite.T(), http.MethodPatch, a.Data.Links.Self, `{ "name": 2" }`)
240-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
240+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
241241
}
242242

243243
func (suite *TestSuiteStandard) TestUpdateAccountInvalidType() {
244-
a := suite.createTestAccount(suite.T(), models.AccountCreate{
244+
a := suite.createTestAccount(models.AccountCreate{
245245
Name: "New Account",
246246
Note: "More tests something something",
247247
})
248248

249249
r := test.Request(suite.controller, suite.T(), http.MethodPatch, a.Data.Links.Self, map[string]any{
250250
"name": 2,
251251
})
252-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
252+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
253253
}
254254

255255
func (suite *TestSuiteStandard) TestUpdateAccountInvalidBudgetID() {
256-
a := suite.createTestAccount(suite.T(), models.AccountCreate{
256+
a := suite.createTestAccount(models.AccountCreate{
257257
Name: "New Account",
258258
Note: "More tests something something",
259259
})
260260

261261
// Sets the BudgetID to uuid.Nil
262262
r := test.Request(suite.controller, suite.T(), http.MethodPatch, a.Data.Links.Self, models.AccountCreate{})
263-
test.AssertHTTPStatus(suite.T(), &r, http.StatusBadRequest)
263+
suite.assertHTTPStatus(&r, http.StatusBadRequest)
264264
}
265265

266266
func (suite *TestSuiteStandard) TestUpdateNonExistingAccount() {
267267
recorder := test.Request(suite.controller, suite.T(), http.MethodPatch, "http://example.com/v1/accounts/9b81de41-eead-451d-bc6b-31fceedd236c", models.AccountCreate{Name: "This account does not exist"})
268-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusNotFound)
268+
suite.assertHTTPStatus(&recorder, http.StatusNotFound)
269269
}
270270

271271
func (suite *TestSuiteStandard) TestDeleteAccountsAndEmptyList() {
272272
r := test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts", "")
273273

274274
var l controllers.AccountListResponse
275-
test.DecodeResponse(suite.T(), &r, &l)
275+
suite.decodeResponse(&r, &l)
276276

277277
for _, a := range l.Data {
278278
r = test.Request(suite.controller, suite.T(), http.MethodDelete, a.Links.Self, "")
279-
test.AssertHTTPStatus(suite.T(), &r, http.StatusNoContent)
279+
suite.assertHTTPStatus(&r, http.StatusNoContent)
280280
}
281281

282282
r = test.Request(suite.controller, suite.T(), http.MethodGet, "http://example.com/v1/accounts", "")
283-
test.DecodeResponse(suite.T(), &r, &l)
283+
suite.decodeResponse(&r, &l)
284284

285285
// Verify that the account list is an empty list, not null
286286
assert.NotNil(suite.T(), l.Data)
@@ -289,14 +289,14 @@ func (suite *TestSuiteStandard) TestDeleteAccountsAndEmptyList() {
289289

290290
func (suite *TestSuiteStandard) TestDeleteNonExistingAccount() {
291291
recorder := test.Request(suite.controller, suite.T(), http.MethodDelete, "http://example.com/v1/accounts/77b70a75-4bb3-4d1d-90cf-5b7a61f452f5", "")
292-
test.AssertHTTPStatus(suite.T(), &recorder, http.StatusNotFound)
292+
suite.assertHTTPStatus(&recorder, http.StatusNotFound)
293293
}
294294

295295
func (suite *TestSuiteStandard) TestDeleteAccountWithBody() {
296-
a := suite.createTestAccount(suite.T(), models.AccountCreate{Name: "Delete me now!"})
296+
a := suite.createTestAccount(models.AccountCreate{Name: "Delete me now!"})
297297

298298
r := test.Request(suite.controller, suite.T(), http.MethodDelete, a.Data.Links.Self, models.AccountCreate{Name: "Some other account"})
299-
test.AssertHTTPStatus(suite.T(), &r, http.StatusNoContent)
299+
suite.assertHTTPStatus(&r, http.StatusNoContent)
300300

301301
r = test.Request(suite.controller, suite.T(), http.MethodGet, a.Data.Links.Self, "")
302302
}

0 commit comments

Comments
 (0)