#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Test file for: compile_tex_structure.py
import os
import re
import sys
from pathlib import Path
import pytest
# Add scripts/python to path for imports
ROOT_DIR = Path(__file__).resolve().parent.parent.parent
sys.path.insert(0, str(ROOT_DIR / "scripts" / "python"))
from compile_tex_structure import ( # noqa: E402
compile_tex_structure,
expand_inputs,
generate_signature,
)
class TestGenerateSignature:
"""Test signature generation."""
def test_generate_signature_contains_scitex_writer(self):
"""Signature should contain 'SciTeX Writer'."""
signature = generate_signature()
assert "SciTeX Writer" in signature
def test_generate_signature_contains_version(self):
"""Signature should contain version number or 'unknown'."""
signature = generate_signature()
# Should have version line
assert "SciTeX Writer" in signature
# Version is present (either from pyproject.toml or 'unknown')
assert "SciTeX Writer unknown" in signature or re.search(
r"SciTeX Writer \d+\.\d+", signature
)
def test_generate_signature_contains_engine(self):
"""Signature should contain engine information."""
signature = generate_signature()
assert "LaTeX compilation engine:" in signature
# Default should be 'auto' if env vars not set
assert "auto" in signature or "tectonic" in signature or "latexmk" in signature
def test_generate_signature_with_env_engine(self, monkeypatch):
"""Signature should use SCITEX_WRITER_ENGINE if set."""
monkeypatch.setenv("SCITEX_WRITER_ENGINE", "tectonic")
signature = generate_signature()
assert "engine: tectonic" in signature
def test_generate_signature_with_source_file(self, tmp_path):
"""Signature should include source file path when provided."""
source_file = tmp_path / "test.tex"
signature = generate_signature(source_file=source_file)
assert "Source:" in signature
assert str(source_file) in signature
def test_generate_signature_has_timestamp(self):
"""Signature should contain compilation timestamp."""
signature = generate_signature()
assert "Compiled:" in signature
# Should match date format YYYY-MM-DD
assert re.search(r"\d{4}-\d{2}-\d{2}", signature)
def test_generate_signature_is_comment(self):
"""Signature should be LaTeX comments."""
signature = generate_signature()
lines = signature.split("\n")
# Non-empty lines should start with %
for line in lines:
if line.strip():
assert line.startswith("%")
class TestExpandInputs:
"""Test TeX input expansion."""
def test_expand_inputs_simple_file(self, tmp_path):
"""Should read and return simple file content."""
test_file = tmp_path / "test.tex"
test_file.write_text("Hello, world!")
result = expand_inputs(test_file)
assert "Hello, world!" in result
def test_expand_inputs_with_input_command(self, tmp_path):
"""Should expand \\input{} commands."""
# Create child file
child_file = tmp_path / "child.tex"
child_file.write_text("Child content here")
# Create parent file that references child
parent_file = tmp_path / "parent.tex"
parent_file.write_text("Start\n\\input{child}\nEnd")
result = expand_inputs(parent_file)
# Should contain both parent and child content
assert "Start" in result
assert "Child content here" in result
assert "End" in result
# Should have header comment for expanded file
assert "File: child" in result
def test_expand_inputs_missing_file(self, tmp_path):
"""Should handle missing input file gracefully."""
parent_file = tmp_path / "parent.tex"
parent_file.write_text("\\input{nonexistent}")
result = expand_inputs(parent_file)
# Should contain SKIPPED comment
assert "SKIPPED" in result
assert "file not found" in result
def test_expand_inputs_circular_reference(self, tmp_path):
"""Should detect and prevent circular references."""
# Create file that references itself
self_ref_file = tmp_path / "circular.tex"
self_ref_file.write_text("Start\n\\input{circular}\nEnd")
result = expand_inputs(self_ref_file)
# Should contain circular reference warning
assert "SKIPPED" in result
assert "circular reference" in result or "already processed" in result
def test_expand_inputs_max_depth(self, tmp_path):
"""Should stop at max recursion depth."""
# Create deeply nested structure
files = []
for i in range(15):
f = tmp_path / f"level_{i}.tex"
if i < 14:
f.write_text(f"Level {i}\n\\input{{level_{i + 1}}}")
else:
f.write_text(f"Level {i}")
files.append(f)
result = expand_inputs(files[0], max_depth=5)
# Should stop before reaching the deepest level
assert "Level 0" in result
assert "Level 5" in result or "Level 6" in result
# Should hit depth limit
assert "ERROR" in result or "Max recursion depth" in result
def test_expand_inputs_commented_line_skipped(self, tmp_path):
"""Should skip \\input{} in commented lines."""
child_file = tmp_path / "child.tex"
child_file.write_text("This should not appear")
parent_file = tmp_path / "parent.tex"
parent_file.write_text("Start\n% \\input{child}\nEnd")
result = expand_inputs(parent_file)
# Should NOT expand commented input
assert "This should not appear" not in result
# Original comment should be preserved
assert "% \\input{child}" in result
def test_expand_inputs_adds_tex_extension(self, tmp_path):
"""Should add .tex extension if not present."""
child_file = tmp_path / "child.tex"
child_file.write_text("Child content")
parent_file = tmp_path / "parent.tex"
# Reference without .tex extension
parent_file.write_text("\\input{child}")
result = expand_inputs(parent_file)
# Should successfully expand even without .tex
assert "Child content" in result
def test_expand_inputs_nested_multiple_levels(self, tmp_path):
"""Should handle multiple levels of nesting."""
level2 = tmp_path / "level2.tex"
level2.write_text("Level 2 content")
level1 = tmp_path / "level1.tex"
level1.write_text("Level 1 start\n\\input{level2}\nLevel 1 end")
level0 = tmp_path / "level0.tex"
level0.write_text("Level 0 start\n\\input{level1}\nLevel 0 end")
result = expand_inputs(level0)
# All levels should be present
assert "Level 0 start" in result
assert "Level 1 start" in result
assert "Level 2 content" in result
assert "Level 1 end" in result
assert "Level 0 end" in result
def test_expand_inputs_nonexistent_file(self, tmp_path):
"""Should handle nonexistent file at top level."""
nonexistent = tmp_path / "does_not_exist.tex"
result = expand_inputs(nonexistent)
# Should return SKIPPED message
assert "SKIPPED" in result
assert "file not found" in result
class TestCompileTexStructure:
"""Test full TeX structure compilation."""
def test_compile_tex_structure_creates_output(self, tmp_path):
"""Should create output file."""
base_file = tmp_path / "base.tex"
base_file.write_text(
"\\documentclass{article}\n\\begin{document}\nHello\n\\end{document}"
)
output_file = tmp_path / "output.tex"
success = compile_tex_structure(
base_tex=base_file, output_tex=output_file, verbose=False
)
assert success is True
assert output_file.exists()
def test_compile_tex_structure_contains_signature(self, tmp_path):
"""Output should contain compilation signature."""
base_file = tmp_path / "base.tex"
base_file.write_text("Content")
output_file = tmp_path / "output.tex"
compile_tex_structure(base_tex=base_file, output_tex=output_file, verbose=False)
output_content = output_file.read_text()
assert "SciTeX Writer" in output_content
assert "Compiled:" in output_content
def test_compile_tex_structure_expands_inputs(self, tmp_path):
"""Should expand \\input{} commands in base file."""
child_file = tmp_path / "child.tex"
child_file.write_text("Child content")
base_file = tmp_path / "base.tex"
base_file.write_text("Start\n\\input{child}\nEnd")
output_file = tmp_path / "output.tex"
compile_tex_structure(base_tex=base_file, output_tex=output_file, verbose=False)
output_content = output_file.read_text()
assert "Child content" in output_content
def test_compile_tex_structure_missing_base_file(self, tmp_path):
"""Should return False for missing base file."""
base_file = tmp_path / "nonexistent.tex"
output_file = tmp_path / "output.tex"
success = compile_tex_structure(
base_tex=base_file, output_tex=output_file, verbose=False
)
assert success is False
assert not output_file.exists()
def test_compile_tex_structure_creates_output_dir(self, tmp_path):
"""Should create output directory if it doesn't exist."""
base_file = tmp_path / "base.tex"
base_file.write_text("Content")
output_dir = tmp_path / "nested" / "dir"
output_file = output_dir / "output.tex"
success = compile_tex_structure(
base_tex=base_file, output_tex=output_file, verbose=False
)
assert success is True
assert output_dir.exists()
assert output_file.exists()
def test_tectonic_mode_comments_out_lineno(self, tmp_path):
"""Tectonic mode should comment out lineno package."""
base_file = tmp_path / "base.tex"
base_file.write_text(
"\\usepackage{lineno}\n\\linenumbers\n\\begin{document}\nContent\n\\end{document}"
)
output_file = tmp_path / "output.tex"
compile_tex_structure(
base_tex=base_file,
output_tex=output_file,
verbose=False,
tectonic_mode=True,
)
output_content = output_file.read_text()
# lineno package should be commented out
assert "% \\usepackage{lineno}" in output_content
# linenumbers command should be commented out
assert "% \\linenumbers" in output_content
def test_tectonic_mode_comments_out_bashful(self, tmp_path):
"""Tectonic mode should comment out bashful package."""
base_file = tmp_path / "base.tex"
base_file.write_text(
"\\usepackage{bashful}\n\\begin{document}\nContent\n\\end{document}"
)
output_file = tmp_path / "output.tex"
compile_tex_structure(
base_tex=base_file,
output_tex=output_file,
verbose=False,
tectonic_mode=True,
)
output_content = output_file.read_text()
# bashful package should be commented out
assert "% \\usepackage{bashful}" in output_content
def test_dark_mode_injection(self, tmp_path):
"""Dark mode should inject styling before document."""
# Create the dark_mode.tex file structure
dark_mode_dir = tmp_path / "00_shared" / "latex_styles"
dark_mode_dir.mkdir(parents=True)
dark_mode_file = dark_mode_dir / "dark_mode.tex"
dark_mode_file.write_text(
"% Dark mode test content\n\\pagecolor{black}\n\\color{white}"
)
base_file = tmp_path / "01_manuscript" / "base.tex"
base_file.parent.mkdir(parents=True)
base_file.write_text("\\begin{document}\nContent\n\\end{document}")
output_file = tmp_path / "01_manuscript" / "output.tex"
compile_tex_structure(
base_tex=base_file, output_tex=output_file, verbose=False, dark_mode=True
)
output_content = output_file.read_text()
# Should have dark mode comment
assert "Dark mode styling" in output_content
# Should have dark mode content
assert "pagecolor{black}" in output_content
# Dark mode should come before \begin{document}
dark_pos = output_content.find("Dark mode")
doc_pos = output_content.find("\\begin{document}")
assert dark_pos < doc_pos
if __name__ == "__main__":
pytest.main([os.path.abspath(__file__), "-v"])
/