π OpenHands: AI-Driven Development
Fix UserData validation error when GitHub user has no OpenHands account (#13135)
Rohit Malhotra5cad59a6610d
diff --git a/enterprise/integrations/github/github_manager.py b/enterprise/integrations/github/github_manager.pyindex 7d0501dc46..2447b12894 100644--- a/enterprise/integrations/github/github_manager.py+++ b/enterprise/integrations/github/github_manager.py@@ -23,6 +23,7 @@ from integrations.utils import (HOST_URL,OPENHANDS_RESOLVER_TEMPLATES_DIR,get_session_expired_message,+ get_user_not_found_message,)from integrations.v1_utils import get_saas_user_authfrom jinja2 import Environment, FileSystemLoader@@ -127,6 +128,76 @@ class GithubManager(Manager[GithubViewType]):return False+ def _get_issue_number_from_payload(self, message: Message) -> int | None:+ """Extract issue/PR number from a GitHub webhook payload.++ Supports all event types that can trigger jobs:+ - Labeled issues: payload['issue']['number']+ - Issue comments: payload['issue']['number']+ - PR comments: payload['issue']['number'] (PRs are accessed via issue endpoint)+ - Inline PR comments: payload['pull_request']['number']++ Args:+ message: The incoming GitHub webhook message++ Returns:+ The issue/PR number, or None if not found+ """+ payload = message.message.get('payload', {})++ # Labeled issues, issue comments, and PR comments all have 'issue' in payload+ if 'issue' in payload:+ return payload['issue']['number']++ # Inline PR comments have 'pull_request' directly in payload+ if 'pull_request' in payload:+ return payload['pull_request']['number']++ return None++ def _send_user_not_found_message(self, message: Message, username: str):+ """Send a message to the user informing them they need to create an OpenHands account.++ This method handles all supported trigger types:+ - Labeled issues (action='labeled' with openhands label)+ - Issue comments (comment containing @openhands)+ - PR comments (comment containing @openhands on a PR)+ - Inline PR review comments (comment containing @openhands)++ Args:+ message: The incoming GitHub webhook message+ username: The GitHub username to mention in the response+ """+ payload = message.message.get('payload', {})+ installation_id = message.message['installation']+ repo_obj = payload['repository']+ full_repo_name = self._get_full_repo_name(repo_obj)++ # Get installation token to post the comment+ installation_token = self._get_installation_access_token(installation_id)++ # Determine the issue/PR number based on the event type+ issue_number = self._get_issue_number_from_payload(message)++ if not issue_number:+ logger.warning(+ f'[GitHub] Could not determine issue/PR number to send user not found message for {username}. '+ f'Payload keys: {list(payload.keys())}'+ )+ return++ # Post the comment+ try:+ with Github(auth=Auth.Token(installation_token)) as github_client:+ repo = github_client.get_repo(full_repo_name)+ issue = repo.get_issue(number=issue_number)+ issue.create_comment(get_user_not_found_message(username))+ except Exception as e:+ logger.error(+ f'[GitHub] Failed to send user not found message to {username} '+ f'on {full_repo_name}#{issue_number}: {e}'+ )+async def is_job_requested(self, message: Message) -> bool:self._confirm_incoming_source_type(message)@@ -180,9 +251,20 @@ class GithubManager(Manager[GithubViewType]):if await self.is_job_requested(message):payload = message.message.get('payload', {})user_id = payload['sender']['id']+ username = payload['sender']['login']keycloak_user_id = await self.token_manager.get_user_id_from_idp_user_id(user_id, ProviderType.GITHUB)++ # Check if the user has an OpenHands account+ if not keycloak_user_id:+ logger.warning(+ f'[GitHub] User {username} (id={user_id}) not found in Keycloak. '+ f'User must create an OpenHands account first.'+ )+ self._send_user_not_found_message(message, username)+ return+github_view = await GithubFactory.create_github_view_from_payload(message, keycloak_user_id)diff --git a/enterprise/integrations/utils.py b/enterprise/integrations/utils.pyindex b038c0c542..9adadd5ae6 100644--- a/enterprise/integrations/utils.py+++ b/enterprise/integrations/utils.py@@ -65,6 +65,25 @@ def get_session_expired_message(username: str | None = None) -> str:return f'Your session has expired. Please login again at [OpenHands Cloud]({HOST_URL}) and try again.'+def get_user_not_found_message(username: str | None = None) -> str:+ """Get a user-friendly message when a user hasn't created an OpenHands account.++ Used by integrations to notify users when they try to use OpenHands features+ but haven't logged into OpenHands Cloud yet (no Keycloak account exists).++ Args:+ username: Optional username to mention in the message. If provided,+ the message will include @username prefix (used by Git providers+ like GitHub, GitLab, Slack). If None, returns a generic message.++ Returns:+ A formatted user not found message+ """+ if username:+ return f"@{username} it looks like you haven't created an OpenHands account yet. Please sign up at [OpenHands Cloud]({HOST_URL}) and try again."+ return f"It looks like you haven't created an OpenHands account yet. Please sign up at [OpenHands Cloud]({HOST_URL}) and try again."++# Toggle for solvability report featureENABLE_SOLVABILITY_ANALYSIS = (os.getenv('ENABLE_SOLVABILITY_ANALYSIS', 'false').lower() == 'true'diff --git a/enterprise/tests/unit/integrations/github/test_github_manager.py b/enterprise/tests/unit/integrations/github/test_github_manager.pynew file mode 100644index 0000000000..864be4ef38--- /dev/null+++ b/enterprise/tests/unit/integrations/github/test_github_manager.py@@ -0,0 +1,599 @@+"""+Tests for the GithubManager class.++Covers:+- User not found scenario when a GitHub user hasn't created an OpenHands account+- Sign-up message posting to GitHub issues/PRs+- All supported trigger types: labeled issues, issue comments, PR comments, inline PR comments+"""++from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from integrations.github.github_manager import GithubManager+from integrations.models import Message, SourceType+from integrations.utils import HOST_URL, get_user_not_found_message+++class TestGithubManagerUserNotFound:+ """Test cases for when a valid GitHub user hasn't created an OpenHands account."""++ @pytest.fixture+ def mock_token_manager(self):+ """Create a mock token manager."""+ token_manager = MagicMock()+ token_manager.get_user_id_from_idp_user_id = AsyncMock(return_value=None)+ return token_manager++ @pytest.fixture+ def mock_data_collector(self):+ """Create a mock data collector."""+ data_collector = MagicMock()+ data_collector.process_payload = MagicMock()+ return data_collector++ @pytest.fixture+ def github_issue_comment_message(self):+ """Create a sample GitHub issue comment message with an @openhands mention."""+ return Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'action': 'created',+ 'sender': {+ 'id': 67890,+ 'login': 'testuser',+ },+ 'repository': {+ 'owner': {'login': 'test-owner'},+ 'name': 'test-repo',+ },+ 'issue': {+ 'number': 42,+ },+ 'comment': {+ 'body': '@openhands please help with this issue',+ },+ },+ },+ )++ # Alias for backward compatibility with existing tests+ @pytest.fixture+ def github_issue_message(self, github_issue_comment_message):+ """Alias for github_issue_comment_message for backward compatibility."""+ return github_issue_comment_message++ @pytest.fixture+ def github_labeled_issue_message(self):+ """Create a sample GitHub labeled issue message (when openhands label is added)."""+ return Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'action': 'labeled',+ 'sender': {+ 'id': 67890,+ 'login': 'labeluser',+ },+ 'repository': {+ 'owner': {'login': 'test-owner'},+ 'name': 'test-repo',+ },+ 'issue': {+ 'number': 55,+ },+ 'label': {+ 'name': 'openhands',+ },+ },+ },+ )++ @pytest.fixture+ def github_pr_comment_message(self):+ """Create a sample GitHub PR comment message (comment on a PR, accessed via issue endpoint)."""+ return Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'action': 'created',+ 'sender': {+ 'id': 67890,+ 'login': 'prcommentuser',+ },+ 'repository': {+ 'owner': {'login': 'test-owner'},+ 'name': 'test-repo',+ },+ 'issue': {+ 'number': 77,+ 'pull_request': {+ 'url': 'https://api.github.com/repos/test-owner/test-repo/pulls/77',+ },+ },+ 'comment': {+ 'body': '@openhands please review this PR',+ },+ },+ },+ )++ @pytest.fixture+ def github_inline_pr_comment_message(self):+ """Create a sample GitHub inline PR review comment message."""+ return Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'action': 'created',+ 'sender': {+ 'id': 67890,+ 'login': 'inlineuser',+ },+ 'repository': {+ 'owner': {'login': 'test-owner'},+ 'name': 'test-repo',+ },+ 'pull_request': {+ 'number': 100,+ 'head': {+ 'ref': 'feature-branch',+ },+ },+ 'comment': {+ 'id': 12345,+ 'node_id': 'PRRC_abc123',+ 'body': '@openhands fix this code',+ 'path': 'src/main.py',+ 'line': 42,+ },+ },+ },+ )++ # Alias for backward compatibility+ @pytest.fixture+ def github_pr_message(self, github_inline_pr_comment_message):+ """Alias for github_inline_pr_comment_message for backward compatibility."""+ return github_inline_pr_comment_message++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ @patch('integrations.github.github_manager.Github')+ def test_send_user_not_found_message_for_issue(+ self,+ mock_github_class,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ github_issue_message,+ ):+ """Test that a sign-up message is sent when a valid user hasn't created an OpenHands account on an issue."""+ # Set up mocks+ mock_github_instance = MagicMock()+ mock_github_class.return_value.__enter__ = MagicMock(+ return_value=mock_github_instance+ )+ mock_github_class.return_value.__exit__ = MagicMock(return_value=False)++ mock_repo = MagicMock()+ mock_issue = MagicMock()+ mock_github_instance.get_repo.return_value = mock_repo+ mock_repo.get_issue.return_value = mock_issue++ mock_integration_instance = MagicMock()+ mock_github_integration.return_value = mock_integration_instance+ mock_integration_instance.get_access_token.return_value = MagicMock(+ token='fake-token'+ )++ # Create manager and call the method+ manager = GithubManager(mock_token_manager, mock_data_collector)++ manager._send_user_not_found_message(github_issue_message, 'testuser')++ # Verify the comment was posted+ mock_github_instance.get_repo.assert_called_once_with('test-owner/test-repo')+ mock_repo.get_issue.assert_called_once_with(number=42)++ # Verify the comment contains the expected sign-up message+ mock_issue.create_comment.assert_called_once()+ comment_text = mock_issue.create_comment.call_args[0][0]+ assert '@testuser' in comment_text+ assert "haven't created an OpenHands account" in comment_text+ assert 'sign up' in comment_text.lower()+ assert HOST_URL in comment_text++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ @patch('integrations.github.github_manager.Github')+ def test_send_user_not_found_message_for_pr(+ self,+ mock_github_class,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ github_pr_message,+ ):+ """Test that a sign-up message is sent when a valid user hasn't created an OpenHands account on a PR."""+ # Set up mocks+ mock_github_instance = MagicMock()+ mock_github_class.return_value.__enter__ = MagicMock(+ return_value=mock_github_instance+ )+ mock_github_class.return_value.__exit__ = MagicMock(return_value=False)++ mock_repo = MagicMock()+ mock_issue = MagicMock()+ mock_github_instance.get_repo.return_value = mock_repo+ mock_repo.get_issue.return_value = mock_issue++ mock_integration_instance = MagicMock()+ mock_github_integration.return_value = mock_integration_instance+ mock_integration_instance.get_access_token.return_value = MagicMock(+ token='fake-token'+ )++ # Create manager and call the method+ manager = GithubManager(mock_token_manager, mock_data_collector)++ manager._send_user_not_found_message(github_pr_message, 'pruser')++ # Verify the comment was posted with PR number+ mock_github_instance.get_repo.assert_called_once_with('test-owner/test-repo')+ mock_repo.get_issue.assert_called_once_with(number=100)++ # Verify the comment contains the expected sign-up message+ mock_issue.create_comment.assert_called_once()+ comment_text = mock_issue.create_comment.call_args[0][0]+ assert '@pruser' in comment_text+ assert "haven't created an OpenHands account" in comment_text++ @pytest.mark.asyncio+ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ @patch('integrations.github.github_manager.Github')+ async def test_receive_message_sends_user_not_found_when_keycloak_user_id_is_none(+ self,+ mock_github_class,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ github_issue_message,+ ):+ """Test that receive_message sends a sign-up message when get_user_id_from_idp_user_id returns None."""+ # Set up mocks+ mock_github_instance = MagicMock()+ mock_github_class.return_value.__enter__ = MagicMock(+ return_value=mock_github_instance+ )+ mock_github_class.return_value.__exit__ = MagicMock(return_value=False)++ mock_repo = MagicMock()+ mock_issue = MagicMock()+ mock_github_instance.get_repo.return_value = mock_repo+ mock_repo.get_issue.return_value = mock_issue++ mock_integration_instance = MagicMock()+ mock_github_integration.return_value = mock_integration_instance+ mock_integration_instance.get_access_token.return_value = MagicMock(+ token='fake-token'+ )+ mock_integration_instance.get_github_for_installation.return_value.__enter__ = (+ MagicMock(return_value=mock_github_instance)+ )+ mock_integration_instance.get_github_for_installation.return_value.__exit__ = (+ MagicMock(return_value=False)+ )++ # Mock user having write access (so is_job_requested returns True)+ mock_repo.get_collaborator_permission.return_value = 'write'++ # Token manager returns None for keycloak_user_id (user hasn't created an account)+ mock_token_manager.get_user_id_from_idp_user_id = AsyncMock(return_value=None)++ # Create manager+ manager = GithubManager(mock_token_manager, mock_data_collector)++ # Call receive_message+ await manager.receive_message(github_issue_message)++ # Verify get_user_id_from_idp_user_id was called+ mock_token_manager.get_user_id_from_idp_user_id.assert_called_once()++ # Verify the sign-up message was posted+ mock_issue.create_comment.assert_called_once()+ comment_text = mock_issue.create_comment.call_args[0][0]+ assert '@testuser' in comment_text+ assert "haven't created an OpenHands account" in comment_text+ assert 'sign up' in comment_text.lower()++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ @patch('integrations.github.github_manager.logger')+ def test_send_user_not_found_message_logs_warning_when_no_issue_number(+ self,+ mock_logger,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ ):+ """Test that a warning is logged when issue/PR number cannot be determined."""+ mock_integration_instance = MagicMock()+ mock_github_integration.return_value = mock_integration_instance+ mock_integration_instance.get_access_token.return_value = MagicMock(+ token='fake-token'+ )++ # Create a message without issue or pull_request+ message_without_issue = Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'action': 'created',+ 'sender': {+ 'id': 67890,+ 'login': 'testuser',+ },+ 'repository': {+ 'owner': {'login': 'test-owner'},+ 'name': 'test-repo',+ },+ },+ },+ )++ manager = GithubManager(mock_token_manager, mock_data_collector)++ manager._send_user_not_found_message(message_without_issue, 'testuser')++ # Verify warning was logged+ mock_logger.warning.assert_called_once()+ assert 'Could not determine issue/PR number' in str(+ mock_logger.warning.call_args+ )++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ @patch('integrations.github.github_manager.Github')+ def test_send_user_not_found_message_for_labeled_issue(+ self,+ mock_github_class,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ github_labeled_issue_message,+ ):+ """Test that a sign-up message is sent for labeled issue events."""+ # Set up mocks+ mock_github_instance = MagicMock()+ mock_github_class.return_value.__enter__ = MagicMock(+ return_value=mock_github_instance+ )+ mock_github_class.return_value.__exit__ = MagicMock(return_value=False)++ mock_repo = MagicMock()+ mock_issue = MagicMock()+ mock_github_instance.get_repo.return_value = mock_repo+ mock_repo.get_issue.return_value = mock_issue++ mock_integration_instance = MagicMock()+ mock_github_integration.return_value = mock_integration_instance+ mock_integration_instance.get_access_token.return_value = MagicMock(+ token='fake-token'+ )++ # Create manager and call the method+ manager = GithubManager(mock_token_manager, mock_data_collector)++ manager._send_user_not_found_message(github_labeled_issue_message, 'labeluser')++ # Verify the comment was posted with correct issue number+ mock_github_instance.get_repo.assert_called_once_with('test-owner/test-repo')+ mock_repo.get_issue.assert_called_once_with(number=55)++ # Verify the comment contains the expected sign-up message+ mock_issue.create_comment.assert_called_once()+ comment_text = mock_issue.create_comment.call_args[0][0]+ assert '@labeluser' in comment_text+ assert "haven't created an OpenHands account" in comment_text+ assert 'sign up' in comment_text.lower()++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ @patch('integrations.github.github_manager.Github')+ def test_send_user_not_found_message_for_pr_comment_via_issue_endpoint(+ self,+ mock_github_class,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ github_pr_comment_message,+ ):+ """Test that a sign-up message is sent for PR comments (accessed via issue endpoint)."""+ # Set up mocks+ mock_github_instance = MagicMock()+ mock_github_class.return_value.__enter__ = MagicMock(+ return_value=mock_github_instance+ )+ mock_github_class.return_value.__exit__ = MagicMock(return_value=False)++ mock_repo = MagicMock()+ mock_issue = MagicMock()+ mock_github_instance.get_repo.return_value = mock_repo+ mock_repo.get_issue.return_value = mock_issue++ mock_integration_instance = MagicMock()+ mock_github_integration.return_value = mock_integration_instance+ mock_integration_instance.get_access_token.return_value = MagicMock(+ token='fake-token'+ )++ # Create manager and call the method+ manager = GithubManager(mock_token_manager, mock_data_collector)++ manager._send_user_not_found_message(github_pr_comment_message, 'prcommentuser')++ # Verify the comment was posted with correct PR number (from issue.number)+ mock_github_instance.get_repo.assert_called_once_with('test-owner/test-repo')+ mock_repo.get_issue.assert_called_once_with(number=77)++ # Verify the comment contains the expected sign-up message+ mock_issue.create_comment.assert_called_once()+ comment_text = mock_issue.create_comment.call_args[0][0]+ assert '@prcommentuser' in comment_text+ assert "haven't created an OpenHands account" in comment_text+ assert 'sign up' in comment_text.lower()+++class TestGetIssueNumberFromPayload:+ """Test cases for the _get_issue_number_from_payload helper method."""++ @pytest.fixture+ def mock_token_manager(self):+ """Create a mock token manager."""+ token_manager = MagicMock()+ return token_manager++ @pytest.fixture+ def mock_data_collector(self):+ """Create a mock data collector."""+ data_collector = MagicMock()+ return data_collector++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ def test_extracts_issue_number_from_issue_payload(+ self,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ ):+ """Test extraction from payload with 'issue' key (labeled issues, issue comments, PR comments)."""+ message = Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'issue': {'number': 42},+ 'repository': {'owner': {'login': 'owner'}, 'name': 'repo'},+ },+ },+ )++ manager = GithubManager(mock_token_manager, mock_data_collector)+ result = manager._get_issue_number_from_payload(message)++ assert result == 42++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ def test_extracts_pr_number_from_pull_request_payload(+ self,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ ):+ """Test extraction from payload with 'pull_request' key (inline PR comments)."""+ message = Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'pull_request': {'number': 100},+ 'repository': {'owner': {'login': 'owner'}, 'name': 'repo'},+ },+ },+ )++ manager = GithubManager(mock_token_manager, mock_data_collector)+ result = manager._get_issue_number_from_payload(message)++ assert result == 100++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ def test_prefers_issue_over_pull_request_when_both_present(+ self,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ ):+ """Test that issue takes precedence over pull_request (edge case)."""+ message = Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'issue': {'number': 42},+ 'pull_request': {'number': 100},+ 'repository': {'owner': {'login': 'owner'}, 'name': 'repo'},+ },+ },+ )++ manager = GithubManager(mock_token_manager, mock_data_collector)+ result = manager._get_issue_number_from_payload(message)++ assert result == 42++ @patch('integrations.github.github_manager.Auth')+ @patch('integrations.github.github_manager.GithubIntegration')+ def test_returns_none_when_no_issue_or_pr(+ self,+ mock_github_integration,+ mock_auth,+ mock_token_manager,+ mock_data_collector,+ ):+ """Test that None is returned when neither issue nor pull_request is in payload."""+ message = Message(+ source=SourceType.GITHUB,+ message={+ 'installation': 12345,+ 'payload': {+ 'repository': {'owner': {'login': 'owner'}, 'name': 'repo'},+ },+ },+ )++ manager = GithubManager(mock_token_manager, mock_data_collector)+ result = manager._get_issue_number_from_payload(message)++ assert result is None+++class TestGetUserNotFoundMessageIntegration:+ """Integration tests to verify the user not found message content matches expectations."""++ def test_message_mentions_openhands_cloud(self):+ """Test that the message directs users to OpenHands Cloud."""+ message = get_user_not_found_message('testuser')+ assert 'OpenHands Cloud' in message++ def test_message_contains_actionable_instruction(self):+ """Test that the message tells users to sign up."""+ message = get_user_not_found_message('testuser')+ assert 'sign up' in message.lower()+ assert 'try again' in message.lower()++ def test_message_is_friendly_and_informative(self):+ """Test that the message is friendly and explains the situation."""+ message = get_user_not_found_message('testuser')+ assert 'it looks like' in message.lower()+ assert "haven't created an openhands account" in message.lower()diff --git a/enterprise/tests/unit/integrations/test_utils.py b/enterprise/tests/unit/integrations/test_utils.pyindex 38710af083..e3e5c5e6e6 100644--- a/enterprise/tests/unit/integrations/test_utils.py+++ b/enterprise/tests/unit/integrations/test_utils.py@@ -8,6 +8,7 @@ from integrations.utils import (append_conversation_footer,get_session_expired_message,get_summary_for_agent_state,+ get_user_not_found_message,)from openhands.core.schema.agent import AgentState@@ -228,6 +229,72 @@ class TestGetSessionExpiredMessage:assert 'Your session' in result+class TestGetUserNotFoundMessage:+ """Test cases for get_user_not_found_message function.++ This function is used to notify users when they try to use OpenHands features+ but haven't created an OpenHands account yet (no Keycloak account exists).+ """++ def test_message_with_username_contains_at_prefix(self):+ """Test that the message contains the username with @ prefix."""+ result = get_user_not_found_message('testuser')+ assert '@testuser' in result++ def test_message_with_username_contains_sign_up_text(self):+ """Test that the message contains sign up text."""+ result = get_user_not_found_message('testuser')+ assert "haven't created an OpenHands account" in result++ def test_message_with_username_contains_sign_up_instruction(self):+ """Test that the message contains sign up instruction."""+ result = get_user_not_found_message('testuser')+ assert 'sign up' in result.lower()++ def test_message_with_username_contains_host_url(self):+ """Test that the message contains the OpenHands Cloud URL."""+ result = get_user_not_found_message('testuser')+ assert HOST_URL in result+ assert 'OpenHands Cloud' in result++ def test_different_usernames(self):+ """Test that different usernames produce different messages."""+ result1 = get_user_not_found_message('user1')+ result2 = get_user_not_found_message('user2')+ assert '@user1' in result1+ assert '@user2' in result2+ assert '@user1' not in result2+ assert '@user2' not in result1++ def test_message_without_username_contains_sign_up_text(self):+ """Test that the message without username contains sign up text."""+ result = get_user_not_found_message()+ assert "haven't created an OpenHands account" in result++ def test_message_without_username_contains_sign_up_instruction(self):+ """Test that the message without username contains sign up instruction."""+ result = get_user_not_found_message()+ assert 'sign up' in result.lower()++ def test_message_without_username_contains_host_url(self):+ """Test that the message without username contains the OpenHands Cloud URL."""+ result = get_user_not_found_message()+ assert HOST_URL in result+ assert 'OpenHands Cloud' in result++ def test_message_without_username_does_not_contain_at_prefix(self):+ """Test that the message without username does not contain @ prefix."""+ result = get_user_not_found_message()+ assert not result.startswith('@')+ assert 'It looks like' in result++ def test_message_with_none_username(self):+ """Test that passing None explicitly works the same as no argument."""+ result = get_user_not_found_message(None)+ assert not result.startswith('@')+ assert 'It looks like' in result++class TestAppendConversationFooter:"""Test cases for append_conversation_footer function."""