chore(project): initialize project with core configuration and dependencies

- Add .gitignore and .env.example files for project setup
- Create build script for proto compilation with tonic-prost
- Generate Cargo.lock with all project dependencies
- Configure project structure and ignore patterns for development environment

tests/queue_tests.rs

@@ -0,0 +1,127 @@
+use emailks::{
+    error::EmailError,
+    pb::email::v1::{EmailAddress, SendEmailRequest},
+    queue::EmailQueue,
+};
+use std::sync::{
+    Arc,
+    atomic::{AtomicUsize, Ordering},
+};
+
+fn dummy_request() -> SendEmailRequest {
+    SendEmailRequest {
+        from: None,
+        to: vec![],
+        cc: vec![],
+        bcc: vec![],
+        subject: "test".into(),
+        text_body: "body".into(),
+        html_body: String::new(),
+        attachments: vec![],
+        priority: 0,
+        headers: Default::default(),
+        reply_to: String::new(),
+    }
+}
+
+#[tokio::test]
+async fn enqueue_and_consume_success() {
+    let (queue, worker) = EmailQueue::unbounded();
+    let counter = Arc::new(AtomicUsize::new(0));
+    let c = counter.clone();
+
+    let mut req = dummy_request();
+    req.to.push(EmailAddress {
+        email: "test@example.com".into(),
+        name: String::new(),
+    });
+
+    let id = queue.enqueue(req).expect("enqueue should work");
+    assert!(id > 0);
+
+    worker.spawn(move |_job| {
+        let c = c.clone();
+        async move {
+            c.fetch_add(1, Ordering::SeqCst);
+            Ok::<(), EmailError>(())
+        }
+    });
+
+    // Wait for async consumption
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+    assert_eq!(counter.load(Ordering::SeqCst), 1);
+}
+
+#[tokio::test]
+async fn retry_then_succeed() {
+    let (queue, worker) = EmailQueue::unbounded();
+    let attempts = Arc::new(AtomicUsize::new(0));
+    let a = attempts.clone();
+
+    let _id = queue.enqueue(dummy_request()).unwrap();
+
+    worker.spawn(move |_job| {
+        let a = a.clone();
+        async move {
+            let n = a.fetch_add(1, Ordering::SeqCst);
+            if n < 2 {
+                Err(EmailError::Send("temp failure".into()))
+            } else {
+                Ok(())
+            }
+        }
+    });
+
+    tokio::time::sleep(std::time::Duration::from_millis(700)).await;
+    assert_eq!(attempts.load(Ordering::SeqCst), 3); // 2 fails + 1 success
+}
+
+#[tokio::test]
+async fn terminal_error_destroyed_immediately() {
+    let (queue, worker) = EmailQueue::unbounded();
+    let store = queue.status_store().clone();
+    let attempts = Arc::new(AtomicUsize::new(0));
+    let a = attempts.clone();
+
+    let id = queue.enqueue(dummy_request()).unwrap();
+
+    worker.spawn(move |_job| {
+        let a = a.clone();
+        async move {
+            a.fetch_add(1, Ordering::SeqCst);
+            Err(EmailError::MissingRecipients)
+        }
+    });
+
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+    assert_eq!(attempts.load(Ordering::SeqCst), 1);
+
+    let entry = store.get(id).expect("should have status entry");
+    assert_eq!(entry.status, emailks::pb::email::v1::SendStatus::Failed);
+}
+
+#[tokio::test]
+async fn bounded_channel_blocks_when_full() {
+    let (queue, _worker) = EmailQueue::bounded(1);
+    let _id1 = queue.enqueue(dummy_request()).unwrap();
+    // Second enqueue should fail with Full
+    let err = queue.enqueue(dummy_request()).unwrap_err();
+    assert!(matches!(err, emailks::error::QueueError::Full));
+}
+
+#[tokio::test]
+async fn status_store_tracks_lifecycle() {
+    let (queue, worker) = EmailQueue::unbounded();
+    let store = queue.status_store().clone();
+
+    let id = queue.enqueue(dummy_request()).unwrap();
+    // Status should be Queued
+    let entry = store.get(id).unwrap();
+    assert_eq!(entry.status, emailks::pb::email::v1::SendStatus::Queued);
+
+    worker.spawn(move |_job| async move { Ok::<(), EmailError>(()) });
+
+    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+    let entry = store.get(id).unwrap();
+    assert_eq!(entry.status, emailks::pb::email::v1::SendStatus::Sent);
+}