class FileDiffTests(TestCase):
"""Unit tests for FileDiff."""
fixtures = ['test_scmtools']
def setUp(self):
super(FileDiffTests, self).setUp()
diff = (
b'diff --git a/README b/README\n'
b'index 3d2b777..48272a3 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -2 +2,2 @@\n'
b'-blah blah\n'
b'+blah!\n'
b'+blah!!\n'
)
self.repository = self.create_repository(tool_name='Test')
self.diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=self.diffset,
diff64=diff,
parent_diff64=b'')
def test_get_line_counts_with_defaults(self):
"""Testing FileDiff.get_line_counts with default values"""
counts = self.filediff.get_line_counts()
self.assertIn('raw_insert_count', counts)
self.assertIn('raw_delete_count', counts)
self.assertIn('insert_count', counts)
self.assertIn('delete_count', counts)
self.assertIn('replace_count', counts)
self.assertIn('equal_count', counts)
self.assertIn('total_line_count', counts)
self.assertEqual(counts['raw_insert_count'], 2)
self.assertEqual(counts['raw_delete_count'], 1)
self.assertEqual(counts['insert_count'], 2)
self.assertEqual(counts['delete_count'], 1)
self.assertIsNone(counts['replace_count'])
self.assertIsNone(counts['equal_count'])
self.assertIsNone(counts['total_line_count'])
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 2)
self.assertEqual(diff_hash.delete_count, 1)
def test_set_line_counts(self):
"""Testing FileDiff.set_line_counts"""
self.filediff.set_line_counts(
raw_insert_count=1,
raw_delete_count=2,
insert_count=3,
delete_count=4,
replace_count=5,
equal_count=6,
total_line_count=7)
counts = self.filediff.get_line_counts()
self.assertEqual(counts['raw_insert_count'], 1)
self.assertEqual(counts['raw_delete_count'], 2)
self.assertEqual(counts['insert_count'], 3)
self.assertEqual(counts['delete_count'], 4)
self.assertEqual(counts['replace_count'], 5)
self.assertEqual(counts['equal_count'], 6)
self.assertEqual(counts['total_line_count'], 7)
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 1)
self.assertEqual(diff_hash.delete_count, 2)
def test_long_filenames(self):
"""Testing FileDiff with long filenames (1024 characters)"""
long_filename = 'x' * 1024
filediff = FileDiff.objects.create(source_file=long_filename,
dest_file='foo',
diffset=self.diffset)
self.assertEqual(filediff.source_file, long_filename)
def test_diff_hashes(self):
"""Testing FileDiff with multiple entries and same diff data
deduplicates data
"""
data = (
b'diff -rcN orig_src/foo.c new_src/foo.c\n'
b'*** orig_src/foo.c\t2007-01-24 02:11:31.000000000 -0800\n'
b'--- new_src/foo.c\t2007-01-24 02:14:42.000000000 -0800\n'
b'***************\n'
b'*** 1,5 ****\n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo\n");\n'
b' }\n'
b'--- 1,8 ----\n'
b'+ #include <stdio.h>\n'
b'+ \n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo bar\n");\n'
b'! \treturn 0;\n'
b' }\n')
filediff1 = FileDiff.objects.create(diff=data, diffset=self.diffset)
filediff2 = FileDiff.objects.create(diff=data, diffset=self.diffset)
self.assertEqual(filediff1.diff_hash, filediff2.diff_hash)
def test_get_base_filediff(self):
"""Testing FileDiff.get_base_filediff"""
commit1 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r1',
parent_id='r0',
diff_contents=(
b'diff --git a/ABC b/ABC\n'
b'index 94bdd3e..197009f 100644\n'
b'--- ABC\n'
b'+++ ABC\n'
b'@@ -1,1 +1,1 @@\n'
b'-line!\n'
b'+line..\n'
))
commit2 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r2',
parent_id='r1',
diff_contents=(
b'diff --git a/README b/README\n'
b'index 94bdd3e..197009f 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -1,1 +1,1 @@\n'
b'-Hello, world!\n'
b'+Hi, world!\n'
))
commit3 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r3',
parent_id='r2',
diff_contents=(
b'diff --git a/FOO b/FOO\n'
b'index 84bda3e..b975034 100644\n'
b'--- FOO\n'
b'+++ FOO\n'
b'@@ -1,1 +0,0 @@\n'
b'-Some line\n'
))
commit4 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r4',
parent_id='r3',
diff_contents=(
b'diff --git a/README b/README\n'
b'index 197009f..87abad9 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -1,1 +1,1 @@\n'
b'-Hi, world!\n'
b'+Yo, world.\n'
))
self.diffset.finalize_commit_series(
cumulative_diff=(
b'diff --git a/ABC b/ABC\n'
b'index 94bdd3e..197009f 100644\n'
b'--- ABC\n'
b'+++ ABC\n'
b'@@ -1,1 +1,1 @@\n'
b'-line!\n'
b'+line..\n'
b'diff --git a/FOO b/FOO\n'
b'index 84bda3e..b975034 100644\n'
b'--- FOO\n'
b'+++ FOO\n'
b'@@ -1,1 +0,0 @@\n'
b'-Some line\n'
b'diff --git a/README b/README\n'
b'index 94bdd3e..87abad9 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -1,1 +1,1 @@\n'
b'-Hello, world!\n'
b'+Yo, world.\n'
),
validation_info=None,
validate=False,
save=True)
filediff1 = commit1.files.get()
filediff2 = commit2.files.get()
filediff3 = commit3.files.get()
filediff4 = commit4.files.get()
for commit in (commit1, commit2, commit3, commit4):
self.assertIsNone(filediff1.get_base_filediff(base_commit=commit))
self.assertIsNone(filediff2.get_base_filediff(base_commit=commit))
self.assertIsNone(filediff3.get_base_filediff(base_commit=commit))
self.assertIsNone(filediff4.get_base_filediff(base_commit=commit1))
self.assertEqual(filediff4.get_base_filediff(base_commit=commit2),
filediff2)
self.assertEqual(filediff4.get_base_filediff(base_commit=commit3),
filediff2)
self.assertEqual(filediff4.get_base_filediff(base_commit=commit4),
filediff2)
def test_get_base_filediff_without_commit(self):
"""Testing FileDiff.get_base_filediff without associated commit"""
filediff = self.create_filediff(self.diffset)
self.assertIsNone(filediff.get_base_filediff(base_commit=None))
class FileDiffTests(TestCase):
"""Unit tests for FileDiff."""
fixtures = ['test_scmtools']
def setUp(self):
super(FileDiffTests, self).setUp()
diff = (b'diff --git a/README b/README\n'
b'index 3d2b777..48272a3 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -2 +2,2 @@\n'
b'-blah blah\n'
b'+blah!\n'
b'+blah!!\n')
self.repository = self.create_repository(tool_name='Test')
self.diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=self.diffset,
diff64=diff,
parent_diff64=b'')
def test_get_line_counts_with_defaults(self):
"""Testing FileDiff.get_line_counts with default values"""
counts = self.filediff.get_line_counts()
self.assertIn('raw_insert_count', counts)
self.assertIn('raw_delete_count', counts)
self.assertIn('insert_count', counts)
self.assertIn('delete_count', counts)
self.assertIn('replace_count', counts)
self.assertIn('equal_count', counts)
self.assertIn('total_line_count', counts)
self.assertEqual(counts['raw_insert_count'], 2)
self.assertEqual(counts['raw_delete_count'], 1)
self.assertEqual(counts['insert_count'], 2)
self.assertEqual(counts['delete_count'], 1)
self.assertIsNone(counts['replace_count'])
self.assertIsNone(counts['equal_count'])
self.assertIsNone(counts['total_line_count'])
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 2)
self.assertEqual(diff_hash.delete_count, 1)
def test_set_line_counts(self):
"""Testing FileDiff.set_line_counts"""
self.filediff.set_line_counts(raw_insert_count=1,
raw_delete_count=2,
insert_count=3,
delete_count=4,
replace_count=5,
equal_count=6,
total_line_count=7)
counts = self.filediff.get_line_counts()
self.assertEqual(counts['raw_insert_count'], 1)
self.assertEqual(counts['raw_delete_count'], 2)
self.assertEqual(counts['insert_count'], 3)
self.assertEqual(counts['delete_count'], 4)
self.assertEqual(counts['replace_count'], 5)
self.assertEqual(counts['equal_count'], 6)
self.assertEqual(counts['total_line_count'], 7)
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 1)
self.assertEqual(diff_hash.delete_count, 2)
def test_long_filenames(self):
"""Testing FileDiff with long filenames (1024 characters)"""
long_filename = 'x' * 1024
filediff = FileDiff.objects.create(source_file=long_filename,
dest_file='foo',
diffset=self.diffset)
self.assertEqual(filediff.source_file, long_filename)
def test_diff_hashes(self):
"""Testing FileDiff with multiple entries and same diff data
deduplicates data
"""
data = (b'diff -rcN orig_src/foo.c new_src/foo.c\n'
b'*** orig_src/foo.c\t2007-01-24 02:11:31.000000000 -0800\n'
b'--- new_src/foo.c\t2007-01-24 02:14:42.000000000 -0800\n'
b'***************\n'
b'*** 1,5 ****\n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo\n");\n'
b' }\n'
b'--- 1,8 ----\n'
b'+ #include <stdio.h>\n'
b'+ \n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo bar\n");\n'
b'! \treturn 0;\n'
b' }\n')
filediff1 = FileDiff.objects.create(diff=data, diffset=self.diffset)
filediff2 = FileDiff.objects.create(diff=data, diffset=self.diffset)
self.assertEqual(filediff1.diff_hash, filediff2.diff_hash)
class FileDiffTests(TestCase):
"""Unit tests for FileDiff."""
fixtures = ['test_scmtools']
def setUp(self):
super(FileDiffTests, self).setUp()
diff = (b'diff --git a/README b/README\n'
b'index 3d2b777..48272a3 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -2 +2,2 @@\n'
b'-blah blah\n'
b'+blah!\n'
b'+blah!!\n')
self.repository = self.create_repository(tool_name='Test')
self.diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=self.diffset,
diff64=diff,
parent_diff64=b'')
def test_get_line_counts_with_defaults(self):
"""Testing FileDiff.get_line_counts with default values"""
counts = self.filediff.get_line_counts()
self.assertIn('raw_insert_count', counts)
self.assertIn('raw_delete_count', counts)
self.assertIn('insert_count', counts)
self.assertIn('delete_count', counts)
self.assertIn('replace_count', counts)
self.assertIn('equal_count', counts)
self.assertIn('total_line_count', counts)
self.assertEqual(counts['raw_insert_count'], 2)
self.assertEqual(counts['raw_delete_count'], 1)
self.assertEqual(counts['insert_count'], 2)
self.assertEqual(counts['delete_count'], 1)
self.assertIsNone(counts['replace_count'])
self.assertIsNone(counts['equal_count'])
self.assertIsNone(counts['total_line_count'])
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 2)
self.assertEqual(diff_hash.delete_count, 1)
def test_set_line_counts(self):
"""Testing FileDiff.set_line_counts"""
self.filediff.set_line_counts(raw_insert_count=1,
raw_delete_count=2,
insert_count=3,
delete_count=4,
replace_count=5,
equal_count=6,
total_line_count=7)
counts = self.filediff.get_line_counts()
self.assertEqual(counts['raw_insert_count'], 1)
self.assertEqual(counts['raw_delete_count'], 2)
self.assertEqual(counts['insert_count'], 3)
self.assertEqual(counts['delete_count'], 4)
self.assertEqual(counts['replace_count'], 5)
self.assertEqual(counts['equal_count'], 6)
self.assertEqual(counts['total_line_count'], 7)
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 1)
self.assertEqual(diff_hash.delete_count, 2)
def test_long_filenames(self):
"""Testing FileDiff with long filenames (1024 characters)"""
long_filename = 'x' * 1024
filediff = FileDiff.objects.create(source_file=long_filename,
dest_file='foo',
diffset=self.diffset)
self.assertEqual(filediff.source_file, long_filename)
def test_diff_hashes(self):
"""Testing FileDiff with multiple entries and same diff data
deduplicates data
"""
data = (b'diff -rcN orig_src/foo.c new_src/foo.c\n'
b'*** orig_src/foo.c\t2007-01-24 02:11:31.000000000 -0800\n'
b'--- new_src/foo.c\t2007-01-24 02:14:42.000000000 -0800\n'
b'***************\n'
b'*** 1,5 ****\n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo\n");\n'
b' }\n'
b'--- 1,8 ----\n'
b'+ #include <stdio.h>\n'
b'+ \n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo bar\n");\n'
b'! \treturn 0;\n'
b' }\n')
filediff1 = FileDiff.objects.create(diff=data, diffset=self.diffset)
filediff2 = FileDiff.objects.create(diff=data, diffset=self.diffset)
self.assertEqual(filediff1.diff_hash, filediff2.diff_hash)
def test_get_base_filediff(self):
"""Testing FileDiff.get_base_filediff"""
commit1 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r1',
parent_id='r0',
diff_contents=(b'diff --git a/ABC b/ABC\n'
b'index 94bdd3e..197009f 100644\n'
b'--- ABC\n'
b'+++ ABC\n'
b'@@ -1,1 +1,1 @@\n'
b'-line!\n'
b'+line..\n'))
commit2 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r2',
parent_id='r1',
diff_contents=(b'diff --git a/README b/README\n'
b'index 94bdd3e..197009f 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -1,1 +1,1 @@\n'
b'-Hello, world!\n'
b'+Hi, world!\n'))
commit3 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r3',
parent_id='r2',
diff_contents=(b'diff --git a/FOO b/FOO\n'
b'index 84bda3e..b975034 100644\n'
b'--- FOO\n'
b'+++ FOO\n'
b'@@ -1,1 +0,0 @@\n'
b'-Some line\n'))
commit4 = self.create_diffcommit(
diffset=self.diffset,
commit_id='r4',
parent_id='r3',
diff_contents=(b'diff --git a/README b/README\n'
b'index 197009f..87abad9 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -1,1 +1,1 @@\n'
b'-Hi, world!\n'
b'+Yo, world.\n'))
self.diffset.finalize_commit_series(
cumulative_diff=(b'diff --git a/ABC b/ABC\n'
b'index 94bdd3e..197009f 100644\n'
b'--- ABC\n'
b'+++ ABC\n'
b'@@ -1,1 +1,1 @@\n'
b'-line!\n'
b'+line..\n'
b'diff --git a/FOO b/FOO\n'
b'index 84bda3e..b975034 100644\n'
b'--- FOO\n'
b'+++ FOO\n'
b'@@ -1,1 +0,0 @@\n'
b'-Some line\n'
b'diff --git a/README b/README\n'
b'index 94bdd3e..87abad9 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -1,1 +1,1 @@\n'
b'-Hello, world!\n'
b'+Yo, world.\n'),
validation_info=None,
validate=False,
save=True)
filediff1 = commit1.files.get()
filediff2 = commit2.files.get()
filediff3 = commit3.files.get()
filediff4 = commit4.files.get()
for commit in (commit1, commit2, commit3, commit4):
self.assertIsNone(filediff1.get_base_filediff(base_commit=commit))
self.assertIsNone(filediff2.get_base_filediff(base_commit=commit))
self.assertIsNone(filediff3.get_base_filediff(base_commit=commit))
self.assertIsNone(filediff4.get_base_filediff(base_commit=commit1))
self.assertEqual(filediff4.get_base_filediff(base_commit=commit2),
filediff2)
self.assertEqual(filediff4.get_base_filediff(base_commit=commit3),
filediff2)
self.assertEqual(filediff4.get_base_filediff(base_commit=commit4),
filediff2)
def test_get_base_filediff_without_commit(self):
"""Testing FileDiff.get_base_filediff without associated commit"""
filediff = self.create_filediff(self.diffset)
self.assertIsNone(filediff.get_base_filediff(base_commit=None))
class FileDiffTests(TestCase):
"""Unit tests for FileDiff."""
fixtures = ['test_scmtools']
def setUp(self):
super(FileDiffTests, self).setUp()
diff = (
b'diff --git a/README b/README\n'
b'index 3d2b777..48272a3 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -2 +2,2 @@\n'
b'-blah blah\n'
b'+blah!\n'
b'+blah!!\n'
)
self.repository = self.create_repository(tool_name='Test')
self.diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=self.diffset,
diff64=diff,
parent_diff64=b'')
def test_get_line_counts_with_defaults(self):
"""Testing FileDiff.get_line_counts with default values"""
counts = self.filediff.get_line_counts()
self.assertIn('raw_insert_count', counts)
self.assertIn('raw_delete_count', counts)
self.assertIn('insert_count', counts)
self.assertIn('delete_count', counts)
self.assertIn('replace_count', counts)
self.assertIn('equal_count', counts)
self.assertIn('total_line_count', counts)
self.assertEqual(counts['raw_insert_count'], 2)
self.assertEqual(counts['raw_delete_count'], 1)
self.assertEqual(counts['insert_count'], 2)
self.assertEqual(counts['delete_count'], 1)
self.assertIsNone(counts['replace_count'])
self.assertIsNone(counts['equal_count'])
self.assertIsNone(counts['total_line_count'])
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 2)
self.assertEqual(diff_hash.delete_count, 1)
def test_set_line_counts(self):
"""Testing FileDiff.set_line_counts"""
self.filediff.set_line_counts(
raw_insert_count=1,
raw_delete_count=2,
insert_count=3,
delete_count=4,
replace_count=5,
equal_count=6,
total_line_count=7)
counts = self.filediff.get_line_counts()
self.assertEqual(counts['raw_insert_count'], 1)
self.assertEqual(counts['raw_delete_count'], 2)
self.assertEqual(counts['insert_count'], 3)
self.assertEqual(counts['delete_count'], 4)
self.assertEqual(counts['replace_count'], 5)
self.assertEqual(counts['equal_count'], 6)
self.assertEqual(counts['total_line_count'], 7)
diff_hash = self.filediff.diff_hash
self.assertEqual(diff_hash.insert_count, 1)
self.assertEqual(diff_hash.delete_count, 2)
def test_long_filenames(self):
"""Testing FileDiff with long filenames (1024 characters)"""
long_filename = 'x' * 1024
filediff = FileDiff.objects.create(source_file=long_filename,
dest_file='foo',
diffset=self.diffset)
self.assertEqual(filediff.source_file, long_filename)
def test_diff_hashes(self):
"""Testing FileDiff with multiple entries and same diff data
deduplicates data
"""
data = (
b'diff -rcN orig_src/foo.c new_src/foo.c\n'
b'*** orig_src/foo.c\t2007-01-24 02:11:31.000000000 -0800\n'
b'--- new_src/foo.c\t2007-01-24 02:14:42.000000000 -0800\n'
b'***************\n'
b'*** 1,5 ****\n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo\n");\n'
b' }\n'
b'--- 1,8 ----\n'
b'+ #include <stdio.h>\n'
b'+ \n'
b' int\n'
b' main()\n'
b' {\n'
b'! \tprintf("foo bar\n");\n'
b'! \treturn 0;\n'
b' }\n')
filediff1 = FileDiff.objects.create(diff=data, diffset=self.diffset)
filediff2 = FileDiff.objects.create(diff=data, diffset=self.diffset)
self.assertEqual(filediff1.diff_hash, filediff2.diff_hash)
class FileDiffMigrationTests(TestCase):
"""Unit tests for FileDiff migration."""
fixtures = ['test_scmtools']
def setUp(self):
super(FileDiffMigrationTests, self).setUp()
self.repository = self.create_repository(tool_name='Test')
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=diffset,
diff64=b'',
parent_diff64=b'')
self.parent_diff = (b'diff --git a/README b/README\n'
b'index 94bdd3e..3d2b777 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -2 +2 @@\n'
b'-blah..\n'
b'+blah blah\n')
repository = self.create_repository(tool_name='Test')
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=diffset,
diff64=b'',
parent_diff64=b'')
def test_migration_by_diff(self):
"""Testing RawFileDiffData migration accessing FileDiff.diff"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA_DIFF
self.assertIsNone(self.filediff.diff_hash)
self.assertIsNone(self.filediff.parent_diff_hash)
# This should prompt the migration.
diff = self.filediff.diff
self.assertIsNone(self.filediff.parent_diff_hash)
self.assertIsNotNone(self.filediff.diff_hash)
self.assertEqual(diff, self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(self.filediff.diff64, b'')
self.assertEqual(self.filediff.diff_hash.binary,
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(self.filediff.diff, diff)
self.assertIsNone(self.filediff.parent_diff)
self.assertIsNone(self.filediff.parent_diff_hash)
def test_migration_by_parent_diff(self):
"""Testing RawFileDiffData migration accessing FileDiff.parent_diff"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA_DIFF
self.filediff.parent_diff64 = self.parent_diff
self.assertIsNone(self.filediff.parent_diff_hash)
# This should prompt the migration.
parent_diff = self.filediff.parent_diff
self.assertIsNotNone(self.filediff.parent_diff_hash)
self.assertEqual(parent_diff, self.parent_diff)
self.assertEqual(self.filediff.parent_diff64, b'')
self.assertEqual(self.filediff.parent_diff_hash.binary,
self.parent_diff)
self.assertEqual(self.filediff.parent_diff, self.parent_diff)
def test_migration_by_delete_count(self):
"""Testing RawFileDiffData migration accessing FileDiff.delete_count"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA_DIFF
self.assertIsNone(self.filediff.diff_hash)
# This should prompt the migration.
counts = self.filediff.get_line_counts()
self.assertIsNotNone(self.filediff.diff_hash)
self.assertEqual(counts['raw_delete_count'], 1)
self.assertEqual(self.filediff.diff_hash.delete_count, 1)
def test_migration_by_insert_count(self):
"""Testing RawFileDiffData migration accessing FileDiff.insert_count"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA_DIFF
self.assertIsNone(self.filediff.diff_hash)
# This should prompt the migration.
counts = self.filediff.get_line_counts()
self.assertIsNotNone(self.filediff.diff_hash)
self.assertEqual(counts['raw_insert_count'], 1)
self.assertEqual(self.filediff.diff_hash.insert_count, 1)
def test_migration_by_set_line_counts(self):
"""Testing RawFileDiffData migration calling FileDiff.set_line_counts
"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA_DIFF
self.assertIsNone(self.filediff.diff_hash)
# This should prompt the migration, but with our line counts.
self.filediff.set_line_counts(raw_insert_count=10, raw_delete_count=20)
self.assertIsNotNone(self.filediff.diff_hash)
counts = self.filediff.get_line_counts()
self.assertEqual(counts['raw_insert_count'], 10)
self.assertEqual(counts['raw_delete_count'], 20)
self.assertEqual(self.filediff.diff_hash.insert_count, 10)
self.assertEqual(self.filediff.diff_hash.delete_count, 20)
def test_migration_by_legacy_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.diff
with associated LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.DEFAULT_GIT_FILEDIFF_DATA_DIFF))
self.filediff.legacy_diff_hash = legacy
self.filediff.save()
# This should prompt the migration.
diff = self.filediff.diff
self.assertIsNotNone(self.filediff.diff_hash)
self.assertIsNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_diff_hash)
self.assertEqual(LegacyFileDiffData.objects.count(), 0)
self.assertEqual(diff, self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(self.filediff.diff64, b'')
self.assertEqual(self.filediff.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(self.filediff.diff, diff)
self.assertIsNone(self.filediff.parent_diff)
self.assertIsNone(self.filediff.parent_diff_hash)
def test_migration_by_shared_legacy_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.diff
with associated shared LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.DEFAULT_GIT_FILEDIFF_DATA_DIFF))
self.filediff.legacy_diff_hash = legacy
self.filediff.save()
# Create a second FileDiff using this legacy data.
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
FileDiff.objects.create(source_file='README',
dest_file='README',
diffset=diffset,
diff64=b'',
parent_diff64=b'',
legacy_diff_hash=legacy)
# This should prompt the migration.
diff = self.filediff.diff
self.assertIsNotNone(self.filediff.diff_hash)
self.assertIsNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_diff_hash)
self.assertEqual(LegacyFileDiffData.objects.count(), 1)
self.assertEqual(diff, self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(self.filediff.diff64, b'')
self.assertEqual(self.filediff.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(self.filediff.diff, diff)
self.assertIsNone(self.filediff.parent_diff)
self.assertIsNone(self.filediff.parent_diff_hash)
def test_migration_by_legacy_parent_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.parent_diff
with associated LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(binary_hash='abc123',
binary=Base64DecodedValue(
self.parent_diff))
self.filediff.legacy_parent_diff_hash = legacy
self.filediff.save()
# This should prompt the migration.
parent_diff = self.filediff.parent_diff
self.assertIsNotNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_parent_diff_hash)
self.assertEqual(parent_diff, self.parent_diff)
self.assertEqual(self.filediff.parent_diff64, b'')
self.assertEqual(self.filediff.parent_diff_hash.content,
self.parent_diff)
self.assertEqual(self.filediff.parent_diff, parent_diff)
def test_migration_by_shared_legacy_parent_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.parent_diff
with associated shared LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(binary_hash='abc123',
binary=Base64DecodedValue(
self.parent_diff))
self.filediff.legacy_parent_diff_hash = legacy
self.filediff.save()
# Create a second FileDiff using this legacy data.
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
FileDiff.objects.create(source_file='README',
dest_file='README',
diffset=diffset,
diff64=b'',
parent_diff64=b'',
legacy_parent_diff_hash=legacy)
# This should prompt the migration.
parent_diff = self.filediff.parent_diff
self.assertIsNotNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_parent_diff_hash)
self.assertEqual(LegacyFileDiffData.objects.count(), 1)
self.assertEqual(parent_diff, self.parent_diff)
self.assertEqual(self.filediff.parent_diff64, b'')
self.assertEqual(self.filediff.parent_diff_hash.content,
self.parent_diff)
self.assertEqual(self.filediff.parent_diff, parent_diff)
def test_migration_with_legacy_and_race_condition(self):
"""Testing RawFileDiffData migration with LegacyFileDiffData and race
condition in migrating
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.DEFAULT_GIT_FILEDIFF_DATA_DIFF))
parent_legacy = LegacyFileDiffData.objects.create(
binary_hash='def456', binary=Base64DecodedValue(self.parent_diff))
filediff1 = self.filediff
filediff1.legacy_diff_hash = legacy
filediff1.legacy_parent_diff_hash = parent_legacy
filediff1.save()
filediff2 = FileDiff.objects.get(pk=filediff1.pk)
# Make sure that we're in the expected state.
self.assertEqual(filediff1.legacy_diff_hash_id, legacy.pk)
self.assertEqual(filediff1.legacy_parent_diff_hash_id,
parent_legacy.pk)
self.assertEqual(filediff2.legacy_diff_hash_id, legacy.pk)
self.assertEqual(filediff2.legacy_parent_diff_hash_id,
parent_legacy.pk)
# This should prompt the migration of the first instance.
diff1 = self.filediff.diff
parent_diff1 = filediff1.parent_diff
# This should prompt the migration of the second instance.
diff2 = filediff2.diff
parent_diff2 = filediff2.parent_diff
# At this point, we should have valid diffs, and neither call
# above should have raised an exception due to a dangling hash ID.
self.assertEqual(diff1, self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(diff1, diff2)
self.assertEqual(parent_diff1, self.parent_diff)
self.assertEqual(parent_diff1, parent_diff2)
self.assertEqual(LegacyFileDiffData.objects.count(), 0)
self.assertEqual(RawFileDiffData.objects.count(), 2)
# Check the hash references.
self.assertIsNotNone(filediff1.diff_hash)
self.assertIsNotNone(filediff2.diff_hash)
self.assertEqual(filediff1.diff_hash, filediff2.diff_hash)
self.assertIsNotNone(filediff1.parent_diff_hash)
self.assertIsNotNone(filediff2.parent_diff_hash)
self.assertEqual(filediff1.parent_diff_hash,
filediff2.parent_diff_hash)
self.assertIsNone(filediff1.legacy_diff_hash)
self.assertIsNone(filediff2.legacy_diff_hash)
self.assertIsNone(filediff1.legacy_parent_diff_hash)
self.assertIsNone(filediff2.legacy_parent_diff_hash)
# Check the diff content.
self.assertEqual(filediff1.diff64, b'')
self.assertEqual(filediff2.diff64, b'')
self.assertEqual(filediff1.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
self.assertEqual(filediff2.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA_DIFF)
# Check the parent_diff content.
self.assertEqual(filediff1.parent_diff64, b'')
self.assertEqual(filediff2.parent_diff64, b'')
self.assertEqual(filediff1.parent_diff_hash.content, self.parent_diff)
self.assertEqual(filediff2.parent_diff_hash.content, self.parent_diff)
class FileDiffMigrationTests(TestCase):
"""Unit tests for FileDiff migration."""
fixtures = ['test_scmtools']
def setUp(self):
super(FileDiffMigrationTests, self).setUp()
self.repository = self.create_repository(tool_name='Test')
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=diffset,
diff64='',
parent_diff64='')
self.parent_diff = (
b'diff --git a/README b/README\n'
b'index 94bdd3e..3d2b777 100644\n'
b'--- README\n'
b'+++ README\n'
b'@@ -2 +2 @@\n'
b'-blah..\n'
b'+blah blah\n'
)
repository = self.create_repository(tool_name='Test')
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=repository)
self.filediff = FileDiff(source_file='README',
dest_file='README',
diffset=diffset,
diff64='',
parent_diff64=b'')
def test_migration_by_diff(self):
"""Testing RawFileDiffData migration accessing FileDiff.diff"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA
self.assertIsNone(self.filediff.diff_hash)
self.assertIsNone(self.filediff.parent_diff_hash)
# This should prompt the migration.
diff = self.filediff.diff
self.assertIsNone(self.filediff.parent_diff_hash)
self.assertIsNotNone(self.filediff.diff_hash)
self.assertEqual(diff, self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(self.filediff.diff64, b'')
self.assertEqual(self.filediff.diff_hash.binary,
self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(self.filediff.diff, diff)
self.assertIsNone(self.filediff.parent_diff)
self.assertIsNone(self.filediff.parent_diff_hash)
def test_migration_by_parent_diff(self):
"""Testing RawFileDiffData migration accessing FileDiff.parent_diff"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA
self.filediff.parent_diff64 = self.parent_diff
self.assertIsNone(self.filediff.parent_diff_hash)
# This should prompt the migration.
parent_diff = self.filediff.parent_diff
self.assertIsNotNone(self.filediff.parent_diff_hash)
self.assertEqual(parent_diff, self.parent_diff)
self.assertEqual(self.filediff.parent_diff64, b'')
self.assertEqual(self.filediff.parent_diff_hash.binary,
self.parent_diff)
self.assertEqual(self.filediff.parent_diff, self.parent_diff)
def test_migration_by_delete_count(self):
"""Testing RawFileDiffData migration accessing FileDiff.delete_count"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA
self.assertIsNone(self.filediff.diff_hash)
# This should prompt the migration.
counts = self.filediff.get_line_counts()
self.assertIsNotNone(self.filediff.diff_hash)
self.assertEqual(counts['raw_delete_count'], 1)
self.assertEqual(self.filediff.diff_hash.delete_count, 1)
def test_migration_by_insert_count(self):
"""Testing RawFileDiffData migration accessing FileDiff.insert_count"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA
self.assertIsNone(self.filediff.diff_hash)
# This should prompt the migration.
counts = self.filediff.get_line_counts()
self.assertIsNotNone(self.filediff.diff_hash)
self.assertEqual(counts['raw_insert_count'], 1)
self.assertEqual(self.filediff.diff_hash.insert_count, 1)
def test_migration_by_set_line_counts(self):
"""Testing RawFileDiffData migration calling FileDiff.set_line_counts
"""
self.filediff.diff64 = self.DEFAULT_GIT_FILEDIFF_DATA
self.assertIsNone(self.filediff.diff_hash)
# This should prompt the migration, but with our line counts.
self.filediff.set_line_counts(raw_insert_count=10,
raw_delete_count=20)
self.assertIsNotNone(self.filediff.diff_hash)
counts = self.filediff.get_line_counts()
self.assertEqual(counts['raw_insert_count'], 10)
self.assertEqual(counts['raw_delete_count'], 20)
self.assertEqual(self.filediff.diff_hash.insert_count, 10)
self.assertEqual(self.filediff.diff_hash.delete_count, 20)
def test_migration_by_legacy_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.diff
with associated LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.DEFAULT_GIT_FILEDIFF_DATA))
self.filediff.legacy_diff_hash = legacy
self.filediff.save()
# This should prompt the migration.
diff = self.filediff.diff
self.assertIsNotNone(self.filediff.diff_hash)
self.assertIsNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_diff_hash)
self.assertEqual(LegacyFileDiffData.objects.count(), 0)
self.assertEqual(diff, self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(self.filediff.diff64, '')
self.assertEqual(self.filediff.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(self.filediff.diff, diff)
self.assertIsNone(self.filediff.parent_diff)
self.assertIsNone(self.filediff.parent_diff_hash)
def test_migration_by_shared_legacy_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.diff
with associated shared LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.DEFAULT_GIT_FILEDIFF_DATA))
self.filediff.legacy_diff_hash = legacy
self.filediff.save()
# Create a second FileDiff using this legacy data.
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
FileDiff.objects.create(source_file='README',
dest_file='README',
diffset=diffset,
diff64='',
parent_diff64='',
legacy_diff_hash=legacy)
# This should prompt the migration.
diff = self.filediff.diff
self.assertIsNotNone(self.filediff.diff_hash)
self.assertIsNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_diff_hash)
self.assertEqual(LegacyFileDiffData.objects.count(), 1)
self.assertEqual(diff, self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(self.filediff.diff64, '')
self.assertEqual(self.filediff.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(self.filediff.diff, diff)
self.assertIsNone(self.filediff.parent_diff)
self.assertIsNone(self.filediff.parent_diff_hash)
def test_migration_by_legacy_parent_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.parent_diff
with associated LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.parent_diff))
self.filediff.legacy_parent_diff_hash = legacy
self.filediff.save()
# This should prompt the migration.
parent_diff = self.filediff.parent_diff
self.assertIsNotNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_parent_diff_hash)
self.assertEqual(parent_diff, self.parent_diff)
self.assertEqual(self.filediff.parent_diff64, '')
self.assertEqual(self.filediff.parent_diff_hash.content,
self.parent_diff)
self.assertEqual(self.filediff.parent_diff, parent_diff)
def test_migration_by_shared_legacy_parent_diff_hash(self):
"""Testing RawFileDiffData migration accessing FileDiff.parent_diff
with associated shared LegacyFileDiffData
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.parent_diff))
self.filediff.legacy_parent_diff_hash = legacy
self.filediff.save()
# Create a second FileDiff using this legacy data.
diffset = DiffSet.objects.create(name='test',
revision=1,
repository=self.repository)
FileDiff.objects.create(source_file='README',
dest_file='README',
diffset=diffset,
diff64='',
parent_diff64='',
legacy_parent_diff_hash=legacy)
# This should prompt the migration.
parent_diff = self.filediff.parent_diff
self.assertIsNotNone(self.filediff.parent_diff_hash)
self.assertIsNone(self.filediff.legacy_parent_diff_hash)
self.assertEqual(LegacyFileDiffData.objects.count(), 1)
self.assertEqual(parent_diff, self.parent_diff)
self.assertEqual(self.filediff.parent_diff64, '')
self.assertEqual(self.filediff.parent_diff_hash.content,
self.parent_diff)
self.assertEqual(self.filediff.parent_diff, parent_diff)
def test_migration_with_legacy_and_race_condition(self):
"""Testing RawFileDiffData migration with LegacyFileDiffData and race
condition in migrating
"""
legacy = LegacyFileDiffData.objects.create(
binary_hash='abc123',
binary=Base64DecodedValue(self.DEFAULT_GIT_FILEDIFF_DATA))
parent_legacy = LegacyFileDiffData.objects.create(
binary_hash='def456',
binary=Base64DecodedValue(self.parent_diff))
filediff1 = self.filediff
filediff1.legacy_diff_hash = legacy
filediff1.legacy_parent_diff_hash = parent_legacy
filediff1.save()
filediff2 = FileDiff.objects.get(pk=filediff1.pk)
# Make sure that we're in the expected state.
self.assertEqual(filediff1.legacy_diff_hash_id, legacy.pk)
self.assertEqual(filediff1.legacy_parent_diff_hash_id,
parent_legacy.pk)
self.assertEqual(filediff2.legacy_diff_hash_id, legacy.pk)
self.assertEqual(filediff2.legacy_parent_diff_hash_id,
parent_legacy.pk)
# This should prompt the migration of the first instance.
diff1 = self.filediff.diff
parent_diff1 = filediff1.parent_diff
# This should prompt the migration of the second instance.
diff2 = filediff2.diff
parent_diff2 = filediff2.parent_diff
# At this point, we should have valid diffs, and neither call
# above should have raised an exception due to a dangling hash ID.
self.assertEqual(diff1, self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(diff1, diff2)
self.assertEqual(parent_diff1, self.parent_diff)
self.assertEqual(parent_diff1, parent_diff2)
self.assertEqual(LegacyFileDiffData.objects.count(), 0)
self.assertEqual(RawFileDiffData.objects.count(), 2)
# Check the hash references.
self.assertIsNotNone(filediff1.diff_hash)
self.assertIsNotNone(filediff2.diff_hash)
self.assertEqual(filediff1.diff_hash, filediff2.diff_hash)
self.assertIsNotNone(filediff1.parent_diff_hash)
self.assertIsNotNone(filediff2.parent_diff_hash)
self.assertEqual(filediff1.parent_diff_hash,
filediff2.parent_diff_hash)
self.assertIsNone(filediff1.legacy_diff_hash)
self.assertIsNone(filediff2.legacy_diff_hash)
self.assertIsNone(filediff1.legacy_parent_diff_hash)
self.assertIsNone(filediff2.legacy_parent_diff_hash)
# Check the diff content.
self.assertEqual(filediff1.diff64, '')
self.assertEqual(filediff2.diff64, '')
self.assertEqual(filediff1.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA)
self.assertEqual(filediff2.diff_hash.content,
self.DEFAULT_GIT_FILEDIFF_DATA)
# Check the parent_diff content.
self.assertEqual(filediff1.parent_diff64, '')
self.assertEqual(filediff2.parent_diff64, '')
self.assertEqual(filediff1.parent_diff_hash.content, self.parent_diff)
self.assertEqual(filediff2.parent_diff_hash.content, self.parent_diff)
