@arimakouyou/spec-workflow-mcp 2.2.7

package/.claude-plugin/skills/tdd-skills-rust/references/test-doubles.md

@@ -0,0 +1,208 @@
+# テストダブル（Test Double）
+
+外部依存を切り離してテストを高速・安定化させる手法。
+
+## Rust におけるテストダブルの実現方法
+
+Rust では trait を活用してテストダブルを実現する。
+主な方法: 手動の trait 実装、`mockall` クレート。
+
+## テストダブルの5種類
+
+### 1. Dummy（ダミー）
+
+引数を埋めるだけで実際には使われない。
+
+```rust
+struct DummyLogger;
+impl Logger for DummyLogger {
+    fn log(&self, _msg: &str) {}
+}
+```
+
+### 2. Stub（スタブ）
+
+決まった値を返すだけ。
+
+```rust
+struct StubUserRepository;
+impl UserRepository for StubUserRepository {
+    fn find_by_id(&self, id: i64) -> Result<Option<User>, DbError> {
+        Ok(Some(User { id, name: "Test User".into() }))
+    }
+}
+
+#[test]
+fn get_user_name() {
+    let repo = StubUserRepository;
+    let service = UserService::new(Box::new(repo));
+
+    let name = service.get_user_name(1).unwrap();
+
+    assert_eq!(name, "Test User");
+}
+```
+
+使用場面:
+- DB からの取得結果を固定したい
+- 外部 API のレスポンスをコントロールしたい
+
+### 3. Spy（スパイ）
+
+呼び出しを記録する。
+
+```rust
+use std::sync::{Arc, Mutex};
+
+struct SpyEmailService {
+    sent_emails: Arc<Mutex<Vec<String>>>,
+}
+
+impl SpyEmailService {
+    fn new() -> Self {
+        Self { sent_emails: Arc::new(Mutex::new(vec![])) }
+    }
+}
+
+impl EmailService for SpyEmailService {
+    fn send(&self, to: &str, _subject: &str, _body: &str) {
+        self.sent_emails.lock().unwrap().push(to.to_string());
+    }
+}
+
+#[test]
+fn send_welcome_email() {
+    let spy = SpyEmailService::new();
+    let emails = spy.sent_emails.clone();
+    let service = RegistrationService::new(Box::new(spy));
+
+    service.register("user@example.com").unwrap();
+
+    let sent = emails.lock().unwrap();
+    assert_eq!(sent.len(), 1);
+    assert_eq!(sent[0], "user@example.com");
+}
+```
+
+### 4. Mock（モック）
+
+期待する呼び出しを検証する。`mockall` クレートを使用。
+
+```rust
+use mockall::automock;
+
+#[automock]
+trait UserRepository: Send + Sync {
+    fn find_by_id(&self, id: i64) -> Result<Option<User>, DbError>;
+    fn save(&self, user: &NewUser) -> Result<User, DbError>;
+    fn delete(&self, id: i64) -> Result<(), DbError>;
+}
+
+#[test]
+fn delete_user_calls_repository() {
+    let mut mock_repo = MockUserRepository::new();
+    mock_repo
+        .expect_delete()
+        .with(mockall::predicate::eq(123))
+        .times(1)
+        .returning(|_| Ok(()));
+
+    let service = UserService::new(Box::new(mock_repo));
+    service.delete_user(123).unwrap();
+    // mock のドロップ時に expect が満たされたか自動検証
+}
+```
+
+Mock vs Spy:
+- Mock: 期待を事前に設定して検証（振る舞い検証）
+- Spy: 実際の呼び出しを記録して後で確認（状態検証）
+
+### 5. Fake（フェイク）
+
+簡易的な実装（インメモリ DB 等）。
+
+```rust
+use std::collections::HashMap;
+use std::sync::Mutex;
+
+struct FakeUserRepository {
+    users: Mutex<HashMap<i64, User>>,
+    next_id: Mutex<i64>,
+}
+
+impl FakeUserRepository {
+    fn new() -> Self {
+        Self {
+            users: Mutex::new(HashMap::new()),
+            next_id: Mutex::new(1),
+        }
+    }
+}
+
+impl UserRepository for FakeUserRepository {
+    fn find_by_id(&self, id: i64) -> Result<Option<User>, DbError> {
+        Ok(self.users.lock().unwrap().get(&id).cloned())
+    }
+
+    fn save(&self, new_user: &NewUser) -> Result<User, DbError> {
+        let mut next_id = self.next_id.lock().unwrap();
+        let user = User { id: *next_id, name: new_user.name.clone() };
+        self.users.lock().unwrap().insert(*next_id, user.clone());
+        *next_id += 1;
+        Ok(user)
+    }
+
+    fn delete(&self, id: i64) -> Result<(), DbError> {
+        self.users.lock().unwrap().remove(&id);
+        Ok(())
+    }
+}
+```
+
+使用場面:
+- 複雑なビジネスロジックのテスト
+- 複数の操作を組み合わせたテスト
+- 本物に近い振る舞いが必要
+
+## テストダブルの選択基準
+
+```
+何をテストしたい？
+  ├─ 戻り値だけ → Stub
+  ├─ 呼び出されたか → Mock (mockall)
+  ├─ 呼び出し履歴 → Spy
+  ├─ 複雑な状態遷移 → Fake
+  └─ 何も使わない → Dummy
+```
+
+| 状況 | 推奨 | 理由 |
+|------|------|------|
+| DB アクセス | Fake (InMemory) / Stub | 高速、状態管理 |
+| 外部 API 呼び出し | Stub / Mock | 固定レスポンス、呼び出し検証 |
+| メール送信等の副作用 | Spy / Mock | 送信履歴確認 |
+| 時刻・乱数 | Stub (trait 経由) | 固定値で再現性確保 |
+
+## アンチパターン
+
+### 過度な Mock 使用
+
+```rust
+// 悪い: すべてを mock にする
+#[test]
+fn calculate_price() {
+    let mut mock_item = MockItem::new();
+    mock_item.expect_price().returning(|| 100);
+    // mock だらけで何をテストしているか不明確
+}
+
+// 良い: 実際のオブジェクトと組み合わせ
+#[test]
+fn calculate_price() {
+    let item = Item { name: "Book".into(), price: 100 };
+    let mut cart = ShoppingCart::new();
+    cart.add_item(item);
+    assert_eq!(cart.total(), 100);
+}
+```
+
+原則: 最もシンプルなテストダブルを使う。迷ったら Stub から始める。

package/.claude-plugin/skills/tdd-skills-rust/references/test-patterns.md

@@ -0,0 +1,223 @@
+# テストパターン
+
+## テストフィクスチャ
+
+テストで共通して使うデータやオブジェクトの準備。
+
+### ヘルパー関数
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn create_cart() -> ShoppingCart {
+        ShoppingCart::new()
+    }
+
+    fn sample_item() -> Item {
+        Item { name: "Book".into(), price: 1000 }
+    }
+
+    #[test]
+    fn empty_cart_total() {
+        let cart = create_cart();
+        assert_eq!(cart.total(), 0);
+    }
+
+    #[test]
+    fn add_item() {
+        let mut cart = create_cart();
+        cart.add_item(sample_item());
+        assert_eq!(cart.item_count(), 1);
+    }
+}
+```
+
+### rstest によるフィクスチャ
+
+`rstest` クレートで pytest 風のフィクスチャを使える。
+
+```rust
+use rstest::*;
+
+#[fixture]
+fn cart() -> ShoppingCart {
+    ShoppingCart::new()
+}
+
+#[fixture]
+fn sample_item() -> Item {
+    Item { name: "Book".into(), price: 1000 }
+}
+
+#[rstest]
+fn empty_cart_total(cart: ShoppingCart) {
+    assert_eq!(cart.total(), 0);
+}
+
+#[rstest]
+fn add_item(mut cart: ShoppingCart, sample_item: Item) {
+    cart.add_item(sample_item);
+    assert_eq!(cart.item_count(), 1);
+}
+```
+
+## テストデータビルダー
+
+複雑なオブジェクトを柔軟に構築。
+
+```rust
+struct ItemBuilder {
+    name: String,
+    price: u64,
+    stock: u32,
+}
+
+impl ItemBuilder {
+    fn new() -> Self {
+        Self {
+            name: "Default Item".into(),
+            price: 1000,
+            stock: 10,
+        }
+    }
+
+    fn name(mut self, name: &str) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    fn price(mut self, price: u64) -> Self {
+        self.price = price;
+        self
+    }
+
+    fn stock(mut self, stock: u32) -> Self {
+        self.stock = stock;
+        self
+    }
+
+    fn build(self) -> Item {
+        Item {
+            name: self.name,
+            price: self.price,
+            stock: self.stock,
+        }
+    }
+}
+
+#[test]
+fn expensive_item() {
+    let item = ItemBuilder::new()
+        .name("Luxury Watch")
+        .price(1_000_000)
+        .build();
+
+    assert!(item.is_expensive());
+}
+```
+
+## パラメータ化テスト
+
+### rstest によるパラメータ化
+
+```rust
+use rstest::rstest;
+
+#[rstest]
+#[case(0, 0)]
+#[case(500, 0)]
+#[case(999, 0)]
+#[case(1000, 50)]
+#[case(3000, 150)]
+#[case(5000, 500)]
+#[case(10000, 1000)]
+fn calculate_discount(#[case] amount: u64, #[case] expected: u64) {
+    assert_eq!(super::calculate_discount(amount), expected);
+}
+```
+
+### マクロによるパラメータ化（rstest 不使用時）
+
+```rust
+macro_rules! discount_tests {
+    ($($name:ident: ($amount:expr, $expected:expr),)*) => {
+        $(
+            #[test]
+            fn $name() {
+                assert_eq!(calculate_discount($amount), $expected);
+            }
+        )*
+    };
+}
+
+discount_tests! {
+    no_discount_0: (0, 0),
+    no_discount_500: (500, 0),
+    boundary_999: (999, 0),
+    discount_5pct_1000: (1000, 50),
+    discount_10pct_5000: (5000, 500),
+}
+```
+
+## 1テスト1アサート（の意図）
+
+原則: 1つのテストで検証する概念は1つ。
+
+```rust
+// 悪い: 複数の概念
+#[test]
+fn shopping_cart() {
+    let mut cart = ShoppingCart::new();
+    assert!(cart.is_empty());         // 空の検証
+    cart.add_item(Item { price: 100 });
+    assert_eq!(cart.item_count(), 1); // 個数の検証
+    assert_eq!(cart.total(), 100);    // 合計の検証
+}
+
+// 良い: 概念ごとに分割
+#[test]
+fn new_cart_should_be_empty() {
+    let cart = ShoppingCart::new();
+    assert!(cart.is_empty());
+}
+
+#[test]
+fn add_item_increases_item_count() {
+    let mut cart = ShoppingCart::new();
+    cart.add_item(Item { price: 100 });
+    assert_eq!(cart.item_count(), 1);
+}
+
+#[test]
+fn add_item_increases_total() {
+    let mut cart = ShoppingCart::new();
+    cart.add_item(Item { price: 100 });
+    assert_eq!(cart.total(), 100);
+}
+```
+
+例外: 関連する複数のアサートが1つの概念を検証する場合は OK。
+
+```rust
+#[test]
+fn add_item_updates_cart_state() {
+    let mut cart = ShoppingCart::new();
+    let item = Item { name: "Book".into(), price: 100 };
+
+    cart.add_item(item);
+
+    // これらは全て「商品追加」という1つの概念を検証
+    assert_eq!(cart.item_count(), 1);
+    assert_eq!(cart.total(), 100);
+    assert!(cart.contains("Book"));
+}
+```
+
+## まとめ
+
+- ヘルパー関数 or `rstest` フィクスチャで共通データを準備
+- Builder パターンで柔軟なテストデータ
+- `rstest` のパラメータ化で重複削減
+- 1テスト1概念を意識

package/.claude-plugin/with-dashboard/.mcp.json

@@ -0,0 +1,8 @@
+{
+  "mcpServers": {
+    "spec-workflow": {
+      "command": "npx",
+      "args": ["-y", "@arimakouyou/spec-workflow-mcp@latest", "."]
+    }
+  }
+}

package/.claude-plugin/with-dashboard/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "spec-workflow-mcp-with-dashboard",
+  "version": "2.2.7",
+  "description": "Lightweight MCP server for structured spec-driven development (no skills/agents/rules/hooks). Start the dashboard separately with --dashboard.",
+  "author": {
+    "name": "arimakouyou"
+  },
+  "homepage": "https://github.com/arimakouyou/spec-workflow-mcp",
+  "license": "GPL-3.0"
+}