new message: initial commit

core/kordophone/src/tests/mod.rs

@@ -3,7 +3,7 @@ use self::test_client::TestClient;
 use crate::APIInterface;
 
 pub mod api_interface {
-    use crate::model::Conversation;
+    use crate::model::{Conversation, HandleResolutionStatus, OutgoingMessage};
 
     use super::*;
 
@@ -28,4 +28,28 @@ pub mod api_interface {
         assert_eq!(conversations.len(), 1);
         assert_eq!(conversations[0].display_name, test_convo.display_name);
     }
+
+    #[tokio::test]
+    async fn test_resolve_handle() {
+        let mut client = TestClient::new();
+
+        let resolved = client.resolve_handle("user@example.com").await.unwrap();
+        assert_eq!(resolved.resolved_handle.id, "user@example.com");
+        assert_eq!(resolved.status, HandleResolutionStatus::Valid);
+        assert_eq!(resolved.existing_chat, None);
+    }
+
+    #[tokio::test]
+    async fn test_send_message_with_handles() {
+        let mut client = TestClient::new();
+
+        let outgoing_message = OutgoingMessage::builder()
+            .text("hello".to_string())
+            .handle_ids(vec!["user@example.com".to_string()])
+            .build();
+
+        let sent = client.send_message(&outgoing_message).await.unwrap();
+        assert_eq!(sent.message.text, "hello");
+        assert_eq!(sent.conversation_id, None);
+    }
 }

core/kordophone/src/tests/test_client.rs

@@ -9,14 +9,17 @@ use crate::{
     api::event_socket::{EventSocket, SinkMessage, SocketEvent, SocketUpdate},
     api::http_client::Credentials,
     model::{
-        Conversation, ConversationID, Event, JwtToken, Message, MessageID, OutgoingMessage,
-        UpdateItem,
+        Conversation, ConversationID, Event, HandleResolutionStatus, JwtToken, Message, MessageID,
+        OutgoingMessage, OutgoingMessageTarget, ResolveHandleResponse, ResolvedHandle,
+        SendMessageResponse,
     },
 };
 
 use bytes::Bytes;
+use futures_util::sink::drain;
 use futures_util::stream::BoxStream;
 use futures_util::Sink;
+use futures_util::SinkExt;
 use futures_util::StreamExt;
 
 pub struct TestClient {
@@ -63,13 +66,18 @@ impl EventSocket for TestEventSocket {
         impl Sink<SinkMessage, Error = Self::Error>,
     ) {
         (
-            futures_util::stream::iter(self.events.into_iter().map(Ok)).boxed(),
-            futures_util::sink::sink(),
+            futures_util::stream::iter(
+                self.events
+                    .into_iter()
+                    .map(|event| Ok(SocketEvent::Update(event))),
+            )
+            .boxed(),
+            drain().sink_map_err(|err| match err {}),
         )
     }
 
     async fn raw_updates(self) -> Self::UpdateStream {
-        let results: Vec<Result<Vec<UpdateItem>, TestError>> = vec![];
+        let results: Vec<Result<SocketUpdate, TestError>> = vec![];
         futures_util::stream::iter(results.into_iter()).boxed()
     }
 }
@@ -94,9 +102,9 @@ impl APIInterface for TestClient {
     async fn get_messages(
         &mut self,
         conversation_id: &ConversationID,
-        limit: Option<u32>,
-        before: Option<MessageID>,
-        after: Option<MessageID>,
+        _limit: Option<u32>,
+        _before: Option<MessageID>,
+        _after: Option<MessageID>,
     ) -> Result<Vec<Message>, Self::Error> {
         if let Some(messages) = self.messages.get(conversation_id) {
             return Ok(messages.clone());
@@ -108,18 +116,42 @@ impl APIInterface for TestClient {
     async fn send_message(
         &mut self,
         outgoing_message: &OutgoingMessage,
-    ) -> Result<Message, Self::Error> {
+    ) -> Result<SendMessageResponse, Self::Error> {
         let message = Message::builder()
             .guid(Uuid::new_v4().to_string())
             .text(outgoing_message.text.clone())
             .date(OffsetDateTime::now_utc())
             .build();
 
-        self.messages
-            .entry(outgoing_message.conversation_id.clone())
-            .or_insert(vec![])
-            .push(message.clone());
-        Ok(message)
+        let conversation_id = match &outgoing_message.target {
+            OutgoingMessageTarget::Conversation(conversation_id) => {
+                self.messages
+                    .entry(conversation_id.clone())
+                    .or_insert(vec![])
+                    .push(message.clone());
+                None
+            }
+            OutgoingMessageTarget::Handles(_) => None,
+        };
+
+        Ok(SendMessageResponse {
+            message,
+            conversation_id,
+        })
+    }
+
+    async fn resolve_handle(
+        &mut self,
+        handle_id: &str,
+    ) -> Result<ResolveHandleResponse, Self::Error> {
+        Ok(ResolveHandleResponse {
+            resolved_handle: ResolvedHandle {
+                id: handle_id.to_string(),
+                name: None,
+            },
+            status: HandleResolutionStatus::Valid,
+            existing_chat: None,
+        })
     }
 
     async fn open_event_socket(
@@ -131,17 +163,17 @@ impl APIInterface for TestClient {
 
     async fn fetch_attachment_data(
         &mut self,
-        guid: &str,
-        preview: bool,
+        _guid: &str,
+        _preview: bool,
     ) -> Result<Self::ResponseStream, Self::Error> {
         Ok(futures_util::stream::iter(vec![Ok(Bytes::from_static(b"test"))]).boxed())
     }
 
     async fn upload_attachment<R>(
         &mut self,
-        data: tokio::io::BufReader<R>,
-        filename: &str,
-        size: u64,
+        _data: tokio::io::BufReader<R>,
+        _filename: &str,
+        _size: u64,
     ) -> Result<String, Self::Error>
     where
         R: tokio::io::AsyncRead + Unpin + Send + Sync + 'static,
@@ -151,7 +183,7 @@ impl APIInterface for TestClient {
 
     async fn mark_conversation_as_read(
         &mut self,
-        conversation_id: &ConversationID,
+        _conversation_id: &ConversationID,
     ) -> Result<(), Self::Error> {
         Ok(())
     }