18634744198

Committed 19 Oct 2025 07:00PM UTC coverage: 31.618% (-29.9%) from 61.514%

Build # 18634744198

Build Type

push

github

Committed by

mpasternak

Commit Message

Merge branch 'release/v202510.1270'

Coverage Stats

657 of 9430 branches covered (6.97%)

Branch coverage included in aggregate %.

229 of 523 new or added lines in 42 files covered. (43.79%)

11303 existing lines in 316 files now uncovered.

14765 of 39346 relevant lines covered (37.53%)

0.38 hits per line

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

64.06

src/conftest.py

from datetime import timedelta
from uuid import uuid4

import pytest
from django.apps import apps
from django.utils import timezone

from channels_live_server import *  # noqa

# Fix for VCR.py compatibility with urllib3
# This resolves the AttributeError: 'VCRHTTPConnection' has no attribute 'debuglevel'


def pytest_configure(config):  # noqa
    try:
        import http.client

        import vcr

        # Patch VCR's HTTP connection classes to include required attributes
        original_vcr_stubs_init = (
            vcr.stubs.VCRHTTPConnection.__init__ if hasattr(vcr, "stubs") else None
        )

        def patched_init(self, *args, **kwargs):
            # Set default debuglevel before calling original init
            self.debuglevel = getattr(http.client.HTTPConnection, "debuglevel", 0)
            if original_vcr_stubs_init:
                original_vcr_stubs_init(self, *args, **kwargs)

        if hasattr(vcr, "stubs"):
            vcr.stubs.VCRHTTPConnection.__init__ = patched_init
            vcr.stubs.VCRHTTPSConnection.__init__ = patched_init

            # Ensure the class has all required attributes from http.client
            if not hasattr(vcr.stubs.VCRHTTPConnection, "debuglevel"):
                vcr.stubs.VCRHTTPConnection.debuglevel = 0
            if not hasattr(vcr.stubs.VCRHTTPSConnection, "debuglevel"):
                vcr.stubs.VCRHTTPSConnection.debuglevel = 0

            # Add _http_vsn and _http_vsn_str attributes required by urllib3
            if not hasattr(vcr.stubs.VCRHTTPConnection, "_http_vsn"):
                vcr.stubs.VCRHTTPConnection._http_vsn = 11
            if not hasattr(vcr.stubs.VCRHTTPConnection, "_http_vsn_str"):
                vcr.stubs.VCRHTTPConnection._http_vsn_str = "HTTP/1.1"
            if not hasattr(vcr.stubs.VCRHTTPSConnection, "_http_vsn"):
                vcr.stubs.VCRHTTPSConnection._http_vsn = 11
            if not hasattr(vcr.stubs.VCRHTTPSConnection, "_http_vsn_str"):
                vcr.stubs.VCRHTTPSConnection._http_vsn_str = "HTTP/1.1"

            # Add version_string property to VCRHTTPResponse for urllib3 2.5.0+ compatibility
            if hasattr(vcr.stubs, "VCRHTTPResponse"):
                if not hasattr(vcr.stubs.VCRHTTPResponse, "version_string"):
                    # Create a property that returns HTTP/1.1 as the version string
                    def _get_version_string(self):
                        # Return HTTP/1.1 as a sensible default
                        # This matches the _http_vsn_str we set above
                        return "HTTP/1.1"

                    vcr.stubs.VCRHTTPResponse.version_string = property(
                        _get_version_string
                    )

    except ImportError:
        # VCR not installed, skip configuration
        pass


pytest.mark.uruchom_tylko_bez_microsoft_auth = pytest.mark.skipif(
    apps.is_installed("microsoft_auth"),
    reason="działa wyłącznie bez django_microsoft_auth. Ta "
    "funkcja prawdopodobnie potrzebuje zalogowac do systemu zwykłego "
    "użytkownika i nie potrzebuje autoryzacji do niczego więcej. "
    "Możesz ją spokojnie przetestować z wyłączonym modułem microsoft_auth",
)


@pytest.fixture
def pbn_dyscyplina2(db, pbn_discipline_group):
    from pbn_api.models import Discipline

    return Discipline.objects.get_or_create(
        parent_group=pbn_discipline_group,
        uuid=uuid4(),
        code="202",
        name="druga dyscyplina",
        scientificFieldName="Dziedzina drugich dyscyplin",
    )[0]


@pytest.fixture
def pbn_discipline_group(db):
    from pbn_api.models import DisciplineGroup

    n = timezone.now().date()
    try:
        return DisciplineGroup.objects.get_or_create(
            validityDateTo=None,
            validityDateFrom=n - timedelta(days=7),
            defaults=dict(uuid=uuid4()),
        )[0]
    except DisciplineGroup.MultipleObjectsReturned:
        return DisciplineGroup.objects.filter(
            validityDateTo=None,
            validityDateFrom=n - timedelta(days=7),
        ).first()


@pytest.fixture
def pbn_dyscyplina1(db, pbn_discipline_group):
    from pbn_api.models import Discipline

    return Discipline.objects.get_or_create(
        parent_group=pbn_discipline_group,
        code="301",
        name="memetyka stosowana",
        scientificFieldName="Dziedzina memetyk",
        defaults=dict(uuid=uuid4()),
    )[0]


@pytest.fixture
@pytest.mark.django_db
def zwarte_z_dyscyplinami(
    wydawnictwo_zwarte,
    autor_jan_nowak,
    autor_jan_kowalski,
    jednostka,
    dyscyplina1,
    dyscyplina2,
    charaktery_formalne,
    wydawca,
    typy_odpowiedzialnosci,
    rok,
):
    from model_bakery import baker

    from bpp.models import Autor_Dyscyplina, Charakter_Formalny

    # Żeby eksportować oświadczenia, autor musi mieć swój odpowiednik w PBNie:
    autor_jan_nowak.pbn_uid = baker.make("pbn_api.Scientist")
    autor_jan_nowak.save()

    autor_jan_kowalski.pbn_uid = baker.make("pbn_api.Scientist")
    autor_jan_kowalski.save()

    # Musi miec też przypisania do dyscyplin
    Autor_Dyscyplina.objects.create(
        autor=autor_jan_nowak, dyscyplina_naukowa=dyscyplina1, rok=rok
    )
    Autor_Dyscyplina.objects.create(
        autor=autor_jan_kowalski, dyscyplina_naukowa=dyscyplina2, rok=rok
    )
    wydawnictwo_zwarte.dodaj_autora(
        autor_jan_nowak, jednostka, dyscyplina_naukowa=dyscyplina1
    )

    wydawnictwo_zwarte.dodaj_autora(
        autor_jan_kowalski, jednostka, dyscyplina_naukowa=dyscyplina2
    )

    # domyslnie: ksiazka/autorstwo/wydawca spoza wykazu
    wydawnictwo_zwarte.punkty_kbn = 20
    wydawnictwo_zwarte.wydawca = wydawca
    wydawnictwo_zwarte.charakter_formalny = Charakter_Formalny.objects.get(skrot="KSP")
    wydawnictwo_zwarte.save()

    return wydawnictwo_zwarte


def _dyscyplina_maker(nazwa, kod, dyscyplina_pbn):
    """Produkuje dyscypliny naukowe WRAZ z odpowiednim wpisem tłumacza
    dyscyplin"""
    from bpp.models import Dyscyplina_Naukowa
    from pbn_api.models import TlumaczDyscyplin

    d = Dyscyplina_Naukowa.objects.get_or_create(nazwa=nazwa, kod=kod)[0]
    TlumaczDyscyplin.objects.get_or_create(
        dyscyplina_w_bpp=d,
        pbn_2017_2021=dyscyplina_pbn,
        pbn_2022_2023=dyscyplina_pbn,
        pbn_2024_now=dyscyplina_pbn,
    )
    return d


@pytest.fixture
def dyscyplina1(db, pbn_dyscyplina1):
    return _dyscyplina_maker(
        nazwa="memetyka stosowana", kod="3.1", dyscyplina_pbn=pbn_dyscyplina1
    )


@pytest.fixture
def dyscyplina1_hst(db, pbn_dyscyplina1_hst):
    return _dyscyplina_maker(
        nazwa="nauka teologiczna", kod="7.1", dyscyplina_pbn=pbn_dyscyplina1_hst
    )


@pytest.fixture
def dyscyplina2(db, pbn_dyscyplina2):
    return _dyscyplina_maker(
        nazwa="druga dyscyplina", kod="2.2", dyscyplina_pbn=pbn_dyscyplina2
    )


# Import Playwright fixtures
from fixtures.playwright_fixtures import (  # noqa
    admin_page,
    preauth_asgi_page,
    preauth_page,
)


@pytest.fixture
def rodzaj_autora_n(db):
    """Fixture dla rodzaju autora N (pracownik naukowy w liczbie N)"""
    from ewaluacja_common.models import Rodzaj_Autora

    obj, _ = Rodzaj_Autora.objects.get_or_create(
        skrot="N",
        defaults=dict(
            nazwa="pracownik naukowy w liczbie N",
            jest_w_n=True,
            licz_sloty=True,
            sort=1,
        ),
    )
    return obj


@pytest.fixture
def rodzaj_autora_d(db):
    """Fixture dla rodzaju autora D (doktorant)"""
    from ewaluacja_common.models import Rodzaj_Autora

    obj, _ = Rodzaj_Autora.objects.get_or_create(
        skrot="D",
        defaults=dict(nazwa="doktorant", jest_w_n=False, licz_sloty=True, sort=3),
    )
    return obj


@pytest.fixture
def rodzaj_autora_b(db):
    """Fixture dla rodzaju autora B (pracownik badawczy spoza N)"""
    from ewaluacja_common.models import Rodzaj_Autora

    obj, _ = Rodzaj_Autora.objects.get_or_create(
        skrot="B",
        defaults=dict(
            nazwa="pracownik badawczy spoza N",
            jest_w_n=False,
            licz_sloty=True,
            sort=2,
        ),
    )
    return obj


@pytest.fixture
def rodzaj_autora_z(db):
    """Fixture dla rodzaju autora Z (inny zatrudniony, nie naukowy)"""
    from ewaluacja_common.models import Rodzaj_Autora

    obj, _ = Rodzaj_Autora.objects.get_or_create(
        skrot="Z",
        defaults=dict(
            nazwa="inny zatrudniony, nie naukowy",
            jest_w_n=False,
            licz_sloty=False,
            sort=4,
        ),
    )
    return obj

1	from datetime import timedelta	1✔
2	from uuid import uuid4	1✔
3
4	import pytest	1✔
5	from django.apps import apps	1✔
6	from django.utils import timezone	1✔
7
8	from channels_live_server import * # noqa	1✔
9
10	# Fix for VCR.py compatibility with urllib3
11	# This resolves the AttributeError: 'VCRHTTPConnection' has no attribute 'debuglevel'
12
13
14	def pytest_configure(config): # noqa	1✔
15	try:	1✔
16	import http.client	1✔
17
18	import vcr	1✔
19
20	# Patch VCR's HTTP connection classes to include required attributes
21	original_vcr_stubs_init = (	1✔
22	vcr.stubs.VCRHTTPConnection.__init__ if hasattr(vcr, "stubs") else None
23	)
24
25	def patched_init(self, args, *kwargs):	1✔
26	# Set default debuglevel before calling original init
27	self.debuglevel = getattr(http.client.HTTPConnection, "debuglevel", 0)	1✔
28	if original_vcr_stubs_init:	1!
29	original_vcr_stubs_init(self, args, *kwargs)	1✔
30
31	if hasattr(vcr, "stubs"):	1!
32	vcr.stubs.VCRHTTPConnection.__init__ = patched_init	1✔
33	vcr.stubs.VCRHTTPSConnection.__init__ = patched_init	1✔
34
35	# Ensure the class has all required attributes from http.client
36	if not hasattr(vcr.stubs.VCRHTTPConnection, "debuglevel"):	1!
37	vcr.stubs.VCRHTTPConnection.debuglevel = 0	×
38	if not hasattr(vcr.stubs.VCRHTTPSConnection, "debuglevel"):	1!
39	vcr.stubs.VCRHTTPSConnection.debuglevel = 0	×
40
41	# Add _http_vsn and _http_vsn_str attributes required by urllib3
42	if not hasattr(vcr.stubs.VCRHTTPConnection, "_http_vsn"):	1!
43	vcr.stubs.VCRHTTPConnection._http_vsn = 11	×
44	if not hasattr(vcr.stubs.VCRHTTPConnection, "_http_vsn_str"):	1!
45	vcr.stubs.VCRHTTPConnection._http_vsn_str = "HTTP/1.1"	1✔
46	if not hasattr(vcr.stubs.VCRHTTPSConnection, "_http_vsn"):	1!
47	vcr.stubs.VCRHTTPSConnection._http_vsn = 11	×
48	if not hasattr(vcr.stubs.VCRHTTPSConnection, "_http_vsn_str"):	1!
49	vcr.stubs.VCRHTTPSConnection._http_vsn_str = "HTTP/1.1"	1✔
50
51	# Add version_string property to VCRHTTPResponse for urllib3 2.5.0+ compatibility
52	if hasattr(vcr.stubs, "VCRHTTPResponse"):	1!
53	if not hasattr(vcr.stubs.VCRHTTPResponse, "version_string"):	1!
54	# Create a property that returns HTTP/1.1 as the version string
55	def _get_version_string(self):	1✔
56	# Return HTTP/1.1 as a sensible default
57	# This matches the _http_vsn_str we set above
58	return "HTTP/1.1"	1✔
59
60	vcr.stubs.VCRHTTPResponse.version_string = property(	1✔
61	_get_version_string
62	)
63
64	except ImportError:	×
65	# VCR not installed, skip configuration
66	pass	×
67
68
69	pytest.mark.uruchom_tylko_bez_microsoft_auth = pytest.mark.skipif(	1✔
70	apps.is_installed("microsoft_auth"),
71	reason="działa wyłącznie bez django_microsoft_auth. Ta "
72	"funkcja prawdopodobnie potrzebuje zalogowac do systemu zwykłego "
73	"użytkownika i nie potrzebuje autoryzacji do niczego więcej. "
74	"Możesz ją spokojnie przetestować z wyłączonym modułem microsoft_auth",
75	)
76
77
78	@pytest.fixture	1✔
79	def pbn_dyscyplina2(db, pbn_discipline_group):	1✔
80	from pbn_api.models import Discipline	1✔
81
82	return Discipline.objects.get_or_create(	1✔
83	parent_group=pbn_discipline_group,
84	uuid=uuid4(),
85	code="202",
86	name="druga dyscyplina",
87	scientificFieldName="Dziedzina drugich dyscyplin",
88	)[0]
89
90
91	@pytest.fixture	1✔
92	def pbn_discipline_group(db):	1✔
93	from pbn_api.models import DisciplineGroup	1✔
94
95	n = timezone.now().date()	1✔
96	try:	1✔
97	return DisciplineGroup.objects.get_or_create(	1✔
98	validityDateTo=None,
99	validityDateFrom=n - timedelta(days=7),
100	defaults=dict(uuid=uuid4()),
101	)[0]
102	except DisciplineGroup.MultipleObjectsReturned:	×
103	return DisciplineGroup.objects.filter(	×
104	validityDateTo=None,
105	validityDateFrom=n - timedelta(days=7),
106	).first()
107
108
109	@pytest.fixture	1✔
110	def pbn_dyscyplina1(db, pbn_discipline_group):	1✔
111	from pbn_api.models import Discipline	1✔
112
113	return Discipline.objects.get_or_create(	1✔
114	parent_group=pbn_discipline_group,
115	code="301",
116	name="memetyka stosowana",
117	scientificFieldName="Dziedzina memetyk",
118	defaults=dict(uuid=uuid4()),
119	)[0]
120
121
122	@pytest.fixture	1✔
123	@pytest.mark.django_db	1✔
124	def zwarte_z_dyscyplinami(	1✔
125	wydawnictwo_zwarte,
126	autor_jan_nowak,
127	autor_jan_kowalski,
128	jednostka,
129	dyscyplina1,
130	dyscyplina2,
131	charaktery_formalne,
132	wydawca,
133	typy_odpowiedzialnosci,
134	rok,
135	):
UNCOV 136	from model_bakery import baker	×
137
UNCOV 138	from bpp.models import Autor_Dyscyplina, Charakter_Formalny	×
139
140	# Żeby eksportować oświadczenia, autor musi mieć swój odpowiednik w PBNie:
UNCOV 141	autor_jan_nowak.pbn_uid = baker.make("pbn_api.Scientist")	×
UNCOV 142	autor_jan_nowak.save()	×
143
UNCOV 144	autor_jan_kowalski.pbn_uid = baker.make("pbn_api.Scientist")	×
UNCOV 145	autor_jan_kowalski.save()	×
146
147	# Musi miec też przypisania do dyscyplin
UNCOV 148	Autor_Dyscyplina.objects.create(	×
149	autor=autor_jan_nowak, dyscyplina_naukowa=dyscyplina1, rok=rok
150	)
UNCOV 151	Autor_Dyscyplina.objects.create(	×
152	autor=autor_jan_kowalski, dyscyplina_naukowa=dyscyplina2, rok=rok
153	)
UNCOV 154	wydawnictwo_zwarte.dodaj_autora(	×
155	autor_jan_nowak, jednostka, dyscyplina_naukowa=dyscyplina1
156	)
157
UNCOV 158	wydawnictwo_zwarte.dodaj_autora(	×
159	autor_jan_kowalski, jednostka, dyscyplina_naukowa=dyscyplina2
160	)
161
162	# domyslnie: ksiazka/autorstwo/wydawca spoza wykazu
UNCOV 163	wydawnictwo_zwarte.punkty_kbn = 20	×
UNCOV 164	wydawnictwo_zwarte.wydawca = wydawca	×
UNCOV 165	wydawnictwo_zwarte.charakter_formalny = Charakter_Formalny.objects.get(skrot="KSP")	×
UNCOV 166	wydawnictwo_zwarte.save()	×
167
UNCOV 168	return wydawnictwo_zwarte	×
169
170
171	def _dyscyplina_maker(nazwa, kod, dyscyplina_pbn):	1✔
172	"""Produkuje dyscypliny naukowe WRAZ z odpowiednim wpisem tłumacza
173	dyscyplin"""
174	from bpp.models import Dyscyplina_Naukowa	1✔
175	from pbn_api.models import TlumaczDyscyplin	1✔
176
177	d = Dyscyplina_Naukowa.objects.get_or_create(nazwa=nazwa, kod=kod)[0]	1✔
178	TlumaczDyscyplin.objects.get_or_create(	1✔
179	dyscyplina_w_bpp=d,
180	pbn_2017_2021=dyscyplina_pbn,
181	pbn_2022_2023=dyscyplina_pbn,
182	pbn_2024_now=dyscyplina_pbn,
183	)
184	return d	1✔
185
186
187	@pytest.fixture	1✔
188	def dyscyplina1(db, pbn_dyscyplina1):	1✔
189	return _dyscyplina_maker(	1✔
190	nazwa="memetyka stosowana", kod="3.1", dyscyplina_pbn=pbn_dyscyplina1
191	)
192
193
194	@pytest.fixture	1✔
195	def dyscyplina1_hst(db, pbn_dyscyplina1_hst):	1✔
UNCOV 196	return _dyscyplina_maker(	×
197	nazwa="nauka teologiczna", kod="7.1", dyscyplina_pbn=pbn_dyscyplina1_hst
198	)
199
200
201	@pytest.fixture	1✔
202	def dyscyplina2(db, pbn_dyscyplina2):	1✔
203	return _dyscyplina_maker(	1✔
204	nazwa="druga dyscyplina", kod="2.2", dyscyplina_pbn=pbn_dyscyplina2
205	)
206
207
208	# Import Playwright fixtures
209	from fixtures.playwright_fixtures import ( # noqa	1✔
210	admin_page,
211	preauth_asgi_page,
212	preauth_page,
213	)
214
215
216	@pytest.fixture	1✔
217	def rodzaj_autora_n(db):	1✔
218	"""Fixture dla rodzaju autora N (pracownik naukowy w liczbie N)"""
UNCOV 219	from ewaluacja_common.models import Rodzaj_Autora	×
220
UNCOV 221	obj, _ = Rodzaj_Autora.objects.get_or_create(	×
222	skrot="N",
223	defaults=dict(
224	nazwa="pracownik naukowy w liczbie N",
225	jest_w_n=True,
226	licz_sloty=True,
227	sort=1,
228	),
229	)
UNCOV 230	return obj	×
231
232
233	@pytest.fixture	1✔
234	def rodzaj_autora_d(db):	1✔
235	"""Fixture dla rodzaju autora D (doktorant)"""
UNCOV 236	from ewaluacja_common.models import Rodzaj_Autora	×
237
UNCOV 238	obj, _ = Rodzaj_Autora.objects.get_or_create(	×
239	skrot="D",
240	defaults=dict(nazwa="doktorant", jest_w_n=False, licz_sloty=True, sort=3),
241	)
UNCOV 242	return obj	×
243
244
245	@pytest.fixture	1✔
246	def rodzaj_autora_b(db):	1✔
247	"""Fixture dla rodzaju autora B (pracownik badawczy spoza N)"""
UNCOV 248	from ewaluacja_common.models import Rodzaj_Autora	×
249
UNCOV 250	obj, _ = Rodzaj_Autora.objects.get_or_create(	×
251	skrot="B",
252	defaults=dict(
253	nazwa="pracownik badawczy spoza N",
254	jest_w_n=False,
255	licz_sloty=True,
256	sort=2,
257	),
258	)
UNCOV 259	return obj	×
260
261
262	@pytest.fixture	1✔
263	def rodzaj_autora_z(db):	1✔
264	"""Fixture dla rodzaju autora Z (inny zatrudniony, nie naukowy)"""
UNCOV 265	from ewaluacja_common.models import Rodzaj_Autora	×
266
UNCOV 267	obj, _ = Rodzaj_Autora.objects.get_or_create(	×
268	skrot="Z",
269	defaults=dict(
270	nazwa="inny zatrudniony, nie naukowy",
271	jest_w_n=False,
272	licz_sloty=False,
273	sort=4,
274	),
275	)
UNCOV 276	return obj	×

iplweb / bpp / 18634744198

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