@ruaruababa/vibe-kit 1.0.0

package/skills/temporal-python-testing/resources/unit-testing.md

@@ -0,0 +1,328 @@
+# Unit Testing Temporal Workflows and Activities
+
+Focused guide for testing individual workflows and activities in isolation using WorkflowEnvironment and ActivityEnvironment.
+
+## WorkflowEnvironment with Time-Skipping
+
+**Purpose**: Test workflows in isolation with instant time progression (month-long workflows → seconds)
+
+### Basic Setup Pattern
+
+```python
+import pytest
+from temporalio.testing import WorkflowEnvironment
+from temporalio.worker import Worker
+
+@pytest.fixture
+async def workflow_env():
+    """Reusable time-skipping test environment"""
+    env = await WorkflowEnvironment.start_time_skipping()
+    yield env
+    await env.shutdown()
+
+@pytest.mark.asyncio
+async def test_workflow_execution(workflow_env):
+    """Test workflow with time-skipping"""
+    async with Worker(
+        workflow_env.client,
+        task_queue="test-queue",
+        workflows=[YourWorkflow],
+        activities=[your_activity],
+    ):
+        result = await workflow_env.client.execute_workflow(
+            YourWorkflow.run,
+            "test-input",
+            id="test-wf-id",
+            task_queue="test-queue",
+        )
+        assert result == "expected-output"
+```
+
+**Key Benefits**:
+
+- `workflow.sleep(timedelta(days=30))` completes instantly
+- Fast feedback loop (milliseconds vs hours)
+- Deterministic test execution
+
+### Time-Skipping Examples
+
+**Sleep Advancement**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_with_delays(workflow_env):
+    """Workflow sleeps are instant in time-skipping mode"""
+
+    @workflow.defn
+    class DelayedWorkflow:
+        @workflow.run
+        async def run(self) -> str:
+            await workflow.sleep(timedelta(hours=24))  # Instant in tests
+            return "completed"
+
+    async with Worker(
+        workflow_env.client,
+        task_queue="test",
+        workflows=[DelayedWorkflow],
+    ):
+        result = await workflow_env.client.execute_workflow(
+            DelayedWorkflow.run,
+            id="delayed-wf",
+            task_queue="test",
+        )
+        assert result == "completed"
+```
+
+**Manual Time Control**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_manual_time(workflow_env):
+    """Manually advance time for precise control"""
+
+    handle = await workflow_env.client.start_workflow(
+        TimeBasedWorkflow.run,
+        id="time-wf",
+        task_queue="test",
+    )
+
+    # Advance time by specific amount
+    await workflow_env.sleep(timedelta(hours=1))
+
+    # Verify intermediate state via query
+    state = await handle.query(TimeBasedWorkflow.get_state)
+    assert state == "processing"
+
+    # Advance to completion
+    await workflow_env.sleep(timedelta(hours=23))
+    result = await handle.result()
+    assert result == "completed"
+```
+
+### Testing Workflow Logic
+
+**Decision Testing**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_branching(workflow_env):
+    """Test different execution paths"""
+
+    @workflow.defn
+    class ConditionalWorkflow:
+        @workflow.run
+        async def run(self, condition: bool) -> str:
+            if condition:
+                return "path-a"
+            return "path-b"
+
+    async with Worker(
+        workflow_env.client,
+        task_queue="test",
+        workflows=[ConditionalWorkflow],
+    ):
+        # Test true path
+        result_a = await workflow_env.client.execute_workflow(
+            ConditionalWorkflow.run,
+            True,
+            id="cond-wf-true",
+            task_queue="test",
+        )
+        assert result_a == "path-a"
+
+        # Test false path
+        result_b = await workflow_env.client.execute_workflow(
+            ConditionalWorkflow.run,
+            False,
+            id="cond-wf-false",
+            task_queue="test",
+        )
+        assert result_b == "path-b"
+```
+
+## ActivityEnvironment Testing
+
+**Purpose**: Test activities in isolation without workflows or Temporal server
+
+### Basic Activity Test
+
+```python
+from temporalio.testing import ActivityEnvironment
+
+async def test_activity_basic():
+    """Test activity without workflow context"""
+
+    @activity.defn
+    async def process_data(input: str) -> str:
+        return input.upper()
+
+    env = ActivityEnvironment()
+    result = await env.run(process_data, "test")
+    assert result == "TEST"
+```
+
+### Testing Activity Context
+
+**Heartbeat Testing**:
+
+```python
+async def test_activity_heartbeat():
+    """Verify heartbeat calls"""
+
+    @activity.defn
+    async def long_running_activity(total_items: int) -> int:
+        for i in range(total_items):
+            activity.heartbeat(i)  # Report progress
+            await asyncio.sleep(0.1)
+        return total_items
+
+    env = ActivityEnvironment()
+    result = await env.run(long_running_activity, 10)
+    assert result == 10
+```
+
+**Cancellation Testing**:
+
+```python
+async def test_activity_cancellation():
+    """Test activity cancellation handling"""
+
+    @activity.defn
+    async def cancellable_activity() -> str:
+        try:
+            while True:
+                if activity.is_cancelled():
+                    return "cancelled"
+                await asyncio.sleep(0.1)
+        except asyncio.CancelledError:
+            return "cancelled"
+
+    env = ActivityEnvironment(cancellation_reason="test-cancel")
+    result = await env.run(cancellable_activity)
+    assert result == "cancelled"
+```
+
+### Testing Error Handling
+
+**Exception Propagation**:
+
+```python
+async def test_activity_error():
+    """Test activity error handling"""
+
+    @activity.defn
+    async def failing_activity(should_fail: bool) -> str:
+        if should_fail:
+            raise ApplicationError("Validation failed", non_retryable=True)
+        return "success"
+
+    env = ActivityEnvironment()
+
+    # Test success path
+    result = await env.run(failing_activity, False)
+    assert result == "success"
+
+    # Test error path
+    with pytest.raises(ApplicationError) as exc_info:
+        await env.run(failing_activity, True)
+    assert "Validation failed" in str(exc_info.value)
+```
+
+## Pytest Integration Patterns
+
+### Shared Fixtures
+
+```python
+# conftest.py
+import pytest
+from temporalio.testing import WorkflowEnvironment
+
+@pytest.fixture(scope="module")
+async def workflow_env():
+    """Module-scoped environment (reused across tests)"""
+    env = await WorkflowEnvironment.start_time_skipping()
+    yield env
+    await env.shutdown()
+
+@pytest.fixture
+def activity_env():
+    """Function-scoped environment (fresh per test)"""
+    return ActivityEnvironment()
+```
+
+### Parameterized Tests
+
+```python
+@pytest.mark.parametrize("input,expected", [
+    ("test", "TEST"),
+    ("hello", "HELLO"),
+    ("123", "123"),
+])
+async def test_activity_parameterized(activity_env, input, expected):
+    """Test multiple input scenarios"""
+    result = await activity_env.run(process_data, input)
+    assert result == expected
+```
+
+## Best Practices
+
+1. **Fast Execution**: Use time-skipping for all workflow tests
+2. **Isolation**: Test workflows and activities separately
+3. **Shared Fixtures**: Reuse WorkflowEnvironment across related tests
+4. **Coverage Target**: ≥80% for workflow logic
+5. **Mock Activities**: Use ActivityEnvironment for activity-specific logic
+6. **Determinism**: Ensure test results are consistent across runs
+7. **Error Cases**: Test both success and failure scenarios
+
+## Common Patterns
+
+**Testing Retry Logic**:
+
+```python
+@pytest.mark.asyncio
+async def test_workflow_with_retries(workflow_env):
+    """Test activity retry behavior"""
+
+    call_count = 0
+
+    @activity.defn
+    async def flaky_activity() -> str:
+        nonlocal call_count
+        call_count += 1
+        if call_count < 3:
+            raise Exception("Transient error")
+        return "success"
+
+    @workflow.defn
+    class RetryWorkflow:
+        @workflow.run
+        async def run(self) -> str:
+            return await workflow.execute_activity(
+                flaky_activity,
+                start_to_close_timeout=timedelta(seconds=10),
+                retry_policy=RetryPolicy(
+                    initial_interval=timedelta(milliseconds=1),
+                    maximum_attempts=5,
+                ),
+            )
+
+    async with Worker(
+        workflow_env.client,
+        task_queue="test",
+        workflows=[RetryWorkflow],
+        activities=[flaky_activity],
+    ):
+        result = await workflow_env.client.execute_workflow(
+            RetryWorkflow.run,
+            id="retry-wf",
+            task_queue="test",
+        )
+        assert result == "success"
+        assert call_count == 3  # Verify retry attempts
+```
+
+## Additional Resources
+
+- Python SDK Testing: docs.temporal.io/develop/python/testing-suite
+- pytest Documentation: docs.pytest.org
+- Temporal Samples: github.com/temporalio/samples-python

package/skills/terraform-module-library/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: terraform-module-library
+description: Build reusable Terraform modules for AWS, Azure, and GCP infrastructure following infrastructure-as-code best practices. Use when creating infrastructure modules, standardizing cloud provisioning, or implementing reusable IaC components.
+---
+
+# Terraform Module Library
+
+Production-ready Terraform module patterns for AWS, Azure, and GCP infrastructure.
+
+## Do not use this skill when
+
+- The task is unrelated to terraform module library
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Purpose
+
+Create reusable, well-tested Terraform modules for common cloud infrastructure patterns across multiple cloud providers.
+
+## Use this skill when
+
+- Build reusable infrastructure components
+- Standardize cloud resource provisioning
+- Implement infrastructure as code best practices
+- Create multi-cloud compatible modules
+- Establish organizational Terraform standards
+
+## Module Structure
+
+```
+terraform-modules/
+├── aws/
+│   ├── vpc/
+│   ├── eks/
+│   ├── rds/
+│   └── s3/
+├── azure/
+│   ├── vnet/
+│   ├── aks/
+│   └── storage/
+└── gcp/
+    ├── vpc/
+    ├── gke/
+    └── cloud-sql/
+```
+
+## Standard Module Pattern
+
+```
+module-name/
+├── main.tf          # Main resources
+├── variables.tf     # Input variables
+├── outputs.tf       # Output values
+├── versions.tf      # Provider versions
+├── README.md        # Documentation
+├── examples/        # Usage examples
+│   └── complete/
+│       ├── main.tf
+│       └── variables.tf
+└── tests/           # Terratest files
+    └── module_test.go
+```
+
+## AWS VPC Module Example
+
+**main.tf:**
+```hcl
+resource "aws_vpc" "main" {
+  cidr_block           = var.cidr_block
+  enable_dns_hostnames = var.enable_dns_hostnames
+  enable_dns_support   = var.enable_dns_support
+
+  tags = merge(
+    {
+      Name = var.name
+    },
+    var.tags
+  )
+}
+
+resource "aws_subnet" "private" {
+  count             = length(var.private_subnet_cidrs)
+  vpc_id            = aws_vpc.main.id
+  cidr_block        = var.private_subnet_cidrs[count.index]
+  availability_zone = var.availability_zones[count.index]
+
+  tags = merge(
+    {
+      Name = "${var.name}-private-${count.index + 1}"
+      Tier = "private"
+    },
+    var.tags
+  )
+}
+
+resource "aws_internet_gateway" "main" {
+  count  = var.create_internet_gateway ? 1 : 0
+  vpc_id = aws_vpc.main.id
+
+  tags = merge(
+    {
+      Name = "${var.name}-igw"
+    },
+    var.tags
+  )
+}
+```
+
+**variables.tf:**
+```hcl
+variable "name" {
+  description = "Name of the VPC"
+  type        = string
+}
+
+variable "cidr_block" {
+  description = "CIDR block for VPC"
+  type        = string
+  validation {
+    condition     = can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", var.cidr_block))
+    error_message = "CIDR block must be valid IPv4 CIDR notation."
+  }
+}
+
+variable "availability_zones" {
+  description = "List of availability zones"
+  type        = list(string)
+}
+
+variable "private_subnet_cidrs" {
+  description = "CIDR blocks for private subnets"
+  type        = list(string)
+  default     = []
+}
+
+variable "enable_dns_hostnames" {
+  description = "Enable DNS hostnames in VPC"
+  type        = bool
+  default     = true
+}
+
+variable "tags" {
+  description = "Additional tags"
+  type        = map(string)
+  default     = {}
+}
+```
+
+**outputs.tf:**
+```hcl
+output "vpc_id" {
+  description = "ID of the VPC"
+  value       = aws_vpc.main.id
+}
+
+output "private_subnet_ids" {
+  description = "IDs of private subnets"
+  value       = aws_subnet.private[*].id
+}
+
+output "vpc_cidr_block" {
+  description = "CIDR block of VPC"
+  value       = aws_vpc.main.cidr_block
+}
+```
+
+## Best Practices
+
+1. **Use semantic versioning** for modules
+2. **Document all variables** with descriptions
+3. **Provide examples** in examples/ directory
+4. **Use validation blocks** for input validation
+5. **Output important attributes** for module composition
+6. **Pin provider versions** in versions.tf
+7. **Use locals** for computed values
+8. **Implement conditional resources** with count/for_each
+9. **Test modules** with Terratest
+10. **Tag all resources** consistently
+
+## Module Composition
+
+```hcl
+module "vpc" {
+  source = "../../modules/aws/vpc"
+
+  name               = "production"
+  cidr_block         = "10.0.0.0/16"
+  availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"]
+
+  private_subnet_cidrs = [
+    "10.0.1.0/24",
+    "10.0.2.0/24",
+    "10.0.3.0/24"
+  ]
+
+  tags = {
+    Environment = "production"
+    ManagedBy   = "terraform"
+  }
+}
+
+module "rds" {
+  source = "../../modules/aws/rds"
+
+  identifier     = "production-db"
+  engine         = "postgres"
+  engine_version = "15.3"
+  instance_class = "db.t3.large"
+
+  vpc_id     = module.vpc.vpc_id
+  subnet_ids = module.vpc.private_subnet_ids
+
+  tags = {
+    Environment = "production"
+  }
+}
+```
+
+## Reference Files
+
+- `assets/vpc-module/` - Complete VPC module example
+- `assets/rds-module/` - RDS module example
+- `references/aws-modules.md` - AWS module patterns
+- `references/azure-modules.md` - Azure module patterns
+- `references/gcp-modules.md` - GCP module patterns
+
+## Testing
+
+```go
+// tests/vpc_test.go
+package test
+
+import (
+    "testing"
+    "github.com/gruntwork-io/terratest/modules/terraform"
+    "github.com/stretchr/testify/assert"
+)
+
+func TestVPCModule(t *testing.T) {
+    terraformOptions := &terraform.Options{
+        TerraformDir: "../examples/complete",
+    }
+
+    defer terraform.Destroy(t, terraformOptions)
+    terraform.InitAndApply(t, terraformOptions)
+
+    vpcID := terraform.Output(t, terraformOptions, "vpc_id")
+    assert.NotEmpty(t, vpcID)
+}
+```
+
+## Related Skills
+
+- `multi-cloud-architecture` - For architectural decisions
+- `cost-optimization` - For cost-effective designs

package/skills/terraform-module-library/references/aws-modules.md

@@ -0,0 +1,63 @@
+# AWS Terraform Module Patterns
+
+## VPC Module
+- VPC with public/private subnets
+- Internet Gateway and NAT Gateways
+- Route tables and associations
+- Network ACLs
+- VPC Flow Logs
+
+## EKS Module
+- EKS cluster with managed node groups
+- IRSA (IAM Roles for Service Accounts)
+- Cluster autoscaler
+- VPC CNI configuration
+- Cluster logging
+
+## RDS Module
+- RDS instance or cluster
+- Automated backups
+- Read replicas
+- Parameter groups
+- Subnet groups
+- Security groups
+
+## S3 Module
+- S3 bucket with versioning
+- Encryption at rest
+- Bucket policies
+- Lifecycle rules
+- Replication configuration
+
+## ALB Module
+- Application Load Balancer
+- Target groups
+- Listener rules
+- SSL/TLS certificates
+- Access logs
+
+## Lambda Module
+- Lambda function
+- IAM execution role
+- CloudWatch Logs
+- Environment variables
+- VPC configuration (optional)
+
+## Security Group Module
+- Reusable security group rules
+- Ingress/egress rules
+- Dynamic rule creation
+- Rule descriptions
+
+## Best Practices
+
+1. Use AWS provider version ~> 5.0
+2. Enable encryption by default
+3. Use least-privilege IAM
+4. Tag all resources consistently
+5. Enable logging and monitoring
+6. Use KMS for encryption
+7. Implement backup strategies
+8. Use PrivateLink when possible
+9. Enable GuardDuty/SecurityHub
+10. Follow AWS Well-Architected Framework