@hybridlabor-api/bdb-hardware-pcb 0.1.0

package/mcp_servers/openscad-mcp-server/legacy/test_gemini_api.py

@@ -0,0 +1,168 @@
+"""
+Test script for Google Gemini API integration.
+"""
+
+import os
+import sys
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add the src directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.ai.gemini_api import GeminiImageGenerator
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestGeminiAPI(unittest.TestCase):
+    """
+    Test cases for Google Gemini API integration.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create a test output directory
+        self.test_output_dir = "output/test_gemini"
+        os.makedirs(self.test_output_dir, exist_ok=True)
+        
+        # Mock API key
+        self.api_key = "test_api_key"
+        
+        # Create the generator with the mock API key
+        self.gemini_generator = GeminiImageGenerator(
+            api_key=self.api_key,
+            output_dir=self.test_output_dir
+        )
+    
+    @patch('requests.post')
+    def test_generate_image(self, mock_post):
+        """
+        Test generating a single image with Gemini API.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {
+                                "text": "Generated image description"
+                            },
+                            {
+                                "inlineData": {
+                                    "mimeType": "image/png",
+                                    "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        # Test parameters
+        prompt = "A low-poly rabbit with black background"
+        model = "gemini-2.0-flash-exp-image-generation"
+        
+        # Call the method
+        result = self.gemini_generator.generate_image(prompt, model)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["prompt"], prompt)
+        self.assertEqual(result["model"], model)
+        self.assertTrue("local_path" in result)
+        self.assertTrue(os.path.exists(result["local_path"]))
+        
+        # Verify the API call
+        mock_post.assert_called_once()
+        args, kwargs = mock_post.call_args
+        self.assertTrue("generativelanguage.googleapis.com" in args[0])
+        self.assertEqual(kwargs["headers"]["x-goog-api-key"], self.api_key)
+        self.assertTrue("prompt" in str(kwargs["json"]))
+    
+    @patch('requests.post')
+    def test_generate_multiple_views(self, mock_post):
+        """
+        Test generating multiple views of an object with Gemini API.
+        """
+        # Mock response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "candidates": [
+                {
+                    "content": {
+                        "parts": [
+                            {
+                                "text": "Generated image description"
+                            },
+                            {
+                                "inlineData": {
+                                    "mimeType": "image/png",
+                                    "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+        mock_post.return_value = mock_response
+        
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        num_views = 3
+        
+        # Call the method
+        results = self.gemini_generator.generate_multiple_views(prompt, num_views)
+        
+        # Verify the results
+        self.assertEqual(len(results), num_views)
+        for i, result in enumerate(results):
+            self.assertTrue("view_direction" in result)
+            self.assertEqual(result["view_index"], i + 1)
+            self.assertTrue("local_path" in result)
+            self.assertTrue(os.path.exists(result["local_path"]))
+        
+        # Verify the API calls
+        self.assertEqual(mock_post.call_count, num_views)
+    
+    @patch('requests.post')
+    def test_error_handling(self, mock_post):
+        """
+        Test error handling in the Gemini API client.
+        """
+        # Mock error response
+        mock_response = MagicMock()
+        mock_response.status_code = 400
+        mock_response.raise_for_status.side_effect = Exception("API Error")
+        mock_post.return_value = mock_response
+        
+        # Test parameters
+        prompt = "A low-poly rabbit"
+        
+        # Call the method and expect an exception
+        with self.assertRaises(Exception):
+            self.gemini_generator.generate_image(prompt)
+    
+    def tearDown(self):
+        """
+        Clean up after tests.
+        """
+        # Clean up test output directory
+        import shutil
+        if os.path.exists(self.test_output_dir):
+            shutil.rmtree(self.test_output_dir)
+
+if __name__ == "__main__":
+    unittest.main()

package/mcp_servers/openscad-mcp-server/legacy/test_image_approval.py

@@ -0,0 +1,192 @@
+"""
+Test script for image approval tool.
+"""
+
+import os
+import sys
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add the src directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.workflow.image_approval import ImageApprovalTool
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestImageApproval(unittest.TestCase):
+    """
+    Test cases for image approval tool.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create a test output directory
+        self.test_output_dir = "output/test_approval"
+        os.makedirs(self.test_output_dir, exist_ok=True)
+        
+        # Create test images directory
+        self.test_images_dir = "output/test_approval/images"
+        os.makedirs(self.test_images_dir, exist_ok=True)
+        
+        # Create test images
+        self.test_images = []
+        for i in range(3):
+            image_path = os.path.join(self.test_images_dir, f"view_{i}.png")
+            with open(image_path, "w") as f:
+                f.write(f"Mock image {i}")
+            self.test_images.append(image_path)
+        
+        # Create the approval tool
+        self.approval_tool = ImageApprovalTool(
+            output_dir=os.path.join(self.test_output_dir, "approved")
+        )
+    
+    def test_present_image_for_approval(self):
+        """
+        Test presenting an image for approval.
+        """
+        # Test parameters
+        image_path = self.test_images[0]
+        metadata = {
+            "prompt": "A test image",
+            "view_direction": "front view",
+            "view_index": 1
+        }
+        
+        # Call the method
+        result = self.approval_tool.present_image_for_approval(image_path, metadata)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertTrue("approval_id" in result)
+        self.assertEqual(result["image_path"], image_path)
+        self.assertTrue("image_url" in result)
+        self.assertEqual(result["metadata"], metadata)
+    
+    def test_process_approval_approved(self):
+        """
+        Test processing an approved image.
+        """
+        # Test parameters
+        image_path = self.test_images[0]
+        approval_id = "test_approval_1"
+        
+        # Call the method
+        result = self.approval_tool.process_approval(approval_id, True, image_path)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["approval_id"], approval_id)
+        self.assertTrue(result["approved"])
+        self.assertEqual(result["original_path"], image_path)
+        self.assertTrue("approved_path" in result)
+        
+        # Verify the file was copied
+        self.assertTrue(os.path.exists(result["approved_path"]))
+    
+    def test_process_approval_denied(self):
+        """
+        Test processing a denied image.
+        """
+        # Test parameters
+        image_path = self.test_images[1]
+        approval_id = "test_approval_2"
+        
+        # Call the method
+        result = self.approval_tool.process_approval(approval_id, False, image_path)
+        
+        # Verify the result
+        self.assertIsNotNone(result)
+        self.assertEqual(result["approval_id"], approval_id)
+        self.assertFalse(result["approved"])
+        self.assertEqual(result["original_path"], image_path)
+        self.assertFalse("approved_path" in result)
+    
+    def test_get_approved_images(self):
+        """
+        Test getting approved images.
+        """
+        # Approve some images
+        for i, image_path in enumerate(self.test_images):
+            self.approval_tool.process_approval(f"test_approval_{i}", True, image_path)
+        
+        # Call the method
+        approved_images = self.approval_tool.get_approved_images()
+        
+        # Verify the result
+        self.assertEqual(len(approved_images), len(self.test_images))
+    
+    def test_get_approval_status(self):
+        """
+        Test getting approval status.
+        """
+        # Approve an image
+        approval_id = "test_approval_status"
+        self.approval_tool.process_approval(approval_id, True, self.test_images[0])
+        
+        # Call the method
+        status = self.approval_tool.get_approval_status(approval_id)
+        
+        # Verify the result
+        self.assertIsNotNone(status)
+        self.assertEqual(status["approval_id"], approval_id)
+        self.assertTrue(status["approved"])
+        self.assertTrue("approved_path" in status)
+        
+        # Test with non-existent approval ID
+        status = self.approval_tool.get_approval_status("non_existent")
+        self.assertIsNotNone(status)
+        self.assertEqual(status["approval_id"], "non_existent")
+        self.assertFalse(status["approved"])
+    
+    def test_batch_process_approvals(self):
+        """
+        Test batch processing of approvals.
+        """
+        # Test parameters
+        approvals = [
+            {
+                "approval_id": "batch_1",
+                "approved": True,
+                "image_path": self.test_images[0]
+            },
+            {
+                "approval_id": "batch_2",
+                "approved": False,
+                "image_path": self.test_images[1]
+            },
+            {
+                "approval_id": "batch_3",
+                "approved": True,
+                "image_path": self.test_images[2]
+            }
+        ]
+        
+        # Call the method
+        results = self.approval_tool.batch_process_approvals(approvals)
+        
+        # Verify the results
+        self.assertEqual(len(results), len(approvals))
+        
+        # Check approved images
+        approved_images = self.approval_tool.get_approved_images()
+        self.assertEqual(len(approved_images), 2)  # Two images were approved
+    
+    def tearDown(self):
+        """
+        Clean up after tests.
+        """
+        # Clean up test output directory
+        import shutil
+        if os.path.exists(self.test_output_dir):
+            shutil.rmtree(self.test_output_dir)
+
+if __name__ == "__main__":
+    unittest.main()

package/mcp_servers/openscad-mcp-server/legacy/test_image_approval_workflow.py

@@ -0,0 +1,251 @@
+"""
+Test script for the image approval workflow.
+"""
+
+import os
+import sys
+import json
+import logging
+import unittest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add the src directory to the path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from src.workflow.image_approval import ImageApprovalManager
+from src.config import IMAGE_APPROVAL
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TestImageApprovalWorkflow(unittest.TestCase):
+    """
+    Test cases for the image approval workflow.
+    """
+    
+    def setUp(self):
+        """
+        Set up test environment.
+        """
+        # Create test output directories
+        self.test_output_dir = "output/test_image_approval"
+        self.test_approved_dir = os.path.join(self.test_output_dir, "approved")
+        os.makedirs(self.test_output_dir, exist_ok=True)
+        os.makedirs(self.test_approved_dir, exist_ok=True)
+        
+        # Create the approval manager
+        self.approval_manager = ImageApprovalManager(
+            output_dir=self.test_output_dir,
+            approved_dir=self.test_approved_dir,
+            min_approved_images=3,
+            auto_approve=False
+        )
+        
+        # Create test images
+        self.test_images = []
+        for i in range(5):
+            image_path = os.path.join(self.test_output_dir, f"test_image_{i}.png")
+            with open(image_path, "w") as f:
+                f.write(f"test image data {i}")
+            self.test_images.append({
+                "id": f"image_{i}",
+                "local_path": image_path,
+                "view_index": i,
+                "view_direction": f"view_{i}"
+            })
+    
+    def test_add_images(self):
+        """
+        Test adding images to the approval manager.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Verify images were added
+        self.assertEqual(len(self.approval_manager.images), 5)
+        self.assertEqual(len(self.approval_manager.pending_images), 5)
+        self.assertEqual(len(self.approval_manager.approved_images), 0)
+        self.assertEqual(len(self.approval_manager.rejected_images), 0)
+    
+    def test_approve_image(self):
+        """
+        Test approving an image.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Approve an image
+        result = self.approval_manager.approve_image("image_0")
+        
+        # Verify the result
+        self.assertTrue(result["success"])
+        self.assertEqual(result["image_id"], "image_0")
+        self.assertEqual(result["status"], "approved")
+        
+        # Verify the image was moved to approved
+        self.assertEqual(len(self.approval_manager.pending_images), 4)
+        self.assertEqual(len(self.approval_manager.approved_images), 1)
+        self.assertEqual(len(self.approval_manager.rejected_images), 0)
+        
+        # Verify the image was copied to the approved directory
+        approved_path = os.path.join(self.test_approved_dir, "image_0.png")
+        self.assertTrue(os.path.exists(approved_path))
+    
+    def test_reject_image(self):
+        """
+        Test rejecting an image.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Reject an image
+        result = self.approval_manager.reject_image("image_1")
+        
+        # Verify the result
+        self.assertTrue(result["success"])
+        self.assertEqual(result["image_id"], "image_1")
+        self.assertEqual(result["status"], "rejected")
+        
+        # Verify the image was moved to rejected
+        self.assertEqual(len(self.approval_manager.pending_images), 4)
+        self.assertEqual(len(self.approval_manager.approved_images), 0)
+        self.assertEqual(len(self.approval_manager.rejected_images), 1)
+    
+    def test_get_approval_status(self):
+        """
+        Test getting the approval status.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Approve some images
+        self.approval_manager.approve_image("image_0")
+        self.approval_manager.approve_image("image_1")
+        self.approval_manager.approve_image("image_2")
+        
+        # Reject an image
+        self.approval_manager.reject_image("image_3")
+        
+        # Get the status
+        status = self.approval_manager.get_status()
+        
+        # Verify the status
+        self.assertEqual(status["total_images"], 5)
+        self.assertEqual(status["pending_count"], 1)
+        self.assertEqual(status["approved_count"], 3)
+        self.assertEqual(status["rejected_count"], 1)
+        self.assertTrue(status["has_minimum_approved"])
+        self.assertEqual(len(status["approved_images"]), 3)
+        self.assertEqual(len(status["pending_images"]), 1)
+        self.assertEqual(len(status["rejected_images"]), 1)
+    
+    def test_get_approved_images(self):
+        """
+        Test getting approved images.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Approve some images
+        self.approval_manager.approve_image("image_0")
+        self.approval_manager.approve_image("image_2")
+        self.approval_manager.approve_image("image_4")
+        
+        # Get approved images
+        approved = self.approval_manager.get_approved_images()
+        
+        # Verify approved images
+        self.assertEqual(len(approved), 3)
+        self.assertEqual(approved[0]["id"], "image_0")
+        self.assertEqual(approved[1]["id"], "image_2")
+        self.assertEqual(approved[2]["id"], "image_4")
+    
+    def test_auto_approve(self):
+        """
+        Test auto-approval mode.
+        """
+        # Create an auto-approve manager
+        auto_manager = ImageApprovalManager(
+            output_dir=self.test_output_dir,
+            approved_dir=self.test_approved_dir,
+            min_approved_images=3,
+            auto_approve=True
+        )
+        
+        # Add images
+        auto_manager.add_images(self.test_images)
+        
+        # Verify all images were auto-approved
+        self.assertEqual(len(auto_manager.pending_images), 0)
+        self.assertEqual(len(auto_manager.approved_images), 5)
+        self.assertEqual(len(auto_manager.rejected_images), 0)
+    
+    def test_has_minimum_approved(self):
+        """
+        Test checking if minimum approved images are met.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Initially should not have minimum
+        self.assertFalse(self.approval_manager.has_minimum_approved())
+        
+        # Approve two images
+        self.approval_manager.approve_image("image_0")
+        self.approval_manager.approve_image("image_1")
+        
+        # Still should not have minimum
+        self.assertFalse(self.approval_manager.has_minimum_approved())
+        
+        # Approve one more image
+        self.approval_manager.approve_image("image_2")
+        
+        # Now should have minimum
+        self.assertTrue(self.approval_manager.has_minimum_approved())
+    
+    def test_save_and_load_state(self):
+        """
+        Test saving and loading the approval state.
+        """
+        # Add images
+        self.approval_manager.add_images(self.test_images)
+        
+        # Approve and reject some images
+        self.approval_manager.approve_image("image_0")
+        self.approval_manager.approve_image("image_2")
+        self.approval_manager.reject_image("image_3")
+        
+        # Save the state
+        state_file = os.path.join(self.test_output_dir, "approval_state.json")
+        self.approval_manager.save_state(state_file)
+        
+        # Create a new manager
+        new_manager = ImageApprovalManager(
+            output_dir=self.test_output_dir,
+            approved_dir=self.test_approved_dir,
+            min_approved_images=3,
+            auto_approve=False
+        )
+        
+        # Load the state
+        new_manager.load_state(state_file)
+        
+        # Verify the state was loaded correctly
+        self.assertEqual(len(new_manager.images), 5)
+        self.assertEqual(len(new_manager.pending_images), 2)
+        self.assertEqual(len(new_manager.approved_images), 2)
+        self.assertEqual(len(new_manager.rejected_images), 1)
+    
+    def tearDown(self):
+        """
+        Clean up after tests.
+        """
+        # Clean up test output directory
+        import shutil
+        if os.path.exists(self.test_output_dir):
+            shutil.rmtree(self.test_output_dir)
+
+if __name__ == "__main__":
+    unittest.main()