"""
title, authors = verifier._parse_google_scholar_first_result(html)
# Should handle gracefully and return None or empty string
assert title is None or title == ""
assert authors is None
@pytest.mark.integration
def test_parse_google_scholar_tomasello_book():
"""Test parsing Google Scholar HTML for the Tomasello book entry with real HTTP request."""
verifier = CitationVerifier()
# Make actual HTTP request to Google Scholar
title_query = "Becoming human: A theory of ontogeny"
from urllib.parse import quote_plus
search_url = f"https://scholar.google.com/scholar?q={quote_plus(title_query)}"
try:
response = verifier._make_request_with_retry('get', search_url, timeout=verifier.timeout)
if response.status_code == 200:
html = response.text
title, authors = verifier._parse_google_scholar_first_result(html)
# Verify title extraction - should find the Tomasello book
assert title is not None, "Should extract a title from Google Scholar"
# Title should be similar to the query
bibtex_title = "Becoming human: A theory of ontogeny"
similarity = verifier._calculate_title_similarity(bibtex_title.lower(), title.lower())
# Be more lenient since Google Scholar results may vary
assert similarity >= 0.3, f"Title similarity {similarity:.2%} should be >= 30% for '{title}'"
# Verify author extraction if authors are found
if authors:
author_str = ', '.join(authors).lower()
# Check if Tomasello appears in the author list
assert 'tomasello' in author_str, f"Expected 'tomasello' in authors: {authors}"
elif response.status_code == 429:
pytest.skip("Google Scholar rate limited (429) - skipping test")
else:
pytest.skip(f"Google Scholar returned status {response.status_code} - skipping test")
except Exception as e:
pytest.skip(f"Network error accessing Google Scholar: {str(e)}")
def test_retry_on_429():
"""Test that 429 errors trigger retry with exponential backoff."""
from unittest.mock import Mock, patch
import time
verifier = CitationVerifier()
# Mock response that returns 429 first time, then 200
mock_response_429 = Mock()
mock_response_429.status_code = 429
mock_response_200 = Mock()
mock_response_200.status_code = 200
with patch.object(verifier.session, 'get', side_effect=[mock_response_429, mock_response_200]) as mock_get:
with patch('time.sleep') as mock_sleep:
response = verifier._make_request_with_retry('get', 'https://example.com')
# Should have called get twice
assert mock_get.call_count == 2
# Should have slept once (after first 429)
assert mock_sleep.call_count == 1
# Should have slept for initial delay
mock_sleep.assert_called_with(verifier.INITIAL_RETRY_DELAY)
# Final response should be 200
assert response.status_code == 200
def test_max_retries_on_429():
"""Test that max retries are respected for 429 errors."""
from unittest.mock import Mock, patch
verifier = CitationVerifier()
# Mock response that always returns 429
mock_response_429 = Mock()
mock_response_429.status_code = 429
with patch.object(verifier.session, 'get', return_value=mock_response_429) as mock_get:
with patch('time.sleep') as mock_sleep:
response = verifier._make_request_with_retry('get', 'https://example.com')
# Should have called get max_retries + 1 times (initial + retries)
assert mock_get.call_count == verifier.max_retries + 1
# Should have slept max_retries times
assert mock_sleep.call_count == verifier.max_retries
# Final response should still be 429
assert response.status_code == 429
def test_exponential_backoff_on_429():
"""Test that exponential backoff is used for 429 retries."""
from unittest.mock import Mock, patch
verifier = CitationVerifier()
# Mock response that always returns 429
mock_response_429 = Mock()
mock_response_429.status_code = 429
with patch.object(verifier.session, 'get', return_value=mock_response_429) as mock_get:
with patch('time.sleep') as mock_sleep:
response = verifier._make_request_with_retry('get', 'https://example.com')
# Check that sleep was called with increasing delays
sleep_calls = [call[0][0] for call in mock_sleep.call_args_list]
assert len(sleep_calls) == verifier.max_retries
# Verify exponential backoff
expected_delays = []
delay = verifier.INITIAL_RETRY_DELAY
for _ in range(verifier.max_retries):
expected_delays.append(delay)
delay = min(delay * 2, verifier.MAX_RETRY_DELAY)
assert sleep_calls == expected_delays
def test_url_valid_handles_429():
"""Test that _check_url_valid properly handles 429 errors."""
from unittest.mock import Mock, patch
verifier = CitationVerifier()
# Mock response that returns 429 after retries
mock_response_429 = Mock()
mock_response_429.status_code = 429
with patch.object(verifier, '_make_request_with_retry', return_value=mock_response_429):
result, message = verifier._check_url_valid('https://example.com/paper.pdf')
# Should return None (warning) for 429
assert result is None
assert '429' in message
assert 'Rate limited' in message
def test_search_continues_after_429():
"""Test that search continues to next source after 429."""
from unittest.mock import Mock, patch
verifier = CitationVerifier()
entry = {
'ID': 'test2023',
'title': 'Test Paper About Machine Learning',
'author': 'Smith, John',
'year': '2023'
}
# Mock arxiv to return 429, but Semantic Scholar to succeed
mock_response_429 = Mock()
mock_response_429.status_code = 429
mock_response_200 = Mock()
mock_response_200.status_code = 200
mock_response_200.json.return_value = {
'data': [{
'title': 'Test Paper About Machine Learning',
'paperId': 'abc123'
}]
}
# First two calls (arXiv ID and search) return 429, third call (Semantic Scholar) succeeds
with patch.object(verifier, '_make_request_with_retry',
side_effect=[mock_response_429, mock_response_429, mock_response_200]):
findable, search_url, logs = verifier._check_findable_online(entry)
# Should find the paper via alternative source
assert findable is True
assert 'semanticscholar.org' in search_url
# Logs should mention rate limiting
log_text = ' '.join(logs)
assert '429' in log_text or 'rate limited' in log_text.lower()
def test_verbose_logging_for_retries():
"""Test that verbose logs are generated for retry attempts."""
from unittest.mock import Mock, patch
verifier = CitationVerifier()
# Mock response that returns 429 twice, then 200
mock_response_429 = Mock()
mock_response_429.status_code = 429
mock_response_200 = Mock()
mock_response_200.status_code = 200
with patch.object(verifier.session, 'get',
side_effect=[mock_response_429, mock_response_429, mock_response_200]):
with patch('time.sleep'):
verbose_logs = []
response = verifier._make_request_with_retry('get', 'https://example.com', verbose_logs)
# Should have logged retry attempts
assert len(verbose_logs) > 0
log_text = ' '.join(verbose_logs)
# Should mention 429 and waiting
assert '429' in log_text
assert 'Rate Limited' in log_text
assert 'Waiting' in log_text
# Should show attempt numbers
assert 'attempt' in log_text.lower()
# Final response should be 200
assert response.status_code == 200
def test_verbose_logging_for_semantic_scholar_authors():
"""Test that verbose logs are generated for author verification in Semantic Scholar."""
from unittest.mock import Mock, patch
verifier = CitationVerifier()
entry = {
'ID': 'test2023',
'title': 'Test Paper About Machine Learning',
'author': 'Smith, John and Doe, Jane',
'year': '2023'
}
search_url = 'https://www.semanticscholar.org/paper/abc123'
# Mock the Semantic Scholar API response
mock_response = Mock()
mock_response.status_code = 200
mock_response.json.return_value = {
'title': 'Test Paper About Machine Learning',
'authors': [
{'name': 'John Smith'},
{'name': 'Jane Doe'}
]
}
with patch.object(verifier, '_make_request_with_retry', return_value=mock_response):
correct, message, details, logs = verifier._check_metadata(entry, search_url)
# Should have verbose logs
assert len(logs) > 0
log_text = ' '.join(logs)
# Should mention author comparison
assert 'Comparing authors' in log_text or 'authors' in log_text.lower()
assert 'BibTeX' in log_text
assert 'Online' in log_text
assert 'Extracted' in log_text
# Should show similarity or match result
assert 'Similarity' in log_text or 'Match' in log_text or 'Result' in log_text
@pytest.mark.integration
def test_sotopia_pi_paper_google_scholar():
"""Test parsing Google Scholar HTML for SOTOPIA-π paper with real HTTP request."""
verifier = CitationVerifier()
# Make actual HTTP request to Google Scholar for SOTOPIA-π paper
title_query = "SOTOPIA-π: Interactive Learning of Socially Intelligent Language Agents"
from urllib.parse import quote_plus
search_url = f"https://scholar.google.com/scholar?q={quote_plus(title_query)}"
try:
response = verifier._make_request_with_retry('get', search_url, timeout=verifier.timeout)
if response.status_code == 200:
html = response.text
title, authors = verifier._parse_google_scholar_first_result(html)
# Verify title extraction
assert title is not None, "Should extract a title from Google Scholar"
# Title should contain key parts (be lenient as Google Scholar may format differently)
assert "SOTOPIA" in title or "sotopia" in title.lower(), f"Expected 'SOTOPIA' in title: '{title}'"
# BibTeX title has LaTeX notation: SOTOPIA-$\pi$
bibtex_title = "SOTOPIA-$\\pi$: Interactive Learning of Socially Intelligent Language Agents"
cleaned_bibtex_title = verifier._remove_curly_braces(bibtex_title).lower()
# Calculate similarity
similarity = verifier._calculate_title_similarity(cleaned_bibtex_title, title.lower())
# Be more lenient since Google Scholar may format titles differently
assert similarity >= 0.3, \
f"Title similarity {similarity:.2%} should be >= 30% for '{title}'"
# Verify author extraction
if authors:
author_str = ', '.join(authors).lower()
# Check that at least some key authors are present
# Google Scholar may abbreviate names differently
key_authors_found = 0
for key_author in ['wang', 'neubig', 'zhu', 'yu', 'sap', 'bisk']:
if key_author in author_str:
key_authors_found += 1
assert key_authors_found >= 3, \
f"Expected at least 3 key authors in {authors}, found {key_authors_found}"
# Verify author matching would work
bibtex_authors = "Wang, Ruiyi and Yu, Haofei and Zhang, Wenxin and Qi, Zhengyang and Sap, Maarten and Bisk, Yonatan and Neubig, Graham and Zhu, Hao"
bibtex_author_names = verifier._extract_author_names(bibtex_authors)
online_author_names = verifier._extract_author_names(', '.join(authors))
# Calculate author similarity
author_similarity = verifier._calculate_author_similarity(bibtex_author_names, online_author_names)
# Be lenient as Google Scholar may format authors differently
assert author_similarity >= 0.25, \
f"Author similarity {author_similarity:.2%} should be >= 25%"
elif response.status_code == 429:
pytest.skip("Google Scholar rate limited (429) - skipping test")
else:
pytest.skip(f"Google Scholar returned status {response.status_code} - skipping test")
except Exception as e:
pytest.skip(f"Network error accessing Google Scholar: {str(e)}")
def test_custom_max_retries():
"""Test that max_retries parameter can be customized."""
from unittest.mock import Mock, patch
# Create verifier with custom max_retries
verifier = CitationVerifier(max_retries=5)
# Verify the value is set correctly
assert verifier.max_retries == 5
# Mock response that always returns 429
mock_response_429 = Mock()
mock_response_429.status_code = 429
with patch.object(verifier.session, 'get', return_value=mock_response_429) as mock_get:
with patch('time.sleep') as mock_sleep:
response = verifier._make_request_with_retry('get', 'https://example.com')
# Should have called get 6 times (initial + 5 retries)
assert mock_get.call_count == 6
# Should have slept 5 times
assert mock_sleep.call_count == 5
# Final response should still be 429
assert response.status_code == 429
if __name__ == '__main__':
pytest.main([__file__, '-v'])