def test_set_duplicate_exception_delete_a_duplicate(self):
set_duplicate(self.finding_a, self.finding_b)
self.assertEqual(self.finding_b.original_finding.first().id,
self.finding_a.id)
self.finding_a.delete()
self.assertEqual(self.finding_a.id, None)
self.assertEqual(self.finding_b.original_finding.first(), None)
def test_false_positive_reopen(self):
self.finding_a.active = False
self.finding_a.verified = False # in the gui, a FP can not be true
set_duplicate(self.finding_b, self.finding_a)
self.finding_b.duplicate = True
self.finding_b.duplicate_finding = self.finding_a
super(Finding, self.finding_a).save()
super(Finding, self.finding_b).save()
fix_loop_duplicates()
candidates = Finding.objects.filter(
duplicate_finding__isnull=False,
original_finding__isnull=False).count()
self.assertEqual(candidates, 0)
# Get latest status
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.finding_b = Finding.objects.get(id=self.finding_b.id)
self.assertTrue(self.finding_a.false_p)
self.assertTrue(self.finding_a.is_Mitigated)
self.assertFalse(self.finding_a.active)
self.assertFalse(self.finding_a.verified)
self.assertFalse(self.finding_b.false_p)
self.assertFalse(self.finding_b.is_Mitigated)
self.assertFalse(self.finding_b.active)
self.assertFalse(self.finding_b.verified)
def test_set_duplicate_exception_delete_2(self):
set_duplicate(self.finding_a, self.finding_b)
self.assertEqual(self.finding_b.original_finding.first().id, self.finding_a.id)
self.finding_b.delete()
with self.assertRaises(Finding.DoesNotExist):
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.assertEqual(self.finding_b.id, None)
def test_out_of_scope_reopen(self):
self.finding_c.active = False
self.finding_c.verified = False
set_duplicate(self.finding_d, self.finding_c)
self.finding_d.duplicate = True
self.finding_d.duplicate_finding = self.finding_c
super(Finding, self.finding_c).save()
super(Finding, self.finding_d).save()
fix_loop_duplicates()
candidates = Finding.objects.filter(
duplicate_finding__isnull=False,
original_finding__isnull=False).count()
self.assertEqual(candidates, 0)
# Get latest status
self.finding_c = Finding.objects.get(id=self.finding_c.id)
self.finding_d = Finding.objects.get(id=self.finding_d.id)
self.assertTrue(self.finding_c.out_of_scope)
self.assertFalse(self.finding_c.is_Mitigated)
self.assertFalse(self.finding_c.active)
self.assertFalse(self.finding_c.verified)
self.assertFalse(self.finding_d.out_of_scope)
self.assertFalse(self.finding_d.is_Mitigated)
self.assertFalse(self.finding_d.active)
self.assertFalse(self.finding_d.verified)
def test_list_relations_for_three_reverse(self):
# C -> B, B -> A
set_duplicate(self.finding_c, self.finding_b)
self.finding_b.duplicate = True
self.finding_b.duplicate_finding = self.finding_a
super(Finding, self.finding_a).save()
super(Finding, self.finding_b).save()
super(Finding, self.finding_c).save()
loop_count = fix_loop_duplicates()
self.assertEqual(loop_count, 0)
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.finding_b = Finding.objects.get(id=self.finding_b.id)
self.finding_c = Finding.objects.get(id=self.finding_c.id)
# B -> A, C -> A
self.assertTrue(self.finding_b.duplicate)
self.assertTrue(self.finding_c.duplicate)
self.assertFalse(self.finding_a.duplicate)
self.assertEqual(self.finding_b.duplicate_finding.id,
self.finding_a.id)
self.assertEqual(self.finding_c.duplicate_finding.id,
self.finding_a.id)
self.assertEqual(self.finding_a.duplicate_finding, None)
self.assertEqual(self.finding_c.duplicate_finding_set().count(), 2)
self.assertEqual(self.finding_b.duplicate_finding_set().count(), 2)
def test_loop_relations_for_two(self):
set_duplicate(self.finding_a, self.finding_b)
self.finding_b.duplicate = True
self.finding_b.duplicate_finding = self.finding_a
super(Finding, self.finding_a).save()
super(Finding, self.finding_b).save()
fix_loop_duplicates()
candidates = Finding.objects.filter(duplicate_finding__isnull=False, original_finding__isnull=False).count()
self.assertEqual(candidates, 0)
# Get latest status
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.finding_b = Finding.objects.get(id=self.finding_b.id)
if self.finding_a.duplicate_finding:
self.assertTrue(self.finding_a.duplicate)
self.assertEqual(self.finding_a.original_finding.count(), 0)
else:
self.assertFalse(self.finding_a.duplicate)
self.assertEqual(self.finding_a.original_finding.count(), 1)
if self.finding_b.duplicate_finding:
self.assertTrue(self.finding_b.duplicate)
self.assertEqual(self.finding_b.original_finding.count(), 0)
else:
self.assertFalse(self.finding_b.duplicate)
self.assertEqual(self.finding_b.original_finding.count(), 1)
def test_loop_relations_for_four(self):
self.finding_d = Finding.objects.get(id=4)
self.finding_d.pk = None
self.finding_d.duplicate = False
self.finding_d.duplicate_finding = None
self.finding_d.save()
# A -> B, B -> C, C -> D, D -> A
set_duplicate(self.finding_a, self.finding_b)
self.finding_b.duplicate = True
self.finding_b.duplicate_finding = self.finding_c
self.finding_c.duplicate = True
self.finding_c.duplicate_finding = self.finding_d
self.finding_d.duplicate = True
self.finding_d.duplicate_finding = self.finding_a
super(Finding, self.finding_a).save()
super(Finding, self.finding_b).save()
super(Finding, self.finding_c).save()
super(Finding, self.finding_d).save()
loop_count = fix_loop_duplicates()
self.assertEqual(loop_count, 0)
# Get latest status
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.finding_b = Finding.objects.get(id=self.finding_b.id)
self.finding_c = Finding.objects.get(id=self.finding_c.id)
self.finding_d = Finding.objects.get(id=self.finding_d.id)
if self.finding_a.duplicate_finding:
self.assertTrue(self.finding_a.duplicate)
self.assertEqual(self.finding_a.original_finding.count(), 0)
else:
self.assertFalse(self.finding_a.duplicate)
self.assertEqual(self.finding_a.original_finding.count(), 3)
if self.finding_b.duplicate_finding:
self.assertTrue(self.finding_b.duplicate)
self.assertEqual(self.finding_b.original_finding.count(), 0)
else:
self.assertFalse(self.finding_b.duplicate)
self.assertEqual(self.finding_b.original_finding.count(), 3)
if self.finding_c.duplicate_finding:
self.assertTrue(self.finding_c.duplicate)
self.assertEqual(self.finding_c.original_finding.count(), 0)
else:
self.assertFalse(self.finding_c.duplicate)
self.assertEqual(self.finding_c.original_finding.count(), 3)
if self.finding_d.duplicate_finding:
self.assertTrue(self.finding_d.duplicate)
self.assertEqual(self.finding_d.original_finding.count(), 0)
else:
self.assertFalse(self.finding_d.duplicate)
self.assertEqual(self.finding_d.original_finding.count(), 3)
def test_set_duplicate_exception_delete_original_cascade(self):
set_duplicate(self.finding_a, self.finding_b)
self.assertEqual(self.finding_b.original_finding.first().id,
self.finding_a.id)
logger.debug('going to delete finding B')
self.finding_b.delete()
logger.debug('deleted finding B')
with self.assertRaises(Finding.DoesNotExist):
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.assertEqual(self.finding_b.id, None)
def test_set_duplicate_basic(self):
set_duplicate(self.finding_a, self.finding_b)
self.assertTrue(self.finding_a.duplicate)
self.assertFalse(self.finding_b.duplicate)
self.assertEqual(self.finding_a.duplicate_finding.id, self.finding_b.id)
self.assertEqual(self.finding_b.duplicate_finding, None)
self.assertEqual(self.finding_b.original_finding.first().id, self.finding_a.id)
self.assertEqual(self.finding_a.duplicate_finding_set().count(), 1)
self.assertEqual(self.finding_b.duplicate_finding_set().count(), 1)
self.assertEqual(self.finding_b.duplicate_finding_set().first().id, self.finding_a.id)
def test_set_duplicate_exception_merge(self):
set_duplicate(self.finding_a, self.finding_b)
set_duplicate(self.finding_b, self.finding_c)
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.assertTrue(self.finding_b.duplicate)
self.assertTrue(self.finding_a.duplicate)
self.assertFalse(self.finding_c.duplicate)
self.assertEqual(self.finding_b.duplicate_finding.id, self.finding_c.id)
self.assertEqual(self.finding_a.duplicate_finding.id, self.finding_c.id)
self.assertEqual(self.finding_c.duplicate_finding, None)
self.assertEqual(self.finding_a.duplicate_finding_set().count(), 2)
self.assertEqual(self.finding_b.duplicate_finding_set().count(), 2)
self.assertEqual(self.finding_a.duplicate_finding.id, self.finding_c.id)
def test_set_duplicate_exception_delete_original_1_duplicate_adapt(self):
set_duplicate(self.finding_a, self.finding_b)
self.assertEqual(self.finding_b.original_finding.first().id,
self.finding_a.id)
logger.debug('going to delete finding B')
b_id = self.finding_b.id
self.finding_b.delete()
logger.debug('deleted finding B')
self.finding_a.refresh_from_db()
self.assertEqual(self.finding_a.original_finding.first(), None)
self.assertEqual(self.finding_a.duplicate_finding, None)
self.assertEqual(self.finding_a.duplicate, False)
self.assertEqual(self.finding_a.active, True)
with self.assertRaises(Finding.DoesNotExist):
self.finding_b = Finding.objects.get(id=b_id)
def test_out_of_scope_reopen(self):
logger.debug('c: is_mitigated1: %s', self.finding_c.is_Mitigated)
logger.debug('d: is_mitigated1: %s', self.finding_d.is_Mitigated)
self.finding_c.active = False
self.finding_c.verified = False
logger.debug('set_duplicate(d,c)')
set_duplicate(self.finding_d, self.finding_c)
logger.debug('c: is_mitigated2: %s', self.finding_c.is_Mitigated)
logger.debug('d: is_mitigated2: %s', self.finding_d.is_Mitigated)
# self.finding_d.duplicate = True
# self.finding_d.duplicate_finding = self.finding_c
logger.debug('saving finding_c')
super(Finding, self.finding_c).save()
logger.debug('saving finding_d')
super(Finding, self.finding_d).save()
logger.debug('c: is_mitigated3: %s', self.finding_c.is_Mitigated)
logger.debug('d: is_mitigated3: %s', self.finding_d.is_Mitigated)
candidates = Finding.objects.filter(
duplicate_finding__isnull=False,
original_finding__isnull=False).count()
self.assertEqual(candidates, 0)
# Get latest status
self.finding_c = Finding.objects.get(id=self.finding_c.id)
self.finding_d = Finding.objects.get(id=self.finding_d.id)
self.assertTrue(self.finding_c.out_of_scope)
self.assertTrue(self.finding_c.is_Mitigated)
self.assertFalse(self.finding_c.active)
self.assertFalse(self.finding_c.verified)
self.assertFalse(self.finding_d.out_of_scope)
self.assertFalse(self.finding_d.is_Mitigated)
self.assertFalse(self.finding_d.active)
self.assertFalse(self.finding_d.verified)
def test_loop_relations_for_three(self):
set_duplicate(self.finding_a, self.finding_b)
self.finding_b.duplicate = True
self.finding_b.duplicate_finding = self.finding_c
self.finding_c.duplicate = True
self.finding_c.duplicate_finding = self.finding_a
super(Finding, self.finding_a).save()
super(Finding, self.finding_b).save()
super(Finding, self.finding_c).save()
fix_loop_duplicates()
# Get latest status
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.finding_b = Finding.objects.get(id=self.finding_b.id)
self.finding_c = Finding.objects.get(id=self.finding_c.id)
if self.finding_a.duplicate_finding:
self.assertTrue(self.finding_a.duplicate)
self.assertEqual(self.finding_a.original_finding.count(), 0)
else:
self.assertFalse(self.finding_a.duplicate)
self.assertEqual(self.finding_a.original_finding.count(), 2)
if self.finding_b.duplicate_finding:
self.assertTrue(self.finding_b.duplicate)
self.assertEqual(self.finding_b.original_finding.count(), 0)
else:
self.assertFalse(self.finding_b.duplicate)
self.assertEqual(self.finding_b.original_finding.count(), 2)
if self.finding_c.duplicate_finding:
self.assertTrue(self.finding_c.duplicate)
self.assertEqual(self.finding_c.original_finding.count(), 0)
else:
self.assertFalse(self.finding_c.duplicate)
self.assertEqual(self.finding_c.original_finding.count(), 2)
def test_list_relations_for_three(self):
set_duplicate(self.finding_a, self.finding_b)
self.finding_b.duplicate = True
self.finding_b.duplicate_finding = self.finding_c
super(Finding, self.finding_a).save()
super(Finding, self.finding_b).save()
super(Finding, self.finding_c).save()
fix_loop_duplicates()
self.finding_a = Finding.objects.get(id=self.finding_a.id)
self.finding_b = Finding.objects.get(id=self.finding_b.id)
self.finding_c = Finding.objects.get(id=self.finding_c.id)
self.assertTrue(self.finding_b.duplicate)
self.assertTrue(self.finding_a.duplicate)
self.assertFalse(self.finding_c.duplicate)
self.assertEqual(self.finding_b.duplicate_finding.id, self.finding_c.id)
self.assertEqual(self.finding_a.duplicate_finding.id, self.finding_c.id)
self.assertEqual(self.finding_c.duplicate_finding, None)
self.assertEqual(self.finding_a.duplicate_finding_set().count(), 2)
self.assertEqual(self.finding_b.duplicate_finding_set().count(), 2)
def test_set_duplicate_exception_3(self):
set_duplicate(self.finding_a, self.finding_b)
set_duplicate(self.finding_c, self.finding_b)
with self.assertRaisesRegex(Exception,
"Existing finding is a duplicate"):
set_duplicate(self.finding_a, self.finding_c)
def test_set_duplicate_exception_2(self):
with self.assertRaisesRegex(Exception,
"Can not add duplicate to itself"):
set_duplicate(self.finding_b, self.finding_b)
def test_set_duplicate_exception_1(self):
self.finding_a.duplicate = True
self.finding_a.save()
with self.assertRaisesRegex(Exception,
"Existing finding is a duplicate"):
set_duplicate(self.finding_b, self.finding_a)
