audioarxiv 0.1.2rc62.post1__tar.gz → 0.1.2rc68.post1__tar.gz

{audioarxiv-0.1.2rc62.post1 → audioarxiv-0.1.2rc68.post1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: audioarxiv
-Version: 0.1.2rc62.post1
+Version: 0.1.2rc68.post1
 Summary: Turn arXiv papers into audio. audioarxiv lets you fetch the research papers from arXiv and read them aloud.
 Author-email: "Isaac C. F. Wong" <isaac.cf.wong@gmail.com>
 Requires-Python: >=3.9

{audioarxiv-0.1.2rc62.post1 → audioarxiv-0.1.2rc68.post1}/docs/installation.rst

@@ -3,19 +3,9 @@ Installation
 
 To install audioarxiv, you need Python 3.9 or higher. You can install the package using pip:
 
-.. tabs::
-
-   .. tab:: Conda
-
-      .. code-block:: console
-
-          $ conda install -c conda-forge audioarxiv
-
-   .. tab:: Pip
-
-      .. code-block:: console
+.. code-block:: console
 
-          $ pip install audioarxiv
+      $ pip install audioarxiv
 
 Requirements
 ------------

{audioarxiv-0.1.2rc62.post1 → audioarxiv-0.1.2rc68.post1}/src/audioarxiv/__init__.py

@@ -24,7 +24,7 @@ from pandas import DataFrame
 
 from . import audio, preprocess, resources
 
-__version__ = "0.1.2-rc62-post1"
+__version__ = "0.1.2-rc68-post1"
 
 
 def get_version_information() -> str:
@@ -111,11 +111,11 @@ def env_package_list(as_dataframe: bool = False) -> list | DataFrame:
 
     Returns:
     Union[list, DataFrame]:
-    If ``as_dataframe=False`` is given, the output is a `list` of `dict`,
-    one for each package, at least with ``'name'`` and ``'version'`` keys
-    (more if `conda` is used).
-    If ``as_dataframe=True`` is given, the output is a `DataFrame`
-    created from the `list` of `dicts`.
+        If ``as_dataframe=False`` is given, the output is a `list` of `dict`,
+        one for each package, at least with ``'name'`` and ``'version'`` keys
+        (more if `conda` is used).
+        If ``as_dataframe=True`` is given, the output is a `DataFrame`
+        created from the `list` of `dicts`.
     """
     prefix = sys.prefix
     pkgs = []

{audioarxiv-0.1.2rc62.post1 → audioarxiv-0.1.2rc68.post1}/src/audioarxiv/tools/main.py

@@ -57,7 +57,6 @@ def initialize_configuration(args: configargparse.Namespace) -> tuple:
     os.makedirs(config_dir, exist_ok=True)
     config_file = 'config.json'
     config_path = os.path.join(config_dir, config_file)
-
     # Default settings.
     settings = {
         'audio': {
@@ -159,36 +158,35 @@ def main():
     paper = Paper(**settings['paper'])
 
     # Search the paper.
-    if args.id is not None:
-        # Print the information
-        logger.info('Configuration file: %s', config_path)
-        logger.info('Audio settings')
-        for key, value in settings['audio'].items():
-            logger.info('%s: %s', key, value)
-
-        logger.info('Paper settings')
-        for key, value in settings['paper'].items():
-            logger.info('%s: %s', key, value)
-
-        logger.info('Searching arxiv: %s...', args.id)
-        paper.search_by_arxiv_id(arxiv_id=args.id)
-        # Get the sections
-        sections = paper.sections
-        if args.output is None:
-            for section in sections:
-                audio.read_article(section['header'])
+    # Print the information
+    logger.info('Configuration file: %s', config_path)
+    logger.info('Audio settings')
+    for key, value in settings['audio'].items():
+        logger.info('%s: %s', key, value)
+
+    logger.info('Paper settings')
+    for key, value in settings['paper'].items():
+        logger.info('%s: %s', key, value)
+
+    logger.info('Searching arxiv: %s...', args.id)
+    paper.search_by_arxiv_id(arxiv_id=args.id)
+    # Get the sections
+    sections = paper.sections
+    if args.output is None:
+        for section in sections:
+            audio.read_article(section['header'])
+            time.sleep(1)
+            for content in section['content']:
+                audio.read_article(content)
                 time.sleep(1)
-                for content in section['content']:
-                    audio.read_article(content)
-                    time.sleep(1)
-        else:
-            article = []
-            for section in sections:
-                if section['header'] is not None:
-                    article.append(section['header'])
-                if section['content'] is not None:
-                    article += section['content']
-            article = " ".join(article)
-            logger.info('Saving audio...')
-            audio.save_article(filename=args.output, article=article)
-            logger.info('Audio is saved to %s.', args.output)
+    else:
+        article = []
+        for section in sections:
+            if section['header'] is not None:
+                article.append(section['header'])
+            if section['content'] is not None:
+                article += section['content']
+        article = " ".join(article)
+        logger.info('Saving audio...')
+        audio.save_article(filename=args.output, article=article)
+        logger.info('Audio is saved to %s.', args.output)

{audioarxiv-0.1.2rc62.post1 → audioarxiv-0.1.2rc68.post1}/tests/audio/test_base.py

@@ -186,10 +186,10 @@ def test_read_article_with_non_string_input(mock_init, caplog):
         assert "is not str. Skipping." in caplog.text
 
 
-@patch('audioarxiv.audio.base.pyttsx3.init')  # control TTS engine
+@patch("audioarxiv.audio.base.pyttsx3.init")
 def test_audio_stop(mock_init):
     mock_engine = MagicMock()
-    mock_init.return_value = mock_engine  # Ensure the mock engine is returned
+    mock_init.return_value = mock_engine
 
     # Create the Audio instance, which should use the mocked engine
     audio = Audio()
@@ -199,3 +199,75 @@ def test_audio_stop(mock_init):
 
     # Verify that the stop method was called on the mocked engine
     mock_engine.stop.assert_called_once()
+
+
+@patch("audioarxiv.audio.base.pyttsx3.init")
+def test_validate_arguments_enabled(mock_init):
+    mock_engine = MagicMock()
+    mock_init.return_value = mock_engine
+
+    # Arrange
+    with patch("audioarxiv.audio.base.validate_audio_arguments") as mock_validate:
+        mock_validate.return_value = {
+            "rate": 150,
+            "volume": 0.8,
+            "voice": "voice_id",
+            "pause_seconds": 0.2
+        }
+
+        # Act
+        audio = Audio(rate=150,  # noqa: F841 # pylint: disable=unused-variable
+                      volume=0.8,
+                      voice="voice_id",
+                      pause_seconds=0.2,
+                      validate_arguments=True)
+
+        # Assert
+        mock_validate.assert_called_once()
+        mock_engine.setProperty.assert_any_call('rate', 150)
+        mock_engine.setProperty.assert_any_call('volume', 0.8)
+        mock_engine.setProperty.assert_any_call('voice', 'voice_id')
+
+
+@patch("audioarxiv.audio.base.pyttsx3.init")
+def test_validate_arguments_disabled(mock_init):
+    mock_engine = MagicMock()
+    mock_init.return_value = mock_engine
+    # Should not call `validate_audio_arguments`
+    with patch("audioarxiv.audio.base.validate_audio_arguments") as mock_validate:
+        audio = Audio(rate=150,  # noqa: F841 # pylint: disable=unused-variable
+                      volume=0.8,
+                      voice="voice_id",
+                      pause_seconds=0.2,
+                      validate_arguments=False)
+
+        mock_validate.assert_not_called()
+        mock_engine.setProperty.assert_any_call('rate', 150)
+        mock_engine.setProperty.assert_any_call('volume', 0.8)
+        mock_engine.setProperty.assert_any_call('voice', 'voice_id')
+
+
+@pytest.mark.parametrize("rate", [100, None])
+@patch("audioarxiv.audio.base.pyttsx3.init")
+def test_rate_handling(mock_init, rate):
+    mock_engine = MagicMock()
+    mock_init.return_value = mock_engine
+    audio = Audio(rate=rate, volume=0.8, validate_arguments=False)  # noqa: F841 # pylint: disable=unused-variable
+    if rate is not None:
+        mock_engine.setProperty.assert_any_call('rate', rate)
+    else:
+        for call in mock_engine.setProperty.call_args_list:
+            assert call[0][0] != 'rate'
+
+
+@pytest.mark.parametrize("volume", [0.5, None])
+@patch("audioarxiv.audio.base.pyttsx3.init")
+def test_volume_handling(mock_init, volume):
+    mock_engine = MagicMock()
+    mock_init.return_value = mock_engine
+    audio = Audio(rate=140, volume=volume, validate_arguments=False) # noqa: F841 # pylint: disable=unused-variable
+    if volume is not None:
+        mock_engine.setProperty.assert_any_call('volume', volume)
+    else:
+        for call in mock_engine.setProperty.call_args_list:
+            assert call[0][0] != 'volume'

{audioarxiv-0.1.2rc62.post1 → audioarxiv-0.1.2rc68.post1}/tests/resources/test_paper.py

@@ -181,3 +181,67 @@ def test_sections_when_no_paper(mock_client_class, caplog):
         # Assertions
         assert 'Paper is None. Cannot download PDF.' in caplog.text
         assert len(sections) == 0  # No sections should be found since paper is None
+
+
+@patch("fitz.open")
+@patch.object(Paper, "download_pdf")
+def test_sections_extraction_logic(download_pdf_mock, fitz_open_mock):
+    # Setup fake PDF text blocks
+    mock_page = MagicMock()
+    mock_page.get_text.return_value = [
+        (0, 0, 100, 100, "1 Introduction", 0, 0, 0),
+        (0, 0, 100, 100, "This is the first paragraph.", 0, 0, 0),
+        (0, 0, 100, 100, "2 Related Work", 0, 0, 0),
+        (0, 0, 100, 100, "Some related work goes here.", 0, 0, 0),
+    ]
+
+    mock_doc = [mock_page]
+    fitz_open_mock.return_value = mock_doc
+
+    paper = Paper()
+    paper.paper = MagicMock()
+    download_pdf_mock.return_value = "mock_path"
+
+    sections = paper.sections
+
+    assert len(sections) == 2  # ✅ tests `if len(self._sections) == 0`
+    assert sections[0]["header"] == "1 Introduction"
+    assert sections[0]["content"] == ["This is the first paragraph."]
+    assert sections[1]["header"] == "2 Related Work"
+    assert sections[1]["content"] == ["Some related work goes here."]
+
+
+@patch("fitz.open")
+@patch.object(Paper, "download_pdf")
+def test_sections_only_appends_nonempty_sections(download_pdf_mock, fitz_open_mock):
+    # Only content, no section header detected
+    mock_page = MagicMock()
+    mock_page.get_text.return_value = [
+        (0, 0, 100, 100, "Just some content without a header", 0, 0, 0)
+    ]
+
+    mock_doc = [mock_page]
+    fitz_open_mock.return_value = mock_doc
+
+    paper = Paper()
+    paper.paper = MagicMock()
+    download_pdf_mock.return_value = "mock_path"
+
+    sections = paper.sections
+
+    # Tests `if current_section["header"] or current_section["content"]`
+    assert len(sections) == 1
+    assert sections[0]["header"] is None
+    assert sections[0]["content"] == ["Just some content without a header"]
+
+
+@patch("fitz.open")
+@patch.object(Paper, "download_pdf")
+def test_sections_empty_when_no_paper(download_pdf_mock, fitz_open_mock):
+    paper = Paper()
+    paper.paper = None  # simulate not setting a paper
+
+    sections = paper.sections
+
+    # Triggers early return due to missing paper
+    assert sections == []

audioarxiv-0.1.2rc68.post1/tests/test_logging.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+import logging
+import tempfile
+from pathlib import Path
+from unittest.mock import patch
+
+from audioarxiv import (env_package_list, get_version_information,
+                        loaded_modules_dict, setup_logger)
+
+
+def test_get_version_information():
+    version = get_version_information()
+    assert isinstance(version, str)
+    assert len(version) > 0
+
+
+def test_setup_logger_creates_handlers():
+    logger = logging.getLogger("test_logger")
+    logger.handlers = []  # Clear any existing handlers
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        setup_logger(logger, outdir=tmpdir, label="test", log_level="INFO", print_version=True)
+
+        # Verify handlers
+        assert any(isinstance(h, logging.StreamHandler) for h in logger.handlers)
+        assert any(isinstance(h, logging.FileHandler) for h in logger.handlers)
+
+        # Verify log file content
+        log_path = Path(tmpdir) / "test.log"
+        assert log_path.exists()
+        with open(log_path) as f:
+            content = f.read()
+        assert "audioarxiv version" in content.lower()
+
+
+def test_loaded_modules_dict_structure():
+    modules = loaded_modules_dict()
+    assert isinstance(modules, dict)
+    for k, v in modules.items():
+        assert isinstance(k, str)
+        assert isinstance(v, str)
+
+
+@patch("audioarxiv.subprocess.check_output")
+def test_env_package_list_conda(mock_sub_proc):
+    mock_pkgs = [
+        {"name": "numpy", "version": "1.24.0"},
+        {"name": "pandas", "version": "2.0.0"},
+    ]
+    mock_sub_proc.return_value = json.dumps(mock_pkgs).encode("utf-8")
+
+    with patch("pathlib.Path.is_dir", return_value=True):  # Simulate conda-meta directory
+        result = env_package_list()
+        assert isinstance(result, list)
+        assert all("name" in pkg and "version" in pkg for pkg in result)
+
+
+@patch("audioarxiv.subprocess.check_output")
+def test_env_package_list_pip(mock_sub_proc):
+    mock_pkgs = [
+        {"name": "requests", "version": "2.31.0"},
+        {"name": "flask", "version": "3.0.0"},
+    ]
+    mock_sub_proc.return_value = json.dumps(mock_pkgs).encode("utf-8")
+
+    with patch("pathlib.Path.is_dir", return_value=False):  # Simulate no conda-meta
+        result = env_package_list()
+        assert isinstance(result, list)
+        assert all("name" in pkg and "version" in pkg for pkg in result)
+
+
+@patch("audioarxiv.subprocess.check_output")
+def test_env_package_list_as_dataframe(mock_sub_proc):
+    mock_pkgs = [
+        {"name": "torch", "version": "2.1.0"},
+        {"name": "scipy", "version": "1.11.0"},
+    ]
+    mock_sub_proc.return_value = json.dumps(mock_pkgs).encode("utf-8")
+
+    with patch("pathlib.Path.is_dir", return_value=False):
+        df = env_package_list(as_dataframe=True)
+        assert df.shape[0] == 2  # type: ignore[attr-defined]
+        assert "name" in df.columns  # type: ignore[attr-defined]
+        assert "version" in df.columns  # type: ignore[attr-defined]

audioarxiv-0.1.2rc68.post1/tests/tools/test_main.py

@@ -0,0 +1,358 @@
+from __future__ import annotations
+
+import json
+import logging
+import os
+import signal
+import tempfile
+from datetime import datetime
+from unittest import mock
+from unittest.mock import MagicMock, patch
+
+import pytest
+import pyttsx3
+
+from audioarxiv.tools.main import (handle_exit, initialize_configuration, main,
+                                   save_settings)
+
+
+@pytest.fixture
+def mock_pyttsx3_init(monkeypatch):
+    mock_engine = MagicMock()
+    monkeypatch.setattr(pyttsx3, "init", lambda: mock_engine)
+    return mock_engine
+
+
+@pytest.fixture
+def mock_paper_object():
+    mock_paper = MagicMock()
+    mock_paper.title = "Test Title"
+    mock_paper.summary = "This is a test abstract."
+
+    author1 = MagicMock()
+    author1.name = "Alice"
+    author2 = MagicMock()
+    author2.name = "Bob"
+    mock_paper.authors = [author1, author2]
+
+    mock_paper.published = datetime(2022, 1, 1)
+    mock_paper.updated = datetime(2022, 1, 2)
+    return mock_paper
+
+
+# Patch where classes/functions are used, not defined
+@pytest.mark.integration
+@patch("audioarxiv.tools.main.Audio")
+@patch("audioarxiv.tools.main.Paper")
+@patch("audioarxiv.tools.main.configargparse.ArgParser.parse_args")
+def test_main_with_id_and_output(mock_parse_args, mock_Paper, mock_Audio):
+    mock_args = MagicMock()
+    mock_args.id = "1234.5678"
+    mock_args.output = "output.mp3"
+    mock_args.list_voices = False
+    mock_args.rate = None
+    mock_args.volume = None
+    mock_args.voice = None
+    mock_args.pause_seconds = None
+    mock_args.page_size = None
+    mock_args.delay_seconds = None
+    mock_args.num_retries = None
+    mock_parse_args.return_value = mock_args
+
+    mock_audio = mock_Audio.return_value
+    mock_paper = mock_Paper.return_value
+    mock_paper.sections = [
+        {'header': "Introduction", 'content': ["This is content."]},
+        {'header': None, 'content': ["More content."]}
+    ]
+
+    with patch("audioarxiv.tools.main.initialize_configuration") as mock_init_config:
+        mock_init_config.return_value = ({"audio": {}, "paper": {}}, "mock/config/path")
+
+        main()
+
+    mock_audio.save_article.assert_called_once()
+    assert mock_audio.save_article.call_args[1]["filename"] == "output.mp3"
+
+
+@pytest.mark.integration
+@patch("audioarxiv.tools.main.Audio")
+@patch("audioarxiv.tools.main.configargparse.ArgParser.parse_args")
+def test_main_list_voices(mock_parse_args, mock_Audio):
+    mock_args = MagicMock()
+    mock_args.list_voices = True
+    mock_parse_args.return_value = mock_args
+
+    mock_audio = mock_Audio.return_value
+
+    main()
+
+    mock_audio.list_voices.assert_called_once()
+
+
+@pytest.mark.integration
+@patch("audioarxiv.tools.main.validate_audio_arguments")
+@patch("audioarxiv.tools.main.validate_paper_arguments")
+def test_initialize_configuration_defaults(mock_validate_paper, mock_validate_audio):
+    mock_validate_audio.return_value = {'rate': 140, 'volume': 0.9, 'voice': None, 'pause_seconds': 0.1}
+    mock_validate_paper.return_value = {'page_size': 100, 'delay_seconds': 3.0, 'num_retries': 3}
+
+    dummy_args = MagicMock()
+    for attr in ['rate', 'volume', 'voice', 'pause_seconds', 'page_size', 'delay_seconds', 'num_retries']:
+        setattr(dummy_args, attr, None)
+
+    with tempfile.TemporaryDirectory() as tmp_dir_name:
+        config_path = os.path.join(tmp_dir_name, 'config.json')  # noqa: F841 # pylint: disable=unused-variable
+
+        with patch("audioarxiv.tools.main.user_config_dir", return_value=tmp_dir_name):
+            settings, path = initialize_configuration(dummy_args)
+            assert settings['audio']['rate'] == 140
+            assert os.path.exists(path)
+
+
+@pytest.mark.integration
+@patch("builtins.open", new_callable=mock.mock_open)
+def test_save_settings(mock_open_func):
+    settings = {"audio": {"rate": 150}, "paper": {"page_size": 50}}
+    save_settings("config.json", settings)
+    mock_open_func.assert_called_once_with("config.json", 'w', encoding='utf-8')
+    handle = mock_open_func()
+    handle.write.assert_called()
+
+
+@pytest.mark.integration
+@patch("audioarxiv.tools.main.sys.exit")
+def test_handle_exit(mock_exit):
+    with patch("audioarxiv.tools.main.logger.info") as mock_logger:
+        handle_exit(signal.SIGINT, None)
+        mock_logger.assert_called_once()
+        mock_exit.assert_called_once_with(0)
+
+
+@patch('builtins.open', side_effect=IOError('Mocked IOError during file open'))
+def test_save_settings_throws_exception(mock_open, caplog):
+    config_path = "test_config.json"
+    settings = {
+        'audio': {
+            'rate': 140,
+            'volume': 0.9,
+            'voice': None,
+            'pause_seconds': 0.1
+        },
+        'paper': {
+            'page_size': 100,
+            'delay_seconds': 3.0,
+            'num_retries': 3
+        }
+    }
+
+    logger = logging.getLogger('audioarxiv')
+    logger.setLevel(logging.ERROR)
+    logger.propagate = True
+
+    with caplog.at_level(logging.ERROR, logger='audioarxiv'):
+        # Call save_settings, which should raise an exception
+        save_settings(config_path, settings)
+
+        # Assert that the open function was called (even though it will raise an exception)
+        mock_open.assert_called_once_with(config_path, 'w', encoding="utf-8")
+
+        assert 'Error saving settings: Mocked IOError during file open' in caplog.text
+
+
+@patch('audioarxiv.tools.main.user_config_dir', return_value='.')  # Mock user_config_dir
+@patch('os.path.exists')
+@patch('builtins.open', new_callable=MagicMock)  # Mock the open function to read the file
+@patch('json.load')  # Mock json.load to simulate loading settings
+@patch('audioarxiv.audio.base.validate_audio_arguments')  # Mock the validate_audio_arguments function
+@patch('audioarxiv.resources.paper.validate_paper_arguments')  # Mock the validate_paper_arguments function
+@patch("audioarxiv.resources.paper.arxiv.Client")
+@patch("configargparse.ArgParser.parse_args")
+def test_load_settings(mock_parse_args,
+                       mock_client_class,
+                       mock_validate_paper,
+                       mock_validate_audio,
+                       mock_json_load,
+                       mock_open,
+                       mock_exists,
+                       mock_user_config_dir,
+                       mock_pyttsx3_init,
+                       mock_paper_object,
+                       caplog):
+    # Set up mock arguments
+    mock_args = MagicMock()
+    mock_args.id = "1234.5678"
+    mock_args.output = None
+    mock_args.list_voices = False
+    mock_args.rate = None
+    mock_args.volume = None
+    mock_args.voice = None
+    mock_args.pause_seconds = None
+    mock_args.page_size = None
+    mock_args.delay_seconds = None
+    mock_args.num_retries = None
+    mock_parse_args.return_value = mock_args
+
+    mock_engine = mock_pyttsx3_init()  # noqa: F841
+
+    mock_client = MagicMock()
+    mock_client.results.return_value = iter([mock_paper_object])
+    mock_client_class.return_value = mock_client
+
+    mock_paper_object.download_pdf.return_value = "path/to/pdf"
+
+    # Set up the logger
+    logger = logging.getLogger('audioarxiv')
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = True
+
+    # Sample settings to be loaded
+    config_dir = mock_user_config_dir('audioarxiv')  # Assuming this function is defined correctly
+    config_file = 'config.json'
+    config_path = os.path.join(config_dir, config_file)
+    settings_from_file = {
+        'audio': {
+            'rate': 150,
+            'volume': 1.0,
+            'voice': None,
+            'pause_seconds': 0.2
+        },
+        'paper': {
+            'page_size': 50,
+            'delay_seconds': 2.0,
+            'num_retries': 5
+        }
+    }
+
+    # Mock file reading
+    mock_file = MagicMock()
+    mock_file.read.return_value = b'mocked file content'
+    mock_open.return_value.__enter__.return_value = mock_file
+    mock_json_load.return_value = settings_from_file
+
+    # Mock validation functions
+    mock_validate_audio.return_value = settings_from_file['audio']
+    mock_validate_paper.return_value = settings_from_file['paper']
+
+    # Mock file existence
+    mock_exists.return_value = True
+
+    with caplog.at_level(logging.ERROR, logger='audioarxiv'):
+        # Mock the `download_pdf` and `fitz.open` methods
+        with patch('fitz.open') as mock_fitz_open:
+            mock_page = MagicMock()
+            mock_page.get_text.return_value = [[None, None, None, None, "SECTION HEADER\n"],
+                                               [None, None, None, None, "Section Content"]]
+            mock_fitz_open.return_value = [mock_page]
+            main()
+
+    # Verify config_path was checked
+    mock_exists.assert_any_call(config_path)
+    mock_json_load.assert_called_once_with(mock_file)
+
+
+@patch('audioarxiv.tools.main.user_config_dir', return_value='.')  # Mock user_config_dir
+@patch('os.path.exists')
+@patch('builtins.open', new_callable=MagicMock)  # Mock the open function to read the file
+@patch('json.load')  # Mock json.load to simulate loading settings
+@patch('audioarxiv.audio.base.validate_audio_arguments')  # Mock the validate_audio_arguments function
+@patch('audioarxiv.resources.paper.validate_paper_arguments')  # Mock the validate_paper_arguments function
+@patch("audioarxiv.resources.paper.arxiv.Client")
+@patch("configargparse.ArgParser.parse_args")
+def test_load_settings_error(mock_parse_args,
+                             mock_client_class,
+                             mock_validate_paper,
+                             mock_validate_audio,
+                             mock_json_load,
+                             mock_open,
+                             mock_exists,
+                             mock_user_config_dir,
+                             mock_pyttsx3_init,
+                             mock_paper_object,
+                             caplog):
+    # Set up mock arguments
+    mock_args = MagicMock()
+    mock_args.id = "1234.5678"
+    mock_args.output = None
+    mock_args.list_voices = False
+    mock_args.rate = None
+    mock_args.volume = None
+    mock_args.voice = None
+    mock_args.pause_seconds = None
+    mock_args.page_size = None
+    mock_args.delay_seconds = None
+    mock_args.num_retries = None
+    mock_parse_args.return_value = mock_args
+
+    mock_engine = mock_pyttsx3_init()  # noqa: F841
+
+    mock_client = MagicMock()
+    mock_client.results.return_value = iter([mock_paper_object])
+    mock_client_class.return_value = mock_client
+
+    mock_paper_object.download_pdf.return_value = "path/to/pdf"
+
+    # Set up the logger
+    logger = logging.getLogger('audioarxiv')
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = True
+
+    # Sample settings to be loaded
+    config_dir = mock_user_config_dir('audioarxiv')  # Assuming this function is defined correctly
+    config_file = 'config.json'
+    config_path = os.path.join(config_dir, config_file)
+
+    settings_from_file = {
+        'audio': {
+            'rate': 150,
+            'volume': 1.0,
+            'voice': None,
+            'pause_seconds': 0.2
+        },
+        'paper': {
+            'page_size': 50,
+            'delay_seconds': 2.0,
+            'num_retries': 5
+        }
+    }
+
+    # Mock validation functions
+    mock_validate_audio.return_value = settings_from_file['audio']
+    mock_validate_paper.return_value = settings_from_file['paper']
+
+    # Set up the mock to simulate file reading failure (File not found error)
+    mock_exists.return_value = False  # Simulate that the file doesn't exist
+    with caplog.at_level(logging.INFO, logger='audioarxiv'):
+        with patch('fitz.open') as mock_fitz_open:
+            mock_page = MagicMock()
+            mock_page.get_text.return_value = [[None, None, None, None, "SECTION HEADER\n"],
+                                               [None, None, None, None, "Section Content"]]
+            mock_fitz_open.return_value = [mock_page]
+            main()
+
+    # Ensure the file existence check was called and failed
+    mock_exists.assert_any_call(config_path)
+    # Check for the error in logs
+    assert 'Saving default settings to ./config.json...' in caplog.text
+
+    # Now simulate an invalid JSON error
+    mock_exists.return_value = True
+    mock_file = MagicMock()
+    mock_file.read.return_value = b'mocked file content'
+    mock_open.return_value.__enter__.return_value = mock_file
+    mock_json_load.side_effect = json.JSONDecodeError("Expecting value", "doc", 0)  # Simulate JSONDecodeError
+    mock_client.results.return_value = iter([mock_paper_object])
+
+    caplog.clear()
+    with caplog.at_level(logging.ERROR, logger='audioarxiv'):
+        with patch('fitz.open') as mock_fitz_open:
+            mock_page = MagicMock()
+            mock_page.get_text.return_value = [[None, None, None, None, "SECTION HEADER\n"],
+                                               [None, None, None, None, "Section Content"]]
+            mock_fitz_open.return_value = [mock_page]
+            main()
+
+    # Ensure json.load was called
+    mock_json_load.assert_called_once_with(mock_file)
+    # Check for the JSON error in logs
+    assert 'Error loading settings: Expecting value' in caplog.text

audioarxiv-0.1.2rc62.post1/tests/tools/test_main.py

@@ -1,101 +0,0 @@
-from __future__ import annotations
-
-import os
-import signal
-import tempfile
-from unittest import mock
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from audioarxiv.tools.main import (handle_exit, initialize_configuration, main,
-                                   save_settings)
-
-
-# Patch where classes/functions are used, not defined
-@pytest.mark.integration
-@patch("audioarxiv.tools.main.Audio")
-@patch("audioarxiv.tools.main.Paper")
-@patch("audioarxiv.tools.main.configargparse.ArgParser.parse_args")
-def test_main_with_id_and_output(mock_parse_args, mock_Paper, mock_Audio):
-    mock_args = MagicMock()
-    mock_args.id = "1234.5678"
-    mock_args.output = "output.mp3"
-    mock_args.list_voices = False
-    mock_args.rate = None
-    mock_args.volume = None
-    mock_args.voice = None
-    mock_args.pause_seconds = None
-    mock_args.page_size = None
-    mock_args.delay_seconds = None
-    mock_args.num_retries = None
-    mock_parse_args.return_value = mock_args
-
-    mock_audio = mock_Audio.return_value
-    mock_paper = mock_Paper.return_value
-    mock_paper.sections = [
-        {'header': "Introduction", 'content': ["This is content."]},
-        {'header': None, 'content': ["More content."]}
-    ]
-
-    with patch("audioarxiv.tools.main.initialize_configuration") as mock_init_config:
-        mock_init_config.return_value = ({"audio": {}, "paper": {}}, "mock/config/path")
-
-        main()
-
-    mock_audio.save_article.assert_called_once()
-    assert mock_audio.save_article.call_args[1]["filename"] == "output.mp3"
-
-
-@pytest.mark.integration
-@patch("audioarxiv.tools.main.Audio")
-@patch("audioarxiv.tools.main.configargparse.ArgParser.parse_args")
-def test_main_list_voices(mock_parse_args, mock_Audio):
-    mock_args = MagicMock()
-    mock_args.list_voices = True
-    mock_parse_args.return_value = mock_args
-
-    mock_audio = mock_Audio.return_value
-
-    main()
-
-    mock_audio.list_voices.assert_called_once()
-
-
-@pytest.mark.integration
-@patch("audioarxiv.tools.main.validate_audio_arguments")
-@patch("audioarxiv.tools.main.validate_paper_arguments")
-def test_initialize_configuration_defaults(mock_validate_paper, mock_validate_audio):
-    mock_validate_audio.return_value = {'rate': 140, 'volume': 0.9, 'voice': None, 'pause_seconds': 0.1}
-    mock_validate_paper.return_value = {'page_size': 100, 'delay_seconds': 3.0, 'num_retries': 3}
-
-    dummy_args = MagicMock()
-    for attr in ['rate', 'volume', 'voice', 'pause_seconds', 'page_size', 'delay_seconds', 'num_retries']:
-        setattr(dummy_args, attr, None)
-
-    with tempfile.TemporaryDirectory() as tmp_dir_name:
-        config_path = os.path.join(tmp_dir_name, 'config.json')  # noqa: F841 # pylint: disable=unused-variable
-
-        with patch("audioarxiv.tools.main.user_config_dir", return_value=tmp_dir_name):
-            settings, path = initialize_configuration(dummy_args)
-            assert settings['audio']['rate'] == 140
-            assert os.path.exists(path)
-
-
-@pytest.mark.integration
-@patch("builtins.open", new_callable=mock.mock_open)
-def test_save_settings(mock_open_func):
-    settings = {"audio": {"rate": 150}, "paper": {"page_size": 50}}
-    save_settings("config.json", settings)
-    mock_open_func.assert_called_once_with("config.json", 'w', encoding='utf-8')
-    handle = mock_open_func()
-    handle.write.assert_called()
-
-
-@pytest.mark.integration
-@patch("audioarxiv.tools.main.sys.exit")
-def test_handle_exit(mock_exit):
-    with patch("audioarxiv.tools.main.logger.info") as mock_logger:
-        handle_exit(signal.SIGINT, None)
-        mock_logger.assert_called_once()
-        mock_exit.assert_called_once_with(0)