src/db/sqlite/rooms.rs

@@ -51,13 +51,6 @@ impl Rooms for Database {
     }
 
     async fn insert_room_info(&self, info: &RoomInfo) -> Result<(), DataError> {
-        //Clear out old info first, because we want this to be an "upsert."
-        sqlx::query("DELETE FROM room_info where room_id = ?")
-            .bind(&info.room_id)
-            .execute(&self.conn)
-            .await
-            .ok();
-
         sqlx::query(r#"INSERT INTO room_info (room_id, room_name) VALUES (?, ?)"#)
             .bind(&info.room_id)
             .bind(&info.room_name)
@@ -206,37 +199,25 @@ mod tests {
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-    async fn insert_room_info_updates_existing() {
+    async fn get_room_info_constraint_test() {
         let db = create_db().await;
 
-        let info1 = RoomInfo {
+        let info = RoomInfo {
             room_id: "myroomid".to_string(),
             room_name: "myroomname".to_string(),
         };
 
-        db.insert_room_info(&info1)
+        db.insert_room_info(&info)
             .await
-            .expect("Could not insert room info1.");
+            .expect("Could not insert room info.");
 
-        let info2 = RoomInfo {
-            room_id: "myroomid".to_string(),
-            room_name: "myroomname2".to_string(),
-        };
+        let second_attempt = db.insert_room_info(&info).await;
 
-        db.insert_room_info(&info2)
-            .await
-            .expect("Could not update room info after first insert");
-
-        let retrieved_info = db
-            .get_room_info("myroomid")
-            .await
-            .expect("Could not get room info");
-
-        assert!(retrieved_info.is_some());
-        let retrieved_info = retrieved_info.unwrap();
-
-        assert_eq!(retrieved_info.room_id, "myroomid");
-        assert_eq!(retrieved_info.room_name, "myroomname2");
+        assert!(second_attempt.is_err());
+        assert!(matches!(
+            second_attempt.err().unwrap(),
+            DataError::SqlxError(sqlx::Error::Database(_))
+        ));
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
@@ -305,44 +286,6 @@ mod tests {
         assert_eq!(users_in_room.len(), 0);
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-    async fn clear_info_does_not_delete_other_rooms() {
-        let db = create_db().await;
-
-        let info1 = RoomInfo {
-            room_id: "myroomid".to_string(),
-            room_name: "myroomname".to_string(),
-        };
-
-        let info2 = RoomInfo {
-            room_id: "myroomid2".to_string(),
-            room_name: "myroomname2".to_string(),
-        };
-
-        db.insert_room_info(&info1)
-            .await
-            .expect("Could not insert room info1.");
-
-        db.insert_room_info(&info2)
-            .await
-            .expect("Could not insert room info2.");
-
-        db.add_user_to_room("myuser", &info1.room_id)
-            .await
-            .expect("Could not add user to room.");
-
-        db.clear_info(&info1.room_id)
-            .await
-            .expect("Could not clear room info1");
-
-        let room_info2 = db
-            .get_room_info(&info2.room_id)
-            .await
-            .expect("Could not get room info2.");
-
-        assert!(room_info2.is_some());
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn clear_info_test() {
         let db = create_db().await;
@@ -356,23 +299,23 @@ mod tests {
             .await
             .expect("Could not insert room info.");
 
-        db.add_user_to_room("myuser", &info.room_id)
+        db.add_user_to_room("myuser", "myroom")
             .await
             .expect("Could not add user to room.");
 
-        db.clear_info(&info.room_id)
+        db.clear_info("myroom")
             .await
             .expect("Could not clear room info");
 
         let users_in_room = db
-            .get_users_in_room(&info.room_id)
+            .get_users_in_room("myroom")
             .await
             .expect("Could not get users in room.");
 
         assert_eq!(users_in_room.len(), 0);
 
         let room_info = db
-            .get_room_info(&info.room_id)
+            .get_room_info("myroom")
             .await
             .expect("Could not get room info.");
 

src/db/sqlite/state.rs

@@ -13,13 +13,6 @@ impl DbState for Database {
     }
 
     async fn set_device_id(&self, device_id: &str) -> Result<(), DataError> {
-        // This will have to be updated if we ever add another column
-        // to this table!
-        sqlx::query("DELETE FROM bot_state")
-            .execute(&self.conn)
-            .await
-            .ok();
-
         sqlx::query(
             r#"INSERT INTO bot_state
                       (device_id)
@@ -32,59 +25,3 @@ impl DbState for Database {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::super::DbState;
-    use super::*;
-
-    async fn create_db() -> Database {
-        let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
-        crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
-            .await
-            .unwrap();
-
-        Database::new(db_path.path().to_str().unwrap())
-            .await
-            .unwrap()
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-    async fn set_and_get_device_id() {
-        let db = create_db().await;
-
-        db.set_device_id("device_id")
-            .await
-            .expect("Could not set device ID");
-
-        let device_id = db.get_device_id().await.expect("Could not get device ID");
-
-        assert!(device_id.is_some());
-        assert_eq!(device_id.unwrap(), "device_id");
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-    async fn no_device_id_set_returns_none() {
-        let db = create_db().await;
-        let device_id = db.get_device_id().await.expect("Could not get device ID");
-        assert!(device_id.is_none());
-    }
-
-    #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-    async fn can_update_device_id() {
-        let db = create_db().await;
-
-        db.set_device_id("device_id")
-            .await
-            .expect("Could not set device ID");
-
-        db.set_device_id("device_id2")
-            .await
-            .expect("Could not set device ID");
-
-        let device_id = db.get_device_id().await.expect("Could not get device ID");
-
-        assert!(device_id.is_some());
-        assert_eq!(device_id.unwrap(), "device_id2");
-    }
-}