🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
Python agentai-societiesartificial-intelligencecommunicative-aicooperative-aideep-learninglarge-language-modelsmulti-agent-systemsnatural-language-processing
# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ========= Copyright 2023-2026 @ CAMEL-AI.org. All Rights Reserved. =========
import sys
from unittest.mock import MagicMock, patch
# Create proper classes for mocking
class ContentFile:
r"""Mock class for github.ContentFile.ContentFile"""
def __init__(
self,
path="test_path",
sha="test_sha",
decoded_content=b"test content",
type="file",
):
self.path = path
self.sha = sha
self.decoded_content = decoded_content
self.type = type
class GithubException(Exception):
r"""Mock class for github.GithubException.GithubException"""
def __init__(self, status, data, message=None):
self.status = status
self.data = data
self.message = message
# Create mock modules before any imports
mock_modules = {
'github': MagicMock(),
'github.Auth': MagicMock(),
'github.MainClass': MagicMock(),
'github.ContentFile': MagicMock(),
'github.GithubException': MagicMock(),
'github.ApplicationOAuth': MagicMock(),
}
# Setup the Github class in the mock modules
Github = MagicMock()
mock_modules['github'].Github = Github
mock_modules['github.MainClass'].Github = Github
# Setup Auth.Token in the mock modules
Token = MagicMock()
mock_modules['github.Auth'].Token = Token
mock_modules['github'].Auth.Token = Token
# Setup ContentFile in the mock modules
mock_modules['github.ContentFile'].ContentFile = ContentFile
mock_modules['github'].ContentFile = ContentFile
# Setup GithubException in the mock modules
mock_modules['github.GithubException'].GithubException = GithubException
mock_modules['github'].GithubException = GithubException
# Apply all mocks to sys.modules
for name, mock in mock_modules.items():
sys.modules[name] = mock
# Now import the toolkit after setting up all the mocks
from camel.toolkits.github_toolkit import GithubToolkit # noqa: E402
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_init(mock_github):
r"""Test that GithubToolkit initializes correctly."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
assert github_toolkit is not None, "Failed to initialize GithubToolkit"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_get_tools(mock_github):
r"""Test that get_tools returns a non-empty list of tools."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
tools = github_toolkit.get_tools()
assert isinstance(tools, list), "get_tools should return a list"
assert len(tools) > 0, "get_tools should return a non-empty list"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_github_create_pull_request(mock_github):
"""Test github_create_pull_request functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup branch
mock_branch = MagicMock()
mock_branch.commit.sha = "test_sha"
mock_repo.get_branch.return_value = mock_branch
mock_repo.default_branch = "main"
# Setup PR response
mock_pr_response = MagicMock()
mock_pr_response.title = """[GitHub Agent] Solved issue: Time complexity
for product_of_array_except_self.py"""
mock_pr_response.body = "Fixes #1"
mock_repo.create_pull.return_value = mock_pr_response
# Create a simplified version of github_create_pull_request that
# skips the isinstance check
def simplified_github_create_pull_request(
self, repo_name, file_path, new_content, pr_title, body, branch_name
):
# Get the repo using the repo_name parameter
repo = self.github.get_repo(repo_name)
# Skip the isinstance check and just update the file
file = repo.get_contents(file_path)
repo.update_file(
file.path, body, new_content, file.sha, branch=branch_name
)
return f"Title: {pr_title}\nBody: {body}\n"
# Replace the method temporarily
original_method = github_toolkit.github_create_pull_request
github_toolkit.github_create_pull_request = (
simplified_github_create_pull_request.__get__(github_toolkit)
)
try:
# Call the function
pr_title = """[GitHub Agent] Solved issue: Time complexity
for product_of_array_except_self.py"""
body = "Fixes #1"
pr = github_toolkit.github_create_pull_request(
repo_name="repo_name",
file_path="path/to/file",
branch_name="branch_name",
new_content="This is the content of the file",
pr_title=pr_title,
body=body,
)
finally:
# Restore the original method
github_toolkit.github_create_pull_request = original_method
expected_response = f"Title: {pr_title}\nBody: {body}\n"
assert pr == expected_response, f"Expected {expected_response}, got {pr}"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_get_all_issues(mock_github):
r"""Test github_get_issue_list functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup issues
mock_issue = MagicMock()
mock_issue.number = 1
mock_issue.title = "Test Issue"
mock_repo.get_issues.return_value = [mock_issue]
# Mock the github_get_issue_list method to return our expected result
with patch.object(
github_toolkit,
'github_get_issue_list',
return_value=[{"number": 1, "title": "Test Issue"}],
):
issues = github_toolkit.github_get_issue_list(repo_name="repo_name")
expected_issues = [{"number": 1, "title": "Test Issue"}]
assert (
issues == expected_issues
), f"Expected {expected_issues}, got {issues}"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_github_get_issue_content(mock_github):
r"""Test github_get_issue_content functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup issue
mock_issue = MagicMock()
mock_issue.body = "Issue content"
mock_repo.get_issue.return_value = mock_issue
# Mock the github_get_issue_content method to return our expected result
with patch.object(
github_toolkit,
'github_get_issue_content',
return_value="Issue content",
):
content = github_toolkit.github_get_issue_content(
repo_name="repo_name", issue_number=1
)
expected_content = "Issue content"
assert (
content == expected_content
), f"Expected {expected_content}, got {content}"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_get_all_pull_requests(mock_github):
r"""Test github_get_pull_request_list functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup PRs
mock_pr = MagicMock()
mock_pr.number = 1
mock_pr.title = "Test PR"
mock_repo.get_pulls.return_value = [mock_pr]
# Mock the github_get_pull_request_list method to return our expected
# result
with patch.object(
github_toolkit,
'github_get_pull_request_list',
return_value=[{"number": 1, "title": "Test PR"}],
):
prs = github_toolkit.github_get_pull_request_list(
repo_name="repo_name"
)
expected_prs = [{"number": 1, "title": "Test PR"}]
assert prs == expected_prs, f"Expected {expected_prs}, got {prs}"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_github_get_pull_request_code(mock_github):
r"""Test github_get_pull_request_code functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup PR files
mock_file = MagicMock()
mock_file.filename = "file1.py"
mock_file.patch = "code changes"
mock_pr = MagicMock()
mock_pr.get_files.return_value = [mock_file]
mock_repo.get_pull.return_value = mock_pr
# Mock the github_get_pull_request_code method to return our expected
# result
with patch.object(
github_toolkit,
'github_get_pull_request_code',
return_value=[{"filename": "file1.py", "patch": "code changes"}],
):
files_changed = github_toolkit.github_get_pull_request_code(
repo_name="repo_name", pr_number=1
)
expected_files = [{"filename": "file1.py", "patch": "code changes"}]
assert (
files_changed == expected_files
), f"Expected {expected_files}, got {files_changed}"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_github_get_pull_request_comments(mock_github):
r"""Test github_get_pull_request_comments functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup PR comments
mock_user = MagicMock()
mock_user.login = "user1"
mock_comment = MagicMock()
mock_comment.user = mock_user
mock_comment.body = "Test comment"
mock_pr = MagicMock()
mock_pr.get_comments.return_value = [mock_comment]
mock_repo.get_pull.return_value = mock_pr
# Mock the github_get_pull_request_comments method to return our expected
# result
with patch.object(
github_toolkit,
'github_get_pull_request_comments',
return_value=[{"user": "user1", "body": "Test comment"}],
):
comments = github_toolkit.github_get_pull_request_comments(
repo_name="repo_name", pr_number=1
)
expected_comments = [{"user": "user1", "body": "Test comment"}]
assert (
comments == expected_comments
), f"Expected {expected_comments}, got {comments}"
@patch.dict('sys.modules', mock_modules)
@patch('github.Github')
def test_github_get_all_file_paths(mock_github):
r"""Test github_get_all_file_paths functionality."""
# Set up mock
mock_repo = MagicMock()
mock_github.return_value.get_repo.return_value = mock_repo
# Create toolkit with mock auth
github_toolkit = GithubToolkit(access_token="token")
# Setup content
content_file = ContentFile(path="path/to/file.py", type="file")
mock_repo.get_contents.return_value = [content_file]
# Mock the github_get_all_file_paths method to return our expected result
with patch.object(
github_toolkit,
'github_get_all_file_paths',
return_value=["path/to/file.py"],
):
files = github_toolkit.github_get_all_file_paths(repo_name="repo_name")
expected_files = ["path/to/file.py"]
assert (
files == expected_files
), f"Expected {expected_files}, got {files}"