refactor: reorganize Dapr components into subdirectories by type

HIGH PRIORITY openai#1 - File Structure Refactoring Complete

Directory Structure:
- bindings/http.yaml (was bindings-http.yaml)
- configuration/default.yaml (was configuration.yaml)
- pubsub/redis.yaml (was pubsub-redis.yaml)
- secretstore/env.yaml (was secretstore-env.yaml)
- statestore/default.yaml (was statestore.yaml)
- statestore/postgres.yaml (was statestore-postgres.yaml)
- statestore/redis.yaml (was statestore-redis.yaml)

Rationale:
- Groups files by component type following proper coding methodology
- Removes redundant prefixes from filenames
- Easier to add new components of same type
- Improves maintainability and discoverability

Testing:
- Created tests/test_dapr_component_structure.py with TDD approach
- Verified Dapr sidecar loads all 6 components from subdirectories
- Dapr metadata endpoint confirms all components active:
  * statestore (default Redis)
  * statestore-redis
  * statestore-postgres
  * pubsub-redis
  * secretstore-env
  * http-binding

No docker-compose.yml changes needed - Dapr recursively scans subdirectories.

Author: DeanLuus22021994

.devcontainer/dapr-components/bindings-http.yaml renamed to .devcontainer/dapr-components/bindings/http.yaml

@@ -0,0 +1,185 @@
+"""Tests for Dapr component directory structure refactoring.
+
+This module verifies that Dapr components can be organized in subdirectories
+by component type (statestore, pubsub, bindings, secretstore, configuration)
+and that Dapr runtime can correctly discover and load them.
+"""
+
+import os
+from pathlib import Path
+from typing import Dict, List
+
+import pytest
+import yaml
+
+
+@pytest.fixture
+def dapr_components_base_path() -> Path:
+    """Get the base path for Dapr components."""
+    repo_root = Path(__file__).parent.parent
+    return repo_root / ".devcontainer" / "dapr-components"
+
+
+@pytest.fixture
+def expected_component_structure() -> Dict[str, List[str]]:
+    """Define the expected directory structure for Dapr components.
+
+    Returns:
+        Dictionary mapping subdirectory names to expected YAML files.
+    """
+    return {
+        "statestore": ["postgres.yaml", "redis.yaml", "default.yaml"],
+        "pubsub": ["redis.yaml"],
+        "bindings": ["http.yaml"],
+        "secretstore": ["env.yaml"],
+        "configuration": ["default.yaml"],
+    }
+
+
+class TestDaprComponentDirectoryStructure:
+    """Test suite for Dapr component directory organization."""
+
+    def test_subdirectories_exist(
+        self, dapr_components_base_path: Path, expected_component_structure: Dict[str, List[str]]
+    ):
+        """Verify all expected subdirectories exist."""
+        for subdir in expected_component_structure.keys():
+            subdir_path = dapr_components_base_path / subdir
+            assert subdir_path.exists(), f"Subdirectory {subdir}/ should exist"
+            assert subdir_path.is_dir(), f"{subdir}/ should be a directory"
+
+    def test_yaml_files_in_correct_locations(
+        self, dapr_components_base_path: Path, expected_component_structure: Dict[str, List[str]]
+    ):
+        """Verify YAML files are in correct subdirectories with correct names."""
+        for subdir, expected_files in expected_component_structure.items():
+            subdir_path = dapr_components_base_path / subdir
+
+            for expected_file in expected_files:
+                file_path = subdir_path / expected_file
+                assert file_path.exists(), f"File {subdir}/{expected_file} should exist"
+                assert file_path.is_file(), f"{subdir}/{expected_file} should be a file"
+                assert file_path.suffix == ".yaml", f"{subdir}/{expected_file} should be a YAML file"
+
+    def test_no_prefixed_files_in_root(self, dapr_components_base_path: Path):
+        """Verify old prefixed files no longer exist in root directory."""
+        old_files = [
+            "statestore-postgres.yaml",
+            "statestore-redis.yaml",
+            "statestore.yaml",
+            "pubsub-redis.yaml",
+            "secretstore-env.yaml",
+            "bindings-http.yaml",
+            "configuration.yaml",
+        ]
+
+        for old_file in old_files:
+            old_file_path = dapr_components_base_path / old_file
+            assert not old_file_path.exists(), f"Old file {old_file} should not exist in root"
+
+    def test_yaml_files_are_valid(
+        self, dapr_components_base_path: Path, expected_component_structure: Dict[str, List[str]]
+    ):
+        """Verify all YAML files have valid syntax and Dapr component structure."""
+        for subdir, expected_files in expected_component_structure.items():
+            subdir_path = dapr_components_base_path / subdir
+
+            for expected_file in expected_files:
+                file_path = subdir_path / expected_file
+
+                with open(file_path, "r") as f:
+                    component = yaml.safe_load(f)
+
+                # Verify required Dapr component fields
+                assert "apiVersion" in component, f"{subdir}/{expected_file} missing apiVersion"
+                assert "kind" in component, f"{subdir}/{expected_file} missing kind"
+                assert "metadata" in component, f"{subdir}/{expected_file} missing metadata"
+                assert "spec" in component, f"{subdir}/{expected_file} missing spec"
+
+                assert component["apiVersion"] == "dapr.io/v1alpha1", f"{subdir}/{expected_file} wrong apiVersion"
+                assert component["kind"] == "Component", f"{subdir}/{expected_file} should be Component kind"
+                assert "name" in component["metadata"], f"{subdir}/{expected_file} missing component name"
+
+    def test_component_names_are_consistent(
+        self, dapr_components_base_path: Path, expected_component_structure: Dict[str, List[str]]
+    ):
+        """Verify component names follow consistent naming conventions."""
+        for subdir, expected_files in expected_component_structure.items():
+            subdir_path = dapr_components_base_path / subdir
+
+            for expected_file in expected_files:
+                file_path = subdir_path / expected_file
+
+                with open(file_path, "r") as f:
+                    component = yaml.safe_load(f)
+
+                component_name = component["metadata"]["name"]
+                file_basename = expected_file.replace(".yaml", "")
+
+                # Component names should reflect their type and backend
+                if file_basename == "default":
+                    # Default components use just the type name
+                    assert component_name in ["statestore", "configuration"], \
+                        f"Default component in {subdir}/ has unexpected name: {component_name}"
+                else:
+                    # Named components should include backend identifier
+                    # e.g., statestore-postgres, statestore-redis, pubsub-redis
+                    assert subdir in component_name or file_basename in component_name, \
+                        f"Component name '{component_name}' should reference {subdir} or {file_basename}"
+
+    def test_statestore_components_have_correct_types(self, dapr_components_base_path: Path):
+        """Verify statestore components have correct Dapr state store types."""
+        statestore_path = dapr_components_base_path / "statestore"
+
+        # postgres.yaml should use state.postgresql
+        with open(statestore_path / "postgres.yaml", "r") as f:
+            postgres = yaml.safe_load(f)
+        assert postgres["spec"]["type"] == "state.postgresql", "postgres.yaml should use state.postgresql"
+
+        # redis.yaml and default.yaml should use state.redis
+        with open(statestore_path / "redis.yaml", "r") as f:
+            redis = yaml.safe_load(f)
+        assert redis["spec"]["type"] == "state.redis", "redis.yaml should use state.redis"
+
+        with open(statestore_path / "default.yaml", "r") as f:
+            default = yaml.safe_load(f)
+        assert default["spec"]["type"] == "state.redis", "default.yaml should use state.redis"
+
+    def test_readme_exists_in_root(self, dapr_components_base_path: Path):
+        """Verify README.md still exists in root directory."""
+        readme_path = dapr_components_base_path / "README.md"
+        assert readme_path.exists(), "README.md should exist in dapr-components root"
+        assert readme_path.is_file(), "README.md should be a file"
+
+
+class TestDaprComponentDiscovery:
+    """Test suite for Dapr runtime component discovery."""
+
+    def test_dapr_scans_subdirectories_recursively(self, dapr_components_base_path: Path):
+        """Verify Dapr components-path supports subdirectory scanning.
+
+        Note: This is a structural test. Runtime verification happens in
+        test-docker-stack.ps1 by checking Dapr metadata endpoint.
+        """
+        # Dapr runtime automatically scans subdirectories for component files
+        # We verify the structure allows for this behavior
+
+        all_component_files = list(dapr_components_base_path.rglob("*.yaml"))
+
+        # Filter out README.md and only include YAML component files
+        component_yamls = [
+            f for f in all_component_files
+            if f.is_file() and f.parent != dapr_components_base_path
+        ]
+
+        # Should have at least 7 component files in subdirectories
+        assert len(component_yamls) >= 7, f"Expected at least 7 components in subdirectories, found {len(component_yamls)}"
+
+        # All component files should be in subdirectories, not root
+        for component_file in component_yamls:
+            assert component_file.parent != dapr_components_base_path, \
+                f"Component {component_file.name} should be in a subdirectory"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])