feat: seed db

Author: pythoninthegrass

src-tauri/Cargo.lock

@@ -23,6 +23,7 @@ rusqlite = { version = "0.38", features = ["bundled"] }
 rand = { version = "0.9", features = ["thread_rng"], default-features = false }
 chrono = { version = "0.4", features = ["now"], default-features = false }
 dirs = "6"
+csv = "1"
 
 [profile.dev]
 debug = 0

src-tauri/Cargo.toml

@@ -0,0 +1,19 @@
+restaurant,option
+Arbys,cheap
+"Bubba's",Normal
+Charlestons,Normal
+Firehouse,Normal
+Freddies,Normal
+Frosted Mug,Normal
+Hideaway,Normal
+"Jersy Mike's",Normal
+Johnnies,Normal
+Mcalisters,Normal
+Mcneilies,Normal
+Olive Garden,Normal
+On The Border,Normal
+Qdoba,Normal
+Tamashii Ramen,Normal
+Teds,Normal
+The Mule,Normal
+Zios,Normal

src-tauri/lunch_list.csv

@@ -26,16 +26,23 @@ impl Database {
     }
 
     pub fn with_connection(conn: Connection) -> Result<Self> {
+        Self::with_connection_internal(conn, true)
+    }
+
+    fn with_connection_internal(conn: Connection, should_seed: bool) -> Result<Self> {
         let db = Database {
             conn: Mutex::new(conn),
         };
         db.init_tables()?;
+        if should_seed {
+            db.seed_database()?;
+        }
         Ok(db)
     }
 
     pub fn in_memory() -> Result<Self> {
         let conn = Connection::open_in_memory()?;
-        Self::with_connection(conn)
+        Self::with_connection_internal(conn, false)
     }
 
     fn init_tables(&self) -> Result<()> {
@@ -55,6 +62,50 @@ impl Database {
         Ok(())
     }
 
+    fn seed_database(&self) -> Result<()> {
+        let conn = self.conn.lock().unwrap();
+
+        // Check if database is empty (first launch)
+        let count: i64 = conn.query_row(
+            "SELECT COUNT(*) FROM lunch_list",
+            [],
+            |row| row.get(0),
+        )?;
+
+        if count > 0 {
+            // Database already has data, skip seeding
+            return Ok(());
+        }
+
+        // Parse embedded CSV and seed database
+        let csv_data = include_str!("../lunch_list.csv");
+        let mut reader = csv::Reader::from_reader(csv_data.as_bytes());
+
+        for result in reader.records() {
+            let record = result.map_err(|e| {
+                rusqlite::Error::FromSqlConversionFailure(
+                    0,
+                    rusqlite::types::Type::Text,
+                    Box::new(e),
+                )
+            })?;
+
+            if record.len() >= 2 {
+                let name = record.get(0).unwrap_or("");
+                let category = record.get(1).unwrap_or("");
+
+                if !name.is_empty() && !category.is_empty() {
+                    conn.execute(
+                        "INSERT INTO lunch_list (restaurants, option) VALUES (?, ?)",
+                        [name, category],
+                    )?;
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn list_all(&self) -> Result<Vec<Restaurant>> {
         let conn = self.conn.lock().unwrap();
         let mut stmt = conn.prepare("SELECT restaurants, option FROM lunch_list ORDER BY restaurants")?;
@@ -164,3 +215,59 @@ fn get_db_path() -> PathBuf {
             .join("lunch.db")
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_seed_database_on_first_launch() {
+        let db = Database::in_memory().unwrap();
+
+        // Explicitly seed the database
+        db.seed_database().unwrap();
+
+        // Verify restaurants were seeded
+        let restaurants = db.list_all().unwrap();
+        assert!(restaurants.len() > 0, "Database should be seeded with restaurants");
+
+        // Verify both cheap and normal categories exist
+        let cheap = db.list_by_category("cheap").unwrap();
+        let normal = db.list_by_category("normal").unwrap();
+        assert!(cheap.len() > 0, "Should have cheap restaurants");
+        assert!(normal.len() > 0, "Should have normal restaurants");
+
+        // Verify specific restaurants from CSV
+        assert!(
+            restaurants.iter().any(|r| r.name == "Arbys"),
+            "Should contain Arbys from seed data"
+        );
+        assert!(
+            restaurants.iter().any(|r| r.name == "Bubba's"),
+            "Should contain Bubba's from seed data"
+        );
+    }
+
+    #[test]
+    fn test_seed_database_does_not_overwrite() {
+        let db = Database::in_memory().unwrap();
+
+        // Add a custom restaurant before seeding
+        db.add("Custom Restaurant", "normal").unwrap();
+
+        // Try seeding (should not add anything because database is not empty)
+        db.seed_database().unwrap();
+
+        // Verify count is only 1 (our custom restaurant)
+        let final_restaurants = db.list_all().unwrap();
+        assert_eq!(
+            final_restaurants.len(),
+            1,
+            "Seeding should not run on non-empty database"
+        );
+        assert!(
+            final_restaurants.iter().any(|r| r.name == "Custom Restaurant"),
+            "Custom restaurant should be preserved"
+        );
+    }
+}