9ca9114a-93fa-4251-97c0-209b41c87924

Committed 20 Aug 2025 09:25PM UTC coverage: 46.283% (+1.3%) from 44.985%

Build # 9ca9114a-93fa-4251-97c0-209b41c87924

Build Type

push

circleci

Committed by

mpasternak

Commit Message

Merge branch 'release/v202508.1194'

Run Details

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

850 existing lines in 53 files now uncovered.

17649 of 38133 relevant lines covered (46.28%)

1.18 hits per line

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

0.0

src/bpp/tests/tests_legacy/test_cache.py

import datetime

import pytest
from django.conf import settings
from django.core.management import call_command
from django.test import TestCase
from model_bakery import baker

from bpp.models import (
    Charakter_Formalny,
    Jednostka,
    Jezyk,
    Patent,
    Patent_Autor,
    Praca_Doktorska,
    Praca_Habilitacyjna,
    Status_Korekty,
    Typ_KBN,
    Typ_Odpowiedzialnosci,
    Tytul,
    Uczelnia,
    Wydawnictwo_Ciagle_Autor,
    Wydzial,
    Zrodlo,
    Zrodlo_Informacji,
)
from bpp.models.cache import Autorzy, AutorzyView, Rekord
from bpp.tests.tests_legacy.test_reports.util import autor, ciagle, zwarte
from bpp.tests.util import any_autor, any_ciagle

CHANGED = "foo-123-changed"


def ramka(msg):
    print("+" + ("-" * 78) + "+")
    print("+ " + msg)
    print("+" + ("-" * 78) + "+")


def clean_dict(ret):
    del ret["ostatnio_zmieniony"]
    del ret["tytul_oryginalny_sort"]
    return ret


class LoadFixturesMixin:
    def loadFixtures(self):
        for db_name in self._databases_names(include_mirrors=False):
            if hasattr(self, "fixtures"):
                call_command(
                    "loaddata",
                    *self.fixtures,
                    **{"verbosity": 0, "database": db_name, "skip_validation": True},
                )


class TestCacheMixin:
    # fixtures = [
    #     'typ_odpowiedzialnosci.json', 'tytul.json', 'zrodlo_informacji.json',
    #     'charakter_formalny.json', 'status_korekty.json', 'typ_kbn.json',
    #     'jezyk.json']

    def setUp(self):
        self.maxDiff = None

        aut = Typ_Odpowiedzialnosci.objects.get(skrot="aut.")
        self.typ_odpowiedzialnosci = aut

        self.uczelnia = baker.make(Uczelnia)
        self.wydzial = baker.make(Wydzial, uczelnia=self.uczelnia)
        self.j = baker.make(
            Jednostka, nazwa="Foo Bar", uczelnia=self.uczelnia, wydzial=self.wydzial
        )

        self.a = autor(self.j)
        self.a.nazwisko = "Kowalski"
        self.a.imiona = "Jan"
        self.a.tytul = Tytul.objects.get(skrot="dr")
        self.a.save()

        wspolne_dane = dict(
            adnotacje="adnotacje",
            informacja_z=Zrodlo_Informacji.objects.all()[0],
            status_korekty=Status_Korekty.objects.all()[0],
            rok=2000,
            www="http://127.0.0.1/",
            recenzowana=True,
            impact_factor=5,
            punkty_kbn=5,
            index_copernicus=5,
            punktacja_wewnetrzna=5,
            weryfikacja_punktacji=True,
            typ_kbn=Typ_KBN.objects.all()[0],
            jezyk=Jezyk.objects.all()[0],
            informacje="informacje",
            szczegoly="szczegoly",
            uwagi="uwagi",
            slowa_kluczowe="slowa kluczowe",
        )

        zwarte_dane = dict(
            miejsce_i_rok="Lublin 2012",
            wydawnictwo="Pholium",
            redakcja="Redkacja",
            isbn="isbn",
            e_isbn="e_isbn",
            tytul="tytul",
        )

        self.z = zwarte(
            self.a,
            self.j,
            aut,
            tytul_oryginalny="zwarte",
            liczba_znakow_wydawniczych=40000,
            charakter_formalny=Charakter_Formalny.objects.all()[0],
            **dict(list(zwarte_dane.items()) + list(wspolne_dane.items())),
        )

        self.zr = baker.make(Zrodlo, nazwa="Zrodlo")

        self.c = ciagle(
            self.a,
            self.j,
            tytul_oryginalny="ciągłe",
            zrodlo=self.zr,
            tytul="tytul",
            issn="issn",
            e_issn="e_issn",
            charakter_formalny=Charakter_Formalny.objects.all()[0],
            **wspolne_dane,
        )
        self.assertEqual(Wydawnictwo_Ciagle_Autor.objects.all().count(), 1)

        wca = Wydawnictwo_Ciagle_Autor.objects.all()[0]
        wca.typ_odpowiedzialnosci = self.typ_odpowiedzialnosci
        wca.save()

        settings.BPP_CACHE_ENABLED = True

        # Doktorat i habilitacja

        doktorat_kw = dict(list(zwarte_dane.items()) + list(wspolne_dane.items()))

        self.d = baker.make(
            Praca_Doktorska,
            tytul_oryginalny="doktorat",
            autor=self.a,
            jednostka=self.j,
            **doktorat_kw,
        )

        self.h = baker.make(
            Praca_Habilitacyjna,
            tytul_oryginalny="habilitacja",
            autor=self.a,
            jednostka=self.j,
            **doktorat_kw,
        )

        # Patent

        Charakter_Formalny.objects.get(skrot="PAT")

        for elem in ["typ_kbn", "jezyk"]:
            del wspolne_dane[elem]

        self.p = baker.make(
            Patent,
            tytul_oryginalny="patent",
            numer_zgloszenia="100",
            data_decyzji=datetime.date(2012, 1, 1),
            **wspolne_dane,
        )

        Patent_Autor.objects.create(
            autor=self.a,
            jednostka=self.j,
            rekord=self.p,
            typ_odpowiedzialnosci=aut,
            zapisany_jako="Kowalski",
        )

        self.wszystkie_modele = [self.d, self.h, self.p, self.c, self.z]


class TestCacheRebuildBug(TestCase):
    def test_liczba_znakow_bug(self):
        Rekord.objects.full_refresh()
        self.assertEqual(Rekord.objects.all().count(), 0)

        any_ciagle(tytul="foo", liczba_znakow_wydawniczych=31337)
        Rekord.objects.full_refresh()

        self.assertEqual(Rekord.objects.all().count(), 1)
        self.assertEqual(Rekord.objects.all()[0].tytul, "foo")
        self.assertEqual(Rekord.objects.all()[0].liczba_znakow_wydawniczych, 31337)


class TestCacheSimple(TestCacheMixin, TestCase):
    def setUp(self):
        Typ_Odpowiedzialnosci.objects.get_or_create(skrot="aut.", nazwa="autor")
        Charakter_Formalny.objects.get_or_create(skrot="PAT")
        for skrot, nazwa in [("ang.", "angielski"), ("fr.", "francuski")]:
            Jezyk.objects.get_or_create(skrot=skrot, nazwa=nazwa)
        for klass in [Typ_KBN, Zrodlo_Informacji, Status_Korekty]:
            baker.make(klass)

        super().setUp()

    def test_get_original_object(self):
        Rekord.objects.full_refresh()
        for model in self.wszystkie_modele:
            c = Rekord.objects.get_original(model)
            self.assertEqual(c.original, model)

    def test_cache_triggers(self):
        T1 = "OMG ROXX"
        T2 = "LOL"

        for model in self.wszystkie_modele:
            model.tytul_oryginalny = T1
            model.save()
            self.assertEqual(Rekord.objects.get_original(model).tytul_oryginalny, T1)

            model.tytul_oryginalny = T2
            model.save()
            self.assertEqual(Rekord.objects.get_original(model).tytul_oryginalny, T2)

    def assertInstanceEquals(self, instance, values_dict):
        for key, value in list(values_dict.items()):
            instance_value = getattr(instance, key)
            self.assertEqual(
                instance_value,
                value,
                msg=f"key={key}, {value}!={instance_value}",
            )

    def test_tytul_sorted_version(self):
        for elem in [self.d, self.h, self.c, self.z]:  # self.p]:
            elem.tytul_oryginalny = "The 'APPROACH'"
            elem.jezyk = Jezyk.objects.get(skrot="ang.")
            elem.save()

            self.assertEqual(
                Rekord.objects.get_original(elem).tytul_oryginalny_sort, "approach"
            )

            elem.tytul_oryginalny = "le 'test'"
            elem.jezyk = Jezyk.objects.get(skrot="fr.")
            elem.save()

            # elem = elem.__class__.objects.get(pk=elem.pk) #reload
            # self.assertEquals(elem.tytul_oryginalny_sort, "test")

            self.assertEqual(
                Rekord.objects.get_original(elem).tytul_oryginalny_sort, "test"
            )


class TestCacheZapisani(LoadFixturesMixin, TestCase):
    fixtures = ["typ_odpowiedzialnosci.json"]

    def test_zapisani_wielu(self):
        aut = any_autor("Kowalski", "Jan")
        aut2 = any_autor("Nowak", "Jan")

        baker.make(Uczelnia)
        jed = baker.make(Jednostka)
        wyd = any_ciagle(tytul_oryginalny="Wydawnictwo ciagle")

        for kolejnosc, autorx in enumerate([aut, aut2]):
            Wydawnictwo_Ciagle_Autor.objects.create(
                autor=autorx,
                jednostka=jed,
                rekord=wyd,
                typ_odpowiedzialnosci_id=1,
                zapisany_jako="FOO BAR",
                kolejnosc=kolejnosc,
            )

        Rekord.objects.full_refresh()
        c = Rekord.objects.get_original(wyd)

        # Upewnij się, że w przypadku pracy z wieloma autorami do cache
        # zapisywane jest nie nazwisko z pól 'zapisany_jako' w bazie danych,
        # a oryginalne
        self.assertEqual(
            c.opis_bibliograficzny_autorzy_cache, ["Kowalski Jan", "Nowak Jan"]
        )

        # Upewnij się, że pole 'opis_bibliograficzny_zapisani_autorzy_cache'
        # zapisywane jest prawidłowo
        self.assertEqual(
            c.opis_bibliograficzny_zapisani_autorzy_cache, "FOO BAR, FOO BAR"
        )

    def test_zapisani_jeden(self):
        aut = any_autor("Kowalski", "Jan")
        baker.make(Uczelnia)
        dok = baker.make(Praca_Doktorska, tytul_oryginalny="Doktorat", autor=aut)

        Rekord.objects.full_refresh()
        c = Rekord.objects.get_original(dok)

        # Upewnij się, że w przypadku pracy z jednym autorem do cache
        # zapisywana jest prawidłowa wartość
        self.assertEqual(c.opis_bibliograficzny_autorzy_cache, ["Kowalski Jan"])

        self.assertEqual(c.opis_bibliograficzny_zapisani_autorzy_cache, "Kowalski Jan")


@pytest.mark.django_db
def test_MinimalCachingProblem_tworzenie(
    statusy_korekt, jezyki, typy_odpowiedzialnosci
):
    def foo():
        j = baker.make(Jednostka)
        a = any_autor()

        assert Autorzy.objects.all().count() == 0

        c = any_ciagle(impact_factor=5, punktacja_wewnetrzna=0)
        assert Rekord.objects.all().count() == 1

        c.dodaj_autora(a, j)

        assert AutorzyView.objects.all().count() == 1
        assert Autorzy.objects.all().count() == 1

    foo()


@pytest.mark.django_db
def test_MinimalCachingProblem_usuwanie(statusy_korekt, jezyki, typy_odpowiedzialnosci):
    def foo():
        j = baker.make(Jednostka)
        a = any_autor()

        assert Autorzy.objects.all().count() == 0

        c = any_ciagle(impact_factor=5, punktacja_wewnetrzna=0)
        assert Rekord.objects.all().count() == 1

        c.dodaj_autora(a, j)

        c.delete()

        assert AutorzyView.objects.all().count() == 0
        assert Autorzy.objects.all().count() == 0

    foo()

UNCOV 1	import datetime	×
2
UNCOV 3	import pytest	×
UNCOV 4	from django.conf import settings	×
UNCOV 5	from django.core.management import call_command	×
UNCOV 6	from django.test import TestCase	×
UNCOV 7	from model_bakery import baker	×
8
UNCOV 9	from bpp.models import (	×
10	Charakter_Formalny,
11	Jednostka,
12	Jezyk,
13	Patent,
14	Patent_Autor,
15	Praca_Doktorska,
16	Praca_Habilitacyjna,
17	Status_Korekty,
18	Typ_KBN,
19	Typ_Odpowiedzialnosci,
20	Tytul,
21	Uczelnia,
22	Wydawnictwo_Ciagle_Autor,
23	Wydzial,
24	Zrodlo,
25	Zrodlo_Informacji,
26	)
UNCOV 27	from bpp.models.cache import Autorzy, AutorzyView, Rekord	×
UNCOV 28	from bpp.tests.tests_legacy.test_reports.util import autor, ciagle, zwarte	×
UNCOV 29	from bpp.tests.util import any_autor, any_ciagle	×
30
UNCOV 31	CHANGED = "foo-123-changed"	×
32
33
UNCOV 34	def ramka(msg):	×
35	print("+" + ("-" * 78) + "+")	×
36	print("+ " + msg)	×
37	print("+" + ("-" * 78) + "+")	×
38
39
UNCOV 40	def clean_dict(ret):	×
41	del ret["ostatnio_zmieniony"]	×
42	del ret["tytul_oryginalny_sort"]	×
43	return ret	×
44
45
UNCOV 46	class LoadFixturesMixin:	×
UNCOV 47	def loadFixtures(self):	×
48	for db_name in self._databases_names(include_mirrors=False):	×
49	if hasattr(self, "fixtures"):	×
50	call_command(	×
51	"loaddata",
52	*self.fixtures,
53	**{"verbosity": 0, "database": db_name, "skip_validation": True},
54	)
55
56
UNCOV 57	class TestCacheMixin:	×
58	# fixtures = [
59	# 'typ_odpowiedzialnosci.json', 'tytul.json', 'zrodlo_informacji.json',
60	# 'charakter_formalny.json', 'status_korekty.json', 'typ_kbn.json',
61	# 'jezyk.json']
62
UNCOV 63	def setUp(self):	×
64	self.maxDiff = None	×
65
66	aut = Typ_Odpowiedzialnosci.objects.get(skrot="aut.")	×
67	self.typ_odpowiedzialnosci = aut	×
68
69	self.uczelnia = baker.make(Uczelnia)	×
70	self.wydzial = baker.make(Wydzial, uczelnia=self.uczelnia)	×
71	self.j = baker.make(	×
72	Jednostka, nazwa="Foo Bar", uczelnia=self.uczelnia, wydzial=self.wydzial
73	)
74
75	self.a = autor(self.j)	×
76	self.a.nazwisko = "Kowalski"	×
77	self.a.imiona = "Jan"	×
78	self.a.tytul = Tytul.objects.get(skrot="dr")	×
79	self.a.save()	×
80
81	wspolne_dane = dict(	×
82	adnotacje="adnotacje",
83	informacja_z=Zrodlo_Informacji.objects.all()[0],
84	status_korekty=Status_Korekty.objects.all()[0],
85	rok=2000,
86	www="http://127.0.0.1/",
87	recenzowana=True,
88	impact_factor=5,
89	punkty_kbn=5,
90	index_copernicus=5,
91	punktacja_wewnetrzna=5,
92	weryfikacja_punktacji=True,
93	typ_kbn=Typ_KBN.objects.all()[0],
94	jezyk=Jezyk.objects.all()[0],
95	informacje="informacje",
96	szczegoly="szczegoly",
97	uwagi="uwagi",
98	slowa_kluczowe="slowa kluczowe",
99	)
100
101	zwarte_dane = dict(	×
102	miejsce_i_rok="Lublin 2012",
103	wydawnictwo="Pholium",
104	redakcja="Redkacja",
105	isbn="isbn",
106	e_isbn="e_isbn",
107	tytul="tytul",
108	)
109
110	self.z = zwarte(	×
111	self.a,
112	self.j,
113	aut,
114	tytul_oryginalny="zwarte",
115	liczba_znakow_wydawniczych=40000,
116	charakter_formalny=Charakter_Formalny.objects.all()[0],
117	**dict(list(zwarte_dane.items()) + list(wspolne_dane.items())),
118	)
119
120	self.zr = baker.make(Zrodlo, nazwa="Zrodlo")	×
121
122	self.c = ciagle(	×
123	self.a,
124	self.j,
125	tytul_oryginalny="ciągłe",
126	zrodlo=self.zr,
127	tytul="tytul",
128	issn="issn",
129	e_issn="e_issn",
130	charakter_formalny=Charakter_Formalny.objects.all()[0],
131	**wspolne_dane,
132	)
133	self.assertEqual(Wydawnictwo_Ciagle_Autor.objects.all().count(), 1)	×
134
135	wca = Wydawnictwo_Ciagle_Autor.objects.all()[0]	×
136	wca.typ_odpowiedzialnosci = self.typ_odpowiedzialnosci	×
137	wca.save()	×
138
139	settings.BPP_CACHE_ENABLED = True	×
140
141	# Doktorat i habilitacja
142
143	doktorat_kw = dict(list(zwarte_dane.items()) + list(wspolne_dane.items()))	×
144
145	self.d = baker.make(	×
146	Praca_Doktorska,
147	tytul_oryginalny="doktorat",
148	autor=self.a,
149	jednostka=self.j,
150	**doktorat_kw,
151	)
152
153	self.h = baker.make(	×
154	Praca_Habilitacyjna,
155	tytul_oryginalny="habilitacja",
156	autor=self.a,
157	jednostka=self.j,
158	**doktorat_kw,
159	)
160
161	# Patent
162
163	Charakter_Formalny.objects.get(skrot="PAT")	×
164
165	for elem in ["typ_kbn", "jezyk"]:	×
166	del wspolne_dane[elem]	×
167
168	self.p = baker.make(	×
169	Patent,
170	tytul_oryginalny="patent",
171	numer_zgloszenia="100",
172	data_decyzji=datetime.date(2012, 1, 1),
173	**wspolne_dane,
174	)
175
176	Patent_Autor.objects.create(	×
177	autor=self.a,
178	jednostka=self.j,
179	rekord=self.p,
180	typ_odpowiedzialnosci=aut,
181	zapisany_jako="Kowalski",
182	)
183
184	self.wszystkie_modele = [self.d, self.h, self.p, self.c, self.z]	×
185
186
UNCOV 187	class TestCacheRebuildBug(TestCase):	×
UNCOV 188	def test_liczba_znakow_bug(self):	×
189	Rekord.objects.full_refresh()	×
190	self.assertEqual(Rekord.objects.all().count(), 0)	×
191
192	any_ciagle(tytul="foo", liczba_znakow_wydawniczych=31337)	×
193	Rekord.objects.full_refresh()	×
194
195	self.assertEqual(Rekord.objects.all().count(), 1)	×
196	self.assertEqual(Rekord.objects.all()[0].tytul, "foo")	×
197	self.assertEqual(Rekord.objects.all()[0].liczba_znakow_wydawniczych, 31337)	×
198
199
UNCOV 200	class TestCacheSimple(TestCacheMixin, TestCase):	×
UNCOV 201	def setUp(self):	×
202	Typ_Odpowiedzialnosci.objects.get_or_create(skrot="aut.", nazwa="autor")	×
203	Charakter_Formalny.objects.get_or_create(skrot="PAT")	×
204	for skrot, nazwa in [("ang.", "angielski"), ("fr.", "francuski")]:	×
205	Jezyk.objects.get_or_create(skrot=skrot, nazwa=nazwa)	×
206	for klass in [Typ_KBN, Zrodlo_Informacji, Status_Korekty]:	×
207	baker.make(klass)	×
208
209	super().setUp()	×
210
UNCOV 211	def test_get_original_object(self):	×
212	Rekord.objects.full_refresh()	×
213	for model in self.wszystkie_modele:	×
214	c = Rekord.objects.get_original(model)	×
215	self.assertEqual(c.original, model)	×
216
UNCOV 217	def test_cache_triggers(self):	×
218	T1 = "OMG ROXX"	×
219	T2 = "LOL"	×
220
221	for model in self.wszystkie_modele:	×
222	model.tytul_oryginalny = T1	×
223	model.save()	×
224	self.assertEqual(Rekord.objects.get_original(model).tytul_oryginalny, T1)	×
225
226	model.tytul_oryginalny = T2	×
227	model.save()	×
228	self.assertEqual(Rekord.objects.get_original(model).tytul_oryginalny, T2)	×
229
UNCOV 230	def assertInstanceEquals(self, instance, values_dict):	×
231	for key, value in list(values_dict.items()):	×
232	instance_value = getattr(instance, key)	×
233	self.assertEqual(	×
234	instance_value,
235	value,
236	msg=f"key={key}, {value}!={instance_value}",
237	)
238
UNCOV 239	def test_tytul_sorted_version(self):	×
240	for elem in [self.d, self.h, self.c, self.z]: # self.p]:	×
241	elem.tytul_oryginalny = "The 'APPROACH'"	×
242	elem.jezyk = Jezyk.objects.get(skrot="ang.")	×
243	elem.save()	×
244
245	self.assertEqual(	×
246	Rekord.objects.get_original(elem).tytul_oryginalny_sort, "approach"
247	)
248
249	elem.tytul_oryginalny = "le 'test'"	×
250	elem.jezyk = Jezyk.objects.get(skrot="fr.")	×
251	elem.save()	×
252
253	# elem = elem.__class__.objects.get(pk=elem.pk) #reload
254	# self.assertEquals(elem.tytul_oryginalny_sort, "test")
255
256	self.assertEqual(	×
257	Rekord.objects.get_original(elem).tytul_oryginalny_sort, "test"
258	)
259
260
UNCOV 261	class TestCacheZapisani(LoadFixturesMixin, TestCase):	×
UNCOV 262	fixtures = ["typ_odpowiedzialnosci.json"]	×
263
UNCOV 264	def test_zapisani_wielu(self):	×
265	aut = any_autor("Kowalski", "Jan")	×
266	aut2 = any_autor("Nowak", "Jan")	×
267
268	baker.make(Uczelnia)	×
269	jed = baker.make(Jednostka)	×
270	wyd = any_ciagle(tytul_oryginalny="Wydawnictwo ciagle")	×
271
272	for kolejnosc, autorx in enumerate([aut, aut2]):	×
273	Wydawnictwo_Ciagle_Autor.objects.create(	×
274	autor=autorx,
275	jednostka=jed,
276	rekord=wyd,
277	typ_odpowiedzialnosci_id=1,
278	zapisany_jako="FOO BAR",
279	kolejnosc=kolejnosc,
280	)
281
282	Rekord.objects.full_refresh()	×
283	c = Rekord.objects.get_original(wyd)	×
284
285	# Upewnij się, że w przypadku pracy z wieloma autorami do cache
286	# zapisywane jest nie nazwisko z pól 'zapisany_jako' w bazie danych,
287	# a oryginalne
288	self.assertEqual(	×
289	c.opis_bibliograficzny_autorzy_cache, ["Kowalski Jan", "Nowak Jan"]
290	)
291
292	# Upewnij się, że pole 'opis_bibliograficzny_zapisani_autorzy_cache'
293	# zapisywane jest prawidłowo
294	self.assertEqual(	×
295	c.opis_bibliograficzny_zapisani_autorzy_cache, "FOO BAR, FOO BAR"
296	)
297
UNCOV 298	def test_zapisani_jeden(self):	×
299	aut = any_autor("Kowalski", "Jan")	×
300	baker.make(Uczelnia)	×
301	dok = baker.make(Praca_Doktorska, tytul_oryginalny="Doktorat", autor=aut)	×
302
303	Rekord.objects.full_refresh()	×
304	c = Rekord.objects.get_original(dok)	×
305
306	# Upewnij się, że w przypadku pracy z jednym autorem do cache
307	# zapisywana jest prawidłowa wartość
308	self.assertEqual(c.opis_bibliograficzny_autorzy_cache, ["Kowalski Jan"])	×
309
310	self.assertEqual(c.opis_bibliograficzny_zapisani_autorzy_cache, "Kowalski Jan")	×
311
312
UNCOV 313	@pytest.mark.django_db	×
UNCOV 314	def test_MinimalCachingProblem_tworzenie(	×
315	statusy_korekt, jezyki, typy_odpowiedzialnosci
316	):
317	def foo():	×
318	j = baker.make(Jednostka)	×
319	a = any_autor()	×
320
321	assert Autorzy.objects.all().count() == 0	×
322
323	c = any_ciagle(impact_factor=5, punktacja_wewnetrzna=0)	×
324	assert Rekord.objects.all().count() == 1	×
325
326	c.dodaj_autora(a, j)	×
327
328	assert AutorzyView.objects.all().count() == 1	×
329	assert Autorzy.objects.all().count() == 1	×
330
331	foo()	×
332
333
UNCOV 334	@pytest.mark.django_db	×
UNCOV 335	def test_MinimalCachingProblem_usuwanie(statusy_korekt, jezyki, typy_odpowiedzialnosci):	×
336	def foo():	×
337	j = baker.make(Jednostka)	×
338	a = any_autor()	×
339
340	assert Autorzy.objects.all().count() == 0	×
341
342	c = any_ciagle(impact_factor=5, punktacja_wewnetrzna=0)	×
343	assert Rekord.objects.all().count() == 1	×
344
345	c.dodaj_autora(a, j)	×
346
347	c.delete()	×
348
349	assert AutorzyView.objects.all().count() == 0	×
350	assert Autorzy.objects.all().count() == 0	×
351
352	foo()	×

iplweb / bpp / 9ca9114a-93fa-4251-97c0-209b41c87924

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