Skip to content

Commit 8580129

Browse files
authored
worker/jobs/rss: Run test setup queries concurrently (#9663)
1 parent 1fda8c1 commit 8580129

File tree

3 files changed

+72
-42
lines changed

3 files changed

+72
-42
lines changed

src/worker/jobs/rss/sync_crate_feed.rs

Lines changed: 24 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,10 @@ mod tests {
180180
use chrono::NaiveDateTime;
181181
use crates_io_test_db::TestDatabase;
182182
use diesel_async::AsyncConnection;
183+
use futures_util::future::join_all;
183184
use insta::assert_debug_snapshot;
185+
use std::borrow::Cow;
186+
use std::future::Future;
184187

185188
#[tokio::test]
186189
async fn test_load_version_updates() {
@@ -197,32 +200,39 @@ mod tests {
197200
let foo = create_crate(&mut conn, "foo").await;
198201

199202
// If there are less than NUM_ITEMS versions, they should all be returned
200-
create_version(&mut conn, foo, "1.0.0", now - Duration::days(123)).await;
201-
create_version(&mut conn, foo, "1.0.1", now - Duration::days(110)).await;
202-
create_version(&mut conn, foo, "1.1.0", now - Duration::days(100)).await;
203-
create_version(&mut conn, foo, "1.2.0", now - Duration::days(90)).await;
203+
let futures = [
204+
create_version(&mut conn, foo, "1.0.0", now - Duration::days(123)),
205+
create_version(&mut conn, foo, "1.0.1", now - Duration::days(110)),
206+
create_version(&mut conn, foo, "1.1.0", now - Duration::days(100)),
207+
create_version(&mut conn, foo, "1.2.0", now - Duration::days(90)),
208+
];
209+
join_all(futures).await;
204210

205211
let updates = assert_ok!(load_version_updates("foo", &mut conn).await);
206212
assert_eq!(updates.len(), 4);
207213
assert_debug_snapshot!(updates.iter().map(|u| &u.version).collect::<Vec<_>>());
208214

209215
// If there are more than NUM_ITEMS versions, only the most recent NUM_ITEMS should be returned
216+
let mut futures = Vec::new();
210217
for i in 1..=NUM_ITEMS {
211218
let version = format!("1.2.{i}");
212219
let publish_time = now - Duration::days(90) + Duration::hours(i);
213-
create_version(&mut conn, foo, &version, publish_time).await;
220+
futures.push(create_version(&mut conn, foo, version, publish_time));
214221
}
222+
join_all(futures).await;
215223

216224
let updates = assert_ok!(load_version_updates("foo", &mut conn).await);
217225
assert_eq!(updates.len() as i64, NUM_ITEMS);
218226
assert_debug_snapshot!(updates.iter().map(|u| &u.version).collect::<Vec<_>>());
219227

220228
// But if there are more than NUM_ITEMS versions that are younger than ALWAYS_INCLUDE_AGE, all of them should be returned
229+
let mut futures = Vec::new();
221230
for i in 1..=(NUM_ITEMS + 10) {
222231
let version = format!("1.3.{i}");
223232
let publish_time = now - Duration::minutes(30) + Duration::seconds(i);
224-
create_version(&mut conn, foo, &version, publish_time).await;
233+
futures.push(create_version(&mut conn, foo, version, publish_time));
225234
}
235+
join_all(futures).await;
226236

227237
let updates = assert_ok!(load_version_updates("foo", &mut conn).await);
228238
assert_eq!(updates.len() as i64, NUM_ITEMS + 10);
@@ -238,23 +248,23 @@ mod tests {
238248
.unwrap()
239249
}
240250

241-
async fn create_version(
251+
fn create_version(
242252
conn: &mut AsyncPgConnection,
243253
crate_id: i32,
244-
version: &str,
254+
version: impl Into<Cow<'static, str>>,
245255
publish_time: NaiveDateTime,
246-
) -> i32 {
247-
diesel::insert_into(versions::table)
256+
) -> impl Future<Output = i32> {
257+
let future = diesel::insert_into(versions::table)
248258
.values((
249259
versions::crate_id.eq(crate_id),
250-
versions::num.eq(version),
260+
versions::num.eq(version.into()),
251261
versions::created_at.eq(publish_time),
252262
versions::updated_at.eq(publish_time),
253263
versions::checksum.eq("checksum"),
254264
))
255265
.returning(versions::id)
256-
.get_result(conn)
257-
.await
258-
.unwrap()
266+
.get_result(conn);
267+
268+
async move { future.await.unwrap() }
259269
}
260270
}

src/worker/jobs/rss/sync_crates_feed.rs

Lines changed: 24 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -158,7 +158,10 @@ mod tests {
158158
use chrono::NaiveDateTime;
159159
use crates_io_test_db::TestDatabase;
160160
use diesel_async::{AsyncConnection, AsyncPgConnection};
161+
use futures_util::future::join_all;
161162
use insta::assert_debug_snapshot;
163+
use std::borrow::Cow;
164+
use std::future::Future;
162165

163166
#[tokio::test]
164167
async fn test_load_version_updates() {
@@ -173,52 +176,59 @@ mod tests {
173176
assert_eq!(new_crates.len(), 0);
174177

175178
// If there are less than NUM_ITEMS crates, they should all be returned
176-
create_crate(&mut conn, "foo", now - Duration::days(123)).await;
177-
create_crate(&mut conn, "bar", now - Duration::days(110)).await;
178-
create_crate(&mut conn, "baz", now - Duration::days(100)).await;
179-
create_crate(&mut conn, "qux", now - Duration::days(90)).await;
179+
let futures = [
180+
create_crate(&mut conn, "foo", now - Duration::days(123)),
181+
create_crate(&mut conn, "bar", now - Duration::days(110)),
182+
create_crate(&mut conn, "baz", now - Duration::days(100)),
183+
create_crate(&mut conn, "qux", now - Duration::days(90)),
184+
];
185+
join_all(futures).await;
180186

181187
let new_crates = assert_ok!(load_new_crates(&mut conn).await);
182188
assert_eq!(new_crates.len(), 4);
183189
assert_debug_snapshot!(new_crates.iter().map(|u| &u.name).collect::<Vec<_>>());
184190

185191
// If there are more than NUM_ITEMS crates, only the most recent NUM_ITEMS should be returned
192+
let mut futures = Vec::new();
186193
for i in 1..=NUM_ITEMS {
187194
let name = format!("crate-{i}");
188195
let publish_time = now - Duration::days(90) + Duration::hours(i);
189-
create_crate(&mut conn, &name, publish_time).await;
196+
futures.push(create_crate(&mut conn, name, publish_time));
190197
}
198+
join_all(futures).await;
191199

192200
let new_crates = assert_ok!(load_new_crates(&mut conn).await);
193201
assert_eq!(new_crates.len() as i64, NUM_ITEMS);
194202
assert_debug_snapshot!(new_crates.iter().map(|u| &u.name).collect::<Vec<_>>());
195203

196204
// But if there are more than NUM_ITEMS crates that are younger than ALWAYS_INCLUDE_AGE, all of them should be returned
205+
let mut futures = Vec::new();
197206
for i in 1..=(NUM_ITEMS + 10) {
198207
let name = format!("other-crate-{i}");
199208
let publish_time = now - Duration::minutes(30) + Duration::seconds(i);
200-
create_crate(&mut conn, &name, publish_time).await;
209+
futures.push(create_crate(&mut conn, name, publish_time));
201210
}
211+
join_all(futures).await;
202212

203213
let new_crates = assert_ok!(load_new_crates(&mut conn).await);
204214
assert_eq!(new_crates.len() as i64, NUM_ITEMS + 10);
205215
assert_debug_snapshot!(new_crates.iter().map(|u| &u.name).collect::<Vec<_>>());
206216
}
207217

208-
async fn create_crate(
218+
fn create_crate(
209219
conn: &mut AsyncPgConnection,
210-
name: &str,
220+
name: impl Into<Cow<'static, str>>,
211221
publish_time: NaiveDateTime,
212-
) -> i32 {
213-
diesel::insert_into(crates::table)
222+
) -> impl Future<Output = i32> {
223+
let future = diesel::insert_into(crates::table)
214224
.values((
215-
crates::name.eq(name),
225+
crates::name.eq(name.into()),
216226
crates::created_at.eq(publish_time),
217227
crates::updated_at.eq(publish_time),
218228
))
219229
.returning(crates::id)
220-
.get_result(conn)
221-
.await
222-
.unwrap()
230+
.get_result(conn);
231+
232+
async move { future.await.unwrap() }
223233
}
224234
}

src/worker/jobs/rss/sync_updates_feed.rs

Lines changed: 24 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -174,7 +174,10 @@ mod tests {
174174
use chrono::NaiveDateTime;
175175
use crates_io_test_db::TestDatabase;
176176
use diesel_async::AsyncConnection;
177+
use futures_util::future::join_all;
177178
use insta::assert_debug_snapshot;
179+
use std::borrow::Cow;
180+
use std::future::Future;
178181

179182
#[tokio::test]
180183
async fn test_load_version_updates() {
@@ -191,32 +194,39 @@ mod tests {
191194
let foo = create_crate(&mut conn, "foo").await;
192195

193196
// If there are less than NUM_ITEMS versions, they should all be returned
194-
create_version(&mut conn, foo, "1.0.0", now - Duration::days(123)).await;
195-
create_version(&mut conn, foo, "1.0.1", now - Duration::days(110)).await;
196-
create_version(&mut conn, foo, "1.1.0", now - Duration::days(100)).await;
197-
create_version(&mut conn, foo, "1.2.0", now - Duration::days(90)).await;
197+
let futures = [
198+
create_version(&mut conn, foo, "1.0.0", now - Duration::days(123)),
199+
create_version(&mut conn, foo, "1.0.1", now - Duration::days(110)),
200+
create_version(&mut conn, foo, "1.1.0", now - Duration::days(100)),
201+
create_version(&mut conn, foo, "1.2.0", now - Duration::days(90)),
202+
];
203+
join_all(futures).await;
198204

199205
let updates = assert_ok!(load_version_updates(&mut conn).await);
200206
assert_eq!(updates.len(), 4);
201207
assert_debug_snapshot!(updates.iter().map(|u| &u.version).collect::<Vec<_>>());
202208

203209
// If there are more than NUM_ITEMS versions, only the most recent NUM_ITEMS should be returned
210+
let mut futures = Vec::new();
204211
for i in 1..=NUM_ITEMS {
205212
let version = format!("1.2.{i}");
206213
let publish_time = now - Duration::days(90) + Duration::hours(i);
207-
create_version(&mut conn, foo, &version, publish_time).await;
214+
futures.push(create_version(&mut conn, foo, version, publish_time));
208215
}
216+
join_all(futures).await;
209217

210218
let updates = assert_ok!(load_version_updates(&mut conn).await);
211219
assert_eq!(updates.len() as i64, NUM_ITEMS);
212220
assert_debug_snapshot!(updates.iter().map(|u| &u.version).collect::<Vec<_>>());
213221

214222
// But if there are more than NUM_ITEMS versions that are younger than ALWAYS_INCLUDE_AGE, all of them should be returned
223+
let mut futures = Vec::new();
215224
for i in 1..=(NUM_ITEMS + 10) {
216225
let version = format!("1.3.{i}");
217226
let publish_time = now - Duration::minutes(30) + Duration::seconds(i);
218-
create_version(&mut conn, foo, &version, publish_time).await;
227+
futures.push(create_version(&mut conn, foo, version, publish_time));
219228
}
229+
join_all(futures).await;
220230

221231
let updates = assert_ok!(load_version_updates(&mut conn).await);
222232
assert_eq!(updates.len() as i64, NUM_ITEMS + 10);
@@ -232,23 +242,23 @@ mod tests {
232242
.unwrap()
233243
}
234244

235-
async fn create_version(
245+
fn create_version(
236246
conn: &mut AsyncPgConnection,
237247
crate_id: i32,
238-
version: &str,
248+
version: impl Into<Cow<'static, str>>,
239249
publish_time: NaiveDateTime,
240-
) -> i32 {
241-
diesel::insert_into(versions::table)
250+
) -> impl Future<Output = i32> {
251+
let future = diesel::insert_into(versions::table)
242252
.values((
243253
versions::crate_id.eq(crate_id),
244-
versions::num.eq(version),
254+
versions::num.eq(version.into()),
245255
versions::created_at.eq(publish_time),
246256
versions::updated_at.eq(publish_time),
247257
versions::checksum.eq("checksum"),
248258
))
249259
.returning(versions::id)
250-
.get_result(conn)
251-
.await
252-
.unwrap()
260+
.get_result(conn);
261+
262+
async move { future.await.unwrap() }
253263
}
254264
}

0 commit comments

Comments
 (0)