Example #1
0
def update_log_version_keys(self):
    # Record count before save and delete operation in log bucket.
    self.log_bucket_count = len(log_bucket.get_keys())
    # Record count before save and delete operation in version bucket.
    self.version_bucket_count = len(version_bucket.get_keys())
    # Keys list in version bucket.
    self.last_version_keys = version_bucket.get_keys()
    # Keys list in log bucket.
    self.last_log_keys = log_bucket.get_keys()
Example #2
0
def update_log_version_keys(self):
    # Record count before save and delete operation in log bucket.
    self.log_bucket_count = len(log_bucket.get_keys())
    # Record count before save and delete operation in version bucket.
    self.version_bucket_count = len(version_bucket.get_keys())
    # Keys list in version bucket.
    self.last_version_keys = version_bucket.get_keys()
    # Keys list in log bucket.
    self.last_log_keys = log_bucket.get_keys()
    def test_gorev_suresi_uzatma(self):
        """
             Test data'daki mithat kullanıcısı ile test işlemi gerçekleştirilir.
             Seçilen personelin görev süresinin açılan formda görev süresi bitiş
             tarihi girilerek görev süresini uzatma mantığına dayanır.
        """
        log_bucket_count = len(log_bucket.get_keys())
        version_bucket_keys = version_bucket.get_keys()

        user = User.objects.get(username="******")
        personel_id = "V9AJztgnQQc6vbIfNice2ZrHAvF"
        personel = Personel.objects.get(personel_id)
        eski_gorev_suresi_bitis = personel.gorev_suresi_bitis
        yeni_gorev_suresi_bitis = eski_gorev_suresi_bitis + relativedelta(
            years=1)
        self.prepare_client("/gorev_suresi_uzatma", user=user)

        # Görev süresi uzatılacak personel seçilir.
        self.client.post(id=personel_id,
                         model="Personel",
                         param="personel_id",
                         wf="gorev_suresi_uzatma")

        # Görev süresi uzatma formu doldurulur.
        self.client.post(
            cmd="kaydet",
            wf="gorev_suresi_uzatma",
            form=dict(gorev_suresi_bitis=yeni_gorev_suresi_bitis.strftime(
                "%d.%m.%Y"),
                      personel_id=personel.key))

        # save() işlemi meta paremetresi olmadan çalıştırıldığı için aktivite kaydının tutulmaması
        # ve aynı kalması beklenir.
        assert len(log_bucket.get_keys()) == log_bucket_count
        # Yeni versiyon keyleri getirilir.
        versiyon_keyleri = list(
            set(version_bucket.get_keys()) - set(version_bucket_keys))
        # Personel kaydı ile ilgili versiyon kaydı bulunur.
        key = ''
        for key in versiyon_keyleri:
            if version_bucket.get(key).data['model'] == 'personel':
                break
        yeni_versiyon_key = key

        # Versiyon kaydındaki görev_suresi_bitis field'ınin belirlenen tarihle ayni olmasi kontrol edilir.
        assert version_bucket.get(yeni_versiyon_key).data['data']['gorev_suresi_bitis'] == \
               yeni_gorev_suresi_bitis.strftime("%Y-%m-%dT%H:%M:%SZ")
        # Versiyon kaydındaki görev_suresi_baslama field'ınin bugünün tarihiyle ayni olması kontrol edilir.
        assert version_bucket.get(yeni_versiyon_key).data['data']['gorev_suresi_baslama'] == \
               datetime.date.today().strftime("%Y-%m-%dT%H:%M:%SZ")

        # Personelin görev süresi bitiş tarihinin belirlediğimiz
        # şekilde değişip değişmediği kontrol ediliyor.
        personel = Personel.objects.get(personel.key)
        assert personel.gorev_suresi_bitis == yeni_gorev_suresi_bitis
Example #4
0
def common_controls_with_meta_data(self):
    # New log bucket record count should be one more than old count.
    assert len(log_bucket.get_keys()) == self.log_bucket_count + 1
    # New version bucket record count should be one more than old count.
    assert len(version_bucket.get_keys()) == self.version_bucket_count + 1
    # New log key is found from difference before and after bucket_keys.
    new_log_key = list(set(log_bucket.get_keys()) - set(self.last_log_keys))
    # New version key is found from difference before and after bucket_keys.
    new_version_key = list(
        set(version_bucket.get_keys()) - set(self.last_version_keys))
    # Log, version keys and counts are updated.
    update_log_version_keys(self)
    # There should be one different key before and after log records.
    assert len(new_log_key) == 1
    # There should be one different key before and after version records.
    assert len(new_version_key) == 1
    # New log data is taken.
    log_data = log_bucket.get(new_log_key[0]).data
    # New log indexes are taken.
    indexes = log_bucket.get(new_log_key[0]).indexes
    # Indexes are controlled.
    assert ('lorem_bin', 'ipsum') in indexes
    assert ('dolar_int', 5) in indexes
    # New version key and log_bucket's record's version key should be same.
    assert log_data['version_key'] == new_version_key[0]
    # Changes are controlled.
    assert log_data['lorem'] == 'ipsum'
    assert log_data['dolar'] == 5
    # Indexed data and search operation are controlled.
    assert new_log_key[0] in log_bucket.get_index('lorem_bin', 'ipsum').results
    assert new_log_key[0] in log_bucket.get_index('dolar_int', 5).results
    assert new_version_key[0] in version_bucket.get_index(
        'model_bin', 'abstract_role').results
    # New version data is taken.
    version_data = version_bucket.get(new_version_key[0]).data
    # Model value should be 'abstract_role'.
    assert version_data['model'] == 'abstract_role'
    # Riak key is controlled.
    assert version_data['key'] == self.another_abs_role.key

    return version_data['data']['name'], version_data['data']['deleted']
Example #5
0
def common_controls_with_meta_data(self):
    # New log bucket record count should be one more than old count.
    assert len(log_bucket.get_keys()) == self.log_bucket_count + 1
    # New version bucket record count should be one more than old count.
    assert len(version_bucket.get_keys()) == self.version_bucket_count + 1
    # New log key is found from difference before and after bucket_keys.
    new_log_key = list(set(log_bucket.get_keys()) - set(self.last_log_keys))
    # New version key is found from difference before and after bucket_keys.
    new_version_key = list(set(version_bucket.get_keys()) - set(self.last_version_keys))
    # Log, version keys and counts are updated.
    update_log_version_keys(self)
    # There should be one different key before and after log records.
    assert len(new_log_key) == 1
    # There should be one different key before and after version records.
    assert len(new_version_key) == 1
    # New log data is taken.
    log_data = log_bucket.get(new_log_key[0]).data
    # New log indexes are taken.
    indexes = log_bucket.get(new_log_key[0]).indexes
    # Indexes are controlled.
    assert ('lorem_bin', 'ipsum') in indexes
    assert ('dolar_int', 5) in indexes
    # New version key and log_bucket's record's version key should be same.
    assert log_data['version_key'] == new_version_key[0]
    # Changes are controlled.
    assert log_data['lorem'] == 'ipsum'
    assert log_data['dolar'] == 5
    # Indexed data and search operation are controlled.
    assert new_log_key[0] in log_bucket.get_index('lorem_bin', 'ipsum').results
    assert new_log_key[0] in log_bucket.get_index('dolar_int', 5).results
    assert new_version_key[0] in version_bucket.get_index('model_bin', 'abstract_role').results
    # New version data is taken.
    version_data = version_bucket.get(new_version_key[0]).data
    # Model value should be 'abstract_role'.
    assert version_data['model'] == 'abstract_role'
    # Riak key is controlled.
    assert version_data['key'] == self.another_abs_role.key

    return version_data['data']['name'], version_data['data']['deleted']
Example #6
0
    def test_guncel_donem_degistirme(self):
        """
        Güncel Dönem Değiştirme iş akışında güncel dönem seçilir,
        kaydedilir, bilgi verilir.
        Seçilen dönemin güncel dönem olarak kaydedilip kaydedilmediği test edilir.
        Sunucudan dönen cevapta msgboz olup olmadığı test edilir.

        Testte üretilen dataların diğer testleri kırmaması için değişiklikler geri alınır.

        """
        log_bucket_count = len(log_bucket.get_keys())
        log_bucket_keys = log_bucket.get_keys()
        version_bucket_keys = version_bucket.get_keys()

        # ögrenci_isleri_1 kullanıcısı seçilir.
        user = User.objects.get(username='******')

        # guncel_donem_degistirme iş akışı başlatılır.
        self.prepare_client('/guncel_donem_degistirme', user=user)
        self.client.post()

        ilk_guncel_donem = Donem.guncel_donem()

        # Seçilen dönem
        secilen_guncel_donem_key = 'SBx09BKCv86hp53HGVT2i7vBxGN'

        # Yeni dönem seçilir ve kaydedilir.
        resp = self.client.post(form={'guncel_donem': secilen_guncel_donem_key, 'kaydet': 1})
        time.sleep(1)

        # Save işlemi meta_data parametresi ile yapıldığından aktivite kaydının tutulması ve
        # bir artması beklenir.
        assert len(log_bucket.get_keys()) == log_bucket_count + 1
        # Yeni log kaydının keyi bulunur.
        yeni_log_key = list(set(log_bucket.get_keys()) - set(log_bucket_keys))[0]
        # WF isminin doğruluğu kontrol edilir.
        assert log_bucket.get(yeni_log_key).data['wf_name'] == 'guncel_donem_degistirme'
        # Her bir save işleminde version logları tutulduğundan yeni kayıtlar birikir.
        yeni_versiyon_kayitlari = list(set(version_bucket.get_keys()) - set(version_bucket_keys))
        # Bu kayıtlardan donemle ilgili olanları süzülür.
        donem_kayitlari = list(filter(lambda x: version_bucket.get(x).data['model'] == 'donem',
                                      yeni_versiyon_kayitlari))
        # Oluşturma zamanına göre sıralanır.
        sirali_donem_kayitlari = sorted(donem_kayitlari,
                                        key=lambda x: version_bucket.get(x).data['timestamp'])
        # Son kaydın güncel field'ının True olduğu kontrol edilir.
        assert version_bucket.get(sirali_donem_kayitlari[-1]).data['data']['guncel'] == True
        # Son kaydın dönem key'inin verilen key olduğu kontrol edilir.
        assert version_bucket.get(sirali_donem_kayitlari[-1]).data[
                   'key'] == 'SBx09BKCv86hp53HGVT2i7vBxGN'
        # Bir önceki dönem kaydının guncel field'ının False olduğu kontrol edilir.
        # Bunun anlamı yeni güncel dönem kaydedilirken, öncelikle güncel olan dönemin güncel fieldı
        # False yapılır ardından yeni istenilen dönem güncel olarak kaydedilir.
        assert version_bucket.get(sirali_donem_kayitlari[-2]).data['data']['guncel'] == False
        # Yeni log kaydının indexleri getirilir.
        indexes = log_bucket.get(yeni_log_key).indexes
        # Belirtilen indexlerin doğru tutulduğu kontrol edilir.
        assert ('user_id_bin', self.client.current.user_id) in indexes
        assert ('wf_name_bin', self.client.current.workflow_name) in indexes
        assert yeni_log_key in log_bucket.get_index('user_id_bin',
                                                    self.client.current.user_id).results
        assert yeni_log_key in log_bucket.get_index('wf_name_bin',
                                                    self.client.current.workflow_name).results

        # Güncel dönem olarak kaydedilip kaydedilmediği test edilir.
        assert Donem.guncel_donem().key == secilen_guncel_donem_key

        assert 'msgbox' in resp.json

        yeni_guncel_donem = Donem.guncel_donem()
        ilk_guncel_donem.guncel = True
        ilk_guncel_donem.blocking_save()
        yeni_guncel_donem.ogretim_yili.blocking_delete()
        yeni_guncel_donem.reload()
        assert yeni_guncel_donem.guncel == False
        assert ilk_guncel_donem.guncel == True
        assert Donem.guncel_donem().key == ilk_guncel_donem.key
Example #7
0
    def test_danisman_atama(self):
        """
        Danışmanı atanamayan öğrenciler öğrenci işleri tarafından atılır.
        Danışman atama iş akışının ilk adımında öğrenci programı seçilir.

        Seçilen öğrenciye ait veritabanından dönen öğrenci programı sayısı ile
        sunucudan dönen öğrenci program sayısının eşitliği karşılaştırılıp test edilir.

        İkinci adımında ise atanacak danışman seçilir.

        Veritabanından dönen danışmanların sayısı ile sunucudan dönen danışmaların sayısının
        eşitliği karşılaştırılıp test edilir.

        Üçüncü adımında ise danışman kaydedilir.

        Mesaj kutusunda danışman ataması yapılan öğrencinin ad ve soyad bilgilerinin olup
        olmadığı test edilir.

        """

        # Kullanıcıya login yaptırılır.
        log_bucket_count = len(log_bucket.get_keys())
        version_bucket_keys = version_bucket.get_keys()

        self.prepare_client('/danisman_atama', username='******')

        resp = self.client.post(id="RnKyAoVDT9Hc89KEZecz0kSRXRF",
                                model="OgrenciProgram",
                                param="ogrenci_id",
                                wf="danisman_atama",
                                filters={
                                    'ogrenci_id': {
                                        'values':
                                        ["KhFizqvCaZGtTloAZoPH1Uy98Pw"],
                                        'type': "check"
                                    }
                                })

        # Öğrenciye ait programlar db'den seçilir.
        op = OgrenciProgram.objects.filter(
            ogrenci_id='RnKyAoVDT9Hc89KEZecz0kSRXRF')

        # Veritabanından öğrenciye ait  çekilen program sayısı ile sunucudan dönen program sayısının
        # eşitliği karşılaştırılıp test edilir.
        assert len(resp.json['forms']['form'][2]['titleMap']) == len(op)

        # Öğrenci programı seçilir.
        resp = self.client.post(model='OgrenciProgram',
                                form={
                                    'program': "UEGET7qn9CDj9VEj4n0nbQ7m89d",
                                    'sec': 1
                                })

        guncel_donem = Donem.guncel_donem()
        # Öğrencinin kayıtlı olduğu öğrenci programlarından biri seçilir.
        program = op[0]
        # Döneme ve birime kayıtlı olan danışmanların listesini tutar.
        donem_danisman = DonemDanisman.objects.filter(
            donem=guncel_donem, bolum=program.program.birim)

        # Veritabanından dönen dönem danışmanların sayısı ile sunucudan dönen dönem  danışmanlarının
        # sayısının eşitliğini karşılaştırıp test eder.
        assert len(donem_danisman) == len(
            resp.json['forms']['form'][2]['titleMap'])

        # Danışman seçilir.
        resp = self.client.post(model='OgrenciProgram',
                                form={
                                    'donem_danisman':
                                    'Js2goP48yA183oMDAN8uM5GOExM',
                                    'sec': 1
                                })

        # save() işlemi meta paremetresi olmadan çalıştırıldığı için aktivite kaydının tutulmaması
        # ve aynı kalması beklenir.
        assert len(log_bucket.get_keys()) == log_bucket_count
        # Yeni versiyon kayıt keyleri alınır.
        yeni_versiyon_keyleri = list(
            set(version_bucket.get_keys()) - set(version_bucket_keys))

        # ogrenci_program modeline ait olan versiyon keyi alınır.
        op_versiyon_key = list(
            filter(
                lambda x: version_bucket.get(x).data['model'] ==
                'ogrenci_program', yeni_versiyon_keyleri))[0]
        # Seçilen danışmanın personel keyi bulunur.
        danisman_key = DonemDanisman.objects.get(
            'Js2goP48yA183oMDAN8uM5GOExM').okutman.personel.key
        # Versiyon loglarındaki danışman id si ile seçilen danısmanın id sinin uyuştuğu kontrol edilir.
        assert version_bucket.get(
            op_versiyon_key).data['data']['danisman_id'] == danisman_key

        ogrenci = Ogrenci.objects.get('RnKyAoVDT9Hc89KEZecz0kSRXRF')
        assert ogrenci.ad + ' ' + ogrenci.soyad in resp.json['msgbox']['msg']
Example #8
0
def common_controls_without_meta_data(self):
    # Controlling log_bucket remain same.
    assert len(log_bucket.get_keys()) == self.log_bucket_count
    # Version bucket record count should be one more than old count.
    assert len(version_bucket.get_keys()) == self.version_bucket_count + 1
Example #9
0
    def test_kayit_silme(self):
        """
        Kayıt silme iş akışı başlatılmadan önce kaydı silinecek öğrenci seçilir.

        İş akışının ikinci adımında personelin iş akışına devam etmek isteyip
        istemediği sorulur.
        Eğer personel vazgeçerse;
        Dönen cevapta işlemin iptal olduğuna dair mesajın olup olmadığı test edilir.

        Aynı öğrenci seçilerek iş akışı tekrardan başlatılır.

        İş akışının ikinci adımında personelin iş akışına devam etmek isteyip
        istemediği sorulur.

        Personelin işleme devam etmesi durumunda;

        Sunucudan dönen ayrılma nedenleri sayısı ile veritabanından dönen ayrılma
        nedenlerinin sayısının eşitliği karşılaştırılıp test edilir.

        Ayrılma nedeni seçilir ve açıklama yazılır.

        Öğrencinin kayıtlı olduğu öğrenci programının ayrılma nedeni ve
        ogrencilik statüsü alanlarına atanan değerlerin doğruluğu test edilir.

        Rolü değiştirilen öğrencinin, değişikliğe sahip olup olmadığı test
        edilir.

        İşlemin başarılı olduğuna dair bilgi mesajı ekrana basılırç
        Dönen cevapta msgbox olup olmadığı test edilir.

        Aynı öğrenci seçilerek iş akışı tekrardan başlatılır.

        Dönen cevapta kaydın daha önceden silindiğine dair mesajın olup olmadığı test edilir.

        """
        log_bucket_count = len(log_bucket.get_keys())
        log_bucket_keys = log_bucket.get_keys()

        # Öğrenci İşleri personeline login yaptırılır.
        self.prepare_client('/kayit_sil', username='******')
        self.client.post(id="RnKyAoVDT9Hc89KEZecz0kSRXRF",
                         param="ogrenci_id",
                         filters={
                             'ogrenci_id': {
                                 'values': ["RnKyAoVDT9Hc89KEZecz0kSRXRF"],
                                 'type': "check"
                             }
                         })

        # Kayıt silme işleminden vazgeçilir.
        resp = self.client.post(form={
            'vazgecme': 1,
            'kaydet': 'null'
        },
                                flow='kayit_silme_isleminden_vazgec')

        # Bilgi mesajı verilip verilmediğini test eder.
        assert resp.json['msgbox'][
            'msg'] == "Kayıt silme işlemi iptal edilmiştir."

        # İş akışı tekrar başlatılır.
        self.client.set_path('/kayit_sil')
        self.client.post(id="RnKyAoVDT9Hc89KEZecz0kSRXRF",
                         param="ogrenci_id",
                         filters={
                             'ogrenci_id': {
                                 'values': ["RnKyAoVDT9Hc89KEZecz0kSRXRF"],
                                 'type': "check"
                             }
                         })

        # Bahtinur Zengin adlı öğrenci veritabanından çekilir.
        ogrenci = Ogrenci.objects.get('RnKyAoVDT9Hc89KEZecz0kSRXRF')

        user = ogrenci.user

        # Öğrencinin kayıtlı olduğu programlar
        ogrenci_program = OgrenciProgram.objects.filter(ogrenci=ogrenci)

        # Her bir program için değiştirilecek rol sayısı bulunur.
        role_count = 0
        for program in ogrenci_program:
            roles = Role.objects.filter(user=user, unit=program.program.birim)
            for role in roles:
                if role.abstract_role.key in ABSTRACT_ROLE_LIST:
                    role_count += 1

        # Öğrenci programı ve rol değişiklikleri toplamı bulunur.
        yeni_kayit_sayisi = len(ogrenci_program) + role_count

        _roles = {
            role.key: role.abstract_role
            for role in Role.objects.filter(user=user)
        }

        # Kayıt silme işleminden onaylanır.
        self.client.post(form={
            'vazgecme': 'null',
            'kaydet': 1
        },
                         flow='fakulte_yonetim_karari')

        # Fakülte karar no girilir.
        resp = self.client.post(form={'karar': "455", 'kaydet': 1})

        # Ayrılma nedenlerini tutan list.
        lst = OgrenciProgram().get_choices_for('ayrilma_nedeni')

        # Sunucudan dönen ayrılma nedenleri sayısı ile
        # veritabanından dönen ayrılma nedenlerinin sayısının
        # eşitliği karşılaştırılır.
        assert len(resp.json['forms']['form'][1]['titleMap']) == len(lst)

        # Kaydı silinecek öğrencinin ayrılma nedeni seçilir ve açıklama yazılır.
        resp = self.client.post(
            form=dict(ayrilma_nedeni=11, sec=1, aciklama='Yatay Geçiş'))

        # Save işlemi meta_data parametresi ile yapıldığından aktivite logunun tutulması ve
        # sayısının yeni_kayit_sayisi kada rolması beklenir.
        assert len(
            log_bucket.get_keys()) == log_bucket_count + yeni_kayit_sayisi
        # Yeni log kayıtlarının keyleri bulunur.
        yeni_log_keyleri = list(
            set(log_bucket.get_keys()) - set(log_bucket_keys))
        # Bu log kayıtlarının içinde bulunan version_key leri bulunur.
        yeni_versiyon_keyleri = [
            log_bucket.get(x).data['version_key'] for x in yeni_log_keyleri
        ]
        # Versiyon kayıtlarından 'ogrenci_program' modeline ait olanlar süzülür.
        ogrenci_program_kayitlari = list(
            filter(
                lambda x: version_bucket.get(x).data['model'] ==
                'ogrenci_program', yeni_versiyon_keyleri))
        # Versiyon kayıtlarından 'role' modeline ait olanlar süzülür.
        rol_kayitlari = list(
            filter(lambda x: version_bucket.get(x).data['model'] == 'role',
                   yeni_versiyon_keyleri))
        # Aktivite log kayıtlarının '455' fakülte karar numarasıyla yapıldığı kontrol edilir.
        # WF isminin 'kayit_sil' olduğu kontrol edilir.
        for kayit in yeni_log_keyleri:
            assert log_bucket.get(
                kayit).data['reason'] == 'FAKÜLTE_KARAR_NO_455'
            assert log_bucket.get(kayit).data['wf_name'] == 'kayit_sil'
        # Öğrenci program sayısı kadar ogrenci_program versiyon kaydı tutulduğu kontrol edilir.
        assert len(ogrenci_program_kayitlari) == len(ogrenci_program)
        # Program versiyon kayıtlarının ayrılma nedeni, ogrencilik statusu fieldlarının belirtildiği
        # gibi olduğu kontrol edilir.
        for kayit in ogrenci_program_kayitlari:
            assert version_bucket.get(
                kayit).data['data']['ayrilma_nedeni'] == 11
            assert version_bucket.get(
                kayit).data['data']['ogrencilik_statusu'] == 21
            assert version_bucket.get(kayit).data['model'] == 'ogrenci_program'
        # Değişiklik yapılan rol sayısı kadar role versiyon kaydı tutulduğu kontrol edilir.
        assert len(rol_kayitlari) == role_count
        # Role versiyon kayıtlarının abstract_role_id bölümlerinin silinmiş olarak işaretlendiği kontrol edilir.
        # Role versiyon kayıtlarının model bölümünün 'role' oldğu kontrol edilir.
        for kayit in rol_kayitlari:
            assert version_bucket.get(kayit).data['model'] == 'role'
            assert version_bucket.get(kayit).data['data'][
                'abstract_role_id'] in ABSTRACT_ROLE_LIST_SILINMIS
        # Yeni log kaydının indexleri getirilir.
        indexes = log_bucket.get(yeni_log_keyleri[0]).indexes
        # Belirtilen indexlerin doğru tutulduğu kontrol edilir.
        assert ('wf_name_bin', self.client.current.workflow_name) in indexes
        # wf_name indexi ile log kaydının getirildiği kontrol edilir.
        assert yeni_log_keyleri[0] in log_bucket.get_index(
            'wf_name_bin', self.client.current.workflow_name).results

        # İş akışı tekrardan başlatılır.
        self.client.set_path('/kayit_sil')
        resp = self.client.post(id="RnKyAoVDT9Hc89KEZecz0kSRXRF",
                                param="ogrenci_id",
                                filters={
                                    'ogrenci_id': {
                                        'values':
                                        ["RnKyAoVDT9Hc89KEZecz0kSRXRF"],
                                        'type': "check"
                                    }
                                })

        assert resp.json['msgbox'][
            'msg'] == " Bahtinur Zengin adlı öğrencinin kaydı daha önceden silinmiştir."

        for program in ogrenci_program:
            # Ayrılma nedenine atanan değerin doğruluğu test eder.
            assert program.ayrilma_nedeni == 11
            # Öğrencilik statüsüne atanan değerin doğruluğunu test eder.
            assert program.ogrencilik_statusu == 21

            program.ayrilma_nedeni = 0
            program.ogrencilik_statusu = 0
            program.save()

        # Rolün değişip değişmediğini test eder
        for key in _roles:
            role = Role.objects.get(key)
            assert role.abstract_role == kaydi_silinmis_abs_role(role)
            role.abstract_role = _roles[key]
            role.save()
Example #10
0
def common_controls_without_meta_data(self):
    # Controlling log_bucket remain same.
    assert len(log_bucket.get_keys()) == self.log_bucket_count
    # Version bucket record count should be one more than old count.
    assert len(version_bucket.get_keys()) == self.version_bucket_count + 1