Add Makefile and tests

Author: CVanF5

.github/workflows/test-module.yml

@@ -9,61 +9,29 @@ on:
 jobs:
   module-toggle-tests:
     runs-on: ubuntu-latest
-    
+
     steps:
     - name: Checkout code
       uses: actions/checkout@v4
-      
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get install -y curl jq
-        
+
     - name: Set up Docker Buildx
       uses: docker/setup-buildx-action@v3
-      
-    - name: Build and start services
-      run: |
-        docker-compose up -d --build
-        
-    - name: Wait for services to be ready
-      run: |
-        echo "Waiting for services..."
-        sleep 30
-        
-        # Health check with retries
-        for i in {1..10}; do
-          if curl -f http://localhost:8081/health; then
-            echo "Services are ready"
-            break
-          fi
-          echo "Waiting for services... (attempt $i/10)"
-          sleep 10
-        done
-        
-    - name: Run module configuration tests
-      run: |
-        chmod +x ./tests/test_docker_simple.sh
-        ./tests/test_docker_simple.sh
-        
-    - name: Run original BBR functionality tests
+
+    - name: Run Docker tests
       run: |
-        chmod +x ./tests/test_large_body.sh
-        # Adapt for Docker environment
-        sed -i 's/localhost:8081/localhost:8081/g' ./tests/test_large_body.sh
-        ./tests/test_large_body.sh
-        
+        make test-docker
+
     - name: Show service logs on failure
       if: failure()
       run: |
         echo "=== Nginx logs ==="
-        docker-compose logs nginx
+        docker compose -f tests/docker-compose.yml logs nginx
         echo "=== Echo server logs ==="
-        docker-compose logs echo-server
+        docker compose -f tests/docker-compose.yml logs echo-server
         echo "=== Mock EPP logs ==="
-        docker-compose logs mock-epp
-        
+        docker compose -f tests/docker-compose.yml logs mock-epp
+
     - name: Cleanup
       if: always()
       run: |
-        docker-compose down -v
+        make clean

README.md

@@ -100,7 +100,7 @@ flowchart TD
   A[Client Request] --> B[NGINX]
   subgraph NGINX Pod
     subgraph NGINX Container
-      B --1--> C[Inference Module<br/> with internal BBR]
+      B --1--> C[Inference Module<br/> with Body-Based Routing]
     end
   end
   C -- 2. gRPC headers --> D[EPP Service<br/>Endpoint Picker]
@@ -112,117 +112,30 @@ flowchart TD
 Testing
 -------
 
-### Quick Start with Docker Compose
+For comprehensive testing information, examples, and troubleshooting guides, see [tests/README.md](tests/README.md).
 
-The project includes a complete testing environment with Docker Compose that sets up:
-- NGINX with the ngx-inference module loaded
-- Mock external processors for both BBR and EPP
-- Echo server as upstream target
+### Local Development Setup
 
-1. **Start the test environment:**
-   ```bash
-   docker-compose up --build
-   ```
+For local development and testing without Docker:
 
-2. **Test EPP (Endpoint Picker Processor):**
+1. **Setup local environment and build the module:**
    ```bash
-   # Headers-only request - EPP selects upstream based on headers
-   curl -i http://localhost:8081/epp-test \
-     -H "Content-Type: application/json" \
-     -H "X-Request-Id: test-epp-123"
-   ```
+   # Setup local development environment
+   make setup-local
 
-3. **Test BBR (Body-Based Routing) with JSON model detection:**
-   ```bash
-   # Request with JSON body - BBR extracts model name from "model" field
-   curl -i http://localhost:8081/bbr-test \
-     -H "Content-Type: application/json" \
-     -d '{"model": "gpt-4", "prompt": "Hello world", "temperature": 0.7}'
+   # Build the module
+   make build
    ```
 
-4. **Test BBR with fallback model:**
+2. **Start local services and run tests:**
    ```bash
-   # JSON without "model" field - BBR uses configured fallback
-   curl -i http://localhost:8081/bbr-test \
-     -H "Content-Type: application/json" \
-     -d '{"prompt": "Hello world", "temperature": 0.7}'
-   ```
+   # Start local nginx with the compiled module plus mock services
+   make start-local
 
-5. **Test combined BBR + EPP pipeline:**
-   ```bash
-   # JSON with model field - both BBR and EPP process the request
-   curl -i http://localhost:8081/responses \
-     -H "Content-Type: application/json" \
-     -H "X-Client-Id: mobile-app" \
-     -d '{"model": "claude-3", "messages": [{"role": "user", "content": "Hello"}]}'
+   # Run configuration tests locally
+   make test-local
    ```
 
-### Expected Response Headers
-
-When testing, you should see these headers in the echo server response indicating successful processing:
-
-- `x-gateway-model-name` - Set by BBR based on JSON "model" field
-- `x-inference-upstream` - Set by EPP for upstream selection
-- Original request headers forwarded to the upstream
-
-### Test Environment Components
-
-The Docker Compose stack includes:
-
-- **nginx** (port 8081) - NGINX with ngx-inference module
-- **extproc-epp** (internal port 9001) - Mock EPP external processor
-- **echo-server** (internal port 80) - Target upstream that echoes request details
-
-### Manual Testing Setup
-
-If you prefer to test without Docker:
-
-1. **Build the module:**
-   ```bash
-   cargo build --features "vendored,export-modules" --release
-   ```
-
-2. **Start mock external processors:**
-   ```bash
-   # Terminal 1: BBR mock (port 9000)
-   EPP_UPSTREAM=localhost:8080 BBR_MODEL=test-model MOCK_ROLE=BBR \
-     cargo run --bin extproc_mock --features extproc-mock -- 0.0.0.0:9000
-
-   # Terminal 2: EPP mock (port 9001)
-   EPP_UPSTREAM=localhost:8080 MOCK_ROLE=EPP \
-     cargo run --bin extproc_mock --features extproc-mock -- 0.0.0.0:9001
-
-   # Terminal 3: Simple upstream server
-   python3 -m http.server 8080
-   ```
-
-3. **Configure and start NGINX:**
-   ```nginx
-   load_module /path/to/target/release/libngx_inference.so;
-   # ... rest of configuration similar to docker/nginx.conf
-   ```
-
-### Troubleshooting Tests
-
-- **502 Bad Gateway:** Check if external processors are running and reachable
-  - Enable fail-open mode: `inference_*_failure_mode_allow on`
-  - Verify endpoints: `inference_bbr_endpoint` and `inference_epp_endpoint`
-
-- **Headers not set:**
-  - Check external processor logs for JSON parsing errors
-  - Verify Content-Type is `application/json` for BBR tests
-  - Ensure JSON contains valid "model" field for BBR
-
-- **DNS resolution errors:**
-  - In Docker: Use service names (`extproc-bbr:9000`)
-  - Local testing: Use `localhost` or `127.0.0.1`
-  - Check NGINX resolver configuration
-
-- **Module not loading:**
-  - Verify dynamic library path in `load_module` directive
-  - Check NGINX error log for loading errors
-  - Ensure library was built with `export-modules` feature
-
 Troubleshooting
 ---------------
 - If EPP endpoints are unreachable or not listening on gRPC, you may see `BAD_GATEWAY` when failure mode allow is off. Toggle `*_failure_mode_allow on` to fail-open during testing.

bin/extproc_mock.rs

@@ -115,7 +115,10 @@ struct ExtProcMock {
 #[tonic::async_trait]
 impl ExternalProcessor for ExtProcMock {
     type ProcessStream = ReceiverStream<Result<ProcessingResponse, Status>>;
-    async fn process(&self, request: Request<tonic::Streaming<ProcessingRequest>>) -> Result<Response<Self::ProcessStream>, Status> {
+    async fn process(
+        &self,
+        request: Request<tonic::Streaming<ProcessingRequest>>,
+    ) -> Result<Response<Self::ProcessStream>, Status> {
         let mut inbound = request.into_inner();
         let (tx, rx) = mpsc::channel::<Result<ProcessingResponse, Status>>(32);
         let epp_upstream = self.epp_upstream.clone();
@@ -129,54 +132,123 @@ impl ExternalProcessor for ExtProcMock {
                 match msg {
                     Ok(pr) => match pr.request {
                         Some(processing_request::Request::RequestHeaders(_)) => {
-                            if role == "EPP" { 
-                                eprintln!("extproc_mock: EPP headers received, selecting endpoint: {}", epp_upstream);
-                                let resp = ProcessingResponse { response: Some(processing_response::Response::RequestHeaders(build_headers_response(&epp_upstream, &bbr_model))), dynamic_metadata: None, mode_override: None, override_message_timeout: None }; if tx.send(Ok(resp)).await.is_err() { break; } sent_headers_response = true; 
+                            if role == "EPP" {
+                                eprintln!(
+                                    "extproc_mock: EPP headers received, selecting endpoint: {}",
+                                    epp_upstream
+                                );
+                                let resp = ProcessingResponse {
+                                    response: Some(processing_response::Response::RequestHeaders(
+                                        build_headers_response(&epp_upstream, &bbr_model),
+                                    )),
+                                    dynamic_metadata: None,
+                                    mode_override: None,
+                                    override_message_timeout: None,
+                                };
+                                if tx.send(Ok(resp)).await.is_err() {
+                                    break;
+                                }
+                                sent_headers_response = true;
                             } else {
-                                eprintln!("extproc_mock: BBR headers received, waiting for body...");
+                                eprintln!(
+                                    "extproc_mock: BBR headers received, waiting for body..."
+                                );
                             }
                         }
                         Some(processing_request::Request::RequestBody(body)) => {
                             body_buf.extend_from_slice(&body.body);
-                            if body.end_of_stream { 
-                                eprintln!("extproc_mock: end of stream, body size: {} bytes", body_buf.len());
-                                if let Ok(v) = serde_json::from_slice::<Value>(&body_buf) { 
-                                    if let Some(m) = v.get("model").and_then(|x| x.as_str()) { 
+                            if body.end_of_stream {
+                                eprintln!(
+                                    "extproc_mock: end of stream, body size: {} bytes",
+                                    body_buf.len()
+                                );
+                                if let Ok(v) = serde_json::from_slice::<Value>(&body_buf) {
+                                    if let Some(m) = v.get("model").and_then(|x| x.as_str()) {
                                         current_bbr_model = m.to_string();
-                                        eprintln!("extproc_mock: detected model in JSON body: {}", current_bbr_model);
-                                    } 
-                                } 
-                                let resp = ProcessingResponse { response: Some(processing_response::Response::RequestBody(build_body_response(&epp_upstream, &current_bbr_model))), dynamic_metadata: None, mode_override: None, override_message_timeout: None }; 
+                                        eprintln!(
+                                            "extproc_mock: detected model in JSON body: {}",
+                                            current_bbr_model
+                                        );
+                                    }
+                                }
+                                let resp = ProcessingResponse {
+                                    response: Some(processing_response::Response::RequestBody(
+                                        build_body_response(&epp_upstream, &current_bbr_model),
+                                    )),
+                                    dynamic_metadata: None,
+                                    mode_override: None,
+                                    override_message_timeout: None,
+                                };
                                 if role == "BBR" {
-                                    eprintln!("extproc_mock: BBR final response - model: {}", current_bbr_model);
+                                    eprintln!(
+                                        "extproc_mock: BBR final response - model: {}",
+                                        current_bbr_model
+                                    );
+                                }
+                                if tx.send(Ok(resp)).await.is_err() {
+                                    break;
                                 }
-                                if tx.send(Ok(resp)).await.is_err() { break; } 
                             } else {
                                 eprintln!("extproc_mock: received body chunk, size: {} bytes, total: {} bytes", body.body.len(), body_buf.len());
                             }
                         }
                         _ => {}
                     },
-                    Err(status) => { let _ = tx.send(Err(status)).await; break; }
+                    Err(status) => {
+                        let _ = tx.send(Err(status)).await;
+                        break;
+                    }
                 }
             }
-            if !sent_headers_response && role == "EPP" { let resp = ProcessingResponse { response: Some(processing_response::Response::RequestHeaders(build_headers_response(&epp_upstream, &bbr_model))), dynamic_metadata: None, mode_override: None, override_message_timeout: None }; let _ = tx.send(Ok(resp)).await; }
+            if !sent_headers_response && role == "EPP" {
+                let resp = ProcessingResponse {
+                    response: Some(processing_response::Response::RequestHeaders(
+                        build_headers_response(&epp_upstream, &bbr_model),
+                    )),
+                    dynamic_metadata: None,
+                    mode_override: None,
+                    override_message_timeout: None,
+                };
+                let _ = tx.send(Ok(resp)).await;
+            }
         });
         Ok(Response::new(ReceiverStream::new(rx)))
     }
 }
 
 #[tokio::main(flavor = "multi_thread")]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let addr: SocketAddr = std::env::args().nth(1).unwrap_or_else(|| "0.0.0.0:9001".to_string()).parse()?;
-    let epp_upstream = env::var("EPP_UPSTREAM").unwrap_or_else(|_| "host.docker.internal:18080".to_string());
+    let addr: SocketAddr = std::env::args()
+        .nth(1)
+        .unwrap_or_else(|| "0.0.0.0:9001".to_string())
+        .parse()?;
+    let epp_upstream =
+        env::var("EPP_UPSTREAM").unwrap_or_else(|_| "host.docker.internal:18080".to_string());
     let bbr_model = env::var("BBR_MODEL").unwrap_or_else(|_| "bbr-chosen-model".to_string());
-    let default_role = if addr.port() == 9001 { "EPP" } else if addr.port() == 9000 { "BBR" } else { "EPP" }; 
+    let default_role = if addr.port() == 9001 {
+        "EPP"
+    } else if addr.port() == 9000 {
+        "BBR"
+    } else {
+        "EPP"
+    };
     let role = env::var("MOCK_ROLE").unwrap_or_else(|_| default_role.to_string());
 
-    println!("extproc_mock: role={}, configured EPP_UPSTREAM={}, BBR_MODEL={}", role, epp_upstream, bbr_model);
+    println!(
+        "extproc_mock: role={}, configured EPP_UPSTREAM={}, BBR_MODEL={}",
+        role, epp_upstream, bbr_model
+    );
 
-    let svc = ExtProcMock { epp_upstream, bbr_model, role };
+    let svc = ExtProcMock {
+        epp_upstream,
+        bbr_model,
+        role,
+    };
 
     println!("extproc_mock listening on {}", addr);
-    tonic::transport::Server::builder().add_service(ExternalProcessorServer::new(svc)).serve(addr).await?; Ok(()) }
+    tonic::transport::Server::builder()
+        .add_service(ExternalProcessorServer::new(svc))
+        .serve(addr)
+        .await?;
+    Ok(())
+}

docker/echo-server/custom-echo-server.js

@@ -29,10 +29,10 @@ app.use('/', (req, res) => {
     },
     environment: process.env
   };
-  
+
   const bodySize = req.body ? JSON.stringify(req.body).length : 0;
   console.log(`${new Date().toISOString()} ${req.method} ${req.originalUrl} - Body size: ${bodySize} bytes`);
-  
+
   res.json(response);
 });