2314acb3-6be8-4e0c-96b0-e8b120678896

Committed 11 Aug 2025 11:35AM UTC coverage: 39.858% (-6.2%) from 46.068%

Build # 2314acb3-6be8-4e0c-96b0-e8b120678896

Build Type

push

circleci

Committed by

mpasternak

Commit Message

Merge branch 'release/v202508.1185'

Run Details

8 of 64 new or added lines in 8 files covered. (12.5%)

683 existing lines in 32 files now uncovered.

15116 of 37925 relevant lines covered (39.86%)

0.4 hits per line

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

0.0

src/pbn_api/tests/test_bpp_admin_helpers.py

import pytest
from model_bakery import baker

from fixtures import MOCK_MONGO_ID, MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA
from fixtures.pbn_api import MOCK_RETURNED_MONGODB_DATA
from pbn_api.adapters.wydawnictwo import WydawnictwoPBNAdapter
from pbn_api.client import (
    PBN_GET_INSTITUTION_STATEMENTS,
    PBN_GET_PUBLICATION_BY_ID_URL,
    PBN_POST_PUBLICATIONS_URL,
)
from pbn_api.const import PBN_GET_INSTITUTION_PUBLICATIONS_V2
from pbn_api.exceptions import AccessDeniedException
from pbn_api.models import Publication, SentData
from pbn_api.tests.utils import middleware

from django.contrib.messages import get_messages

from bpp.admin.helpers.pbn_api.gui import sprobuj_wyslac_do_pbn_gui
from bpp.models import Charakter_Formalny, Wydawnictwo_Ciagle


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_charakter_zly(
    rf,
    pbn_wydawnictwo_zwarte,
):
    req = rf.get("/")

    pbn_wydawnictwo_zwarte.charakter_formalny = baker.make(
        Charakter_Formalny, rodzaj_pbn=None
    )

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(req, pbn_wydawnictwo_zwarte)

    msg = get_messages(req)

    assert "nie będzie eksportowany do PBN" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_uczelnia_brak_obiektu(
    rf, pbn_wydawnictwo_zwarte_z_charakterem
):
    req = rf.get("/")

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(req, pbn_wydawnictwo_zwarte_z_charakterem)

    msg = get_messages(req)

    assert 'w systemie brakuje obiektu "Uczelnia"' in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_uczelnia_integracja_wylaczona(
    rf, pbn_wydawnictwo_zwarte_z_charakterem, uczelnia
):
    req = rf.get("/")

    uczelnia.pbn_integracja = False
    uczelnia.pbn_aktualizuj_na_biezaco = False
    uczelnia.save()

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(req, pbn_wydawnictwo_zwarte_z_charakterem)

    msg = get_messages(req)
    assert len(msg) == 1


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_dane_juz_wyslane(
    pbn_wydawnictwo_zwarte_z_charakterem, pbn_uczelnia, pbn_client, rf
):
    SentData.objects.updated(
        pbn_wydawnictwo_zwarte_z_charakterem,
        WydawnictwoPBNAdapter(pbn_wydawnictwo_zwarte_z_charakterem).pbn_get_json(),
    )

    req = rf.get("/")

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "Identyczne dane rekordu" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_access_denied(
    pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
):
    req = rf.get("/")

    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = (
        AccessDeniedException(url="foo", content="testujemy")
    )

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "Brak dostępu --" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_brak_prawidlowej_odpowiedzi(
    pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
):
    req = rf.get("/")

    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {
        "elem": "coz, jakby nie. "
    }

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "nie odpowiedział prawidłowym PBN UID" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_inny_exception(
    pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
):
    req = rf.get("/")

    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = ZeroDivisionError

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "Nie można zsynchronizować" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_inny_blad(
    pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
):
    req = rf.get("/")

    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = Exception("test")

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "Nie można zsynchronizować" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_sukces(
    pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
):
    req = rf.get("/")

    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {"objectId": "123"}
    pbn_client.transport.return_values[
        PBN_GET_PUBLICATION_BY_ID_URL.format(id="123")
    ] = MOCK_RETURNED_MONGODB_DATA
    pbn_client.transport.return_values[
        PBN_GET_PUBLICATION_BY_ID_URL.format(id="456")
    ] = MOCK_RETURNED_MONGODB_DATA
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_STATEMENTS + "?publicationId=123&size=5120"
    ] = []
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_PUBLICATIONS_V2 + "?publicationId=123&size=10"
    ] = MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "zostały zaktualizowane" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_ostrzezenie_brak_dyscypliny_autora(
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client, rf, pbn_uczelnia
):
    req = rf.get("/")

    for wza in pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.autorzy_set.all():
        wza.afiliuje = True
        wza.przypieta = True
        wza.save()

        jednostka = wza.jednostka
        jednostka.skupia_pracownikow = True
        jednostka.save()

        autor = wza.autor
        autor.pbn_uid = None
        autor.pbn_uid_id = None
        autor.save()

    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {"objectId": "123"}
    pbn_client.transport.return_values[
        PBN_GET_PUBLICATION_BY_ID_URL.format(id="123")
    ] = MOCK_RETURNED_MONGODB_DATA
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_STATEMENTS + "?publicationId=123&size=5120"
    ] = []

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "nie zostanie oświadczona" in list(msg)[0].message


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_przychodzi_istniejacy_pbn_uid_dla_nowego_rekordu(
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina: Wydawnictwo_Ciagle,
    pbn_client,
    rf,
    pbn_uczelnia,
):
    """Ten test sprawdza, jak zachowa się system w przypadku wysyłki nowego rekordu, gdy przyjdzie PBN UID
    takiego rekordu, który już istnieje"""

    req = rf.get("/")

    # To jest istniejące w bazie wydawnictwo ciągłe z PBN UID = MOCK_MONGO_ID ("123")
    publikacja = baker.make(Publication, pk=MOCK_MONGO_ID)
    istniejace_wydawnictwo_ciagle = baker.make(  # noqa
        Wydawnictwo_Ciagle, pbn_uid=publikacja
    )

    # To jest NOWO WYSYŁANE wydawnictwo ciągłe, które nie ma PBN UID
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.pbn_uid = None
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.save(update_fields=["pbn_uid"])

    # To jest odpowiedź z PBNu gdzie zwrotnie przyjdzie objectId = MOCK_MONGO_ID
    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {
        "objectId": MOCK_MONGO_ID
    }
    pbn_client.transport.return_values[
        PBN_GET_PUBLICATION_BY_ID_URL.format(id=MOCK_MONGO_ID)
    ] = MOCK_RETURNED_MONGODB_DATA
    pbn_client.transport.return_values[
        PBN_GET_PUBLICATION_BY_ID_URL.format(id=MOCK_MONGO_ID)
    ] = MOCK_RETURNED_MONGODB_DATA
    pbn_client.transport.return_values[PBN_GET_PUBLICATION_BY_ID_URL.format(id=456)] = (
        MOCK_RETURNED_MONGODB_DATA
    )
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_STATEMENTS + f"?publicationId={MOCK_MONGO_ID}&size=5120"
    ] = []
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_PUBLICATIONS_V2 + "?publicationId=123&size=10"
    ] = MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert (
        "w odpowiedzi z serwera PBN numer UID rekordu JUŻ ISTNIEJĄCEGO"
        in list(msg)[0].message
    )


@pytest.mark.django_db
def test_sprobuj_wyslac_do_pbn_przychodzi_inny_pbn_uid_dla_starego_rekordu(
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina: Wydawnictwo_Ciagle,
    pbn_client,
    rf,
    pbn_uczelnia,
):
    """Ten test sprawdza, jak zachowa się system w przypadku wysyłki nowego rekordu, gdy przyjdzie PBN UID
    takiego rekordu, który już istnieje"""

    req = rf.get("/")

    # To jest istniejące w bazie wydawnictwo ciągłe z PBN UID = MOCK_MONGO_ID ("123")
    publikacja = baker.make(Publication, pk=MOCK_MONGO_ID)

    # To jest wydawnictwo ciągłe, które ma PBN UID
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.pbn_uid = publikacja
    pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.save(update_fields=["pbn_uid"])

    # To jest odpowiedź z PBNu gdzie zwrotnie przyjdzie objectId = MOCK_MONGO_ID*2
    pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {
        "objectId": MOCK_MONGO_ID * 2
    }
    pbn_client.transport.return_values[
        PBN_GET_PUBLICATION_BY_ID_URL.format(id=MOCK_MONGO_ID * 2)
    ] = MOCK_RETURNED_MONGODB_DATA
    pbn_client.transport.return_values[PBN_GET_PUBLICATION_BY_ID_URL.format(id=456)] = (
        MOCK_RETURNED_MONGODB_DATA
    )
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_STATEMENTS + f"?publicationId={MOCK_MONGO_ID}&size=5120"
    ] = []
    pbn_client.transport.return_values[
        PBN_GET_INSTITUTION_PUBLICATIONS_V2 + "?publicationId=123123&size=10"
    ] = MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA

    with middleware(req):
        sprobuj_wyslac_do_pbn_gui(
            req, pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client=pbn_client
        )

    msg = get_messages(req)
    assert "Wg danych z PBN zmodyfikowano PBN UID tego rekordu " in list(msg)[0].message

1	import pytest	×
2	from model_bakery import baker	×
3
NEW 4	from fixtures import MOCK_MONGO_ID, MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA	×
5	from fixtures.pbn_api import MOCK_RETURNED_MONGODB_DATA	×
6	from pbn_api.adapters.wydawnictwo import WydawnictwoPBNAdapter	×
7	from pbn_api.client import (	×
8	PBN_GET_INSTITUTION_STATEMENTS,
9	PBN_GET_PUBLICATION_BY_ID_URL,
10	PBN_POST_PUBLICATIONS_URL,
11	)
NEW 12	from pbn_api.const import PBN_GET_INSTITUTION_PUBLICATIONS_V2	×
13	from pbn_api.exceptions import AccessDeniedException	×
14	from pbn_api.models import Publication, SentData	×
15	from pbn_api.tests.utils import middleware	×
16
17	from django.contrib.messages import get_messages	×
18
19	from bpp.admin.helpers.pbn_api.gui import sprobuj_wyslac_do_pbn_gui	×
20	from bpp.models import Charakter_Formalny, Wydawnictwo_Ciagle	×
21
22
23	@pytest.mark.django_db	×
24	def test_sprobuj_wyslac_do_pbn_charakter_zly(	×
25	rf,
26	pbn_wydawnictwo_zwarte,
27	):
28	req = rf.get("/")	×
29
30	pbn_wydawnictwo_zwarte.charakter_formalny = baker.make(	×
31	Charakter_Formalny, rodzaj_pbn=None
32	)
33
34	with middleware(req):	×
35	sprobuj_wyslac_do_pbn_gui(req, pbn_wydawnictwo_zwarte)	×
36
37	msg = get_messages(req)	×
38
39	assert "nie będzie eksportowany do PBN" in list(msg)[0].message	×
40
41
42	@pytest.mark.django_db	×
43	def test_sprobuj_wyslac_do_pbn_uczelnia_brak_obiektu(	×
44	rf, pbn_wydawnictwo_zwarte_z_charakterem
45	):
46	req = rf.get("/")	×
47
48	with middleware(req):	×
49	sprobuj_wyslac_do_pbn_gui(req, pbn_wydawnictwo_zwarte_z_charakterem)	×
50
51	msg = get_messages(req)	×
52
53	assert 'w systemie brakuje obiektu "Uczelnia"' in list(msg)[0].message	×
54
55
56	@pytest.mark.django_db	×
57	def test_sprobuj_wyslac_do_pbn_uczelnia_integracja_wylaczona(	×
58	rf, pbn_wydawnictwo_zwarte_z_charakterem, uczelnia
59	):
60	req = rf.get("/")	×
61
62	uczelnia.pbn_integracja = False	×
63	uczelnia.pbn_aktualizuj_na_biezaco = False	×
64	uczelnia.save()	×
65
66	with middleware(req):	×
67	sprobuj_wyslac_do_pbn_gui(req, pbn_wydawnictwo_zwarte_z_charakterem)	×
68
69	msg = get_messages(req)	×
70	assert len(msg) == 1	×
71
72
73	@pytest.mark.django_db	×
74	def test_sprobuj_wyslac_do_pbn_dane_juz_wyslane(	×
75	pbn_wydawnictwo_zwarte_z_charakterem, pbn_uczelnia, pbn_client, rf
76	):
77	SentData.objects.updated(	×
78	pbn_wydawnictwo_zwarte_z_charakterem,
79	WydawnictwoPBNAdapter(pbn_wydawnictwo_zwarte_z_charakterem).pbn_get_json(),
80	)
81
82	req = rf.get("/")	×
83
84	with middleware(req):	×
85	sprobuj_wyslac_do_pbn_gui(	×
86	req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
87	)
88
89	msg = get_messages(req)	×
90	assert "Identyczne dane rekordu" in list(msg)[0].message	×
91
92
93	@pytest.mark.django_db	×
94	def test_sprobuj_wyslac_do_pbn_access_denied(	×
95	pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
96	):
97	req = rf.get("/")	×
98
NEW 99	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = (	×
100	AccessDeniedException(url="foo", content="testujemy")
101	)
102
103	with middleware(req):	×
104	sprobuj_wyslac_do_pbn_gui(	×
105	req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
106	)
107
108	msg = get_messages(req)	×
109	assert "Brak dostępu --" in list(msg)[0].message	×
110
111
112	@pytest.mark.django_db	×
113	def test_sprobuj_wyslac_do_pbn_brak_prawidlowej_odpowiedzi(	×
114	pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
115	):
116	req = rf.get("/")	×
117
118	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {	×
119	"elem": "coz, jakby nie. "
120	}
121
122	with middleware(req):	×
123	sprobuj_wyslac_do_pbn_gui(	×
124	req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
125	)
126
127	msg = get_messages(req)	×
128	assert "nie odpowiedział prawidłowym PBN UID" in list(msg)[0].message	×
129
130
131	@pytest.mark.django_db	×
132	def test_sprobuj_wyslac_do_pbn_inny_exception(	×
133	pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
134	):
135	req = rf.get("/")	×
136
137	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = ZeroDivisionError	×
138
139	with middleware(req):	×
140	sprobuj_wyslac_do_pbn_gui(	×
141	req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
142	)
143
144	msg = get_messages(req)	×
145	assert "Nie można zsynchronizować" in list(msg)[0].message	×
146
147
148	@pytest.mark.django_db	×
149	def test_sprobuj_wyslac_do_pbn_inny_blad(	×
150	pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
151	):
152	req = rf.get("/")	×
153
154	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = Exception("test")	×
155
156	with middleware(req):	×
157	sprobuj_wyslac_do_pbn_gui(	×
158	req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
159	)
160
161	msg = get_messages(req)	×
162	assert "Nie można zsynchronizować" in list(msg)[0].message	×
163
164
165	@pytest.mark.django_db	×
166	def test_sprobuj_wyslac_do_pbn_sukces(	×
167	pbn_wydawnictwo_zwarte_z_charakterem, pbn_client, rf, pbn_uczelnia
168	):
169	req = rf.get("/")	×
170
171	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {"objectId": "123"}	×
172	pbn_client.transport.return_values[	×
173	PBN_GET_PUBLICATION_BY_ID_URL.format(id="123")
174	] = MOCK_RETURNED_MONGODB_DATA
NEW 175	pbn_client.transport.return_values[	×
176	PBN_GET_PUBLICATION_BY_ID_URL.format(id="456")
177	] = MOCK_RETURNED_MONGODB_DATA
UNCOV 178	pbn_client.transport.return_values[	×
179	PBN_GET_INSTITUTION_STATEMENTS + "?publicationId=123&size=5120"
180	] = []
NEW 181	pbn_client.transport.return_values[	×
182	PBN_GET_INSTITUTION_PUBLICATIONS_V2 + "?publicationId=123&size=10"
183	] = MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA
184
185	with middleware(req):	×
186	sprobuj_wyslac_do_pbn_gui(	×
187	req, pbn_wydawnictwo_zwarte_z_charakterem, pbn_client=pbn_client
188	)
189
190	msg = get_messages(req)	×
191	assert "zostały zaktualizowane" in list(msg)[0].message	×
192
193
194	@pytest.mark.django_db	×
195	def test_sprobuj_wyslac_do_pbn_ostrzezenie_brak_dyscypliny_autora(	×
196	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client, rf, pbn_uczelnia
197	):
198	req = rf.get("/")	×
199
200	for wza in pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.autorzy_set.all():	×
201	wza.afiliuje = True	×
202	wza.przypieta = True	×
203	wza.save()	×
204
205	jednostka = wza.jednostka	×
206	jednostka.skupia_pracownikow = True	×
207	jednostka.save()	×
208
209	autor = wza.autor	×
210	autor.pbn_uid = None	×
211	autor.pbn_uid_id = None	×
212	autor.save()	×
213
214	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {"objectId": "123"}	×
215	pbn_client.transport.return_values[	×
216	PBN_GET_PUBLICATION_BY_ID_URL.format(id="123")
217	] = MOCK_RETURNED_MONGODB_DATA
218	pbn_client.transport.return_values[	×
219	PBN_GET_INSTITUTION_STATEMENTS + "?publicationId=123&size=5120"
220	] = []
221
222	with middleware(req):	×
223	sprobuj_wyslac_do_pbn_gui(	×
224	req, pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client=pbn_client
225	)
226
227	msg = get_messages(req)	×
228	assert "nie zostanie oświadczona" in list(msg)[0].message	×
229
230
231	@pytest.mark.django_db	×
232	def test_sprobuj_wyslac_do_pbn_przychodzi_istniejacy_pbn_uid_dla_nowego_rekordu(	×
233	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina: Wydawnictwo_Ciagle,
234	pbn_client,
235	rf,
236	pbn_uczelnia,
237	):
238	"""Ten test sprawdza, jak zachowa się system w przypadku wysyłki nowego rekordu, gdy przyjdzie PBN UID
239	takiego rekordu, który już istnieje"""
240
241	req = rf.get("/")	×
242
243	# To jest istniejące w bazie wydawnictwo ciągłe z PBN UID = MOCK_MONGO_ID ("123")
244	publikacja = baker.make(Publication, pk=MOCK_MONGO_ID)	×
245	istniejace_wydawnictwo_ciagle = baker.make( # noqa	×
246	Wydawnictwo_Ciagle, pbn_uid=publikacja
247	)
248
249	# To jest NOWO WYSYŁANE wydawnictwo ciągłe, które nie ma PBN UID
250	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.pbn_uid = None	×
251	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.save(update_fields=["pbn_uid"])	×
252
253	# To jest odpowiedź z PBNu gdzie zwrotnie przyjdzie objectId = MOCK_MONGO_ID
254	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {	×
255	"objectId": MOCK_MONGO_ID
256	}
257	pbn_client.transport.return_values[	×
258	PBN_GET_PUBLICATION_BY_ID_URL.format(id=MOCK_MONGO_ID)
259	] = MOCK_RETURNED_MONGODB_DATA
NEW 260	pbn_client.transport.return_values[	×
261	PBN_GET_PUBLICATION_BY_ID_URL.format(id=MOCK_MONGO_ID)
262	] = MOCK_RETURNED_MONGODB_DATA
NEW 263	pbn_client.transport.return_values[PBN_GET_PUBLICATION_BY_ID_URL.format(id=456)] = (	×
264	MOCK_RETURNED_MONGODB_DATA
265	)
UNCOV 266	pbn_client.transport.return_values[	×
267	PBN_GET_INSTITUTION_STATEMENTS + f"?publicationId={MOCK_MONGO_ID}&size=5120"
268	] = []
NEW 269	pbn_client.transport.return_values[	×
270	PBN_GET_INSTITUTION_PUBLICATIONS_V2 + "?publicationId=123&size=10"
271	] = MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA
272
273	with middleware(req):	×
274	sprobuj_wyslac_do_pbn_gui(	×
275	req, pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client=pbn_client
276	)
277
278	msg = get_messages(req)	×
279	assert (	×
280	"w odpowiedzi z serwera PBN numer UID rekordu JUŻ ISTNIEJĄCEGO"
281	in list(msg)[0].message
282	)
283
284
285	@pytest.mark.django_db	×
286	def test_sprobuj_wyslac_do_pbn_przychodzi_inny_pbn_uid_dla_starego_rekordu(	×
287	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina: Wydawnictwo_Ciagle,
288	pbn_client,
289	rf,
290	pbn_uczelnia,
291	):
292	"""Ten test sprawdza, jak zachowa się system w przypadku wysyłki nowego rekordu, gdy przyjdzie PBN UID
293	takiego rekordu, który już istnieje"""
294
295	req = rf.get("/")	×
296
297	# To jest istniejące w bazie wydawnictwo ciągłe z PBN UID = MOCK_MONGO_ID ("123")
298	publikacja = baker.make(Publication, pk=MOCK_MONGO_ID)	×
299
300	# To jest wydawnictwo ciągłe, które ma PBN UID
301	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.pbn_uid = publikacja	×
302	pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina.save(update_fields=["pbn_uid"])	×
303
304	# To jest odpowiedź z PBNu gdzie zwrotnie przyjdzie objectId = MOCK_MONGO_ID*2
305	pbn_client.transport.return_values[PBN_POST_PUBLICATIONS_URL] = {	×
306	"objectId": MOCK_MONGO_ID * 2
307	}
308	pbn_client.transport.return_values[	×
309	PBN_GET_PUBLICATION_BY_ID_URL.format(id=MOCK_MONGO_ID * 2)
310	] = MOCK_RETURNED_MONGODB_DATA
NEW 311	pbn_client.transport.return_values[PBN_GET_PUBLICATION_BY_ID_URL.format(id=456)] = (	×
312	MOCK_RETURNED_MONGODB_DATA
313	)
UNCOV 314	pbn_client.transport.return_values[	×
315	PBN_GET_INSTITUTION_STATEMENTS + f"?publicationId={MOCK_MONGO_ID}&size=5120"
316	] = []
NEW 317	pbn_client.transport.return_values[	×
318	PBN_GET_INSTITUTION_PUBLICATIONS_V2 + "?publicationId=123123&size=10"
319	] = MOCK_RETURNED_INSTITUTION_PUBLICATION_V2_DATA
320
321	with middleware(req):	×
322	sprobuj_wyslac_do_pbn_gui(	×
323	req, pbn_wydawnictwo_zwarte_z_autorem_z_dyscyplina, pbn_client=pbn_client
324	)
325
326	msg = get_messages(req)	×
327	assert "Wg danych z PBN zmodyfikowano PBN UID tego rekordu " in list(msg)[0].message	×

iplweb / bpp / 2314acb3-6be8-4e0c-96b0-e8b120678896

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