Skip to content

Commit a614dbf

Browse files
Turbo87Turbo87
committed
Replace db() usage with db_conn() 
1 parent d0f800d commit a614dbf

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

64 files changed

+1650
-1774
lines changed

‎src/tests/account_lock.rs‎

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -7,19 +7,19 @@ const URL: &str = "/api/v1/me";
77
const LOCK_REASON: &str = "test lock reason";
88

99
fn lock_account(app: &TestApp, user_id: i32, until: Option<NaiveDateTime>) {
10-
app.db(|conn| {
11-
use crate::schema::users;
12-
use diesel::prelude::*;
13-
14-
diesel::update(users::table)
15-
.set((
16-
users::account_lock_reason.eq(LOCK_REASON),
17-
users::account_lock_until.eq(until),
18-
))
19-
.filter(users::id.eq(user_id))
20-
.execute(conn)
21-
.unwrap();
22-
});
10+
use crate::schema::users;
11+
use diesel::prelude::*;
12+
13+
let mut conn = app.db_conn();
14+
15+
diesel::update(users::table)
16+
.set((
17+
users::account_lock_reason.eq(LOCK_REASON),
18+
users::account_lock_until.eq(until),
19+
))
20+
.filter(users::id.eq(user_id))
21+
.execute(&mut conn)
22+
.unwrap();
2323
}
2424

2525
#[tokio::test(flavor = "multi_thread")]

‎src/tests/blocked_routes.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -10,11 +10,11 @@ async fn test_non_blocked_download_route() {
1010
})
1111
.with_user();
1212

13-
app.db(|conn| {
14-
CrateBuilder::new("foo", user.as_model().id)
15-
.version(VersionBuilder::new("1.0.0"))
16-
.expect_build(conn);
17-
});
13+
let mut conn = app.db_conn();
14+
15+
CrateBuilder::new("foo", user.as_model().id)
16+
.version(VersionBuilder::new("1.0.0"))
17+
.expect_build(&mut conn);
1818

1919
let status = anon
2020
.get::<()>("/api/v1/crates/foo/1.0.0/download")
@@ -34,11 +34,11 @@ async fn test_blocked_download_route() {
3434
})
3535
.with_user();
3636

37-
app.db(|conn| {
38-
CrateBuilder::new("foo", user.as_model().id)
39-
.version(VersionBuilder::new("1.0.0"))
40-
.expect_build(conn);
41-
});
37+
let mut conn = app.db_conn();
38+
39+
CrateBuilder::new("foo", user.as_model().id)
40+
.version(VersionBuilder::new("1.0.0"))
41+
.expect_build(&mut conn);
4242

4343
let status = anon
4444
.get::<()>("/api/v1/crates/foo/1.0.0/download")

‎src/tests/dump_db.rs‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -17,12 +17,11 @@ static PATH_DATE_RE: LazyLock<Regex> =
1717
#[tokio::test(flavor = "multi_thread")]
1818
async fn test_dump_db_job() {
1919
let (app, _, _, token) = TestApp::full().with_token();
20+
let mut conn = app.db_conn();
2021

21-
app.db(|conn| {
22-
CrateBuilder::new("test-crate", token.as_model().user_id).expect_build(conn);
22+
CrateBuilder::new("test-crate", token.as_model().user_id).expect_build(&mut conn);
2323

24-
DumpDb.enqueue(conn).unwrap();
25-
});
24+
DumpDb.enqueue(&mut conn).unwrap();
2625

2726
app.run_pending_background_jobs().await;
2827

‎src/tests/github_secret_scanning.rs‎

Lines changed: 62 additions & 73 deletions
Original file line numberDiff line numberDiff line change
@@ -19,28 +19,25 @@ static GITHUB_PUBLIC_KEY_SIGNATURE: &str = "MEUCIFLZzeK++IhS+y276SRk2Pe5LfDrfvTX
1919
#[tokio::test(flavor = "multi_thread")]
2020
async fn github_secret_alert_revokes_token() {
2121
let (app, anon, user, token) = TestApp::init().with_token();
22+
let mut conn = app.db_conn();
2223

2324
// Ensure no emails were sent up to this point
2425
assert_eq!(app.emails().len(), 0);
2526

2627
// Ensure that the token currently exists in the database
27-
app.db(|conn| {
28-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
29-
.select(ApiToken::as_select())
30-
.filter(api_tokens::revoked.eq(false))
31-
.load(conn));
32-
assert_that!(tokens, len(eq(1)));
33-
assert_eq!(tokens[0].name, token.as_model().name);
34-
});
28+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
29+
.select(ApiToken::as_select())
30+
.filter(api_tokens::revoked.eq(false))
31+
.load(&mut conn));
32+
assert_that!(tokens, len(eq(1)));
33+
assert_eq!(tokens[0].name, token.as_model().name);
3534

3635
// Set token to expected value in signed request
37-
app.db(|conn| {
38-
let hashed_token = HashedToken::hash("some_token");
39-
diesel::update(api_tokens::table)
40-
.set(api_tokens::token.eq(hashed_token))
41-
.execute(conn)
42-
.unwrap();
43-
});
36+
let hashed_token = HashedToken::hash("some_token");
37+
diesel::update(api_tokens::table)
38+
.set(api_tokens::token.eq(hashed_token))
39+
.execute(&mut conn)
40+
.unwrap();
4441

4542
let mut request = anon.post_request(URL);
4643
*request.body_mut() = GITHUB_ALERT.into();
@@ -51,18 +48,17 @@ async fn github_secret_alert_revokes_token() {
5148
assert_json_snapshot!(response.json());
5249

5350
// Ensure that the token was revoked
54-
app.db(|conn| {
55-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
56-
.select(ApiToken::as_select())
57-
.filter(api_tokens::revoked.eq(false))
58-
.load(conn));
59-
assert_that!(tokens, empty());
60-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
61-
.select(ApiToken::as_select())
62-
.filter(api_tokens::revoked.eq(true))
63-
.load(conn));
64-
assert_that!(tokens, len(eq(1)));
65-
});
51+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
52+
.select(ApiToken::as_select())
53+
.filter(api_tokens::revoked.eq(false))
54+
.load(&mut conn));
55+
assert_that!(tokens, empty());
56+
57+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
58+
.select(ApiToken::as_select())
59+
.filter(api_tokens::revoked.eq(true))
60+
.load(&mut conn));
61+
assert_that!(tokens, len(eq(1)));
6662

6763
// Ensure exactly one email was sent
6864
assert_snapshot!(app.emails_snapshot());
@@ -71,31 +67,28 @@ async fn github_secret_alert_revokes_token() {
7167
#[tokio::test(flavor = "multi_thread")]
7268
async fn github_secret_alert_for_revoked_token() {
7369
let (app, anon, user, token) = TestApp::init().with_token();
70+
let mut conn = app.db_conn();
7471

7572
// Ensure no emails were sent up to this point
7673
assert_eq!(app.emails().len(), 0);
7774

7875
// Ensure that the token currently exists in the database
79-
app.db(|conn| {
80-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
81-
.select(ApiToken::as_select())
82-
.filter(api_tokens::revoked.eq(false))
83-
.load(conn));
84-
assert_that!(tokens, len(eq(1)));
85-
assert_eq!(tokens[0].name, token.as_model().name);
86-
});
76+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
77+
.select(ApiToken::as_select())
78+
.filter(api_tokens::revoked.eq(false))
79+
.load(&mut conn));
80+
assert_that!(tokens, len(eq(1)));
81+
assert_eq!(tokens[0].name, token.as_model().name);
8782

8883
// Set token to expected value in signed request and revoke it
89-
app.db(|conn| {
90-
let hashed_token = HashedToken::hash("some_token");
91-
diesel::update(api_tokens::table)
92-
.set((
93-
api_tokens::token.eq(hashed_token),
94-
api_tokens::revoked.eq(true),
95-
))
96-
.execute(conn)
97-
.unwrap();
98-
});
84+
let hashed_token = HashedToken::hash("some_token");
85+
diesel::update(api_tokens::table)
86+
.set((
87+
api_tokens::token.eq(hashed_token),
88+
api_tokens::revoked.eq(true),
89+
))
90+
.execute(&mut conn)
91+
.unwrap();
9992

10093
let mut request = anon.post_request(URL);
10194
*request.body_mut() = GITHUB_ALERT.into();
@@ -106,18 +99,17 @@ async fn github_secret_alert_for_revoked_token() {
10699
assert_json_snapshot!(response.json());
107100

108101
// Ensure that the token is still revoked
109-
app.db(|conn| {
110-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
111-
.select(ApiToken::as_select())
112-
.filter(api_tokens::revoked.eq(false))
113-
.load(conn));
114-
assert_that!(tokens, empty());
115-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
116-
.select(ApiToken::as_select())
117-
.filter(api_tokens::revoked.eq(true))
118-
.load(conn));
119-
assert_that!(tokens, len(eq(1)));
120-
});
102+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
103+
.select(ApiToken::as_select())
104+
.filter(api_tokens::revoked.eq(false))
105+
.load(&mut conn));
106+
assert_that!(tokens, empty());
107+
108+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
109+
.select(ApiToken::as_select())
110+
.filter(api_tokens::revoked.eq(true))
111+
.load(&mut conn));
112+
assert_that!(tokens, len(eq(1)));
121113

122114
// Ensure still no emails were sent
123115
assert_eq!(app.emails().len(), 0);
@@ -126,19 +118,18 @@ async fn github_secret_alert_for_revoked_token() {
126118
#[tokio::test(flavor = "multi_thread")]
127119
async fn github_secret_alert_for_unknown_token() {
128120
let (app, anon, user, token) = TestApp::init().with_token();
121+
let mut conn = app.db_conn();
129122

130123
// Ensure no emails were sent up to this point
131124
assert_eq!(app.emails().len(), 0);
132125

133126
// Ensure that the token currently exists in the database
134-
app.db(|conn| {
135-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
136-
.select(ApiToken::as_select())
137-
.filter(api_tokens::revoked.eq(false))
138-
.load(conn));
139-
assert_that!(tokens, len(eq(1)));
140-
assert_eq!(tokens[0].name, token.as_model().name);
141-
});
127+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
128+
.select(ApiToken::as_select())
129+
.filter(api_tokens::revoked.eq(false))
130+
.load(&mut conn));
131+
assert_that!(tokens, len(eq(1)));
132+
assert_eq!(tokens[0].name, token.as_model().name);
142133

143134
let mut request = anon.post_request(URL);
144135
*request.body_mut() = GITHUB_ALERT.into();
@@ -149,14 +140,12 @@ async fn github_secret_alert_for_unknown_token() {
149140
assert_json_snapshot!(response.json());
150141

151142
// Ensure that the token was not revoked
152-
app.db(|conn| {
153-
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
154-
.select(ApiToken::as_select())
155-
.filter(api_tokens::revoked.eq(false))
156-
.load(conn));
157-
assert_that!(tokens, len(eq(1)));
158-
assert_eq!(tokens[0].name, token.as_model().name);
159-
});
143+
let tokens: Vec<ApiToken> = assert_ok!(ApiToken::belonging_to(user.as_model())
144+
.select(ApiToken::as_select())
145+
.filter(api_tokens::revoked.eq(false))
146+
.load(&mut conn));
147+
assert_that!(tokens, len(eq(1)));
148+
assert_eq!(tokens[0].name, token.as_model().name);
160149

161150
// Ensure still no emails were sent
162151
assert_eq!(app.emails().len(), 0);

‎src/tests/krate/following.rs‎

Lines changed: 7 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -33,10 +33,9 @@ async fn test_unauthenticated_requests() {
3333
const CRATE_NAME: &str = "foo";
3434

3535
let (app, anon, user) = TestApp::init().with_user();
36+
let mut conn = app.db_conn();
3637

37-
app.db(|conn| {
38-
CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(conn);
39-
});
38+
CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(&mut conn);
4039

4140
let response = anon
4241
.get::<()>(&format!("/api/v1/crates/{CRATE_NAME}/following"))
@@ -62,10 +61,9 @@ async fn test_following() {
6261
const CRATE_NAME: &str = "foo_following";
6362

6463
let (app, _, user) = TestApp::init().with_user();
64+
let mut conn = app.db_conn();
6565

66-
app.db(|conn| {
67-
CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(conn);
68-
});
66+
CrateBuilder::new(CRATE_NAME, user.as_model().id).expect_build(&mut conn);
6967

7068
// Check that initially we are not following the crate yet.
7169
assert_is_following(CRATE_NAME, false, &user).await;
@@ -119,12 +117,11 @@ async fn test_api_token_auth() {
119117
const CRATE_NOT_TO_FOLLOW: &str = "another_crate";
120118

121119
let (app, _, user, token) = TestApp::init().with_token();
120+
let mut conn = app.db_conn();
122121
let api_token = token.as_model();
123122

124-
app.db(|conn| {
125-
CrateBuilder::new(CRATE_TO_FOLLOW, api_token.user_id).expect_build(conn);
126-
CrateBuilder::new(CRATE_NOT_TO_FOLLOW, api_token.user_id).expect_build(conn);
127-
});
123+
CrateBuilder::new(CRATE_TO_FOLLOW, api_token.user_id).expect_build(&mut conn);
124+
CrateBuilder::new(CRATE_NOT_TO_FOLLOW, api_token.user_id).expect_build(&mut conn);
128125

129126
follow(CRATE_TO_FOLLOW, &token).await;
130127

‎src/tests/krate/publish/audit_action.rs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,8 @@ async fn publish_records_an_audit_action() {
88

99
let (app, anon, _, token) = TestApp::full().with_token();
1010

11-
app.db(|conn| assert!(VersionOwnerAction::all(conn).unwrap().is_empty()));
11+
let mut conn = app.db_conn();
12+
assert!(VersionOwnerAction::all(&mut conn).unwrap().is_empty());
1213

1314
// Upload a new crate, putting it in the git index
1415
let crate_to_publish = PublishBuilder::new("fyk", "1.0.0");

‎src/tests/krate/publish/auth.rs‎

Lines changed: 8 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@ use insta::assert_snapshot;
99
#[tokio::test(flavor = "multi_thread")]
1010
async fn new_wrong_token() {
1111
let (app, anon, _, token) = TestApp::full().with_token();
12+
let mut conn = app.db_conn();
1213

1314
// Try to publish without a token
1415
let crate_to_publish = PublishBuilder::new("foo", "1.0.0");
@@ -17,12 +18,10 @@ async fn new_wrong_token() {
1718
assert_snapshot!(response.text(), @r###"{"errors":[{"detail":"this action requires authentication"}]}"###);
1819

1920
// Try to publish with the wrong token (by changing the token in the database)
20-
app.db(|conn| {
21-
diesel::update(api_tokens::table)
22-
.set(api_tokens::token.eq(b"bad" as &[u8]))
23-
.execute(conn)
24-
.unwrap();
25-
});
21+
diesel::update(api_tokens::table)
22+
.set(api_tokens::token.eq(b"bad" as &[u8]))
23+
.execute(&mut conn)
24+
.unwrap();
2625

2726
let crate_to_publish = PublishBuilder::new("foo", "1.0.0");
2827
let response = token.publish_crate(crate_to_publish).await;
@@ -35,11 +34,10 @@ async fn new_wrong_token() {
3534
#[tokio::test(flavor = "multi_thread")]
3635
async fn new_krate_wrong_user() {
3736
let (app, _, user) = TestApp::full().with_user();
37+
let mut conn = app.db_conn();
3838

39-
app.db(|conn| {
40-
// Create the foo_wrong crate with one user
41-
CrateBuilder::new("foo_wrong", user.as_model().id).expect_build(conn);
42-
});
39+
// Create the foo_wrong crate with one user
40+
CrateBuilder::new("foo_wrong", user.as_model().id).expect_build(&mut conn);
4341

4442
// Then try to publish with a different user
4543
let another_user = app.db_new_user("another").db_new_token("bar");

0 commit comments

Comments
 (0)