Updated the vote service tests

tdensmore · tdensmore · commit 3169aed8a7f2 · 2024-12-16T15:49:10.000-05:00
diff --git a/.github/workflows/build-test-github.yml b/.github/workflows/build-test-github.yml
@@ -0,0 +1,72 @@
+name: Build and Push Images
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  REGISTRY: ghcr.io
+  VOTE_IMAGE_NAME: ${{ github.repository }}/vote
+  RESULT_IMAGE_NAME: ${{ github.repository }}/result
+  WORKER_IMAGE_NAME: ${{ github.repository }}/worker
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Log in to the Container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and push Vote image
+        uses: docker/build-push-action@v5
+        with:
+          context: ./vote
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ env.REGISTRY }}/${{ env.VOTE_IMAGE_NAME }}:${{ github.sha }},${{ env.REGISTRY }}/${{ env.VOTE_IMAGE_NAME }}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Build and push Result image
+        uses: docker/build-push-action@v5
+        with:
+          context: ./result
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ env.REGISTRY }}/${{ env.RESULT_IMAGE_NAME }}:${{ github.sha }},${{ env.REGISTRY }}/${{ env.RESULT_IMAGE_NAME }}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Build and push Worker image
+        uses: docker/build-push-action@v5
+        with:
+          context: ./worker
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ env.REGISTRY }}/${{ env.WORKER_IMAGE_NAME }}:${{ github.sha }},${{ env.REGISTRY }}/${{ env.WORKER_IMAGE_NAME }}:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Test the application
+        run: |
+          docker compose up -d
+          sleep 30  # Give some time for services to start
+          
+          # Basic health checks
+          curl -f http://localhost:8080 || exit 1  # Vote app
+          curl -f http://localhost:8081 || exit 1  # Result app
+          
+          docker compose down
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -1,47 +1,64 @@
+# Primary workflow for building and testing the voting application
+# This workflow uses standard GitHub-hosted runners and Docker BuildKit
+
 name: Build and Push Images
 
+# Trigger the workflow on push to main branch or when a PR is opened/updated
 on:
   push:
     branches: [ "main" ]
   pull_request:
     branches: [ "main" ]
 
+# Global environment variables used throughout the workflow
 env:
+  # Define the container registry and image names
   REGISTRY: ghcr.io
   VOTE_IMAGE_NAME: ${{ github.repository }}/vote
   RESULT_IMAGE_NAME: ${{ github.repository }}/result
   WORKER_IMAGE_NAME: ${{ github.repository }}/worker
 
 jobs:
   build:
+    # Use latest Ubuntu runner provided by GitHub Actions
     runs-on: ubuntu-latest
+    
+    # Define required permissions for the job
     permissions:
-      contents: read
-      packages: write
+      contents: read      # Required to checkout code
+      packages: write     # Required to push to GitHub Packages
 
     steps:
+      # Step 1: Check out the repository code
       - name: Checkout repository
         uses: actions/checkout@v4
+        # This step clones the repository and sets up the workspace
 
+      # Step 2: Set up Docker Buildx for multi-platform builds
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        # Buildx provides enhanced build capabilities including multi-arch builds
+
+      # Step 3: Authenticate with GitHub Container Registry
       - name: Log in to the Container registry
         uses: docker/login-action@v3
         with:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
+        # This allows us to push images to GitHub Container Registry
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
+      # Step 4: Build and push the Vote service image
       - name: Build and push Vote image
         uses: docker/build-push-action@v5
         with:
           context: ./vote
-          push: ${{ github.event_name != 'pull_request' }}
+          push: ${{ github.event_name != 'pull_request' }}  # Only push on main branch
           tags: ${{ env.REGISTRY }}/${{ env.VOTE_IMAGE_NAME }}:${{ github.sha }},${{ env.REGISTRY }}/${{ env.VOTE_IMAGE_NAME }}:latest
-          cache-from: type=gha
+          cache-from: type=gha  # Use GitHub Actions cache
           cache-to: type=gha,mode=max
 
+      # Step 5: Build and push the Result service image
       - name: Build and push Result image
         uses: docker/build-push-action@v5
         with:
@@ -51,6 +68,7 @@ jobs:
           cache-from: type=gha
           cache-to: type=gha,mode=max
 
+      # Step 6: Build and push the Worker service image
       - name: Build and push Worker image
         uses: docker/build-push-action@v5
         with:
@@ -60,13 +78,18 @@ jobs:
           cache-from: type=gha
           cache-to: type=gha,mode=max
 
+      # Step 7: Test the application
       - name: Test the application
         run: |
+          # Start all services using docker-compose
           docker compose up -d
-          sleep 30  # Give some time for services to start
           
-          # Basic health checks
+          # Wait for services to initialize
+          sleep 30
+          
+          # Perform health checks on the services
           curl -f http://localhost:8080 || exit 1  # Vote app
           curl -f http://localhost:8081 || exit 1  # Result app
           
+          # Clean up containers
           docker compose down
diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml
@@ -0,0 +1,69 @@
+# Integration Test Workflow for the Vote Service
+# This workflow runs testcontainer-based integration tests for the voting application
+
+name: Integration Tests
+
+# Only trigger on changes to the vote service
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - 'vote/**'
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'vote/**'
+
+jobs:
+  test:
+    # Use latest Ubuntu runner provided by GitHub Actions
+    runs-on: ubuntu-latest
+    
+    # Set up required services for testing
+    services:
+      # Docker-in-Docker service required for testcontainers
+      dind:
+        image: docker:dind
+        ports:
+          - 2375:2375  # Expose Docker daemon port
+        env:
+          DOCKER_TLS_CERTDIR: ""  # Disable TLS for local development
+        options: >-
+          --privileged
+          --health-cmd "docker info"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    steps:
+      # Step 1: Check out the repository code
+      - uses: actions/checkout@v4
+        # This provides access to the repository content
+
+      # Step 2: Set up Python environment
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'  # Use Python 3.11 for testing
+          cache: 'pip'  # Enable pip caching for faster installations
+
+      # Step 3: Install test dependencies
+      - name: Install dependencies
+        working-directory: ./vote
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements-test.txt
+        # Install all required packages for running tests
+
+      # Step 4: Run integration tests
+      - name: Run tests
+        working-directory: ./vote
+        env:
+          # Configure Docker host for testcontainers
+          DOCKER_HOST: tcp://localhost:2375
+          TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE: /var/run/docker.sock
+          # Add vote directory to Python path
+          PYTHONPATH: ${{ github.workspace }}/vote
+        run: |
+          # Run pytest with verbose output
+          pytest test_vote_service.py -v
diff --git a/vote/requirements-test.txt b/vote/requirements-test.txt
@@ -2,3 +2,6 @@ pytest==7.4.3
 testcontainers==3.7.1
 requests==2.31.0
 redis==5.0.1
+Flask==3.0.0
+gunicorn==21.2.0
+watchdog==3.0.0
diff --git a/vote/test_vote_service.py b/vote/test_vote_service.py
@@ -2,31 +2,51 @@
 import requests
 from testcontainers.redis import RedisContainer
 from testcontainers.core.container import DockerContainer
+from testcontainers.core.waiting_utils import wait_for_logs
 import json
 import time
 
 class VoteAppContainer(DockerContainer):
-    def __init__(self, redis_host, redis_port):
-        super(VoteAppContainer, self).__init__("example-voting-app-vote")
-        self.with_env("REDIS_HOST", redis_host)
-        self.with_env("REDIS_PORT", str(redis_port))
+    """Custom container class for the voting application"""
+    
+    def __init__(self):
+        # Use the same image name as in docker-compose
+        super(VoteAppContainer, self).__init__("example-voting-app-vote:test")
         self.with_exposed_ports(80)
+        self.with_env("FLASK_ENV", "development")
+        
+    def start(self):
+        """Override start to wait for the application to be ready"""
+        super().start()
+        # Wait for Gunicorn to start
+        wait_for_logs(self, "Listening at: http://0.0.0.0:80")
+        return self
 
 @pytest.fixture(scope="function")
 def vote_app_environment():
+    """Fixture that provides a complete voting app environment with Redis"""
+    
     # Start Redis container
     with RedisContainer() as redis:
+        redis_host = redis.get_container_host_ip()
+        redis_port = redis.get_exposed_port(6379)
+        
         # Build the vote app image
         import subprocess
-        subprocess.run(["docker", "build", "-t", "example-voting-app-vote", "."], check=True)
+        subprocess.run([
+            "docker", "build", 
+            "-t", "example-voting-app-vote:test",
+            "-f", "Dockerfile",
+            "--target", "dev",  # Use dev target for faster builds
+            "."
+        ], check=True)
         
         # Start vote app container
-        with VoteAppContainer(
-            redis_host=redis.get_container_host_ip(),
-            redis_port=redis.get_exposed_port(6379)
-        ) as vote_app:
-            # Wait for the application to be ready
-            time.sleep(2)
+        with VoteAppContainer() as vote_app:
+            # Configure Redis connection
+            vote_app.with_env("REDIS_HOST", redis_host)
+            vote_app.with_env("REDIS_PORT", str(redis_port))
+            
             vote_app_url = f"http://{vote_app.get_container_host_ip()}:{vote_app.get_exposed_port(80)}"
             
             yield {
@@ -35,41 +55,58 @@ def vote_app_environment():
             }
 
 def test_vote_submission(vote_app_environment):
-    # Get the URL where the vote app is running
+    """Test that votes can be submitted and are stored in Redis"""
+    
     vote_app_url = vote_app_environment["vote_app_url"]
     
     # First request to get the cookie
     response = requests.get(vote_app_url)
-    assert response.status_code == 200
+    assert response.status_code == 200, "Failed to get initial page"
     cookies = response.cookies
     
     # Submit a vote
     vote_data = {"vote": "a"}
     response = requests.post(vote_app_url, data=vote_data, cookies=cookies)
-    assert response.status_code == 200
+    assert response.status_code == 200, "Failed to submit vote"
     
     # Verify vote was stored in Redis
     redis = vote_app_environment["redis"]
     redis_client = redis.get_client()
-    votes = redis_client.lrange("votes", 0, -1)
     
-    # There should be at least one vote
-    assert len(votes) > 0
+    # Wait for the vote to be processed (add retry logic)
+    max_retries = 5
+    for _ in range(max_retries):
+        votes = redis_client.lrange("votes", 0, -1)
+        if votes:
+            break
+        time.sleep(1)
+    else:
+        pytest.fail("Vote was not stored in Redis after multiple retries")
     
     # Parse the latest vote
     latest_vote = json.loads(votes[-1])
-    assert "vote" in latest_vote
-    assert latest_vote["vote"] == "a"
+    assert "vote" in latest_vote, "Vote data is missing vote field"
+    assert latest_vote["vote"] == "a", f"Expected vote 'a' but got {latest_vote['vote']}"
 
 def test_options_displayed(vote_app_environment):
-    # Get the URL where the vote app is running
+    """Test that voting options are correctly displayed"""
+    
     vote_app_url = vote_app_environment["vote_app_url"]
     
     # Get the main page
     response = requests.get(vote_app_url)
-    assert response.status_code == 200
+    assert response.status_code == 200, "Failed to get voting page"
     
     # Check if both options are in the response
     content = response.text
-    assert "Cats" in content
-    assert "Dogs" in content
+    assert "Cats" in content, "Option 'Cats' not found in page"
+    assert "Dogs" in content, "Option 'Dogs' not found in page"
+
+def test_health_check(vote_app_environment):
+    """Test the application's health check endpoint"""
+    
+    vote_app_url = vote_app_environment["vote_app_url"]
+    
+    # Make a request to the root endpoint
+    response = requests.get(vote_app_url)
+    assert response.status_code == 200, "Health check failed"
