superset-showtime 0.4.9__tar.gz → 0.5.1__tar.gz

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/.claude/settings.local.json

@@ -42,7 +42,8 @@
       "Bash(showtime status:*)",
       "Bash(showtime sync:*)",
       "Bash(AWS_PROFILE=\"\" showtime sync 34831 --dry-run-aws --dry-run-github)",
-      "Bash(git stash:*)"
+      "Bash(git stash:*)",
+      "Bash(showtime list:*)"
     ],
     "deny": [],
     "ask": []

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superset-showtime
-Version: 0.4.9
+Version: 0.5.1
 Summary: 🎪 Apache Superset ephemeral environment management with circus tent emoji state tracking
 Project-URL: Homepage, https://github.com/apache/superset-showtime
 Project-URL: Documentation, https://superset-showtime.readthedocs.io/

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/showtime/__init__.py

@@ -4,7 +4,7 @@
 Circus tent emoji state tracking for Apache Superset ephemeral environments.
 """
 
-__version__ = "0.4.9"
+__version__ = "0.5.1"
 __author__ = "Maxime Beauchemin"
 __email__ = "maximebeauchemin@gmail.com"
 

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/showtime/cli.py

@@ -319,8 +319,10 @@ def list(
         # Create table with full terminal width
         table = Table(title="🎪 Environment List", expand=True)
         table.add_column("PR", style="cyan", min_width=6)
+        table.add_column("Type", style="white", min_width=8)
         table.add_column("Status", style="white", min_width=12)
         table.add_column("SHA", style="green", min_width=11)
+        table.add_column("Created", style="dim white", min_width=12)
         table.add_column("Superset URL", style="blue", min_width=25)
         table.add_column("AWS Logs", style="dim blue", min_width=15)
         table.add_column("TTL", style="yellow", min_width=6)
@@ -328,9 +330,23 @@ def list(
 
         status_emoji = STATUS_DISPLAY
 
-        for env in sorted(filtered_envs, key=lambda e: e["pr_number"]):
+        # Sort by PR number, then by show type (active first, then building, then orphaned)
+        type_priority = {"active": 1, "building": 2, "orphaned": 3}
+        sorted_envs = sorted(filtered_envs, key=lambda e: (e["pr_number"], type_priority.get(e["show"].get("show_type", "orphaned"), 3)))
+        
+        for env in sorted_envs:
             show_data = env["show"]
             pr_number = env["pr_number"]
+            
+            # Show type with appropriate styling (using single-width chars for alignment)
+            show_type = show_data.get("show_type", "orphaned")
+            if show_type == "active":
+                type_display = "* active"
+            elif show_type == "building": 
+                type_display = "# building"
+            else:
+                type_display = "! orphaned"
+            
             # Make Superset URL clickable and show full URL
             if show_data["ip"]:
                 full_url = f"http://{show_data['ip']}:8080"
@@ -348,10 +364,22 @@ def list(
             pr_url = f"https://github.com/apache/superset/pull/{pr_number}"
             clickable_pr = f"[link={pr_url}]{pr_number}[/link]"
 
+            # Format creation time for display
+            created_display = show_data.get("created_at", "-")
+            if created_display and created_display != "-":
+                # Convert 2025-08-25T05-18 to more readable format
+                try:
+                    parts = created_display.replace("T", " ").replace("-", ":")
+                    created_display = parts[-8:]  # Show just HH:MM:SS
+                except:
+                    pass  # Keep original if parsing fails
+
             table.add_row(
                 clickable_pr,
+                type_display,
                 f"{status_emoji.get(show_data['status'], '❓')} {show_data['status']}",
                 show_data["sha"],
+                created_display,
                 superset_url,
                 aws_logs_link,
                 show_data["ttl"],
@@ -615,6 +643,102 @@ def setup_labels(
         p(f"🎪 [bold red]Error setting up labels:[/bold red] {e}")
 
 
+@app.command()
+def aws_cleanup(
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be cleaned"),
+    force: bool = typer.Option(False, "--force", help="Delete all showtime AWS resources"),
+) -> None:
+    """🧹 Clean up orphaned AWS resources without GitHub labels"""
+    try:
+        from .core.aws import AWSInterface
+        
+        aws = AWSInterface()
+        
+        p("🔍 [bold blue]Scanning for orphaned AWS resources...[/bold blue]")
+        
+        # 1. Get all GitHub PRs with circus labels
+        github_services = set()
+        try:
+            all_pr_numbers = PullRequest.find_all_with_environments()
+            p(f"📋 Found {len(all_pr_numbers)} PRs with circus labels:")
+            
+            for pr_number in all_pr_numbers:
+                pr = PullRequest.from_id(pr_number)
+                p(f"  🎪 PR #{pr_number}: {len(pr.shows)} shows, {len(pr.circus_labels)} circus labels")
+                
+                for show in pr.shows:
+                    service_name = show.ecs_service_name
+                    github_services.add(service_name)
+                    p(f"    📝 Expected service: {service_name}")
+                    
+                # Show labels for debugging
+                if not pr.shows:
+                    p(f"    ⚠️ No shows found, labels: {pr.circus_labels[:3]}...")  # First 3 labels
+                    
+        except Exception as e:
+            p(f"⚠️ GitHub scan failed: {e}")
+            github_services = set()
+        
+        # 2. Get all AWS ECS services matching showtime pattern
+        p("\n☁️ [bold blue]Scanning AWS ECS services...[/bold blue]")
+        try:
+            aws_services = aws.find_showtime_services()
+            p(f"🔍 Found {len(aws_services)} AWS services with pr-* pattern")
+            
+            for service in aws_services:
+                p(f"  ☁️ AWS: {service}")
+        except Exception as e:
+            p(f"❌ AWS scan failed: {e}")
+            return
+            
+        # 3. Find orphaned services
+        orphaned = [service for service in aws_services if service not in github_services]
+        
+        if not orphaned:
+            p("\n✅ [bold green]No orphaned AWS resources found![/bold green]")
+            return
+            
+        p(f"\n🚨 [bold red]Found {len(orphaned)} orphaned AWS resources:[/bold red]")
+        for service in orphaned:
+            p(f"  💰 {service} (consuming resources)")
+            
+        if dry_run:
+            p(f"\n🎪 [bold yellow]DRY RUN[/bold yellow] - Would delete {len(orphaned)} services")
+            return
+            
+        if not force:
+            confirm = typer.confirm(f"Delete {len(orphaned)} orphaned AWS services?")
+            if not confirm:
+                p("🎪 Cancelled")
+                return
+                
+        # 4. Delete orphaned resources
+        deleted_count = 0
+        for service in orphaned:
+            p(f"🗑️ Deleting {service}...")
+            try:
+                # Extract PR number for delete_environment call
+                pr_match = service.replace("pr-", "").replace("-service", "")
+                parts = pr_match.split("-")
+                if len(parts) >= 2:
+                    pr_number = int(parts[0])
+                    success = aws.delete_environment(service, pr_number)
+                    if success:
+                        p(f"✅ Deleted {service}")
+                        deleted_count += 1
+                    else:
+                        p(f"❌ Failed to delete {service}")
+                else:
+                    p(f"❌ Invalid service name format: {service}")
+            except Exception as e:
+                p(f"❌ Error deleting {service}: {e}")
+                
+        p(f"\n🎪 ✅ Cleanup complete: deleted {deleted_count}/{len(orphaned)} services")
+        
+    except Exception as e:
+        p(f"❌ AWS cleanup failed: {e}")
+
+
 @app.command()
 def cleanup(
     dry_run: bool = typer.Option(False, "--dry-run", help="Show what would be cleaned"),

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/showtime/core/aws.py

@@ -175,36 +175,62 @@ class AWSInterface:
 
     def delete_environment(self, service_name: str, pr_number: int) -> bool:
         """
-        Delete ephemeral environment - replicates cleanup GHA logic
+        Delete ephemeral environment with proper verification
 
         Steps:
-        1. Check if ECS service exists and is active
-        2. Delete ECS service with --force
+        1. Check if ECS service exists 
+        2. Delete ECS service with force and wait for completion
         3. Delete ECR image tag
+        4. Verify deletion completed
         """
         try:
-            # Step 1: Check if service exists and is active
-            if not self._service_exists(service_name):
-                return True  # Already deleted
-
-            # Step 2: Delete ECS service (force delete)
-            self.ecs_client.delete_service(cluster=self.cluster, service=service_name, force=True)
+            ecs_service_name = f"{service_name}-service" if not service_name.endswith("-service") else service_name
+            print(f"🗑️ Deleting ECS service: {ecs_service_name}")
+            
+            # Step 1: Check if service exists
+            if not self._service_exists(ecs_service_name):
+                print(f"✅ Service {ecs_service_name} already deleted")
+                return True
+
+            # Step 2: Delete ECS service (force delete) and wait
+            print(f"☁️ Initiating ECS service deletion...")
+            delete_response = self.ecs_client.delete_service(
+                cluster=self.cluster, 
+                service=ecs_service_name, 
+                force=True
+            )
+            print(f"🔄 Delete initiated: {delete_response.get('service', {}).get('status', 'unknown')}")
+
+            # Step 3: Wait for deletion to complete (crucial!)
+            print(f"⏳ Waiting for service deletion to complete...")
+            deletion_success = self._wait_for_service_deletion(ecs_service_name, timeout_minutes=10)
+            
+            if not deletion_success:
+                print(f"⚠️ Service deletion timeout - service may still exist")
+                return False
 
-            # Step 3: Delete ECR image tag
-            # Extract SHA from service name: pr-1234-abc123f → abc123f
-            sha = service_name.split("-")[-1]
-            image_tag = f"pr-{pr_number}-{sha}"
+            # Step 4: Delete ECR image tag
+            print(f"🐳 Cleaning up Docker image...")
+            # Fix SHA extraction: pr-34831-ac533ec-service → ac533ec
+            # Remove "pr-" prefix and "-service" suffix, then get SHA (last part)
+            base_name = service_name.replace("pr-", "").replace("-service", "")
+            parts = base_name.split("-")
+            sha = parts[-1] if len(parts) > 1 else base_name  # Last part is SHA
+            image_tag = f"pr-{pr_number}-{sha}-ci"
 
             try:
                 self.ecr_client.batch_delete_image(
                     repositoryName=self.repository, imageIds=[{"imageTag": image_tag}]
                 )
+                print(f"✅ Deleted ECR image: {image_tag}")
             except self.ecr_client.exceptions.ImageNotFoundException:
-                pass  # Image already deleted
+                print(f"ℹ️ ECR image {image_tag} already deleted")
 
+            print(f"✅ Environment {service_name} fully deleted")
             return True
 
         except Exception as e:
+            print(f"❌ AWS deletion failed: {e}")
             raise AWSError(
                 message=str(e), operation="delete_environment", resource=service_name
             ) from e
@@ -670,6 +696,28 @@ class AWSInterface:
             print(f"❌ Failed to find expired services: {e}")
             return []
 
+    def find_showtime_services(self) -> List[str]:
+        """Find all ECS services managed by showtime (pr-* pattern)"""
+        try:
+            # List all services in cluster
+            response = self.ecs_client.list_services(cluster=self.cluster)
+            
+            if not response.get("serviceArns"):
+                return []
+            
+            # Extract service names and filter for showtime pattern
+            showtime_services = []
+            for service_arn in response["serviceArns"]:
+                service_name = service_arn.split("/")[-1]  # Extract name from ARN
+                if service_name.startswith("pr-") and "-service" in service_name:
+                    showtime_services.append(service_name)
+            
+            return sorted(showtime_services)
+            
+        except Exception as e:
+            print(f"❌ Failed to find showtime services: {e}")
+            return []
+
     def _find_pr_services(self, pr_number: int) -> List[Dict[str, Any]]:
         """Find all ECS services for a specific PR"""
         try:

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/showtime/core/pull_request.py

@@ -356,55 +356,93 @@ class PullRequest:
         all_environments = []
         for pr_number in pr_numbers:
             pr = cls.from_id(pr_number)
-            if pr.current_show:
-                status = pr.get_status()
-                status["pr_number"] = pr_number
-                all_environments.append(status)
+            # Show ALL environments, not just current_show
+            for show in pr.shows:
+                # Determine show type based on pointer presence
+                show_type = "orphaned"  # Default
+                
+                # Check for active pointer
+                if any(label == f"🎪 🎯 {show.sha}" for label in pr.labels):
+                    show_type = "active"
+                # Check for building pointer  
+                elif any(label == f"🎪 🏗️ {show.sha}" for label in pr.labels):
+                    show_type = "building"
+                # No pointer = orphaned
+                
+                environment_data = {
+                    "pr_number": pr_number,
+                    "status": "active",  # Keep for compatibility
+                    "show": {
+                        "sha": show.sha,
+                        "status": show.status,
+                        "ip": show.ip,
+                        "ttl": show.ttl,
+                        "requested_by": show.requested_by,
+                        "created_at": show.created_at,
+                        "aws_service_name": show.aws_service_name,
+                        "show_type": show_type,  # New field for display
+                    },
+                }
+                all_environments.append(environment_data)
 
         return all_environments
 
     def _determine_action(self, target_sha: str) -> str:
-        """Determine what sync action is needed"""
+        """Determine what sync action is needed based on target SHA state"""
+        target_sha_short = target_sha[:7]  # Ensure we're working with short SHA
+        
+        # Get the specific show for the target SHA
+        target_show = self.get_show_by_sha(target_sha_short)
+        
         # Check for explicit trigger labels
         trigger_labels = [label for label in self.labels if "showtime-trigger-" in label]
 
         if trigger_labels:
             for trigger in trigger_labels:
                 if "showtime-trigger-start" in trigger:
-                    if self.current_show and self.current_show.status == "failed":
-                        return "create_environment"  # Replace failed environment
-                    elif self.current_show and self.current_show.needs_update(target_sha):
-                        return "rolling_update"
-                    elif self.current_show:
-                        return "no_action"  # Same commit, healthy environment
+                    if not target_show or target_show.status == "failed":
+                        return "create_environment"  # New SHA or failed SHA
+                    elif target_show.status in ["building", "built", "deploying"]:
+                        return "no_action"  # Target SHA already in progress
+                    elif target_show.status == "running":
+                        return "create_environment"  # Force rebuild with trigger
                     else:
-                        return "create_environment"
+                        return "create_environment"  # Default for unknown states
                 elif "showtime-trigger-stop" in trigger:
                     return "destroy_environment"
 
-        # No explicit triggers - check for auto-sync or creation
-        if self.current_show and self.current_show.status != "failed" and self.current_show.needs_update(target_sha):
-            return "auto_sync"
-        elif not self.current_show or self.current_show.status == "failed":
-            # No environment exists OR failed environment - allow creation without trigger (for CLI start)
+        # No explicit triggers - check target SHA state
+        if not target_show:
+            # Target SHA doesn't exist - create it
+            return "create_environment"
+        elif target_show.status == "failed":
+            # Target SHA failed - rebuild it
             return "create_environment"
+        elif target_show.status in ["building", "built", "deploying"]:
+            # Target SHA in progress - wait
+            return "no_action"
+        elif target_show.status == "running":
+            # Target SHA already running - no action needed
+            return "no_action"
 
         return "no_action"
 
     def _atomic_claim(self, target_sha: str, action: str, dry_run: bool = False) -> bool:
-        """Atomically claim this PR for the current job"""
-        # 1. Validate current state allows this action
+        """Atomically claim this PR for the current job based on target SHA state"""
+        target_sha_short = target_sha[:7]
+        target_show = self.get_show_by_sha(target_sha_short)
+        
+        # 1. Validate current state allows this action for target SHA
         if action in ["create_environment", "rolling_update", "auto_sync"]:
-            if self.current_show and self.current_show.status in [
+            if target_show and target_show.status in [
                 "building",
                 "built", 
                 "deploying",
             ]:
-                return False  # Another job active
+                return False  # Target SHA already in progress
             
-            # For rolling updates, running environments are OK to update
-            if action in ["rolling_update", "auto_sync"] and self.current_show and self.current_show.status == "running":
-                return True  # Allow rolling updates on running environments
+            # Allow actions on failed, running, or non-existent target SHAs
+            return True
 
         if dry_run:
             print(f"🎪 [DRY-RUN] Would atomically claim PR for {action}")
@@ -412,17 +450,31 @@ class PullRequest:
 
         # 2. Remove trigger labels (atomic operation)
         trigger_labels = [label for label in self.labels if "showtime-trigger-" in label]
-        for trigger_label in trigger_labels:
-            get_github().remove_label(self.pr_number, trigger_label)
+        if trigger_labels:
+            print(f"🏷️ Removing trigger labels: {trigger_labels}")
+            for trigger_label in trigger_labels:
+                get_github().remove_label(self.pr_number, trigger_label)
+        else:
+            print("🏷️ No trigger labels to remove")
 
         # 3. Set building state immediately (claim the PR)
         if action in ["create_environment", "rolling_update", "auto_sync"]:
             building_show = self._create_new_show(target_sha)
             building_show.status = "building"
+            
             # Update labels to reflect building state
+            print(f"🏷️ Removing existing circus labels...")
             get_github().remove_circus_labels(self.pr_number)
-            for label in building_show.to_circus_labels():
-                get_github().add_label(self.pr_number, label)
+            
+            new_labels = building_show.to_circus_labels()
+            print(f"🏷️ Creating new labels: {new_labels}")
+            for label in new_labels:
+                try:
+                    get_github().add_label(self.pr_number, label)
+                    print(f"  ✅ Added: {label}")
+                except Exception as e:
+                    print(f"  ❌ Failed to add {label}: {e}")
+                    raise
 
         return True
 

{superset_showtime-0.4.9 → superset_showtime-0.5.1}/showtime/core/show.py

@@ -175,7 +175,7 @@ class Show:
             "--platform",
             "linux/amd64",
             "--target",
-            "ci",
+            "dev",
             "--build-arg",
             "INCLUDE_CHROMIUM=false",
             "--build-arg",
@@ -202,16 +202,14 @@ class Show:
             ])
             print("🐳 Local environment: Using cache-from only (no export)")
 
-        # Add --load only when building for native architecture or explicitly requested
-        # Intel Mac/Linux can load linux/amd64, Apple Silicon cannot
-        native_x86 = platform.machine() in ("x86_64", "AMD64")
+        # Add --load only when explicitly requested for local testing
         force_load = os.getenv("DOCKER_LOAD", "false").lower() == "true"
         
-        if native_x86 or force_load:
+        if force_load:
             cmd.append("--load")
-            print("🐳 Will load image to local Docker daemon (native x86_64 platform)")
+            print("🐳 Will load image to local Docker daemon (DOCKER_LOAD=true)")
         else:
-            print("🐳 Cross-platform build - pushing to registry only (no local load)")
+            print("🐳 Push-only build (no local load) - faster for CI/deployment")
 
         # Add build context path last
         cmd.append(".")
@@ -270,8 +268,10 @@ class Show:
                 elif emoji == "🤡":  # User (clown!)
                     show_data["requested_by"] = value
 
-        # Only return Show if we found relevant labels for this SHA
-        if any(label.endswith(f" {sha}") for label in labels if "🎯" in label or "🏗️" in label):
+        # Return Show if we found any status labels for this SHA
+        # For list purposes, we want to show ALL environments, even orphaned ones
+        has_status = any(label.startswith(f"🎪 {sha} 🚦 ") for label in labels)
+        if has_status:
             return cls(**show_data)  # type: ignore[arg-type]
 
         return None

superset_showtime-0.5.1/tests/unit/test_sha_specific_logic.py

@@ -0,0 +1,146 @@
+"""
+TDD tests for SHA-specific build logic
+
+Tests the correct behavior when multiple environments exist per PR.
+The system should make decisions based on the target SHA's state, 
+not the overall PR state.
+"""
+
+from showtime.core.pull_request import PullRequest
+
+
+def test_target_sha_does_not_exist_should_build():
+    """When target SHA doesn't exist, should create environment"""
+    # PR with existing environments for different SHAs
+    pr = PullRequest(1234, [
+        "🎪 abc123f 🚦 running",    # Different SHA running
+        "🎪 🎯 abc123f",           # Active pointer to different SHA
+        "🎪 def456a 🚦 failed",    # Different SHA failed
+        "🎪 xyz789b 🚦 building",  # Different SHA building
+    ])
+    
+    # Target a completely new SHA
+    action = pr._determine_action("new567c")
+    
+    # Should create environment for new SHA
+    assert action == "create_environment"
+
+
+def test_target_sha_failed_should_rebuild():
+    """When target SHA is in failed state, should rebuild"""
+    pr = PullRequest(1234, [
+        "🎪 abc123f 🚦 running",   # Other SHA running
+        "🎪 🎯 abc123f",          # Active pointer
+        "🎪 def456a 🚦 failed",   # Target SHA failed
+        "🎪 🎯 def456a",          # Target has pointer (failed but pointed to)
+    ])
+    
+    # Target the failed SHA
+    action = pr._determine_action("def456a")
+    
+    # Should rebuild failed environment
+    assert action == "create_environment"
+
+
+def test_target_sha_building_should_wait():
+    """When target SHA is already building, should not start another build"""
+    pr = PullRequest(1234, [
+        "🎪 abc123f 🚦 running",    # Other SHA running
+        "🎪 🎯 abc123f",           # Active pointer
+        "🎪 def456a 🚦 building",  # Target SHA building
+        "🎪 🏗️ def456a",          # Building pointer
+    ])
+    
+    # Target the building SHA
+    action = pr._determine_action("def456a")
+    
+    # Should not start duplicate build
+    assert action == "no_action"
+
+
+def test_target_sha_running_should_not_rebuild():
+    """When target SHA is already running, should not rebuild"""
+    pr = PullRequest(1234, [
+        "🎪 abc123f 🚦 running",   # Target SHA running
+        "🎪 🎯 abc123f",          # Active pointer
+        "🎪 def456a 🚦 building", # Other SHA building
+    ])
+    
+    # Target the running SHA (same as current)
+    action = pr._determine_action("abc123f")
+    
+    # Should not rebuild running environment
+    assert action == "no_action"
+
+
+def test_target_sha_running_with_trigger_should_rebuild():
+    """When target SHA is running but has start trigger, should rebuild"""
+    pr = PullRequest(1234, [
+        "🎪 ⚡ showtime-trigger-start",  # Explicit start trigger
+        "🎪 abc123f 🚦 running",        # Target SHA running
+        "🎪 🎯 abc123f",               # Active pointer
+    ])
+    
+    # Target the running SHA with explicit trigger
+    action = pr._determine_action("abc123f")
+    
+    # Should rebuild due to explicit trigger (force rebuild)
+    assert action == "create_environment"
+
+
+def test_atomic_claim_sha_specific_validation():
+    """Atomic claim should validate based on target SHA state, not any environment"""
+    pr = PullRequest(1234, [
+        "🎪 abc123f 🚦 running",   # Other SHA running
+        "🎪 🎯 abc123f",          # Active pointer
+        "🎪 def456a 🚦 building", # Other SHA building
+    ])
+    
+    # Should allow claim for new SHA even though other SHAs are active
+    can_claim_new = pr._atomic_claim("new567c", "create_environment", dry_run=True)
+    assert can_claim_new is True
+    
+    # Should block claim for SHA that's already building
+    can_claim_building = pr._atomic_claim("def456a", "create_environment", dry_run=True) 
+    assert can_claim_building is False
+    
+    # Should allow claim for running SHA with rolling update
+    can_claim_rolling = pr._atomic_claim("abc123f", "rolling_update", dry_run=True)
+    assert can_claim_rolling is True
+
+
+def test_multiple_environments_pointer_management():
+    """Test proper pointer management with multiple environments"""
+    # Scenario: Multiple environments exist, need to identify which is which
+    pr = PullRequest(1234, [
+        "🎪 abc123f 🚦 running",   # Old active
+        "🎪 🎯 abc123f",          # Active pointer (should be only one)
+        "🎪 def456a 🚦 running",   # Orphaned (no pointer)
+        "🎪 xyz789b 🚦 failed",   # Failed (no pointer)
+    ])
+    
+    # Should have 3 total shows
+    assert len(pr.shows) == 3
+    
+    # Should have 1 active show (with pointer)
+    assert pr.current_show is not None
+    assert pr.current_show.sha == "abc123f"
+    
+    # Should have no building show
+    assert pr.building_show is None
+    
+    # Other shows should be findable but not pointed to
+    def456a_show = pr.get_show_by_sha("def456a")
+    assert def456a_show is not None
+    assert def456a_show.status == "running"
+    
+    xyz789b_show = pr.get_show_by_sha("xyz789b") 
+    assert xyz789b_show is not None
+    assert xyz789b_show.status == "failed"
+
+
+def test_rolling_update_should_clean_old_pointers():
+    """Rolling update should remove old active pointer and add new one"""
+    # This test defines the expected behavior for pointer management
+    # Implementation should ensure only 1 active pointer exists at a time
+    pass  # Implementation test - will write after fixing the logic