def test_multi_user_success(self):
# Start the workflow with the first user
test_user = User.objects.get(username='******')
self.prepare_client('/multiuser/', user=test_user)
TaskInvitation.objects.filter(wf_name='multiuser').delete()
time.sleep(1)
with BlockSave(Message):
resp = self.client.post()
assert resp.json['msgbox']['title'] == settings.MESSAGES[
'lane_change_message_title']
# This user has the necessary permissions and relations, should be able to join the workflow
token, user = self.get_user_token('test_user2')
self.prepare_client('/multiuser/', user=user, token=token)
task_inv = TaskInvitation.objects.filter(wf_name='multiuser',
role=self.client.current.role)
assert task_inv.count() == 1
task_inv.delete()
time.sleep(1)
with BlockSave(Message):
resp = self.client.post()
assert resp.json['msgbox']['title'] == settings.MESSAGES[
'lane_change_message_title']
token, user = self.get_user_token('test_user')
self.prepare_client('/multiuser/', user=user, token=token)
task_inv = TaskInvitation.objects.filter(wf_name='multiuser',
role=self.client.current.role)
assert task_inv.count() == 1
task_inv.delete()
time.sleep(1)
def test_multi_user_owner_fail(self):
# Start the workflow with the first user
wf_name = '/multiuser/'
manager_user = User.objects.get(username='******')
self.prepare_client(wf_name, user=manager_user)
with BlockSave(Message):
self.client.post()
# This user has not the necessary permissions and relations,
# should not have join to workflow.
token, user = self.get_user_token('test_user3')
self.prepare_client(wf_name, user=user, token=token)
with pytest.raises(HTTPError):
self.client.post()
# This user has the necessary permissions and relations, should have join to workflow.
token, user = self.get_user_token('test_user2')
self.prepare_client(wf_name, user=user, token=token)
resp = self.client.post()
assert resp.json['msgbox']['title'] == settings.MESSAGES[
'lane_change_message_title']
time.sleep(1)
TaskInvitation.objects.filter(wf_name='multiuser').delete()
def danisman_kaydet(self):
"""
Seçilen öğretim elemanları danışman olarak kaydeder.
"""
yoksis_no = self.current.task_data['unit_yoksis_no']
unit = Unit.objects.get(yoksis_no=yoksis_no)
donem = Donem.guncel_donem()
danismanlar = self.current.input['form']['Okutmanlar']
self.current.task_data['okutmanlar'] = []
with BlockSave(DonemDanisman):
for danisman in danismanlar:
if danisman['secim']:
key = danisman['key']
okutman = Okutman.objects.get(key)
donem_danisman, is_new = DonemDanisman.objects.get_or_create(okutman=okutman, donem=donem,
bolum=unit)
if is_new:
user = okutman.personel.user if okutman.personel.user else okutman.harici_okutman.user
abstract_role = AbstractRole.objects.get("DANISMAN")
unit = Unit.objects.get(yoksis_no=self.current.task_data['unit_yoksis_no'])
role = Role(user=user, unit=unit, abstract_role=abstract_role)
role.save()
self.current.task_data['okutmanlar'].append(okutman.key)
def subelendirme_kaydet(self):
"""Şubelendirme Kaydet
Şubelendirme formundan gelen dataları kaydeder.
"""
sb = self.input['form']['Subeler']
ders = self.current.task_data['ders_key']
mevcut_subeler = Sube.objects.filter(ders_id=ders)
with BlockSave(Sube):
for s in sb:
okutman = s['okutman']
kontenjan = s['kontenjan']
ad = s['ad']
dis_kontenjan = s['dis_kontenjan']
donem = Donem.guncel_donem()
sube, is_new = Sube.objects.get_or_create(
okutman_id=okutman,
ders_id=ders,
kontenjan=kontenjan,
ad=ad,
dis_kontenjan=dis_kontenjan,
donem=donem)
# mevcut_subelerden cikar
mevcut_subeler = list(set(mevcut_subeler) - {sube})
if is_new:
self.bilgilendirme_mesaji_yolla(sube)
else:
self.current.task_data['yeni_okutmanlar'] = []
# çıkarılan şube
with BlockDelete(Sube):
for s in mevcut_subeler:
self.bilgilendirme_mesaji_yolla(s)
s.delete()
def get_or_create_direct_channel(cls, initiator_key, receiver_key):
"""
Creates a direct messaging channel between two user
Args:
initiator: User, who want's to make first contact
receiver: User, other party
Returns:
(Channel, receiver_name)
"""
existing = cls.objects.OR().filter(
code_name='%s_%s' % (initiator_key, receiver_key)).filter(
code_name='%s_%s' % (receiver_key, initiator_key))
receiver_name = UserModel.objects.get(receiver_key).full_name
if existing:
channel = existing[0]
else:
channel_name = '%s_%s' % (initiator_key, receiver_key)
channel = cls(is_direct=True, code_name=channel_name,
typ=10).blocking_save()
with BlockSave(Subscriber):
Subscriber.objects.get_or_create(channel=channel,
user_id=initiator_key,
name=receiver_name)
Subscriber.objects.get_or_create(
channel=channel,
user_id=receiver_key,
name=UserModel.objects.get(initiator_key).full_name)
return channel, receiver_name
def test_escaping(self):
Student.objects.delete()
with BlockSave(Student):
Student(name='jhon smith', surname='jr.').save()
Student(name='jhon smith', surname='sr.').save()
# assert Student.objects.filter(name__contains='on sm').count() == 2
assert Student.objects.filter(name='jhon smith').count() == 2
def test_range_queries(self):
TimeTable.objects.delete()
with BlockSave(TimeTable):
TimeTable(week_day=4,
hours=2,
adate=datetime.date.today(),
bdate=datetime.date.today() -
datetime.timedelta(days=2)).save()
TimeTable(week_day=2,
hours=4,
bdate=datetime.date.today(),
adate=datetime.date.today() +
datetime.timedelta(2)).save()
TimeTable(week_day=5,
hours=1,
adate=datetime.date.today() - datetime.timedelta(1),
bdate=datetime.date.today() +
datetime.timedelta(12)).save()
TimeTable(week_day=3,
hours=6,
adate=datetime.date.today() + datetime.timedelta(10),
bdate=datetime.date.today() -
datetime.timedelta(2)).save()
assert TimeTable.objects.filter(week_day__range=[2, 4]).count() == 3
assert TimeTable.objects.or_filter(week_day__range=[2, 4],
hours__range=[1, 4]).count() == 4
assert TimeTable.objects.or_filter(adate__range=(
datetime.date.today() - datetime.timedelta(10),
datetime.date.today() + datetime.timedelta(10),
),
hours__range=[1, 4]).count() == 4
def test_missing_relation_not_created(self):
"""
When an object is created, if it has a relation to another object that
is referenced with an id, but the other object doesn't actually exist,
the object referenced in relation automatically gets created. See issue
#5450.
The correct behaviour here should be throwing an exception, as inserting
an incorrect id is a likely mistake that the programmer might make.
"""
# Create a user, giving it a relation that doesn't exist
supervisor_key = 'this_user_doesnt_exist'
user = User(name='TEST_USER', supervisor_id=supervisor_key)
initial_user_count = User.objects.count()
with BlockSave(User):
with pytest.raises(ObjectDoesNotExist):
user.save()
final_user_count = User.objects.count()
# The missing relation should not have been created
assert final_user_count - initial_user_count == 1
# Cleanup
user.delete()
def test_slicing(self):
with BlockDelete(TimeTable):
TimeTable.objects.delete()
with BlockSave(TimeTable):
for i in range(5):
TimeTable(week_day=i, hours=i).save()
items = TimeTable.objects.filter()[1:2]
assert len(list(items)) == 1
def test_lte_gte(self):
self.prepare_testbed()
with BlockSave(TimeTable):
TimeTable(week_day=4, hours=2).save()
TimeTable(week_day=2, hours=4).save()
TimeTable(week_day=5, hours=1).save()
TimeTable(week_day=3, hours=6).save()
assert TimeTable.objects.filter(hours__gte=4).count() == 2
assert TimeTable.objects.filter(hours__lte=4).count() == 3
def test_lt_gt(self):
self.prepare_testbed()
with BlockSave(TimeTable):
TimeTable.objects.get_or_create(week_day=4, hours=2)
TimeTable.objects.get_or_create(week_day=2, hours=4)
TimeTable.objects.get_or_create(week_day=5, hours=1)
TimeTable.objects.get_or_create(week_day=3, hours=6)
assert TimeTable.objects.filter(hours__gt=4).count() == 1
assert TimeTable.objects.filter(hours__lt=4).count() == 2
def test_distinct_values_of(self):
user, new = User.objects.get_or_create(name="Sergio Mena")
role_lst = []
with BlockSave(Role):
for i in range(1, 6, 1):
role = Role(name="Musician%s" % i, usr=user)
role.save()
role_lst.append(role)
user_dict_1 = Role.objects.filter(
name="Musician1").distinct_values_of("usr_id")
assert sum(user_dict_1.values()) == 1
user_dict_2 = Role.objects.filter(
usr_id=user.key).distinct_values_of("usr_id")
assert sum(user_dict_2.values()) == 5
Role.objects.filter(active=True).delete()
with BlockSave(Role, query_dict={'active': True}):
for i, r in enumerate(role_lst):
if i == 3:
pass
else:
r.active = True
r.save()
user_dict_3 = Role.objects.filter(
active=True).distinct_values_of("usr_id")
assert sum(user_dict_3.values()) == 4
new_user = User(name="Valnetin Hegg")
new_user.blocking_save()
role_lst[0].usr = new_user
role_lst[0].blocking_save(query_dict={'usr': new_user})
user_dict_4 = Role.objects.filter(
active=True, usr_id=user.key).distinct_values_of("usr_id")
assert sum(user_dict_4.values()) == 3
with BlockDelete(Role):
for r in role_lst:
r.delete()
def test_block_save(self):
Student.objects.filter().delete()
t1 = time.time()
with BlockSave(Student):
for i in range(10):
Student(surname='bar', name='foo_%s' % i).save()
assert Student.objects.count() == 10
print("BlockSave took %s" % (time.time() - t1))
student = Student.objects.get(surname='bar', name='foo_9')
student.blocking_save(query_dict={
"name": "foo_10",
"surname": "bar_10"
})
assert student.name == "foo_10"
assert student.surname == "bar_10"
with BlockSave(Student, query_dict={'surname': 'zubizu'}):
for i in range(9):
student = Student.objects.get(surname='bar', name='foo_%s' % i)
student.surname = 'zubizu'
student.save()
assert len(Student.objects.filter(surname='zubizu')) == 9
def test_block_delete(self):
Student.objects.filter().delete()
time.sleep(1)
with BlockSave(Student):
for i in range(10):
Student(surname='bar', name='foo_%s' % i).save()
assert Student.objects.count() == 10
t1 = time.time()
with BlockDelete(Student):
for i in range(10):
Student.objects.get(surname='bar', name='foo_%s' % i).delete()
assert Student.objects.count() == 0
print("BlockDelete took %s" % (time.time() - t1))
def create_user_channels(self):
from zengine.messaging.model import Channel, Subscriber
user_model = get_object_from_path(settings.USER_MODEL)
with BlockSave(Channel):
for usr in user_model.objects.all():
# create private exchange of user
# create notification subscription to private exchange
ch, new_ch, sb, new_sb = usr.prepare_channels()
print("%s exchange: %s" %
('created' if new_ch else 'existing', ch.code_name))
print("%s notify sub: %s" %
('created' if new_sb else 'existing', ch.code_name))
def create_channel(current):
"""
Create a public channel. Can be a broadcast channel or normal chat room.
Chat room and broadcast distinction will be made at user subscription phase.
.. code-block:: python
# request:
{
'view':'_zops_create_channel',
'name': string,
'description': string,
}
# response:
{
'description': string,
'name': string,
'no_of_members': int,
'member_list': [
{'name': string,
'is_online': bool,
'avatar_url': string,
}],
'last_messages': [MSG_DICT]
'status': 'Created',
'code': 201,
'key': key, # of just created channel
}
"""
channel = Channel(name=current.input['name'],
description=current.input['description'],
owner=current.user,
typ=15).save()
with BlockSave(Subscriber):
Subscriber.objects.get_or_create(user=channel.owner,
channel=channel,
can_manage=True,
can_leave=False)
current.input['key'] = channel.key
show_channel(current)
current.output.update({
'status': 'Created',
'code': 201
})
def test_slicing_indexing(self):
Student.objects.delete()
with BlockSave(Student):
Student(name='Olavi', surname='Mikkonen').save()
Student(name='Johan', surname='Hegg').save()
Student(name='Johan', surname='Soderberg').save()
Student(name='Ted', surname='Lundstrom').save()
Student(name='Michael', surname='Amott').save()
Student(name='Daniel', surname='Erlandsson').save()
Student(name='Sharlee', surname='D\'Angelo').save()
Student(name='Alissa', surname='White-Gluz').save()
Student(name='Jeff', surname='Loomis').save()
# Check regular slices
assert Student.objects.count() == 9
assert Student.objects[2:5].count() == 3
assert Student.objects[1:5].count() == 4
assert Student.objects[1:6].count() == 5
assert Student.objects[0:10].count() == 9
assert Student.objects[0:11].count() == 9
assert Student.objects[1:11].count() == 8
assert Student.objects[1:12].count() == 8
# Check multi-slicing
assert Student.objects[1:6][2:4].count() == 2
assert Student.objects[0:7][2:4].count() == 2
assert Student.objects[0:7][2:5].count() == 3
# Check get & indexing
s1 = Student.objects[3:4].get()
s2 = Student.objects[3:4][0]
assert s1 == s2
s1 = Student.objects[3:9][4:5].get()
s2 = Student.objects[3:9][4:5][0]
assert s1 == s2
# Check slicing with filters
assert Student.objects.filter(name__startswith='J')[1:3].count() == 2
assert Student.objects.filter(
name__startswith='J')[2:3].get() is not None
def test_ders_programi_yap(self):
usr = User.objects.get(username='******')
unit = usr.role_set[0].role.unit()
ders_etkinligi = DersEtkinligi.objects.filter(
bolum=unit, donem=Donem.guncel_donem())
published_true = ders_etkinligi.filter(published=True)
with BlockSave(DersEtkinligi, query_dict={'published': False}):
for pt in published_true:
pt.published = False
pt.save()
published_false_count = DersEtkinligi.objects.filter(
bolum=unit, donem=Donem.guncel_donem(), published=False).count()
self.prepare_client("/ders_programi_hazirla", user=usr)
resp = self.client.post()
assert resp.json['msgbox']['title'] == "Yayınlanmamış Program Var!"
self.client.post(form={'devam': 1})
self.client.post(cmd='incele')
for i in range(2):
if i == 0:
# Derslik Arama Kayit Yok
ara_form = {
'arama_button': 1,
'arama_sec': 1,
'arama_text': "C4034"
}
title = "Kayıt Bulunamadı"
else:
# Ogretim Elemani Arama Kayit Yok
ara_form = {
'arama_button': 1,
'arama_sec': 2,
'arama_text': "Baba Zula"
}
title = "Kayıt Bulunamadı"
resp = self.client.post(form=ara_form)
assert resp.json['msgbox']['title'] == title
self.client.post(form={'devam': 1})
if i == 0:
# Derslik Arama Kayit Var
ara_form = {
'arama_button': 1,
'arama_sec': 1,
'arama_text': "C50610"
}
title = "C50610 C608 - CAD Laboratuarları 38 - Detaylı Zaman Tablosu"
else:
# Ogretim Elemani Arama Kayit Var
ara_form = {
'arama_button': 1,
'arama_sec': 2,
'arama_text': "İsmet Tarhan"
}
title = "İsmet Tarhan - Detaylı Zaman Tablosu"
resp = self.client.post(form=ara_form)
assert resp.json['objects'][1]['title'] == title
self.client.post(form={'tamamla': 1})
resp = self.client.post(cmd='vazgec')
assert 'incele' and 'yayinla' in resp.json['forms']['model'].keys()
resp = self.client.post(cmd='bitir')
assert resp.json['msgbox']['title'] == "Program Yayınlandı!"
time.sleep(1)
resp = self.client.post()
assert resp.json['msgbox']['title'] == "Yayınlanmış Program Var!"
published_true = DersEtkinligi.objects.filter(
bolum=unit, published=True, donem=Donem.guncel_donem())
assert published_false_count == len(published_true)
self.client.set_path("/derslik_ders_programlari")
resp = self.client.post()
derslikler = [etkinlik.room for etkinlik in published_true]
assert len(
resp.json['forms']['form'][2]['titleMap']) == len(derslikler)
resp = self.client.post(form={
"ileri": 1,
"derslik": "3rPQ4bB2lDtxdCE41RBoNqZM19f"
})
num_of_ders_etkinlikleri = DersEtkinligi.objects.filter(
room_id="3rPQ4bB2lDtxdCE41RBoNqZM19f",
published=True,
donem=Donem.guncel_donem())
count_of_ders_etkinlikleri = 0
for i in range(1, len(resp.json['objects'])):
for day in resp.json['objects'][i]['fields']:
if resp.json['objects'][i]['fields'][day]:
count_of_ders_etkinlikleri += 1
assert len(num_of_ders_etkinlikleri) == count_of_ders_etkinlikleri
with BlockSave(DersEtkinligi, query_dict={'published': False}):
for de in published_true:
de.published = False
de.save()
assert published_false_count == DersEtkinligi.objects.filter(
bolum=unit, published=False, donem=Donem.guncel_donem()).count()
def test_sinav_programi_yap(self):
"""
Derslik Sınav Programları iş akışı aşağıdaki adımlardan oluşur.
İlk adımda sınav etkinlikleri kontrol edilir.
Yayınlanlanmamış sınav etkinlikleri varsa;
Bilgi ver wf adımına geçer. Bu adımda yayınlanmamış sınavların
olduğuna dair bilgi mesajı ekrana basılır.
İlk adımda derslik seçilir.
Veritabanından çekilen derslik sayısı ile sunucudan dönen derslik sayısı karşılaştırılıp test edilir.
İkinci adımda seçilen dersliğe ait sınav programı getirilir.
Veritabanından çekilen sınav etkinlikleri sayısı ile sunucudan dönen sınav etkinlikleri sayısı
karşılaştırılıp test edilir.
"""
usr = User.objects.get(username='******')
unit = usr.role_set[0].role.unit()
sinav_etkinligi = SinavEtkinligi.objects.filter(
bolum=unit, donem=Donem.guncel_donem())
published_true = sinav_etkinligi.filter(published=True)
with BlockSave(SinavEtkinligi, query_dict={'published': False}):
for pt in published_true:
pt.published = False
pt.save()
published_false_count = SinavEtkinligi.objects.filter(
bolum=unit, donem=Donem.guncel_donem(), published=False).count()
self.prepare_client('/sinav_programi_hazirla', user=usr)
resp = self.client.post()
assert resp.json['msgbox']['title'] == "Yayınlanmamış Program Var!"
self.client.set_path("/derslik_sinav_programlari")
resp = self.client.post()
assert "msgbox" in resp.json
self.client.set_path('/sinav_programi_hazirla')
self.client.post()
self.client.post(form={'devam': 1})
self.client.post(cmd='incele')
for i in range(2):
if i == 0:
# Derslik Arama Kayit Yok
ara_form = {
'arama_button': 1,
'arama_sec': 1,
'arama_text': "C4034"
}
title = "Kayıt Bulunamadı"
else:
# Ogretim Elemani Arama Kayit Yok
ara_form = {
'arama_button': 1,
'arama_sec': 2,
'arama_text': "Baba Zula"
}
title = "Kayıt Bulunamadı"
resp = self.client.post(form=ara_form)
assert resp.json['msgbox']['title'] == title
self.client.post(form={'devam': 1})
if i == 0:
# Derslik Arama Kayit Var
ara_form = {
'arama_button': 1,
'arama_sec': 1,
'arama_text': "M50616"
}
title = "M50616 C402 - Theatre 44 - Detaylı Zaman Tablosu"
else:
# Ogretim Elemani Arama Kayit Var
ara_form = {
'arama_button': 1,
'arama_sec': 2,
'arama_text': "İsmet Tarhan"
}
title = "İsmet Tarhan - Detaylı Zaman Tablosu"
resp = self.client.post(form=ara_form)
assert resp.json['objects'][1]['title'] == title
self.client.post(form={'tamamla': 1})
resp = self.client.post(cmd='vazgec')
assert 'incele' and 'yayinla' in resp.json['forms']['model'].keys()
resp = self.client.post(cmd='bitir')
assert resp.json['msgbox']['title'] == "Program Yayınlandı!"
time.sleep(1)
resp = self.client.post()
assert resp.json['msgbox']['title'] == "Yayınlanmış Program Var!"
published_true = SinavEtkinligi.objects.filter(
bolum=unit, published=True, donem=Donem.guncel_donem())
assert published_false_count == len(published_true)
self.client.set_path("derslik_sinav_programlari")
resp = self.client.post()
derslikler = [
s_yerleri.room for s_etkinlik in published_true
for s_yerleri in s_etkinlik.SinavYerleri if s_etkinlik.SinavYerleri
]
assert len(derslikler) == len(
resp.json['forms']['form'][2]['titleMap'])
resp = self.client.post(form={
"ileri": 1,
"derslik": 'Jju1xbrWBsMoFb9fPyNpLnwPuW9'
})
room = Room.objects.get("Jju1xbrWBsMoFb9fPyNpLnwPuW9")
num_of_sinav_etkinlikleri = [
s for s in SinavEtkinligi.objects if room in s.SinavYerleri
]
count_of_sinav_etkinlikleri = 0
for i in range(1, len(resp.json['objects'])):
for day in resp.json['objects'][i]['fields']:
if resp.json['objects'][i]['fields'][day]:
count_of_sinav_etkinlikleri += 1
assert len(num_of_sinav_etkinlikleri) == count_of_sinav_etkinlikleri
with BlockSave(SinavEtkinligi, query_dict={'published': False}):
for se in published_true:
se.published = False
se.save()
assert published_false_count == SinavEtkinligi.objects.filter(
bolum=unit, published=False, donem=Donem.guncel_donem()).count()
def test_ogrenci_sinav_programi_goruntule(self):
user = User.objects.get(username='******')
unit = user.role_set[0].role.unit
sinav_etkinligi = SinavEtkinligi.objects.filter(
bolum=unit, donem=Donem.guncel_donem())
with BlockSave(SinavEtkinligi, query_dict={'published': True}):
for se in sinav_etkinligi:
se.published = True
se.save()
# İlgili öğrenci bulunur.
ogrenci = Ogrenci.objects.get(user=user)
ogrenci_adi = ogrenci.__unicode__()
sinav_etkinlikleri = aktif_sinav_listesi(ogrenci)
for i in range(2):
# Testi çalıştırılacak iş akışı seçilir.
self.prepare_client('/ogrenci_sinav_programi_goruntule', user=user)
cond = False if i == 0 else True
# İlk test yayınlanmış sınav etkinliğinin olmaması durumudur.
# Bu yüzden Sınav Etkinliği modelinin published fieldı False yapılır.
# İkinci test yayınlanmış sınav etkinliğinin olması durumudur.
# Bu yüzden Sınav Etkinliği modelinin published fieldı True yapılır.
with BlockSave(SinavEtkinligi, query_dict={'published': cond}):
for etkinlik in sinav_etkinlikleri:
etkinlik.published = cond
etkinlik.save()
resp = self.client.post()
# Yayınlanmış sınav etkinliği bulunmaması durumunda Uyarı vermesi beklenir.
if i == 0:
assert resp.json['msgbox']['title'] == "Uyarı!"
# Yayınlanmış sınav etkinliği olması durumunda öğretim görevlisinin adının
# bulunduğu bir sınav takvimi gösterilmesi beklenir.
else:
# Öğrencinin güncel dönemde aktif şube
# sayısının 7 olması beklenir.
assert len(ogrenci.donem_subeleri()) == 7
# Sınav etkinlikleri sayısının 7 olması beklenir.
assert len(sinav_etkinlikleri) == 7
# Sınav etkinliklerinin tarihe göre küçükten büyüğe sıralandığı
# kontrol edilir.
assert sinav_etkinlikleri[0].tarih <= sinav_etkinlikleri[
-1].tarih
etkinlikler = map_etkinlik_hafta_gunleri(sinav_etkinlikleri)
# Sınav etkinliklerinin etkinlikler sözlüğü içerisinde istenildiği
# gibi yerleştirildiği kontrol edilir.
for etkinlik in sinav_etkinlikleri:
assert etkinlik.tarih.isoweekday() in etkinlikler
assert etkinlik.__unicode__() in etkinlikler[
etkinlik.tarih.isoweekday()]
# Yayınlanmış sınav etkinliği olması durumunda öğretim görevlisinin adının
# bulunduğu bir sınav takvimi gösterilmesi beklenir.
assert ogrenci_adi in resp.json['forms']['schema']["title"]
etkinlik_sayisi = 0
for i in range(1, len(resp.json['objects'])):
for k, day in enumerate(resp.json['objects'][i]['fields']):
if resp.json['objects'][i]['fields'][day]:
# Ekranda gösterilen sınav etkinliklerinin istenildiği gibi
# gösterildiği kontrol edilir.
assert resp.json['objects'][i]['fields'][
day] == etkinlikler[k + 1][i - 1]
etkinlik_sayisi += 1
# Ekranda gösterilen sınav etkinliklerinin sayısının veri tabanından
# dönen etkinlik sayısıyla eşit olduğu kontrol edilir.
assert etkinlik_sayisi == len(sinav_etkinlikleri)
sinav_etkinligi = SinavEtkinligi.objects.filter(
bolum=unit, donem=Donem.guncel_donem())
with BlockSave(SinavEtkinligi, query_dict={'published': False}):
for se in sinav_etkinligi:
se.published = False
se.save()