Update slackBotFunction unit tests after implementing async events

Author: kris-szlapa

packages/slackBotFunction/tests/test_app.py

@@ -17,33 +17,30 @@ def mock_env():
     env_vars = {
         "SLACK_BOT_TOKEN_PARAMETER": "/test/bot-token",
         "SLACK_SIGNING_SECRET_PARAMETER": "/test/signing-secret",
-        "SLACK_SLASH_COMMAND": "/ask-eps",
+        "SLACK_DEDUPLICATION_TABLE": "test-dedup-table",
         "KNOWLEDGEBASE_ID": "test-kb-id",
         "RAG_MODEL_ID": "test-model-id",
         "AWS_REGION": "eu-west-2",
         "GUARD_RAIL_ID": "test-guard-id",
         "GUARD_RAIL_VERSION": "1",
+        "AWS_LAMBDA_FUNCTION_NAME": "test-function",
     }
     with patch.dict(os.environ, env_vars):
         yield env_vars
 
 
 @pytest.fixture
-def mock_ssm_parameters():
-    """Mock SSM parameters"""
+def mock_dynamodb_table():
+    """Mock DynamoDB table"""
     with mock_aws():
-        client = boto3.client("ssm", region_name="eu-west-2")
-        client.put_parameter(
-            Name="/test/bot-token",
-            Value=json.dumps({"token": TEST_BOT_TOKEN}),
-            Type="SecureString",
+        dynamodb = boto3.resource("dynamodb", region_name="eu-west-2")
+        table = dynamodb.create_table(
+            TableName="test-dedup-table",
+            KeySchema=[{"AttributeName": "eventId", "KeyType": "HASH"}],
+            AttributeDefinitions=[{"AttributeName": "eventId", "AttributeType": "S"}],
+            BillingMode="PAY_PER_REQUEST",
         )
-        client.put_parameter(
-            Name="/test/signing-secret",
-            Value=json.dumps({"secret": TEST_SIGNING_SECRET}),
-            Type="SecureString",
-        )
-        yield
+        yield table
 
 
 @pytest.fixture
@@ -57,174 +54,210 @@ def lambda_context():
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
-def test_log_request(mock_get_parameter, mock_app, mock_env):
+@patch("boto3.resource")
+def test_log_request(mock_boto_resource, mock_get_parameter, mock_app, mock_env):
     """Test middleware function behavior"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
+    mock_boto_resource.return_value.Table.return_value = Mock()
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    # Create a simple test function that mimics the middleware behavior
-    def test_log_request(slack_logger, body, next):
-        # This simulates what the actual middleware does
-        return next()
-
-    slack_logger = Mock()
-    body = {"text": "test query"}
-    next_func = Mock()
-    next_func.return_value = "next_result"
-
-    # Call the test function
-    result = test_log_request(slack_logger, body, next_func)
+    # Test that the middleware function exists and can be imported
+    from app import log_request
 
-    # Verify next was called and result is correct
-    next_func.assert_called_once()
-    assert result == "next_result"
+    assert callable(log_request)
 
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
-def test_respond_to_slack_within_3_seconds(mock_get_parameter, mock_app, mock_env):
-    """Test Slack acknowledgment function"""
+@patch("boto3.resource")
+def test_is_duplicate_event(mock_boto_resource, mock_get_parameter, mock_app, mock_env):
+    """Test duplicate event detection"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
+    mock_table = Mock()
+    mock_boto_resource.return_value.Table.return_value = mock_table
+    mock_table.get_item.return_value = {"Item": {"eventId": "test-event"}}
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    from app import respond_to_slack_within_3_seconds
+    from app import is_duplicate_event
+
+    result = is_duplicate_event("test-event")
+    assert result is True
+
+
+@patch("slack_bolt.App")
+@patch("aws_lambda_powertools.utilities.parameters.get_parameter")
+@patch("boto3.resource")
+@patch("time.time")
+def test_mark_event_processed(mock_time, mock_boto_resource, mock_get_parameter, mock_app, mock_env):
+    """Test marking event as processed"""
+    mock_get_parameter.side_effect = [
+        json.dumps({"token": "test-token"}),
+        json.dumps({"secret": "test-secret"}),
+    ]
+    mock_table = Mock()
+    mock_boto_resource.return_value.Table.return_value = mock_table
+    mock_time.return_value = 1000
 
-    body = {"text": "test query"}
-    ack = Mock()
+    if "app" in sys.modules:
+        del sys.modules["app"]
 
-    respond_to_slack_within_3_seconds(body, ack)
+    from app import mark_event_processed
 
-    ack.assert_called_once_with("\n/ask-eps - Processing Request: test query")
+    mark_event_processed("test-event")
+    mock_table.put_item.assert_called_once_with(Item={"eventId": "test-event", "ttl": 4600, "timestamp": 1000})
 
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
-def test_respond_to_slack_within_3_seconds_error(mock_get_parameter, mock_app, mock_env):
-    """Test Slack acknowledgment error handling"""
+@patch("boto3.resource")
+@patch("boto3.client")
+def test_get_bedrock_knowledgebase_response(
+    mock_boto_client, mock_boto_resource, mock_get_parameter, mock_app, mock_env
+):
+    """Test Bedrock knowledge base integration"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
+    mock_boto_resource.return_value.Table.return_value = Mock()
+
+    mock_client = Mock()
+    mock_boto_client.return_value = mock_client
+    mock_client.retrieve_and_generate.return_value = {"output": {"text": "bedrock response"}}
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    from app import respond_to_slack_within_3_seconds
-
-    body = {}  # Missing 'text' key
-    ack = Mock()
+    from app import get_bedrock_knowledgebase_response
 
-    respond_to_slack_within_3_seconds(body, ack)
+    result = get_bedrock_knowledgebase_response("test query")
 
-    ack.assert_called_once_with("/ask-eps - Sorry an error occurred. Please try again later.")
+    mock_boto_client.assert_called_once_with(service_name="bedrock-agent-runtime", region_name="eu-west-2")
+    mock_client.retrieve_and_generate.assert_called_once()
+    assert result["output"]["text"] == "bedrock response"
 
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
-def test_process_command_request(mock_get_parameter, mock_app, mock_env):
-    """Test command processing function"""
+@patch("boto3.resource")
+def test_handler_normal_event(mock_boto_resource, mock_get_parameter, mock_app, mock_env, lambda_context):
+    """Test Lambda handler function for normal Slack events"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
+    mock_boto_resource.return_value.Table.return_value = Mock()
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    with patch("app.get_bedrock_knowledgebase_response") as mock_bedrock:
-        mock_bedrock.return_value = {"output": {"text": "test response"}}
-        from app import process_command_request
+    with patch("app.SlackRequestHandler") as mock_handler_class:
+        mock_handler = Mock()
+        mock_handler_class.return_value = mock_handler
+        mock_handler.handle.return_value = {"statusCode": 200}
 
-        body = {"text": "test query"}
-        respond = Mock()
+        from app import handler
 
-        process_command_request(respond, body)
+        event = {"body": "test event"}
+        result = handler(event, lambda_context)
 
-        mock_bedrock.assert_called_once_with("test query")
-        respond.assert_called_once_with("\n/ask-eps - Response: test response\n")
+        mock_handler.handle.assert_called_once_with(event, lambda_context)
+        assert result["statusCode"] == 200
 
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
-def test_process_command_request_exception(mock_get_parameter, mock_app, mock_env):
-    """Test process_command_request exception handling"""
+@patch("boto3.resource")
+def test_handler_async_processing(mock_boto_resource, mock_get_parameter, mock_app, mock_env, lambda_context):
+    """Test Lambda handler function for async processing"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
+    mock_boto_resource.return_value.Table.return_value = Mock()
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    with patch("app.get_bedrock_knowledgebase_response") as mock_bedrock:
-        mock_bedrock.side_effect = Exception("Bedrock error")
-        from app import process_command_request
-
-        body = {"text": "test query"}
-        respond = Mock()
+    with patch("app.process_async_slack_event") as mock_process:
+        from app import handler
 
-        process_command_request(respond, body)
+        event = {"async_processing": True, "slack_event": {"test": "data"}}
+        result = handler(event, lambda_context)
 
-        respond.assert_called_once_with("/ask-eps - Sorry an error occurred. Please try again later.")
+        mock_process.assert_called_once_with({"test": "data"})
+        assert result["statusCode"] == 200
 
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
+@patch("boto3.resource")
 @patch("boto3.client")
-def test_get_bedrock_knowledgebase_response(mock_boto_client, mock_get_parameter, mock_app, mock_env):
-    """Test Bedrock knowledge base integration"""
+def test_trigger_async_processing(mock_boto_client, mock_boto_resource, mock_get_parameter, mock_app, mock_env):
+    """Test triggering async processing"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
-
-    mock_client = Mock()
-    mock_boto_client.return_value = mock_client
-    mock_client.retrieve_and_generate.return_value = {"output": {"text": "bedrock response"}}
+    mock_boto_resource.return_value.Table.return_value = Mock()
+    mock_lambda_client = Mock()
+    mock_boto_client.return_value = mock_lambda_client
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    from app import get_bedrock_knowledgebase_response
+    from app import trigger_async_processing
 
-    result = get_bedrock_knowledgebase_response("test query")
+    event_data = {"test": "data"}
+    trigger_async_processing(event_data)
 
-    mock_boto_client.assert_called_once_with(service_name="bedrock-agent-runtime", region_name="eu-west-2")
-    mock_client.retrieve_and_generate.assert_called_once()
-    assert result["output"]["text"] == "bedrock response"
+    mock_boto_client.assert_called_once_with("lambda")
+    mock_lambda_client.invoke.assert_called_once()
 
 
 @patch("slack_bolt.App")
 @patch("aws_lambda_powertools.utilities.parameters.get_parameter")
-def test_handler(mock_get_parameter, mock_app, mock_env, lambda_context):
-    """Test Lambda handler function"""
+@patch("boto3.resource")
+def test_handle_app_mention(mock_boto_resource, mock_get_parameter, mock_app, mock_env):
+    """Test app mention handler exists and is callable"""
     mock_get_parameter.side_effect = [
         json.dumps({"token": "test-token"}),
         json.dumps({"secret": "test-secret"}),
     ]
+    mock_boto_resource.return_value.Table.return_value = Mock()
 
     if "app" in sys.modules:
         del sys.modules["app"]
 
-    with patch("app.SlackRequestHandler") as mock_handler_class:
-        mock_handler = Mock()
-        mock_handler_class.return_value = mock_handler
-        mock_handler.handle.return_value = {"statusCode": 200}
+    from app import handle_app_mention
 
-        from app import handler
+    assert callable(handle_app_mention)
 
-        event = {"body": "test event"}
-        result = handler(event, lambda_context)
 
-        mock_handler.handle.assert_called_once_with(event, lambda_context)
-        assert result["statusCode"] == 200
+@patch("slack_bolt.App")
+@patch("aws_lambda_powertools.utilities.parameters.get_parameter")
+@patch("boto3.resource")
+def test_handle_direct_message(mock_boto_resource, mock_get_parameter, mock_app, mock_env):
+    """Test direct message handler exists and is callable"""
+    mock_get_parameter.side_effect = [
+        json.dumps({"token": "test-token"}),
+        json.dumps({"secret": "test-secret"}),
+    ]
+    mock_boto_resource.return_value.Table.return_value = Mock()
+
+    if "app" in sys.modules:
+        del sys.modules["app"]
+
+    from app import handle_direct_message
+
+    assert callable(handle_direct_message)