Beispiel #1
0
    def test_crashes(self):
        gpm['Crash__limit_size'] = 1
        crash_size = 10 * 1024 * 1023
        CrashFactory.create_batch(200,
                                  archive_size=crash_size,
                                  minidump_size=0)
        self.assertEqual(Crash.objects.all().count(), 200)

        del_count = 98
        deleted = list(
            Crash.objects.values_list('id', 'created', 'signature', 'userid',
                                      'appid'))[:del_count]
        deleted = map(
            lambda x: dict(id=x[0],
                           element_created=x[1].strftime("%d. %B %Y %I:%M%p"),
                           signature=x[2],
                           userid=x[3],
                           appid=x[4]), deleted)

        result = delete_size_is_exceeded('crash', 'Crash')

        self.assertDictEqual(
            result,
            dict(count=del_count,
                 size=del_count * crash_size,
                 elements=deleted))
        self.assertEqual(Crash.objects.all().count(), 102)
Beispiel #2
0
    def test_crashes(self):
        gpm['Crash__duplicate_number'] = 10
        CrashFactory.create_batch(25, signature='test1')
        self.assertEqual(Crash.objects.filter(signature='test1').count(), 25)
        CrashFactory.create_batch(9, signature='test2')
        self.assertEqual(Crash.objects.filter(signature='test2').count(), 9)

        deleted = list(
            Crash.objects.filter(
                signature='test1').order_by('created').values_list(
                    'id', 'created', 'signature', 'userid', 'appid'))[:15]
        deleted = [
            dict(id=x[0],
                 element_created=x[1].strftime("%d. %B %Y %I:%M%p"),
                 signature=x[2],
                 userid=x[3],
                 appid=x[4]) for x in deleted
        ]

        result = delete_duplicate_crashes()

        self.assertDictEqual(result, dict(count=15, size=0, elements=deleted))
        self.assertEqual(
            Crash.objects.filter(signature='test1').count(),
            gpm['Crash__duplicate_number'])
        self.assertEqual(Crash.objects.filter(signature='test2').count(), 9)
Beispiel #3
0
 def test_get_size(self):
     archive_size = 10
     minidump_size = 20
     CrashFactory.create_batch(10,
                               archive_size=archive_size,
                               minidump_size=minidump_size)
     size = Crash.objects.get_size()
     self.assertEqual(size, (archive_size + minidump_size) * 10)
    def test_crashes(self):
        old_date = timezone.now() - timezone.timedelta(days=5)
        gpm['Crash__limit_storage_days'] = 2
        CrashFactory.create_batch(10, created=old_date)
        Crash.objects.update(created=old_date)
        self.assertEqual(Crash.objects.all().count(), 10)

        deleted = list(Crash.objects.values_list('id', 'created', 'signature', 'userid', 'appid'))
        deleted = map(lambda x: dict(id=x[0], element_created=x[1].strftime("%d. %B %Y %I:%M%p"), signature=x[2],
                                     userid=x[3], appid=x[4]), deleted)

        result = delete_older_than('crash', 'Crash')

        self.assertDictEqual(result, dict(count=10, size=0, elements=deleted))
        self.assertEqual(Crash.objects.all().count(), 0)
    def test_crashes(self):
        gpm["Crash__limit_size"] = 1
        crash_size = 10 * 1024 * 1023
        CrashFactory.create_batch(500, archive_size=crash_size, minidump_size=0)
        self.assertEqual(Crash.objects.all().count(), 500)

        del_count = 398
        created_to_string = lambda x: "Created: %s" % x.strftime("%d. %B %Y %I:%M%p")
        signature_to_string = lambda x: "Signature: %s" % x
        deleted = list(Crash.objects.values_list("id", "created", "signature"))[:del_count]
        deleted = map(lambda x: (x[0], created_to_string(x[1]), signature_to_string(x[2])), deleted)
        result = delete_size_is_exceeded("crash", "Crash")

        self.assertDictEqual(result, dict(count=del_count, size=del_count * crash_size, elements=deleted))
        self.assertEqual(Crash.objects.all().count(), 102)
    def test_crashes(self):
        old_date = timezone.now() - timezone.timedelta(days=5)
        gpm["Crash__limit_storage_days"] = 2
        CrashFactory.create_batch(10, created=old_date)
        Crash.objects.update(created=old_date)
        self.assertEqual(Crash.objects.all().count(), 10)

        created_to_string = lambda x: "Created: %s" % x.strftime("%d. %B %Y %I:%M%p")
        signature_to_string = lambda x: "Signature: %s" % x
        deleted = list(Crash.objects.values_list("id", "created", "signature"))
        deleted = map(lambda x: (x[0], created_to_string(x[1]), signature_to_string(x[2])), deleted)

        result = delete_older_than("crash", "Crash")
        self.assertDictEqual(result, dict(count=10, size=0, elements=deleted))
        self.assertEqual(Crash.objects.all().count(), 0)
    def test_crashes(self):
        gpm['Crash__limit_size'] = 1
        crash_size = 10*1024*1023
        CrashFactory.create_batch(200, archive_size=crash_size, minidump_size=0)
        self.assertEqual(Crash.objects.all().count(), 200)

        del_count = 98
        deleted = list(Crash.objects.values_list('id', 'created', 'signature', 'userid', 'appid'))[:del_count]
        deleted = map(lambda x: dict(id=x[0], element_created=x[1].strftime("%d. %B %Y %I:%M%p"), signature=x[2],
                                      userid=x[3], appid=x[4]), deleted)

        result = delete_size_is_exceeded('crash', 'Crash')

        self.assertDictEqual(result, dict(count=del_count, size=del_count * crash_size, elements=deleted))
        self.assertEqual(Crash.objects.all().count(), 102)
Beispiel #8
0
    def test_crashes(self, mocked_get_logger):
        gpm['Crash__duplicate_number'] = 2
        crashes = CrashFactory.create_batch(10, signature='test')
        deleted_crash = crashes[7]
        self.assertEqual(Crash.objects.all().count(), 10)

        extra_meta = dict(count=8,
                          reason='duplicated',
                          meta=True,
                          log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00',
                          model='Crash',
                          size='0 bytes')
        log_extra_msg = add_extra_to_log_message('Automatic cleanup',
                                                 extra=extra_meta)

        extra = dict(Crash_id=deleted_crash.id,
                     element_created=deleted_crash.created.strftime(
                         "%d. %B %Y %I:%M%p"),
                     signature=deleted_crash.signature,
                     userid=deleted_crash.userid,
                     appid=deleted_crash.appid,
                     log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00')
        log_msg = add_extra_to_log_message('Automatic cleanup element',
                                           extra=extra)

        mocked_logger = mocked_get_logger.return_value
        with patch('uuid.uuid4') as mocked_uuid4:
            mocked_uuid4.side_effect = (uuid.UUID(
                '36446dc3-ae7c-42ad-ae4e-6a826dcf0a%02d' % x)
                                        for x in range(100))
            auto_delete_duplicate_crashes()

        self.assertEqual(mocked_logger.info.call_count, 10)
        mocked_logger.info.assert_any_call(log_extra_msg)
        mocked_logger.info.assert_any_call(log_msg)
    def test_crashes(self):
        gpm['Crash__duplicate_number'] = 10
        CrashFactory.create_batch(25, signature='test1')
        self.assertEqual(Crash.objects.filter(signature='test1').count(), 25)
        CrashFactory.create_batch(9, signature='test2')
        self.assertEqual(Crash.objects.filter(signature='test2').count(), 9)

        deleted = list(Crash.objects.filter(signature='test1').values_list('id', 'created', 'signature', 'userid', 'appid'))[:15]
        deleted = map(lambda x: dict(id=x[0], element_created=x[1].strftime("%d. %B %Y %I:%M%p"), signature=x[2],
                                     userid=x[3], appid=x[4]), deleted)

        result = delete_duplicate_crashes()

        self.assertDictEqual(result, dict(count=15, size=0, elements=deleted))
        self.assertEqual(Crash.objects.filter(signature='test1').count(), gpm['Crash__duplicate_number'])
        self.assertEqual(Crash.objects.filter(signature='test2').count(), 9)
    def test_crashes(self):
        gpm["Crash__duplicate_number"] = 10
        CrashFactory.create_batch(20, signature="test1")
        self.assertEqual(Crash.objects.filter(signature="test1").count(), 20)
        CrashFactory.create_batch(9, signature="test2")
        self.assertEqual(Crash.objects.filter(signature="test2").count(), 9)

        created_to_string = lambda x: "Created: %s" % x.strftime("%d. %B %Y %I:%M%p")
        signature_to_string = lambda x: "Signature: %s" % x
        deleted = list(Crash.objects.filter(signature="test1").values_list("id", "created", "signature"))[:10]
        deleted = map(lambda x: (x[0], created_to_string(x[1]), signature_to_string(x[2])), deleted)
        signatures = dict(test1=deleted)

        result = delete_duplicate_crashes()
        self.assertDictEqual(result, dict(count=10, size=0, elements=deleted, signatures=signatures))
        self.assertEqual(Crash.objects.filter(signature="test1").count(), gpm["Crash__duplicate_number"])
        self.assertEqual(Crash.objects.filter(signature="test2").count(), 9)
Beispiel #11
0
 def test_get_good(self):
     crash = CrashFactory()
     comment = 'Crash comment'
     data = dict(comment=comment)
     response = self.client.get(
         reverse('crash_description', kwargs=dict(pk=crash.pk)), data)
     self.assertEqual(response.status_code, 200)
     self.assertEqual(response.context['form'].initial['description'],
                      comment)
Beispiel #12
0
    def test_crashes(self):
        old_date = timezone.now() - timezone.timedelta(days=5)
        gpm['Crash__limit_storage_days'] = 2
        CrashFactory.create_batch(10, created=old_date)
        Crash.objects.update(created=old_date)
        self.assertEqual(Crash.objects.all().count(), 10)

        deleted = list(
            Crash.objects.values_list('id', 'created', 'signature', 'userid',
                                      'appid'))
        deleted = map(
            lambda x: dict(id=x[0],
                           element_created=x[1].strftime("%d. %B %Y %I:%M%p"),
                           signature=x[2],
                           userid=x[3],
                           appid=x[4]), deleted)

        result = delete_older_than('crash', 'Crash')

        self.assertDictEqual(result, dict(count=10, size=0, elements=deleted))
        self.assertEqual(Crash.objects.all().count(), 0)
Beispiel #13
0
    def test_model(self):
        crash = CrashFactory()
        summary = "Test summary"
        description = "Test description"

        obj = CrashDescription.objects.create(crash=crash,
                                              summary=summary,
                                              description=description)

        self.assertTrue(obj)
        self.assertEqual(obj.crash, crash)
        self.assertEqual(obj.summary, summary)
        self.assertEqual(obj.description, description)
Beispiel #14
0
    def test_post_good(self):
        crash = CrashFactory()
        summary = 'Test summary'
        description = 'Test Description'
        form_data = dict(summary=summary, description=description)

        self.assertEqual(CrashDescription.objects.all().count(), 0)
        response = self.client.post(reverse('crash_description',
                                            kwargs=dict(pk=crash.pk)),
                                    form_data,
                                    follow=True)
        self.assertEqual(response.status_code, 200)
        self.assertIn('crash/crash_description_submitted.html',
                      response.template_name)
        self.assertEqual(CrashDescription.objects.all().count(), 1)
        obj = CrashDescription.objects.get()
        self.assertEqual(obj.crash, crash)
        self.assertEqual(obj.summary, summary)
        self.assertEqual(obj.description, description)
Beispiel #15
0
    def test_crashes(self, mocked_get_logger):
        gpm['Crash__limit_size'] = 1
        crash_size = 10 * 1024 * 1023
        crashes = CrashFactory.create_batch(200,
                                            archive_size=crash_size,
                                            minidump_size=0)
        deleted_crash = crashes[97]
        self.assertEqual(Crash.objects.all().count(), 200)

        extra_meta = dict(count=98,
                          reason='size_is_exceeded',
                          meta=True,
                          log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00',
                          model='Crash',
                          size='979.0 MB')
        log_extra_msg = add_extra_to_log_message('Automatic cleanup',
                                                 extra=extra_meta)

        extra = dict(Crash_id=deleted_crash.id,
                     element_created=deleted_crash.created.strftime(
                         "%d. %B %Y %I:%M%p"),
                     signature=deleted_crash.signature,
                     userid=deleted_crash.userid,
                     appid=deleted_crash.appid,
                     log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00')
        log_msg = add_extra_to_log_message('Automatic cleanup element',
                                           extra=extra)

        mocked_logger = mocked_get_logger.return_value
        with patch('uuid.uuid4') as mocked_uuid4:
            mocked_uuid4.side_effect = (uuid.UUID(
                '36446dc3-ae7c-42ad-ae4e-6a826dcf0a%02d' % x)
                                        for x in range(100))
            auto_delete_size_is_exceeded()

        self.assertEqual(mocked_logger.info.call_count, 99)
        mocked_logger.info.assert_any_call(log_extra_msg)
        mocked_logger.info.assert_any_call(log_msg)
Beispiel #16
0
    def test_crashes(self, mocked_get_logger):
        gpm['Crash__duplicate_number'] = 2
        crashes = CrashFactory.create_batch(10, signature='test')
        deleted_crash = crashes[7]
        self.assertEqual(Crash.objects.all().count(), 10)

        extra_meta = dict(count=8, reason='duplicated', meta=True, log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00',
                          model='Crash', size='0 bytes')
        log_extra_msg = add_extra_to_log_message('Automatic cleanup', extra=extra_meta)

        extra = dict(Crash_id=deleted_crash.id, element_created=deleted_crash.created.strftime("%d. %B %Y %I:%M%p"),
                     signature=deleted_crash.signature, userid=deleted_crash.userid, appid=deleted_crash.appid,
                     log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00')
        log_msg = add_extra_to_log_message('Automatic cleanup element', extra=extra)

        mocked_logger = mocked_get_logger.return_value
        with patch('uuid.uuid4') as mocked_uuid4:
            mocked_uuid4.side_effect = (uuid.UUID('36446dc3-ae7c-42ad-ae4e-6a826dcf0a%02d' % x) for x in range(100))
            auto_delete_duplicate_crashes()

        self.assertEqual(mocked_logger.info.call_count, 10)
        mocked_logger.info.assert_any_call(log_extra_msg)
        mocked_logger.info.assert_any_call(log_msg)
Beispiel #17
0
    def test_crashes(self, mocked_get_logger):
        gpm['Crash__limit_size'] = 1
        crash_size = 10*1024*1023
        crashes = CrashFactory.create_batch(200, archive_size=crash_size, minidump_size=0)
        deleted_crash = crashes[97]
        self.assertEqual(Crash.objects.all().count(), 200)

        extra_meta = dict(count=98, reason='size_is_exceeded', meta=True, log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00',
                          model='Crash', size='979.0 MB')
        log_extra_msg = add_extra_to_log_message('Automatic cleanup', extra=extra_meta)

        extra = dict(Crash_id=deleted_crash.id, element_created=deleted_crash.created.strftime("%d. %B %Y %I:%M%p"),
                     signature=deleted_crash.signature, userid=deleted_crash.userid, appid=deleted_crash.appid,
                     log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00')
        log_msg = add_extra_to_log_message('Automatic cleanup element', extra=extra)

        mocked_logger = mocked_get_logger.return_value
        with patch('uuid.uuid4') as mocked_uuid4:
            mocked_uuid4.side_effect = (uuid.UUID('36446dc3-ae7c-42ad-ae4e-6a826dcf0a%02d' % x) for x in range(100))
            auto_delete_size_is_exceeded()

        self.assertEqual(mocked_logger.info.call_count, 99)
        mocked_logger.info.assert_any_call(log_extra_msg)
        mocked_logger.info.assert_any_call(log_msg)
Beispiel #18
0
    def test_crashes(self, mocked_get_logger):
        gpm['Crash__limit_storage_days'] = 2
        with freeze_time("2012-12-21 12:00:00"):
            crashes = CrashFactory.create_batch(10, signature='test')
        deleted_crash = crashes[-1]
        self.assertEqual(Crash.objects.all().count(), 10)

        extra_meta = dict(count=10, reason='old', meta=True, log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00',
                          model='Crash', size=0.0)
        log_extra_msg = add_extra_to_log_message('Automatic cleanup', extra=extra_meta)

        extra = dict(id=deleted_crash.id, element_created=deleted_crash.created.strftime("%d. %B %Y %I:%M%p"),
                     signature=deleted_crash.signature, userid=deleted_crash.userid, appid=deleted_crash.appid,
                     log_id='36446dc3-ae7c-42ad-ae4e-6a826dcf0a00')
        log_msg = add_extra_to_log_message('Automatic cleanup element', extra=extra)

        mocked_logger = mocked_get_logger.return_value
        with patch('uuid.uuid4') as mocked_uuid4:
            mocked_uuid4.side_effect = (uuid.UUID('36446dc3-ae7c-42ad-ae4e-6a826dcf0a%02d' % x) for x in range(100))
            auto_delete_older_than()

        self.assertEqual(mocked_logger.info.call_count, 11)
        mocked_logger.info.assert_any_call(log_extra_msg)
        mocked_logger.info.assert_any_call(log_msg)