#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# File: tests/python/test_writer_sections.py
"""Tests for Writer section API methods: get_section, read_section, write_section, _list_sections."""
from pathlib import Path
from unittest.mock import patch
import pytest
from scitex_writer._dataclasses.core._DocumentSection import DocumentSection
from scitex_writer.writer import Writer
# Path to the actual template used as the project dir for integration-style tests
TEMPLATE_DIR = Path(__file__).resolve().parent.parent.parent
@pytest.fixture
def writer():
"""Provide a Writer instance attached to the actual template project."""
with patch("scitex_writer.writer._find_git_root", return_value=TEMPLATE_DIR):
return Writer(TEMPLATE_DIR)
# ---------------------------------------------------------------------------
# get_section
# ---------------------------------------------------------------------------
class TestGetSection:
"""Tests for Writer.get_section."""
def test_get_section_returns_document_section_for_manuscript(self, writer):
"""Verify get_section returns a DocumentSection for a manuscript section."""
section = writer.get_section("abstract", "manuscript")
assert isinstance(section, DocumentSection)
def test_get_section_returns_document_section_for_shared(self, writer):
"""Verify get_section returns a DocumentSection for a shared section."""
section = writer.get_section("title", "shared")
assert isinstance(section, DocumentSection)
def test_get_section_manuscript_section_has_path(self, writer):
"""Verify returned DocumentSection has a .path attribute."""
section = writer.get_section("introduction", "manuscript")
assert hasattr(section, "path")
assert isinstance(section.path, Path)
def test_get_section_shared_section_has_path(self, writer):
"""Verify shared DocumentSection has a .path attribute."""
section = writer.get_section("authors", "shared")
assert hasattr(section, "path")
assert isinstance(section.path, Path)
def test_get_section_raises_value_error_for_invalid_doc_type(self, writer):
"""Verify get_section raises ValueError for an unknown doc_type."""
with pytest.raises(ValueError) as exc_info:
writer.get_section("abstract", "nonexistent_type")
assert "nonexistent_type" in str(exc_info.value)
def test_get_section_error_message_lists_valid_doc_types(self, writer):
"""Verify ValueError for invalid doc_type includes valid options."""
with pytest.raises(ValueError) as exc_info:
writer.get_section("abstract", "invalid")
error_msg = str(exc_info.value)
for valid_type in ("shared", "manuscript", "supplementary", "revision"):
assert valid_type in error_msg
def test_get_section_raises_value_error_for_invalid_section_name_in_manuscript(
self, writer
):
"""Verify get_section raises ValueError for a nonexistent section in manuscript."""
with pytest.raises(ValueError) as exc_info:
writer.get_section("nonexistent_section_xyz", "manuscript")
assert "nonexistent_section_xyz" in str(exc_info.value)
def test_get_section_error_message_lists_available_sections_for_manuscript(
self, writer
):
"""Verify ValueError for invalid section name includes available section names."""
with pytest.raises(ValueError) as exc_info:
writer.get_section("bogus_section", "manuscript")
error_msg = str(exc_info.value)
# The error message should mention at least one known valid section
assert "abstract" in error_msg or "introduction" in error_msg
def test_get_section_raises_value_error_for_invalid_section_name_in_shared(
self, writer
):
"""Verify get_section raises ValueError for a nonexistent section in shared."""
with pytest.raises(ValueError) as exc_info:
writer.get_section("nonexistent_shared_section", "shared")
assert "nonexistent_shared_section" in str(exc_info.value)
def test_get_section_error_message_lists_available_sections_for_shared(
self, writer
):
"""Verify ValueError for invalid shared section name includes available sections."""
with pytest.raises(ValueError) as exc_info:
writer.get_section("bogus_shared_key", "shared")
error_msg = str(exc_info.value)
assert "title" in error_msg or "authors" in error_msg
def test_get_section_manuscript_routes_via_contents(self, writer):
"""Verify manuscript sections are accessed via .contents attribute."""
section = writer.get_section("abstract", "manuscript")
# Path should be inside the manuscript contents directory
assert "01_manuscript" in str(section.path)
assert "contents" in str(section.path)
def test_get_section_shared_routes_directly(self, writer):
"""Verify shared sections are accessed directly (not via .contents)."""
section = writer.get_section("title", "shared")
# Path should be inside the shared directory
assert "00_shared" in str(section.path)
def test_get_section_supplementary_returns_document_section(self, writer):
"""Verify get_section works for supplementary doc_type."""
section = writer.get_section("methods", "supplementary")
assert isinstance(section, DocumentSection)
def test_get_section_revision_returns_document_section(self, writer):
"""Verify get_section works for revision doc_type."""
section = writer.get_section("introduction", "revision")
assert isinstance(section, DocumentSection)
def test_get_section_section_has_read_method(self, writer):
"""Verify returned DocumentSection has a .read() method."""
section = writer.get_section("abstract", "manuscript")
assert callable(getattr(section, "read", None))
def test_get_section_section_has_write_method(self, writer):
"""Verify returned DocumentSection has a .write() method."""
section = writer.get_section("abstract", "manuscript")
assert callable(getattr(section, "write", None))
# ---------------------------------------------------------------------------
# read_section
# ---------------------------------------------------------------------------
class TestReadSection:
"""Tests for Writer.read_section."""
def test_read_section_returns_string(self, writer):
"""Verify read_section returns a string."""
content = writer.read_section("abstract", "manuscript")
assert isinstance(content, str)
def test_read_section_shared_title_returns_string(self, writer):
"""Verify read_section returns a string for shared title."""
content = writer.read_section("title", "shared")
assert isinstance(content, str)
def test_read_section_returns_empty_string_for_missing_file(self, writer):
"""Verify read_section returns empty string when section file does not exist."""
# Use a section that definitely doesn't have a real file in a tmp setup
# We mock a DocumentSection whose .read() returns None
with patch.object(writer, "get_section") as mock_get:
mock_section = DocumentSection(Path("/nonexistent/path.tex"))
mock_get.return_value = mock_section
content = writer.read_section("abstract", "manuscript")
assert content == ""
def test_read_section_manuscript_introduction(self, writer):
"""Verify read_section returns a string for manuscript introduction."""
content = writer.read_section("introduction", "manuscript")
assert isinstance(content, str)
def test_read_section_joins_list_content(self, writer):
"""Verify read_section joins list content into a single string."""
with patch.object(writer, "get_section") as mock_get:
mock_section = DocumentSection.__new__(DocumentSection)
mock_section.path = Path("/fake/section.tex")
mock_section.read = lambda: ["line one", "line two"]
mock_get.return_value = mock_section
content = writer.read_section("abstract", "manuscript")
assert content == "line one\nline two"
def test_read_section_raises_for_invalid_doc_type(self, writer):
"""Verify read_section propagates ValueError for invalid doc_type."""
with pytest.raises(ValueError):
writer.read_section("abstract", "bad_doc_type")
def test_read_section_raises_for_invalid_section_name(self, writer):
"""Verify read_section propagates ValueError for invalid section name."""
with pytest.raises(ValueError):
writer.read_section("totally_missing_section", "manuscript")
def test_read_section_default_doc_type_is_manuscript(self, writer):
"""Verify default doc_type is manuscript when omitted."""
content_explicit = writer.read_section("abstract", "manuscript")
content_default = writer.read_section("abstract")
assert content_explicit == content_default
# ---------------------------------------------------------------------------
# write_section
# ---------------------------------------------------------------------------
class TestWriteSection:
"""Tests for Writer.write_section."""
def test_write_section_returns_true_on_success(self, tmp_path):
"""Verify write_section returns True when write succeeds."""
_setup_minimal_project(tmp_path)
with patch("scitex_writer.writer._find_git_root", return_value=None):
w = Writer(tmp_path)
result = w.write_section("abstract", "Test abstract content.", "manuscript")
assert result is True
def test_write_section_content_is_readable_back(self, tmp_path):
"""Verify write_section writes content that read_section can read back."""
_setup_minimal_project(tmp_path)
with patch("scitex_writer.writer._find_git_root", return_value=None):
w = Writer(tmp_path)
test_content = "This is a unique test abstract for round-trip verification."
w.write_section("abstract", test_content, "manuscript")
result = w.read_section("abstract", "manuscript")
assert result == test_content
def test_write_section_overwrites_existing_content(self, tmp_path):
"""Verify write_section overwrites previously written content."""
_setup_minimal_project(tmp_path)
with patch("scitex_writer.writer._find_git_root", return_value=None):
w = Writer(tmp_path)
w.write_section("abstract", "First content.", "manuscript")
w.write_section("abstract", "Second content.", "manuscript")
result = w.read_section("abstract", "manuscript")
assert result == "Second content."
def test_write_section_shared_title(self, tmp_path):
"""Verify write_section works for shared doc_type."""
_setup_minimal_project(tmp_path)
with patch("scitex_writer.writer._find_git_root", return_value=None):
w = Writer(tmp_path)
test_title = "My Test Paper Title"
result = w.write_section("title", test_title, "shared")
assert result is True
assert w.read_section("title", "shared") == test_title
def test_write_section_default_doc_type_is_manuscript(self, tmp_path):
"""Verify default doc_type is manuscript when omitted."""
_setup_minimal_project(tmp_path)
with patch("scitex_writer.writer._find_git_root", return_value=None):
w = Writer(tmp_path)
test_content = "Abstract written with default doc_type."
w.write_section("abstract", test_content)
result = w.read_section("abstract", "manuscript")
assert result == test_content
def test_write_and_restore_actual_template(self, writer):
"""Verify write_section on actual template restores original content."""
original_content = writer.read_section("abstract", "manuscript")
try:
writer.write_section(
"abstract",
"Temporary test content for write_section round-trip.",
"manuscript",
)
modified_content = writer.read_section("abstract", "manuscript")
assert (
modified_content
== "Temporary test content for write_section round-trip."
)
finally:
# Always restore original content
writer.write_section("abstract", original_content, "manuscript")
restored_content = writer.read_section("abstract", "manuscript")
assert restored_content == original_content
def test_write_section_raises_for_invalid_doc_type(self, writer):
"""Verify write_section propagates ValueError for invalid doc_type."""
with pytest.raises(ValueError):
writer.write_section("abstract", "content", "bad_type")
def test_write_section_raises_for_invalid_section_name(self, writer):
"""Verify write_section propagates ValueError for invalid section name."""
with pytest.raises(ValueError):
writer.write_section("nonexistent_section", "content", "manuscript")
# ---------------------------------------------------------------------------
# _list_sections
# ---------------------------------------------------------------------------
class TestListSections:
"""Tests for Writer._list_sections."""
def test_list_sections_returns_list(self, writer):
"""Verify _list_sections returns a list."""
result = writer._list_sections(writer.manuscript.contents)
assert isinstance(result, list)
def test_list_sections_returns_list_of_strings(self, writer):
"""Verify _list_sections returns a list of strings."""
result = writer._list_sections(writer.manuscript.contents)
assert all(isinstance(name, str) for name in result)
def test_list_sections_manuscript_includes_abstract(self, writer):
"""Verify _list_sections for manuscript contents includes 'abstract'."""
result = writer._list_sections(writer.manuscript.contents)
assert "abstract" in result
def test_list_sections_manuscript_includes_introduction(self, writer):
"""Verify _list_sections for manuscript contents includes 'introduction'."""
result = writer._list_sections(writer.manuscript.contents)
assert "introduction" in result
def test_list_sections_manuscript_includes_methods(self, writer):
"""Verify _list_sections for manuscript contents includes 'methods'."""
result = writer._list_sections(writer.manuscript.contents)
assert "methods" in result
def test_list_sections_manuscript_includes_results(self, writer):
"""Verify _list_sections for manuscript contents includes 'results'."""
result = writer._list_sections(writer.manuscript.contents)
assert "results" in result
def test_list_sections_manuscript_includes_discussion(self, writer):
"""Verify _list_sections for manuscript contents includes 'discussion'."""
result = writer._list_sections(writer.manuscript.contents)
assert "discussion" in result
def test_list_sections_shared_includes_title(self, writer):
"""Verify _list_sections for shared tree includes 'title'."""
result = writer._list_sections(writer.shared)
assert "title" in result
def test_list_sections_shared_includes_authors(self, writer):
"""Verify _list_sections for shared tree includes 'authors'."""
result = writer._list_sections(writer.shared)
assert "authors" in result
def test_list_sections_shared_includes_keywords(self, writer):
"""Verify _list_sections for shared tree includes 'keywords'."""
result = writer._list_sections(writer.shared)
assert "keywords" in result
def test_list_sections_excludes_private_attributes(self, writer):
"""Verify _list_sections does not include names starting with underscore."""
result = writer._list_sections(writer.manuscript.contents)
for name in result:
assert not name.startswith("_")
def test_list_sections_excludes_path_only_attributes(self, writer):
"""Verify _list_sections excludes plain Path attributes (e.g., figures dir)."""
result = writer._list_sections(writer.manuscript.contents)
# 'figures' and 'tables' are plain Paths, not DocumentSections
assert "figures" not in result
assert "tables" not in result
def test_list_sections_non_empty_for_manuscript(self, writer):
"""Verify _list_sections returns non-empty list for manuscript contents."""
result = writer._list_sections(writer.manuscript.contents)
assert len(result) > 0
def test_list_sections_non_empty_for_shared(self, writer):
"""Verify _list_sections returns non-empty list for shared tree."""
result = writer._list_sections(writer.shared)
assert len(result) > 0
# ---------------------------------------------------------------------------
# shared vs manuscript routing
# ---------------------------------------------------------------------------
class TestSharedVsManuscriptRouting:
"""Tests for shared vs manuscript routing difference in get_section."""
def test_shared_title_path_is_in_shared_dir(self, writer):
"""Verify shared title section path is inside 00_shared."""
section = writer.get_section("title", "shared")
assert "00_shared" in str(section.path)
def test_manuscript_title_path_is_in_manuscript_contents(self, writer):
"""Verify manuscript title section path is inside 01_manuscript/contents."""
section = writer.get_section("title", "manuscript")
assert "01_manuscript" in str(section.path)
assert "contents" in str(section.path)
def test_shared_and_manuscript_title_are_different_paths(self, writer):
"""Verify shared and manuscript title sections point to different files."""
shared_section = writer.get_section("title", "shared")
manuscript_section = writer.get_section("title", "manuscript")
assert shared_section.path != manuscript_section.path
def test_get_section_manuscript_not_shared(self, writer):
"""Verify manuscript does not have extra shared-only attributes exposed directly."""
# 'bibliography' exists in manuscript contents but 'bib_files' (a plain Path) does not
manuscript_sections = writer._list_sections(writer.manuscript.contents)
shared_sections = writer._list_sections(writer.shared)
# Both trees expose 'bibliography' as a DocumentSection
assert "bibliography" in manuscript_sections
assert "bibliography" in shared_sections
def test_shared_doc_raises_for_manuscript_only_section(self, writer):
"""Verify 'introduction' is valid in manuscript but raises in shared."""
# Introduction exists in manuscript contents
section = writer.get_section("introduction", "manuscript")
assert isinstance(section, DocumentSection)
# Introduction does not exist in shared
with pytest.raises(ValueError):
writer.get_section("introduction", "shared")
# ---------------------------------------------------------------------------
# Helper utilities
# ---------------------------------------------------------------------------
def _setup_minimal_project(project_dir: Path) -> None:
"""Create a minimal valid project structure with required section files."""
(project_dir / "00_shared").mkdir(parents=True, exist_ok=True)
(project_dir / "01_manuscript" / "contents").mkdir(parents=True, exist_ok=True)
(project_dir / "02_supplementary" / "contents").mkdir(parents=True, exist_ok=True)
(project_dir / "03_revision" / "contents").mkdir(parents=True, exist_ok=True)
(project_dir / "scripts").mkdir(parents=True, exist_ok=True)
# Shared section files
shared_dir = project_dir / "00_shared"
(shared_dir / "title.tex").write_text("Test Title")
(shared_dir / "authors.tex").write_text("Test Author")
(shared_dir / "keywords.tex").write_text("test, keywords")
(shared_dir / "journal_name.tex").write_text("Test Journal")
bib_dir = shared_dir / "bib_files"
bib_dir.mkdir(parents=True, exist_ok=True)
(bib_dir / "bibliography.bib").write_text("")
# Manuscript section files
ms_contents = project_dir / "01_manuscript" / "contents"
for section in (
"abstract",
"introduction",
"methods",
"results",
"discussion",
"title",
"authors",
"keywords",
"journal_name",
"graphical_abstract",
"highlights",
"data_availability",
"additional_info",
"wordcount",
):
(ms_contents / f"{section}.tex").write_text(f"Placeholder {section}")
(ms_contents / "bibliography.bib").write_text("")
# Supplementary section files
sup_contents = project_dir / "02_supplementary" / "contents"
for section in (
"abstract",
"introduction",
"methods",
"results",
"discussion",
"title",
"authors",
"keywords",
"journal_name",
"graphical_abstract",
"highlights",
"data_availability",
"additional_info",
"wordcount",
):
(sup_contents / f"{section}.tex").write_text(f"Placeholder {section}")
(sup_contents / "bibliography.bib").write_text("")
# Revision section files
rev_contents = project_dir / "03_revision" / "contents"
for section in (
"abstract",
"introduction",
"methods",
"results",
"discussion",
"title",
"authors",
"keywords",
"journal_name",
"graphical_abstract",
"highlights",
"data_availability",
"additional_info",
"wordcount",
):
(rev_contents / f"{section}.tex").write_text(f"Placeholder {section}")
(rev_contents / "bibliography.bib").write_text("")
if __name__ == "__main__":
import os
import pytest
pytest.main([os.path.abspath(__file__)])
/