Merge pull request #64 from csoceanu/feature/add-timeframe-parameter

Add timeframe parameter to list_jira_issues function

Author: eifrach

src/tools.py

@@ -52,7 +52,8 @@ async def list_jira_issues(
         status: Optional[str] = None,
         priority: Optional[str] = None,
         limit: int = 50,
-        search_text: Optional[str] = None
+        search_text: Optional[str] = None,
+        timeframe: int = 30
     ) -> Dict[str, Any]:
         """
 
@@ -63,6 +64,7 @@ async def list_jira_issues(
             priority: Filter by priority ID
             limit: Maximum number of issues to return (default: 50)
             search_text: Search in summary and description fields
+            timeframe: Filter issues updated/created/resolved within last N days (default: 30)
 
         Returns:
             Dictionary containing issues list and metadata
@@ -92,6 +94,15 @@ async def list_jira_issues(
                 search_condition = f"(LOWER(SUMMARY) LIKE '%{sanitize_sql_value(search_text.lower())}%' OR LOWER(DESCRIPTION) LIKE '%{sanitize_sql_value(search_text.lower())}%')"
                 sql_conditions.append(search_condition)
 
+            # Add timeframe filter - check if any of the dates are within the specified timeframe
+            if timeframe > 0:
+                timeframe_condition = f"""(
+                    CREATED >= CURRENT_DATE() - INTERVAL '{timeframe} DAYS'
+                    OR UPDATED >= CURRENT_DATE() - INTERVAL '{timeframe} DAYS'
+                    OR RESOLUTIONDATE >= CURRENT_DATE() - INTERVAL '{timeframe} DAYS'
+                )"""
+                sql_conditions.append(timeframe_condition)
+
             where_clause = ""
             if sql_conditions:
                 where_clause = "WHERE " + " AND ".join(sql_conditions)
@@ -171,6 +182,7 @@ async def list_jira_issues(
                     "status": status,
                     "priority": priority,
                     "search_text": search_text,
+                    "timeframe": timeframe,
                     "limit": limit
                 }
             }

tests/test_tools.py

@@ -199,7 +199,8 @@ async def test_list_jira_issues_with_filters(self, mock_mcp, mock_dependencies):
             issue_type='Bug',
             status='Open',
             priority='High',
-            search_text='test search'
+            search_text='test search',
+            timeframe=14
         )
 
         # Verify SQL conditions were built correctly
@@ -210,6 +211,14 @@ async def test_list_jira_issues_with_filters(self, mock_mcp, mock_dependencies):
         assert "ISSUESTATUS = 'Open'" in sql_call
         assert "PRIORITY = 'High'" in sql_call
         assert "LOWER(SUMMARY) LIKE '%test search%'" in sql_call
+        
+        # Verify timeframe condition is included
+        assert "CREATED >= CURRENT_DATE() - INTERVAL '14 DAYS'" in sql_call
+        assert "UPDATED >= CURRENT_DATE() - INTERVAL '14 DAYS'" in sql_call
+        assert "RESOLUTIONDATE >= CURRENT_DATE() - INTERVAL '14 DAYS'" in sql_call
+        
+        # Verify filters_applied includes timeframe
+        assert result['filters_applied']['timeframe'] == 14
 
     @pytest.mark.asyncio
     async def test_get_jira_issue_details_not_found(self, mock_mcp, mock_dependencies):
@@ -334,4 +343,87 @@ async def test_exception_handling(self, mock_mcp, mock_dependencies):
 
         result = await list_jira_issues()
         assert 'error' in result
-        assert 'Database error' in result['error']
+        assert 'Database error' in result['error']
+
+    @pytest.mark.asyncio
+    async def test_list_jira_issues_default_timeframe(self, mock_mcp, mock_dependencies):
+        """Test list_jira_issues with default timeframe (30 days)"""
+        mock_dependencies['query'].return_value = []
+        
+        register_tools(mock_mcp)
+        list_jira_issues = mock_mcp._registered_tools[0]
+        
+        # Call without specifying timeframe (should use default 30)
+        result = await list_jira_issues(project='TEST')
+        
+        # Verify SQL conditions include default timeframe
+        mock_dependencies['query'].assert_called_once()
+        sql_call = mock_dependencies['query'].call_args[0][0]
+        assert "CREATED >= CURRENT_DATE() - INTERVAL '30 DAYS'" in sql_call
+        assert "UPDATED >= CURRENT_DATE() - INTERVAL '30 DAYS'" in sql_call
+        assert "RESOLUTIONDATE >= CURRENT_DATE() - INTERVAL '30 DAYS'" in sql_call
+        
+        # Verify filters_applied includes default timeframe
+        assert result['filters_applied']['timeframe'] == 30
+
+    @pytest.mark.asyncio
+    async def test_list_jira_issues_custom_timeframe(self, mock_mcp, mock_dependencies):
+        """Test list_jira_issues with custom timeframe (7 days)"""
+        mock_dependencies['query'].return_value = []
+        
+        register_tools(mock_mcp)
+        list_jira_issues = mock_mcp._registered_tools[0]
+        
+        # Test with custom timeframe
+        result = await list_jira_issues(project='KONFLUX', timeframe=7)
+        
+        # Verify SQL conditions include custom timeframe
+        mock_dependencies['query'].assert_called_once()
+        sql_call = mock_dependencies['query'].call_args[0][0]
+        assert "CREATED >= CURRENT_DATE() - INTERVAL '7 DAYS'" in sql_call
+        assert "UPDATED >= CURRENT_DATE() - INTERVAL '7 DAYS'" in sql_call
+        assert "RESOLUTIONDATE >= CURRENT_DATE() - INTERVAL '7 DAYS'" in sql_call
+        
+        # Verify filters_applied includes custom timeframe
+        assert result['filters_applied']['timeframe'] == 7
+
+    @pytest.mark.asyncio
+    async def test_list_jira_issues_zero_timeframe(self, mock_mcp, mock_dependencies):
+        """Test list_jira_issues with timeframe=0 (disabled)"""
+        mock_dependencies['query'].return_value = []
+        
+        register_tools(mock_mcp)
+        list_jira_issues = mock_mcp._registered_tools[0]
+        
+        # Test with timeframe=0 (should disable timeframe filtering)
+        result = await list_jira_issues(project='TEST', timeframe=0)
+        
+        # Verify SQL conditions do NOT include timeframe
+        mock_dependencies['query'].assert_called_once()
+        sql_call = mock_dependencies['query'].call_args[0][0]
+        assert "INTERVAL" not in sql_call
+        assert "CURRENT_DATE()" not in sql_call
+        
+        # Verify filters_applied includes timeframe=0
+        assert result['filters_applied']['timeframe'] == 0
+
+    @pytest.mark.asyncio
+    async def test_list_jira_issues_large_timeframe(self, mock_mcp, mock_dependencies):
+        """Test list_jira_issues with large timeframe (365 days)"""
+        mock_dependencies['query'].return_value = []
+        
+        register_tools(mock_mcp)
+        list_jira_issues = mock_mcp._registered_tools[0]
+        
+        # Test with large timeframe
+        result = await list_jira_issues(timeframe=365)
+        
+        # Verify SQL conditions include large timeframe
+        mock_dependencies['query'].assert_called_once()
+        sql_call = mock_dependencies['query'].call_args[0][0]
+        assert "CREATED >= CURRENT_DATE() - INTERVAL '365 DAYS'" in sql_call
+        assert "UPDATED >= CURRENT_DATE() - INTERVAL '365 DAYS'" in sql_call
+        assert "RESOLUTIONDATE >= CURRENT_DATE() - INTERVAL '365 DAYS'" in sql_call
+        
+        # Verify filters_applied includes large timeframe
+        assert result['filters_applied']['timeframe'] == 365