test(subscriber): add test for tasks being kept open

Cargo.toml

@@ -6,3 +6,6 @@ members = [
  "xtask"
 ]
 resolver = "2"
+
+[patch.crates-io]
+tokio = { git = "https://github.com/tokio-rs/tokio.git", branch = "master" }

console-subscriber/Cargo.toml

@@ -32,7 +32,7 @@ env-filter = ["tracing-subscriber/env-filter"]
 [dependencies]
 
 crossbeam-utils = "0.8.7"
-tokio = { version = "^1.21", features = ["sync", "time", "macros", "tracing"] }
+tokio = { version = "1.34", features = ["sync", "time", "macros", "tracing"] }
 tokio-stream = { version = "0.1", features = ["net"] }
 thread_local = "1.1.3"
 console-api = { version = "0.6.0", path = "../console-api", features = ["transport"] }
@@ -54,7 +54,7 @@ serde_json = "1"
 crossbeam-channel = "0.5"
 
 [dev-dependencies]
-tokio = { version = "^1.21", features = ["full", "rt-multi-thread"] }
+tokio = { version = "1.34", features = ["full", "rt-multi-thread"] }
 tower = { version = "0.4", default-features = false }
 futures = "0.3"
 

console-subscriber/tests/framework.rs

@@ -11,7 +11,7 @@ use futures::future;
 use tokio::{task, time::sleep};
 
 mod support;
-use support::{assert_task, assert_tasks, ExpectedTask};
+use support::{assert_task, assert_tasks, ExpectedTask, TaskState};
 
 #[test]
 fn expect_present() {
@@ -198,6 +198,54 @@ fn fail_polls() {
  assert_task(expected_task, future);
 }
 
+#[test]
+fn main_task_completes() {
+ let expected_task = ExpectedTask::default()
+ .match_default_name()
+ .expect_state(TaskState::Completed);
+
+ let future = async {};
+
+ assert_task(expected_task, future);
+}
+
+#[test]
+#[should_panic(expected = "Test failed: Task validation failed:
+ - Task { name=task }: expected `state` to be Idle, but actual was Completed")]
+fn fail_completed_task_is_idle() {
+ let expected_task = ExpectedTask::default()
+ .match_name("task".into())
+ .expect_state(TaskState::Idle);
+
+ let future = async {
+ _ = task::Builder::new()
+ .name("task")
+ .spawn(futures::future::ready(()))
+ .unwrap()
+ .await;
+ };
+
+ assert_task(expected_task, future);
+}
+
+#[test]
+#[should_panic(expected = "Test failed: Task validation failed:
+ - Task { name=task }: expected `state` to be Completed, but actual was Idle")]
+fn fail_idle_task_is_completed() {
+ let expected_task = ExpectedTask::default()
+ .match_name("task".into())
+ .expect_state(TaskState::Completed);
+
+ let future = async {
+ _ = task::Builder::new()
+ .name("task")
+ .spawn(futures::future::pending::<()>())
+ .unwrap();
+ };
+
+ assert_task(expected_task, future);
+}
+
 async fn yield_to_runtime() {
  // There is a race condition that can occur when tests are run in parallel,
  // caused by tokio-rs/tracing#2743. It tends to cause test failures only

console-subscriber/tests/spawn.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 use tokio::time::sleep;
 
 mod support;
-use support::{assert_tasks, spawn_named, ExpectedTask};
+use support::{assert_tasks, spawn_named, ExpectedTask, TaskState};
 
 /// This test asserts the behavior that was fixed in #440. Before that fix,
 /// the polls of a child were also counted towards the parent (the task which
@@ -34,3 +34,28 @@ fn child_polls_dont_count_towards_parent_polls() {
 
  assert_tasks(expected_tasks, future);
 }
+
+/// This test asserts that the lifetime of a task is not affected by the
+/// lifetimes of tasks that it spawns. The test will pass when #345 is
+/// fixed.
+#[test]
+fn spawner_task_with_running_children_completes() {
+ let expected_tasks = vec![
+ ExpectedTask::default()
+ .match_name("parent".into())
+ .expect_state(TaskState::Completed),
+ ExpectedTask::default()
+ .match_name("child".into())
+ .expect_state(TaskState::Idle),
+ ];
+
+ let future = async {
+ spawn_named("parent", async {
+ spawn_named("child", futures::future::pending::<()>());
+ })
+ .await
+ .expect("joining parent failed");
+ };
+
+ assert_tasks(expected_tasks, future);
+}

console-subscriber/tests/support/mod.rs

@@ -8,6 +8,8 @@ use subscriber::run_test;
 
 pub(crate) use subscriber::MAIN_TASK_NAME;
 pub(crate) use task::ExpectedTask;
+#[allow(unused_imports)]
+pub(crate) use task::TaskState;
 use tokio::task::JoinHandle;
 
 /// Assert that an `expected_task` is recorded by a console-subscriber