Rename "channels" to "conversations."

The term "channel" for a conversational container has a long and storied history, but is mostly evocative of IRC and of other, ah, "nerd-centric" services. It does show up in more widespread contexts: Discord and Slack both refer to their primary conversational containers as "channels," for example. However, I think it's unnecessary jargon, and I'd like to do away with it.

To that end, this change pervasively changes one term to the other wherever it appears, with the following exceptions:

* A `channel` concept (unrelated to conversations) is also provided by an external library; we can't and shouldn't try to rename that.
* The code to deal with the `pilcrow:channelData` and `pilcrow:lastActiveChannel` local storage properties is still present, to migrate existing data to new keys. It will be removed in a later change.

This is a **breaking API change**. As we are not yet managing any API compatibility promises, this is formally not an issue, but it is something to be aware of practically. The major API changes are:

* Paths beginning with `/api/channels` are now under `/api/conversations`, without other modifications.
* Fields labelled with `channel…` terms are now labelled with `conversation…` terms. For example, a `message` `sent` event is now sent to a `conversation`, not a `channel`.

This is also a **breaking UI change**. Specifically, any saved paths for `/ch/CHANNELID` will now lead to a 404. The corresponding paths are `/c/CONVERSATIONID`. While I've made an effort to migrate the location of stored data, I have not tried to provide adapters to fix this specific issue, because the disruption is short-lived and very easily addressed by opening a channel in the client UI.

This change is obnoxiously large and difficult to review, for which I apologize. If this shows up in `git annotate`, please forgive me. These kinds of renamings are hard to carry out without a major disruption, especially when the concept ("channel" in this case) is used so pervasively throughout the system.

I think it's worth making this change that pervasively so that we don't have an indefinitely-long tail of "well, it's a conversation in the docs, but the table is called `channel` for historical reasons" type issues.

Merges conversations-not-channels into main.

5 files changed, 134 insertions, 130 deletions

diff --git a/src/event/handlers/stream/test/channel.rs b/src/event/handlers/stream/test/conversation.rs
index 2b87ce2..5e08075 100644
--- a/src/event/handlers/stream/test/channel.rs
+++ b/src/event/handlers/stream/test/conversation.rs
@@ -23,23 +23,23 @@ async fn creating() {
     .await
     .expect("subscribe never fails");
 
-    // Create a channel
+    // Create a conversation
 
-    let name = fixtures::channel::propose();
-    let channel = app
-        .channels()
+    let name = fixtures::conversation::propose();
+    let conversation = app
+        .conversations()
         .create(&name, &fixtures::now())
         .await
-        .expect("creating a channel succeeds");
+        .expect("creating a conversation succeeds");
 
-    // Verify channel created event
+    // Verify conversation created event
 
     events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::created)
-        .filter(|event| future::ready(event.channel == channel))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::created)
+        .filter(|event| future::ready(event.conversation == conversation))
         .next()
-        .expect_some("channel created event is delivered")
+        .expect_some("conversation created event is delivered")
         .await;
 }
 
@@ -50,14 +50,14 @@ async fn previously_created() {
     let app = fixtures::scratch_app().await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
-    // Create a channel
+    // Create a conversation
 
-    let name = fixtures::channel::propose();
-    let channel = app
-        .channels()
+    let name = fixtures::conversation::propose();
+    let conversation = app
+        .conversations()
         .create(&name, &fixtures::now())
         .await
-        .expect("creating a channel succeeds");
+        .expect("creating a conversation succeeds");
 
     // Subscribe
 
@@ -71,14 +71,14 @@ async fn previously_created() {
     .await
     .expect("subscribe never fails");
 
-    // Verify channel created event
+    // Verify conversation created event
 
     let _ = events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::created)
-        .filter(|event| future::ready(event.channel == channel))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::created)
+        .filter(|event| future::ready(event.conversation == conversation))
         .next()
-        .expect_some("channel created event is delivered")
+        .expect_some("conversation created event is delivered")
         .await;
 }
 
@@ -87,7 +87,7 @@ async fn expiring() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe
@@ -102,20 +102,20 @@ async fn expiring() {
     .await
     .expect("subscribe never fails");
 
-    // Expire channels
+    // Expire conversations
 
-    app.channels()
+    app.conversations()
         .expire(&fixtures::now())
         .await
-        .expect("expiring channels always succeeds");
+        .expect("expiring conversations always succeeds");
 
     // Check for expiry event
     let _ = events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::deleted)
-        .filter(|event| future::ready(event.id == channel.id))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::deleted)
+        .filter(|event| future::ready(event.id == conversation.id))
         .next()
-        .expect_some("a deleted channel event will be delivered")
+        .expect_some("a deleted conversation event will be delivered")
         .await;
 }
 
@@ -124,15 +124,15 @@ async fn previously_expired() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
-    // Expire channels
+    // Expire conversations
 
-    app.channels()
+    app.conversations()
         .expire(&fixtures::now())
         .await
-        .expect("expiring channels always succeeds");
+        .expect("expiring conversation always succeeds");
 
     // Subscribe
 
@@ -148,11 +148,11 @@ async fn previously_expired() {
 
     // Check for expiry event
     let _ = events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::deleted)
-        .filter(|event| future::ready(event.id == channel.id))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::deleted)
+        .filter(|event| future::ready(event.id == conversation.id))
         .next()
-        .expect_some("a deleted channel event will be delivered")
+        .expect_some("a deleted conversation event will be delivered")
         .await;
 }
 
@@ -161,7 +161,7 @@ async fn deleting() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe
@@ -176,20 +176,20 @@ async fn deleting() {
     .await
     .expect("subscribe never fails");
 
-    // Delete the channel
+    // Delete the conversation
 
-    app.channels()
-        .delete(&channel.id, &fixtures::now())
+    app.conversations()
+        .delete(&conversation.id, &fixtures::now())
         .await
-        .expect("deleting a valid channel succeeds");
+        .expect("deleting a valid conversation succeeds");
 
     // Check for delete event
     let _ = events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::deleted)
-        .filter(|event| future::ready(event.id == channel.id))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::deleted)
+        .filter(|event| future::ready(event.id == conversation.id))
         .next()
-        .expect_some("a deleted channel event will be delivered")
+        .expect_some("a deleted conversation event will be delivered")
         .await;
 }
 
@@ -198,15 +198,15 @@ async fn previously_deleted() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
-    // Delete the channel
+    // Delete the conversation
 
-    app.channels()
-        .delete(&channel.id, &fixtures::now())
+    app.conversations()
+        .delete(&conversation.id, &fixtures::now())
         .await
-        .expect("deleting a valid channel succeeds");
+        .expect("deleting a valid conversation succeeds");
 
     // Subscribe
 
@@ -222,11 +222,11 @@ async fn previously_deleted() {
 
     // Check for expiry event
     let _ = events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::deleted)
-        .filter(|event| future::ready(event.id == channel.id))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::deleted)
+        .filter(|event| future::ready(event.id == conversation.id))
         .next()
-        .expect_some("a deleted channel event will be delivered")
+        .expect_some("a deleted conversation event will be delivered")
         .await;
 }
 
@@ -235,20 +235,20 @@ async fn previously_purged() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
-    // Delete and purge the channel
+    // Delete and purge the conversation
 
-    app.channels()
-        .delete(&channel.id, &fixtures::ancient())
+    app.conversations()
+        .delete(&conversation.id, &fixtures::ancient())
         .await
-        .expect("deleting a valid channel succeeds");
+        .expect("deleting a valid conversation succeeds");
 
-    app.channels()
+    app.conversations()
         .purge(&fixtures::now())
         .await
-        .expect("purging channels always succeeds");
+        .expect("purging conversations always succeeds");
 
     // Subscribe
 
@@ -264,10 +264,10 @@ async fn previously_purged() {
 
     // Check for expiry event
     events
-        .filter_map(fixtures::event::stream::channel)
-        .filter_map(fixtures::event::stream::channel::deleted)
-        .filter(|event| future::ready(event.id == channel.id))
+        .filter_map(fixtures::event::stream::conversation)
+        .filter_map(fixtures::event::stream::conversation::deleted)
+        .filter(|event| future::ready(event.id == conversation.id))
         .next()
-        .expect_wait("deleted channel events not delivered")
+        .expect_wait("deleted conversation events not delivered")
         .await;
 }
diff --git a/src/event/handlers/stream/test/message.rs b/src/event/handlers/stream/test/message.rs
index 4369996..3fba317 100644
--- a/src/event/handlers/stream/test/message.rs
+++ b/src/event/handlers/stream/test/message.rs
@@ -12,7 +12,7 @@ async fn sending() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Call the endpoint
@@ -33,7 +33,7 @@ async fn sending() {
     let message = app
         .messages()
         .send(
-            &channel.id,
+            &conversation.id,
             &sender,
             &fixtures::now(),
             &fixtures::message::propose(),
@@ -57,7 +57,7 @@ async fn previously_sent() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Send a message
@@ -66,7 +66,7 @@ async fn previously_sent() {
     let message = app
         .messages()
         .send(
-            &channel.id,
+            &conversation.id,
             &sender,
             &fixtures::now(),
             &fixtures::message::propose(),
@@ -98,27 +98,30 @@ async fn previously_sent() {
 }
 
 #[tokio::test]
-async fn sent_in_multiple_channels() {
+async fn sent_in_multiple_conversations() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
-    let channels = [
-        fixtures::channel::create(&app, &fixtures::now()).await,
-        fixtures::channel::create(&app, &fixtures::now()).await,
+    let conversations = [
+        fixtures::conversation::create(&app, &fixtures::now()).await,
+        fixtures::conversation::create(&app, &fixtures::now()).await,
     ];
 
-    let messages = stream::iter(channels)
-        .then(|channel| {
-            let app = app.clone();
-            let sender = sender.clone();
-            let channel = channel.clone();
-            async move { fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await }
-        })
-        .collect::<Vec<_>>()
-        .await;
+    let messages =
+        stream::iter(conversations)
+            .then(|conversation| {
+                let app = app.clone();
+                let sender = sender.clone();
+                let conversation = conversation.clone();
+                async move {
+                    fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await
+                }
+            })
+            .collect::<Vec<_>>()
+            .await;
 
     // Call the endpoint
 
@@ -152,14 +155,14 @@ async fn sent_sequentially() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     let messages = vec![
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
     ];
 
     // Subscribe
@@ -196,9 +199,9 @@ async fn expiring() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::ancient()).await;
     let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
-    let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
+    let message = fixtures::message::send(&app, &conversation, &sender, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe
@@ -235,9 +238,9 @@ async fn previously_expired() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::ancient()).await;
     let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
-    let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
+    let message = fixtures::message::send(&app, &conversation, &sender, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Expire messages
@@ -274,9 +277,9 @@ async fn deleting() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
-    let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
+    let message = fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Subscribe
@@ -313,9 +316,9 @@ async fn previously_deleted() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
-    let message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
+    let message = fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Delete the message
@@ -352,9 +355,9 @@ async fn previously_purged() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::ancient()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::ancient()).await;
     let sender = fixtures::user::create(&app, &fixtures::ancient()).await;
-    let message = fixtures::message::send(&app, &channel, &sender, &fixtures::ancient()).await;
+    let message = fixtures::message::send(&app, &conversation, &sender, &fixtures::ancient()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Purge the message
diff --git a/src/event/handlers/stream/test/mod.rs b/src/event/handlers/stream/test/mod.rs
index df43deb..3bc634f 100644
--- a/src/event/handlers/stream/test/mod.rs
+++ b/src/event/handlers/stream/test/mod.rs
@@ -1,4 +1,4 @@
-mod channel;
+mod conversation;
 mod invite;
 mod message;
 mod resume;
diff --git a/src/event/handlers/stream/test/resume.rs b/src/event/handlers/stream/test/resume.rs
index 835d350..a0da692 100644
--- a/src/event/handlers/stream/test/resume.rs
+++ b/src/event/handlers/stream/test/resume.rs
@@ -14,15 +14,16 @@ async fn resume() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
-    let initial_message = fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await;
+    let initial_message =
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await;
 
     let later_messages = vec![
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
     ];
 
     // Call the endpoint
@@ -75,8 +76,8 @@ async fn resume() {
 
 // This test verifies a real bug I hit developing the vector-of-sequences
 // approach to resuming events. A small omission caused the event IDs in a
-// resumed stream to _omit_ channels that were in the original stream until
-// those channels also appeared in the resumed stream.
+// resumed stream to _omit_ conversations that were in the original stream
+// until those conversations also appeared in the resumed stream.
 //
 // Clients would see something like
 // * In the original stream, Cfoo=5,Cbar=8
@@ -84,8 +85,8 @@ async fn resume() {
 //
 // Disconnecting and reconnecting a second time, using event IDs from that
 // initial period of the first resume attempt, would then cause the second
-// resume attempt to restart all other channels from the beginning, and not
-// from where the first disconnection happened.
+// resume attempt to restart all other conversations from the beginning, and
+// not from where the first disconnection happened.
 //
 // As we have switched to a single global event sequence number, this scenario
 // can no longer arise, but this test is preserved because the actual behaviour
@@ -97,8 +98,8 @@ async fn serial_resume() {
 
     let app = fixtures::scratch_app().await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
-    let channel_a = fixtures::channel::create(&app, &fixtures::now()).await;
-    let channel_b = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation_a = fixtures::conversation::create(&app, &fixtures::now()).await;
+    let conversation_b = fixtures::conversation::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
     // Call the endpoint
@@ -107,8 +108,8 @@ async fn serial_resume() {
 
     let resume_at = {
         let initial_messages = [
-            fixtures::message::send(&app, &channel_a, &sender, &fixtures::now()).await,
-            fixtures::message::send(&app, &channel_b, &sender, &fixtures::now()).await,
+            fixtures::message::send(&app, &conversation_a, &sender, &fixtures::now()).await,
+            fixtures::message::send(&app, &conversation_b, &sender, &fixtures::now()).await,
         ];
 
         // First subscription
@@ -148,11 +149,11 @@ async fn serial_resume() {
     // Resume after disconnect
     let resume_at = {
         let resume_messages = [
-            // Note that channel_b does not appear here. The buggy behaviour
-            // would be masked if channel_b happened to send a new message
+            // Note that conversation_b does not appear here. The buggy behaviour
+            // would be masked if conversation_b happened to send a new message
             // into the resumed event stream.
-            fixtures::message::send(&app, &channel_a, &sender, &fixtures::now()).await,
-            fixtures::message::send(&app, &channel_a, &sender, &fixtures::now()).await,
+            fixtures::message::send(&app, &conversation_a, &sender, &fixtures::now()).await,
+            fixtures::message::send(&app, &conversation_a, &sender, &fixtures::now()).await,
         ];
 
         // Second subscription
@@ -190,12 +191,12 @@ async fn serial_resume() {
 
     // Resume after disconnect a second time
     {
-        // At this point, we can send on either channel and demonstrate the
-        // problem. The resume point should before both of these messages, but
-        // after _all_ prior messages.
+        // At this point, we can send on either conversation and demonstrate
+        // the problem. The resume point should before both of these messages,
+        // but after _all_ prior messages.
         let final_messages = [
-            fixtures::message::send(&app, &channel_a, &sender, &fixtures::now()).await,
-            fixtures::message::send(&app, &channel_b, &sender, &fixtures::now()).await,
+            fixtures::message::send(&app, &conversation_a, &sender, &fixtures::now()).await,
+            fixtures::message::send(&app, &conversation_b, &sender, &fixtures::now()).await,
         ];
 
         // Third subscription
diff --git a/src/event/handlers/stream/test/token.rs b/src/event/handlers/stream/test/token.rs
index e32b489..5af07a0 100644
--- a/src/event/handlers/stream/test/token.rs
+++ b/src/event/handlers/stream/test/token.rs
@@ -9,7 +9,7 @@ async fn terminates_on_token_expiry() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -37,9 +37,9 @@ async fn terminates_on_token_expiry() {
 
     // These should not be delivered.
     let messages = [
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
     ];
 
     events
@@ -56,7 +56,7 @@ async fn terminates_on_logout() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -83,9 +83,9 @@ async fn terminates_on_logout() {
     // These should not be delivered.
 
     let messages = [
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
     ];
 
     events
@@ -102,7 +102,7 @@ async fn terminates_on_password_change() {
     // Set up the environment
 
     let app = fixtures::scratch_app().await;
-    let channel = fixtures::channel::create(&app, &fixtures::now()).await;
+    let conversation = fixtures::conversation::create(&app, &fixtures::now()).await;
     let sender = fixtures::user::create(&app, &fixtures::now()).await;
     let resume_point = fixtures::boot::resume_point(&app).await;
 
@@ -133,9 +133,9 @@ async fn terminates_on_password_change() {
     // These should not be delivered.
 
     let messages = [
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
-        fixtures::message::send(&app, &channel, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
+        fixtures::message::send(&app, &conversation, &sender, &fixtures::now()).await,
     ];
 
     events