954eab8e-e29d-4864-88d5-f814d498649d

Committed 25 Aug 2025 07:53PM UTC coverage: 42.328% (-1.0%) from 43.284%

Build # 954eab8e-e29d-4864-88d5-f814d498649d

Build Type

push

circleci

Committed by

mpasternak

Commit Message

Merge branch 'release/v202508.1210'

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

1298 existing lines in 55 files now uncovered.

16981 of 40118 relevant lines covered (42.33%)

0.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

4.74

src/bpp/tests/test_export/test_export_bibtex_simple.py

"""
Simplified tests for BibTeX export functionality.
"""

from unittest.mock import Mock

from bpp.export.bibtex import (
    export_to_bibtex,
    generate_bibtex_key,
    patent_to_bibtex,
    praca_doktorska_to_bibtex,
    praca_habilitacyjna_to_bibtex,
    sanitize_bibtex_string,
    wydawnictwo_ciagle_to_bibtex,
    wydawnictwo_zwarte_to_bibtex,
)


class TestBibTeXExportSimple:
    def test_sanitize_bibtex_string(self):
        """Test that problematic characters are properly escaped."""
        test_cases = [
            ("Test & Title", "Test \\& Title"),
            ("Title with {braces}", "Title with \\{braces\\}"),
            ("Math $formula$", "Math \\$formula\\$"),
            ("Percentage 100%", "Percentage 100\\%"),
            ("Hash #tag", "Hash \\#tag"),
            ("Under_score", "Under\\_score"),
            ("Super^script", "Super\\^script"),
            ("Tilde~space", "Tilde\\~space"),
            (None, ""),
            ("", ""),
        ]

        for input_str, expected in test_cases:
            result = sanitize_bibtex_string(input_str)
            assert (
                result == expected
            ), f"Input: {input_str}, Expected: {expected}, Got: {result}"

    def test_generate_bibtex_key_basic(self):
        """Test basic BibTeX key generation with minimal mock."""
        wydawnictwo = Mock()
        wydawnictwo.rok = 2023
        wydawnictwo.pk = 123
        wydawnictwo.autorzy_dla_opisu.return_value.first.return_value = None

        key = generate_bibtex_key(wydawnictwo)
        assert "2023" in key
        assert "id123" in key

    def test_wydawnictwo_ciagle_minimal_bibtex(self):
        """Test minimal BibTeX export for Wydawnictwo_Ciagle."""
        # Mock wydawnictwo with minimal required fields
        wydawnictwo = Mock()
        wydawnictwo.tytul_oryginalny = "Test Article"
        wydawnictwo.rok = 2023
        wydawnictwo.pk = 1
        wydawnictwo.zrodlo = None  # No journal
        wydawnictwo.doi = None
        wydawnictwo.issn = None
        wydawnictwo.www = None
        mock_queryset = Mock()
        mock_queryset.first.return_value = None
        mock_queryset.__iter__ = Mock(return_value=iter([]))
        wydawnictwo.autorzy_dla_opisu.return_value = mock_queryset
        wydawnictwo.opis_bibliograficzny_autorzy_cache = None
        wydawnictwo.numer_tomu.return_value = None
        wydawnictwo.numer_wydania.return_value = None
        wydawnictwo.zakres_stron.return_value = None

        bibtex = wydawnictwo_ciagle_to_bibtex(wydawnictwo)

        # Check basic structure
        assert "@article{" in bibtex
        assert "title = {Test Article}" in bibtex
        assert "year = {2023}" in bibtex
        assert bibtex.endswith("}\n")

    def test_wydawnictwo_zwarte_minimal_bibtex(self):
        """Test minimal BibTeX export for Wydawnictwo_Zwarte."""
        # Mock wydawnictwo with minimal required fields
        wydawnictwo = Mock()
        wydawnictwo.tytul_oryginalny = "Test Book"
        wydawnictwo.rok = 2022
        wydawnictwo.pk = 2
        wydawnictwo.get_wydawnictwo.return_value = "Test Publisher"
        wydawnictwo.miejsce_i_rok = "New York 2022"
        wydawnictwo.isbn = None
        wydawnictwo.www = None
        wydawnictwo.strony = None
        wydawnictwo.wydawnictwo_nadrzedne = None
        wydawnictwo.oznaczenie_wydania = None
        wydawnictwo.seria_wydawnicza = None
        wydawnictwo.doi = None
        wydawnictwo.charakter_formalny = None
        mock_queryset = Mock()
        mock_queryset.first.return_value = None
        mock_queryset.__iter__ = Mock(return_value=iter([]))
        wydawnictwo.autorzy_dla_opisu.return_value = mock_queryset
        wydawnictwo.opis_bibliograficzny_autorzy_cache = None
        wydawnictwo._meta = Mock()
        wydawnictwo._meta.model_name = "wydawnictwo_zwarte"

        bibtex = wydawnictwo_zwarte_to_bibtex(wydawnictwo)

        # Check basic structure
        assert "@book{" in bibtex
        assert "title = {Test Book}" in bibtex
        assert "publisher = {Test Publisher}" in bibtex
        assert "year = {2022}" in bibtex
        assert "address = {New York}" in bibtex
        assert bibtex.endswith("}\n")

    def test_export_to_bibtex_empty_list(self):
        """Test export with empty publication list."""
        result = export_to_bibtex([])
        assert result == ""

    def test_export_to_bibtex_mixed_publications(self):
        """Test export with mixed publication types."""
        # Mock Wydawnictwo_Ciagle
        ciagle = Mock()
        ciagle._meta = Mock()
        ciagle._meta.model_name = "wydawnictwo_ciagle"
        ciagle.tytul_oryginalny = "Article"
        ciagle.rok = 2023
        ciagle.pk = 1
        ciagle.zrodlo = None
        mock_ciagle_queryset = Mock()
        mock_ciagle_queryset.first.return_value = None
        mock_ciagle_queryset.__iter__ = Mock(return_value=iter([]))
        ciagle.autorzy_dla_opisu.return_value = mock_ciagle_queryset
        ciagle.opis_bibliograficzny_autorzy_cache = None
        ciagle.numer_tomu.return_value = None
        ciagle.numer_wydania.return_value = None
        ciagle.zakres_stron.return_value = None
        ciagle.doi = None
        ciagle.issn = None
        ciagle.www = None

        # Mock Wydawnictwo_Zwarte
        zwarte = Mock()
        zwarte._meta = Mock()
        zwarte._meta.model_name = "wydawnictwo_zwarte"
        zwarte.tytul_oryginalny = "Book"
        zwarte.rok = 2022
        zwarte.pk = 2
        zwarte.get_wydawnictwo.return_value = "Publisher"
        zwarte.miejsce_i_rok = "City 2022"
        mock_zwarte_queryset = Mock()
        mock_zwarte_queryset.first.return_value = None
        mock_zwarte_queryset.__iter__ = Mock(return_value=iter([]))
        zwarte.autorzy_dla_opisu.return_value = mock_zwarte_queryset
        zwarte.opis_bibliograficzny_autorzy_cache = None
        zwarte.wydawnictwo_nadrzedne = None
        zwarte.charakter_formalny = None
        zwarte.isbn = None
        zwarte.www = None
        zwarte.strony = None
        zwarte.oznaczenie_wydania = None
        zwarte.seria_wydawnicza = None
        zwarte.doi = None

        publications = [ciagle, zwarte]
        result = export_to_bibtex(publications)

        # Should contain both entries
        assert "@article{" in result
        assert "@book{" in result
        assert "Article" in result
        assert "Book" in result

    def test_patent_minimal_bibtex(self):
        """Test minimal BibTeX export for Patent."""
        # Mock patent with minimal required fields
        patent = Mock()
        patent.tytul_oryginalny = "Test Patent"
        patent.rok = 2023
        patent.pk = 3
        patent.numer_zgloszenia = None
        patent.numer_prawa_wylacznego = None
        patent.data_zgloszenia = None
        patent.data_decyzji = None
        patent.www = None
        mock_queryset = Mock()
        mock_queryset.first.return_value = None
        mock_queryset.__iter__ = Mock(return_value=iter([]))
        patent.autorzy_dla_opisu.return_value = mock_queryset
        patent.opis_bibliograficzny_autorzy_cache = None

        bibtex = patent_to_bibtex(patent)

        # Check basic structure
        assert "@misc{" in bibtex
        assert "title = {Test Patent}" in bibtex
        assert "year = {2023}" in bibtex
        assert bibtex.endswith("}\n")

    def test_praca_doktorska_minimal_bibtex(self):
        """Test minimal BibTeX export for Praca_Doktorska."""
        # Mock praca_doktorska with minimal required fields
        praca = Mock()
        praca.tytul_oryginalny = "Test PhD Thesis"
        praca.rok = 2023
        praca.pk = 4
        praca.jednostka = None
        praca.miejsce_i_rok = None
        praca.www = None
        mock_queryset = Mock()
        mock_queryset.first.return_value = None
        mock_queryset.__iter__ = Mock(return_value=iter([]))
        praca.autorzy_dla_opisu.return_value = mock_queryset
        praca.opis_bibliograficzny_autorzy_cache = None

        bibtex = praca_doktorska_to_bibtex(praca)

        # Check basic structure
        assert "@phdthesis{" in bibtex
        assert "title = {Test PhD Thesis}" in bibtex
        assert "year = {2023}" in bibtex
        assert "type = {Rozprawa doktorska}" in bibtex
        assert bibtex.endswith("}\n")

    def test_praca_habilitacyjna_minimal_bibtex(self):
        """Test minimal BibTeX export for Praca_Habilitacyjna."""
        # Mock praca_habilitacyjna with minimal required fields
        praca = Mock()
        praca.tytul_oryginalny = "Test Habilitation Thesis"
        praca.rok = 2022
        praca.pk = 5
        praca.jednostka = None
        praca.miejsce_i_rok = None
        praca.www = None
        mock_queryset = Mock()
        mock_queryset.first.return_value = None
        mock_queryset.__iter__ = Mock(return_value=iter([]))
        praca.autorzy_dla_opisu.return_value = mock_queryset
        praca.opis_bibliograficzny_autorzy_cache = None

        bibtex = praca_habilitacyjna_to_bibtex(praca)

        # Check basic structure
        assert "@misc{" in bibtex
        assert "title = {Test Habilitation Thesis}" in bibtex
        assert "year = {2022}" in bibtex
        assert "note = {Rozprawa habilitacyjna}" in bibtex
        assert bibtex.endswith("}\n")

    def test_export_to_bibtex_all_types(self):
        """Test export with all publication types."""
        # Create mocks for all types
        models = []

        # Wydawnictwo_Ciagle
        ciagle = Mock()
        ciagle._meta = Mock()
        ciagle._meta.model_name = "wydawnictwo_ciagle"
        ciagle.tytul_oryginalny = "Article"
        ciagle.rok = 2023
        ciagle.pk = 1
        ciagle.zrodlo = None
        mock_ciagle_queryset = Mock()
        mock_ciagle_queryset.first.return_value = None
        mock_ciagle_queryset.__iter__ = Mock(return_value=iter([]))
        ciagle.autorzy_dla_opisu.return_value = mock_ciagle_queryset
        ciagle.opis_bibliograficzny_autorzy_cache = None
        ciagle.numer_tomu.return_value = None
        ciagle.numer_wydania.return_value = None
        ciagle.zakres_stron.return_value = None
        ciagle.doi = None
        ciagle.issn = None
        ciagle.www = None
        models.append(ciagle)

        # Wydawnictwo_Zwarte
        zwarte = Mock()
        zwarte._meta = Mock()
        zwarte._meta.model_name = "wydawnictwo_zwarte"
        zwarte.tytul_oryginalny = "Book"
        zwarte.rok = 2023
        zwarte.pk = 2
        zwarte.get_wydawnictwo.return_value = "Publisher"
        zwarte.miejsce_i_rok = "City 2023"
        mock_zwarte_queryset = Mock()
        mock_zwarte_queryset.first.return_value = None
        mock_zwarte_queryset.__iter__ = Mock(return_value=iter([]))
        zwarte.autorzy_dla_opisu.return_value = mock_zwarte_queryset
        zwarte.opis_bibliograficzny_autorzy_cache = None
        zwarte.wydawnictwo_nadrzedne = None
        zwarte.charakter_formalny = None
        zwarte.isbn = None
        zwarte.www = None
        zwarte.strony = None
        zwarte.oznaczenie_wydania = None
        zwarte.seria_wydawnicza = None
        zwarte.doi = None
        models.append(zwarte)

        # Patent
        patent = Mock()
        patent._meta = Mock()
        patent._meta.model_name = "patent"
        patent.tytul_oryginalny = "Patent"
        patent.rok = 2023
        patent.pk = 3
        patent.numer_zgloszenia = None
        patent.numer_prawa_wylacznego = None
        patent.data_zgloszenia = None
        patent.data_decyzji = None
        patent.www = None
        mock_patent_queryset = Mock()
        mock_patent_queryset.first.return_value = None
        mock_patent_queryset.__iter__ = Mock(return_value=iter([]))
        patent.autorzy_dla_opisu.return_value = mock_patent_queryset
        patent.opis_bibliograficzny_autorzy_cache = None
        models.append(patent)

        # Praca_Doktorska
        doktorska = Mock()
        doktorska._meta = Mock()
        doktorska._meta.model_name = "praca_doktorska"
        doktorska.tytul_oryginalny = "PhD"
        doktorska.rok = 2023
        doktorska.pk = 4
        doktorska.jednostka = None
        doktorska.miejsce_i_rok = None
        doktorska.www = None
        mock_doktorska_queryset = Mock()
        mock_doktorska_queryset.first.return_value = None
        mock_doktorska_queryset.__iter__ = Mock(return_value=iter([]))
        doktorska.autorzy_dla_opisu.return_value = mock_doktorska_queryset
        doktorska.opis_bibliograficzny_autorzy_cache = None
        models.append(doktorska)

        # Praca_Habilitacyjna
        habilitacyjna = Mock()
        habilitacyjna._meta = Mock()
        habilitacyjna._meta.model_name = "praca_habilitacyjna"
        habilitacyjna.tytul_oryginalny = "Habil"
        habilitacyjna.rok = 2023
        habilitacyjna.pk = 5
        habilitacyjna.jednostka = None
        habilitacyjna.miejsce_i_rok = None
        habilitacyjna.www = None
        mock_habilitacyjna_queryset = Mock()
        mock_habilitacyjna_queryset.first.return_value = None
        mock_habilitacyjna_queryset.__iter__ = Mock(return_value=iter([]))
        habilitacyjna.autorzy_dla_opisu.return_value = mock_habilitacyjna_queryset
        habilitacyjna.opis_bibliograficzny_autorzy_cache = None
        models.append(habilitacyjna)

        result = export_to_bibtex(models)

        # Should contain all entry types
        assert "@article{" in result
        assert "@book{" in result
        assert "@misc{" in result
        assert "@phdthesis{" in result
        assert "Article" in result
        assert "Book" in result
        assert "Patent" in result
        assert "PhD" in result
        assert "Habil" in result

1	"""
2	Simplified tests for BibTeX export functionality.
3	"""
4
UNCOV 5	from unittest.mock import Mock	1✔
6
UNCOV 7	from bpp.export.bibtex import (	1✔
8	export_to_bibtex,
9	generate_bibtex_key,
10	patent_to_bibtex,
11	praca_doktorska_to_bibtex,
12	praca_habilitacyjna_to_bibtex,
13	sanitize_bibtex_string,
14	wydawnictwo_ciagle_to_bibtex,
15	wydawnictwo_zwarte_to_bibtex,
16	)
17
18
UNCOV 19	class TestBibTeXExportSimple:	1✔
UNCOV 20	def test_sanitize_bibtex_string(self):	1✔
21	"""Test that problematic characters are properly escaped."""
22	test_cases = [	×
23	("Test & Title", "Test \\& Title"),
24	("Title with {braces}", "Title with \\{braces\\}"),
25	("Math $formula$", "Math \\$formula\\$"),
26	("Percentage 100%", "Percentage 100\\%"),
27	("Hash #tag", "Hash \\#tag"),
28	("Under_score", "Under\\_score"),
29	("Super^script", "Super\\^script"),
30	("Tilde~space", "Tilde\\~space"),
31	(None, ""),
32	("", ""),
33	]
34
35	for input_str, expected in test_cases:	×
36	result = sanitize_bibtex_string(input_str)	×
37	assert (	×
38	result == expected
39	), f"Input: {input_str}, Expected: {expected}, Got: {result}"
40
UNCOV 41	def test_generate_bibtex_key_basic(self):	1✔
42	"""Test basic BibTeX key generation with minimal mock."""
43	wydawnictwo = Mock()	×
44	wydawnictwo.rok = 2023	×
45	wydawnictwo.pk = 123	×
46	wydawnictwo.autorzy_dla_opisu.return_value.first.return_value = None	×
47
48	key = generate_bibtex_key(wydawnictwo)	×
49	assert "2023" in key	×
50	assert "id123" in key	×
51
UNCOV 52	def test_wydawnictwo_ciagle_minimal_bibtex(self):	1✔
53	"""Test minimal BibTeX export for Wydawnictwo_Ciagle."""
54	# Mock wydawnictwo with minimal required fields
55	wydawnictwo = Mock()	×
56	wydawnictwo.tytul_oryginalny = "Test Article"	×
57	wydawnictwo.rok = 2023	×
58	wydawnictwo.pk = 1	×
59	wydawnictwo.zrodlo = None # No journal	×
60	wydawnictwo.doi = None	×
61	wydawnictwo.issn = None	×
62	wydawnictwo.www = None	×
63	mock_queryset = Mock()	×
64	mock_queryset.first.return_value = None	×
65	mock_queryset.__iter__ = Mock(return_value=iter([]))	×
66	wydawnictwo.autorzy_dla_opisu.return_value = mock_queryset	×
67	wydawnictwo.opis_bibliograficzny_autorzy_cache = None	×
68	wydawnictwo.numer_tomu.return_value = None	×
69	wydawnictwo.numer_wydania.return_value = None	×
70	wydawnictwo.zakres_stron.return_value = None	×
71
72	bibtex = wydawnictwo_ciagle_to_bibtex(wydawnictwo)	×
73
74	# Check basic structure
75	assert "@article{" in bibtex	×
76	assert "title = {Test Article}" in bibtex	×
77	assert "year = {2023}" in bibtex	×
78	assert bibtex.endswith("}\n")	×
79
UNCOV 80	def test_wydawnictwo_zwarte_minimal_bibtex(self):	1✔
81	"""Test minimal BibTeX export for Wydawnictwo_Zwarte."""
82	# Mock wydawnictwo with minimal required fields
83	wydawnictwo = Mock()	×
84	wydawnictwo.tytul_oryginalny = "Test Book"	×
85	wydawnictwo.rok = 2022	×
86	wydawnictwo.pk = 2	×
87	wydawnictwo.get_wydawnictwo.return_value = "Test Publisher"	×
88	wydawnictwo.miejsce_i_rok = "New York 2022"	×
89	wydawnictwo.isbn = None	×
90	wydawnictwo.www = None	×
91	wydawnictwo.strony = None	×
92	wydawnictwo.wydawnictwo_nadrzedne = None	×
93	wydawnictwo.oznaczenie_wydania = None	×
94	wydawnictwo.seria_wydawnicza = None	×
95	wydawnictwo.doi = None	×
96	wydawnictwo.charakter_formalny = None	×
97	mock_queryset = Mock()	×
98	mock_queryset.first.return_value = None	×
99	mock_queryset.__iter__ = Mock(return_value=iter([]))	×
100	wydawnictwo.autorzy_dla_opisu.return_value = mock_queryset	×
101	wydawnictwo.opis_bibliograficzny_autorzy_cache = None	×
102	wydawnictwo._meta = Mock()	×
103	wydawnictwo._meta.model_name = "wydawnictwo_zwarte"	×
104
105	bibtex = wydawnictwo_zwarte_to_bibtex(wydawnictwo)	×
106
107	# Check basic structure
108	assert "@book{" in bibtex	×
109	assert "title = {Test Book}" in bibtex	×
110	assert "publisher = {Test Publisher}" in bibtex	×
111	assert "year = {2022}" in bibtex	×
112	assert "address = {New York}" in bibtex	×
113	assert bibtex.endswith("}\n")	×
114
UNCOV 115	def test_export_to_bibtex_empty_list(self):	1✔
116	"""Test export with empty publication list."""
117	result = export_to_bibtex([])	×
118	assert result == ""	×
119
UNCOV 120	def test_export_to_bibtex_mixed_publications(self):	1✔
121	"""Test export with mixed publication types."""
122	# Mock Wydawnictwo_Ciagle
123	ciagle = Mock()	×
124	ciagle._meta = Mock()	×
125	ciagle._meta.model_name = "wydawnictwo_ciagle"	×
126	ciagle.tytul_oryginalny = "Article"	×
127	ciagle.rok = 2023	×
128	ciagle.pk = 1	×
129	ciagle.zrodlo = None	×
130	mock_ciagle_queryset = Mock()	×
131	mock_ciagle_queryset.first.return_value = None	×
132	mock_ciagle_queryset.__iter__ = Mock(return_value=iter([]))	×
133	ciagle.autorzy_dla_opisu.return_value = mock_ciagle_queryset	×
134	ciagle.opis_bibliograficzny_autorzy_cache = None	×
135	ciagle.numer_tomu.return_value = None	×
136	ciagle.numer_wydania.return_value = None	×
137	ciagle.zakres_stron.return_value = None	×
138	ciagle.doi = None	×
139	ciagle.issn = None	×
140	ciagle.www = None	×
141
142	# Mock Wydawnictwo_Zwarte
143	zwarte = Mock()	×
144	zwarte._meta = Mock()	×
145	zwarte._meta.model_name = "wydawnictwo_zwarte"	×
146	zwarte.tytul_oryginalny = "Book"	×
147	zwarte.rok = 2022	×
148	zwarte.pk = 2	×
149	zwarte.get_wydawnictwo.return_value = "Publisher"	×
150	zwarte.miejsce_i_rok = "City 2022"	×
151	mock_zwarte_queryset = Mock()	×
152	mock_zwarte_queryset.first.return_value = None	×
153	mock_zwarte_queryset.__iter__ = Mock(return_value=iter([]))	×
154	zwarte.autorzy_dla_opisu.return_value = mock_zwarte_queryset	×
155	zwarte.opis_bibliograficzny_autorzy_cache = None	×
156	zwarte.wydawnictwo_nadrzedne = None	×
157	zwarte.charakter_formalny = None	×
158	zwarte.isbn = None	×
159	zwarte.www = None	×
160	zwarte.strony = None	×
161	zwarte.oznaczenie_wydania = None	×
162	zwarte.seria_wydawnicza = None	×
163	zwarte.doi = None	×
164
165	publications = [ciagle, zwarte]	×
166	result = export_to_bibtex(publications)	×
167
168	# Should contain both entries
169	assert "@article{" in result	×
170	assert "@book{" in result	×
171	assert "Article" in result	×
172	assert "Book" in result	×
173
UNCOV 174	def test_patent_minimal_bibtex(self):	1✔
175	"""Test minimal BibTeX export for Patent."""
176	# Mock patent with minimal required fields
177	patent = Mock()	×
178	patent.tytul_oryginalny = "Test Patent"	×
179	patent.rok = 2023	×
180	patent.pk = 3	×
181	patent.numer_zgloszenia = None	×
182	patent.numer_prawa_wylacznego = None	×
183	patent.data_zgloszenia = None	×
184	patent.data_decyzji = None	×
185	patent.www = None	×
186	mock_queryset = Mock()	×
187	mock_queryset.first.return_value = None	×
188	mock_queryset.__iter__ = Mock(return_value=iter([]))	×
189	patent.autorzy_dla_opisu.return_value = mock_queryset	×
190	patent.opis_bibliograficzny_autorzy_cache = None	×
191
192	bibtex = patent_to_bibtex(patent)	×
193
194	# Check basic structure
195	assert "@misc{" in bibtex	×
196	assert "title = {Test Patent}" in bibtex	×
197	assert "year = {2023}" in bibtex	×
198	assert bibtex.endswith("}\n")	×
199
UNCOV 200	def test_praca_doktorska_minimal_bibtex(self):	1✔
201	"""Test minimal BibTeX export for Praca_Doktorska."""
202	# Mock praca_doktorska with minimal required fields
203	praca = Mock()	×
204	praca.tytul_oryginalny = "Test PhD Thesis"	×
205	praca.rok = 2023	×
206	praca.pk = 4	×
207	praca.jednostka = None	×
208	praca.miejsce_i_rok = None	×
209	praca.www = None	×
210	mock_queryset = Mock()	×
211	mock_queryset.first.return_value = None	×
212	mock_queryset.__iter__ = Mock(return_value=iter([]))	×
213	praca.autorzy_dla_opisu.return_value = mock_queryset	×
214	praca.opis_bibliograficzny_autorzy_cache = None	×
215
216	bibtex = praca_doktorska_to_bibtex(praca)	×
217
218	# Check basic structure
219	assert "@phdthesis{" in bibtex	×
220	assert "title = {Test PhD Thesis}" in bibtex	×
221	assert "year = {2023}" in bibtex	×
222	assert "type = {Rozprawa doktorska}" in bibtex	×
223	assert bibtex.endswith("}\n")	×
224
UNCOV 225	def test_praca_habilitacyjna_minimal_bibtex(self):	1✔
226	"""Test minimal BibTeX export for Praca_Habilitacyjna."""
227	# Mock praca_habilitacyjna with minimal required fields
228	praca = Mock()	×
229	praca.tytul_oryginalny = "Test Habilitation Thesis"	×
230	praca.rok = 2022	×
231	praca.pk = 5	×
232	praca.jednostka = None	×
233	praca.miejsce_i_rok = None	×
234	praca.www = None	×
235	mock_queryset = Mock()	×
236	mock_queryset.first.return_value = None	×
237	mock_queryset.__iter__ = Mock(return_value=iter([]))	×
238	praca.autorzy_dla_opisu.return_value = mock_queryset	×
239	praca.opis_bibliograficzny_autorzy_cache = None	×
240
241	bibtex = praca_habilitacyjna_to_bibtex(praca)	×
242
243	# Check basic structure
244	assert "@misc{" in bibtex	×
245	assert "title = {Test Habilitation Thesis}" in bibtex	×
246	assert "year = {2022}" in bibtex	×
247	assert "note = {Rozprawa habilitacyjna}" in bibtex	×
248	assert bibtex.endswith("}\n")	×
249
UNCOV 250	def test_export_to_bibtex_all_types(self):	1✔
251	"""Test export with all publication types."""
252	# Create mocks for all types
253	models = []	×
254
255	# Wydawnictwo_Ciagle
256	ciagle = Mock()	×
257	ciagle._meta = Mock()	×
258	ciagle._meta.model_name = "wydawnictwo_ciagle"	×
259	ciagle.tytul_oryginalny = "Article"	×
260	ciagle.rok = 2023	×
261	ciagle.pk = 1	×
262	ciagle.zrodlo = None	×
263	mock_ciagle_queryset = Mock()	×
264	mock_ciagle_queryset.first.return_value = None	×
265	mock_ciagle_queryset.__iter__ = Mock(return_value=iter([]))	×
266	ciagle.autorzy_dla_opisu.return_value = mock_ciagle_queryset	×
267	ciagle.opis_bibliograficzny_autorzy_cache = None	×
268	ciagle.numer_tomu.return_value = None	×
269	ciagle.numer_wydania.return_value = None	×
270	ciagle.zakres_stron.return_value = None	×
271	ciagle.doi = None	×
272	ciagle.issn = None	×
273	ciagle.www = None	×
274	models.append(ciagle)	×
275
276	# Wydawnictwo_Zwarte
277	zwarte = Mock()	×
278	zwarte._meta = Mock()	×
279	zwarte._meta.model_name = "wydawnictwo_zwarte"	×
280	zwarte.tytul_oryginalny = "Book"	×
281	zwarte.rok = 2023	×
282	zwarte.pk = 2	×
283	zwarte.get_wydawnictwo.return_value = "Publisher"	×
284	zwarte.miejsce_i_rok = "City 2023"	×
285	mock_zwarte_queryset = Mock()	×
286	mock_zwarte_queryset.first.return_value = None	×
287	mock_zwarte_queryset.__iter__ = Mock(return_value=iter([]))	×
288	zwarte.autorzy_dla_opisu.return_value = mock_zwarte_queryset	×
289	zwarte.opis_bibliograficzny_autorzy_cache = None	×
290	zwarte.wydawnictwo_nadrzedne = None	×
291	zwarte.charakter_formalny = None	×
292	zwarte.isbn = None	×
293	zwarte.www = None	×
294	zwarte.strony = None	×
295	zwarte.oznaczenie_wydania = None	×
296	zwarte.seria_wydawnicza = None	×
297	zwarte.doi = None	×
298	models.append(zwarte)	×
299
300	# Patent
301	patent = Mock()	×
302	patent._meta = Mock()	×
303	patent._meta.model_name = "patent"	×
304	patent.tytul_oryginalny = "Patent"	×
305	patent.rok = 2023	×
306	patent.pk = 3	×
307	patent.numer_zgloszenia = None	×
308	patent.numer_prawa_wylacznego = None	×
309	patent.data_zgloszenia = None	×
310	patent.data_decyzji = None	×
311	patent.www = None	×
312	mock_patent_queryset = Mock()	×
313	mock_patent_queryset.first.return_value = None	×
314	mock_patent_queryset.__iter__ = Mock(return_value=iter([]))	×
315	patent.autorzy_dla_opisu.return_value = mock_patent_queryset	×
316	patent.opis_bibliograficzny_autorzy_cache = None	×
317	models.append(patent)	×
318
319	# Praca_Doktorska
320	doktorska = Mock()	×
321	doktorska._meta = Mock()	×
322	doktorska._meta.model_name = "praca_doktorska"	×
323	doktorska.tytul_oryginalny = "PhD"	×
324	doktorska.rok = 2023	×
325	doktorska.pk = 4	×
326	doktorska.jednostka = None	×
327	doktorska.miejsce_i_rok = None	×
328	doktorska.www = None	×
329	mock_doktorska_queryset = Mock()	×
330	mock_doktorska_queryset.first.return_value = None	×
331	mock_doktorska_queryset.__iter__ = Mock(return_value=iter([]))	×
332	doktorska.autorzy_dla_opisu.return_value = mock_doktorska_queryset	×
333	doktorska.opis_bibliograficzny_autorzy_cache = None	×
334	models.append(doktorska)	×
335
336	# Praca_Habilitacyjna
337	habilitacyjna = Mock()	×
338	habilitacyjna._meta = Mock()	×
339	habilitacyjna._meta.model_name = "praca_habilitacyjna"	×
340	habilitacyjna.tytul_oryginalny = "Habil"	×
341	habilitacyjna.rok = 2023	×
342	habilitacyjna.pk = 5	×
343	habilitacyjna.jednostka = None	×
344	habilitacyjna.miejsce_i_rok = None	×
345	habilitacyjna.www = None	×
346	mock_habilitacyjna_queryset = Mock()	×
347	mock_habilitacyjna_queryset.first.return_value = None	×
348	mock_habilitacyjna_queryset.__iter__ = Mock(return_value=iter([]))	×
349	habilitacyjna.autorzy_dla_opisu.return_value = mock_habilitacyjna_queryset	×
350	habilitacyjna.opis_bibliograficzny_autorzy_cache = None	×
351	models.append(habilitacyjna)	×
352
353	result = export_to_bibtex(models)	×
354
355	# Should contain all entry types
356	assert "@article{" in result	×
357	assert "@book{" in result	×
358	assert "@misc{" in result	×
359	assert "@phdthesis{" in result	×
360	assert "Article" in result	×
361	assert "Book" in result	×
362	assert "Patent" in result	×
363	assert "PhD" in result	×
364	assert "Habil" in result	×

iplweb / bpp / 954eab8e-e29d-4864-88d5-f814d498649d

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous