# -*- coding: utf-8 -*- # The MIT License (MIT) # Copyright (c) 2014-2021 Matias Bordese # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. # IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE # OR OTHER DEALINGS IN THE SOFTWARE. """Tests for the unified diff parser process.""" from __future__ import unicode_literals import codecs import os.path import unittest from unidiff import PatchSet from unidiff.patch import PY2 from unidiff.errors import UnidiffParseError if not PY2: unicode = str class TestUnidiffParser(unittest.TestCase): """Tests for Unified Diff Parser.""" def setUp(self): super(TestUnidiffParser, self).setUp() self.samples_dir = os.path.dirname(os.path.realpath(__file__)) self.sample_file = os.path.join( self.samples_dir, 'samples/sample0.diff') self.sample_bad_file = os.path.join( self.samples_dir, 'samples/sample1.diff') def test_missing_encoding(self): utf8_file = os.path.join(self.samples_dir, 'samples/sample3.diff') # read bytes with open(utf8_file, 'rb') as diff_file: if PY2: self.assertRaises(UnicodeDecodeError, PatchSet, diff_file) else: # unicode expected self.assertRaises(TypeError, PatchSet, diff_file) def test_encoding_param(self): utf8_file = os.path.join(self.samples_dir, 'samples/sample3.diff') with open(utf8_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8') # 3 files updated by diff self.assertEqual(len(res), 3) added_unicode_line = res.added_files[0][0][1] self.assertEqual(added_unicode_line.value, 'holá mundo!\n') def test_no_newline_at_end_of_file(self): utf8_file = os.path.join(self.samples_dir, 'samples/sample3.diff') with open(utf8_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8') # 3 files updated by diff self.assertEqual(len(res), 3) added_unicode_line = res.added_files[0][0][4] self.assertEqual(added_unicode_line.line_type, '\\') self.assertEqual(added_unicode_line.value, ' No newline at end of file\n') added_unicode_line = res.modified_files[0][0][8] self.assertEqual(added_unicode_line.line_type, '\\') self.assertEqual(added_unicode_line.value, ' No newline at end of file\n') def test_preserve_dos_line_endings(self): utf8_file = os.path.join(self.samples_dir, 'samples/sample4.diff') with open(utf8_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8') # 3 files updated by diff self.assertEqual(len(res), 3) added_unicode_line = res.added_files[0][0][1] self.assertEqual(added_unicode_line.value, 'holá mundo!\r\n') def test_preserve_dos_line_endings_empty_line_type(self): utf8_file = os.path.join(self.samples_dir, 'samples/sample5.diff') with open(utf8_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8') # 2 files updated by diff self.assertEqual(len(res), 2) modified_unicode_line = res.modified_files[0][0][6] self.assertEqual(modified_unicode_line.value, '\r\n') self.assertEqual(modified_unicode_line.line_type, ' ') modified_unicode_line = res.modified_files[1][0][6] self.assertEqual(modified_unicode_line.value, '\n') self.assertEqual(modified_unicode_line.line_type, ' ') def test_print_hunks_without_gaps(self): with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: res = PatchSet(diff_file) lines = unicode(res).splitlines() self.assertEqual(lines[12], '@@ -5,16 +11,10 @@') self.assertEqual(lines[31], '@@ -22,3 +22,7 @@') def _test_parse_sample(self, metadata_only): """Parse sample file.""" with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: res = PatchSet(diff_file, metadata_only=metadata_only) # three file in the patch self.assertEqual(len(res), 3) # three hunks self.assertEqual(len(res[0]), 3) # first file is modified self.assertTrue(res[0].is_modified_file) self.assertFalse(res[0].is_removed_file) self.assertFalse(res[0].is_added_file) self.assertFalse(res[0].is_binary_file) # Hunk 1: five additions, no deletions, a section header self.assertEqual(res[0][0].added, 6) self.assertEqual(res[0][0].removed, 0) self.assertEqual(res[0][0].section_header, 'Section Header') # Hunk 2: 2 additions, 8 deletions, no section header self.assertEqual(res[0][1].added, 2) self.assertEqual(res[0][1].removed, 8) self.assertEqual(res[0][1].section_header, '') # Hunk 3: four additions, no deletions, no section header self.assertEqual(res[0][2].added, 4) self.assertEqual(res[0][2].removed, 0) self.assertEqual(res[0][2].section_header, '') # Check file totals self.assertEqual(res[0].added, 12) self.assertEqual(res[0].removed, 8) # second file is added self.assertFalse(res[1].is_modified_file) self.assertFalse(res[1].is_removed_file) self.assertTrue(res[1].is_added_file) self.assertFalse(res[1].is_binary_file) # third file is removed self.assertFalse(res[2].is_modified_file) self.assertTrue(res[2].is_removed_file) self.assertFalse(res[2].is_added_file) self.assertFalse(res[2].is_binary_file) self.assertEqual(res.added, 21) self.assertEqual(res.removed, 17) def test_parse_sample_full(self): self._test_parse_sample(metadata_only=False) def test_parse_sample_metadata_only(self): self._test_parse_sample(metadata_only=True) def test_patchset_compare(self): with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: ps1 = PatchSet(diff_file) with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: ps2 = PatchSet(diff_file) other_file = os.path.join(self.samples_dir, 'samples/sample3.diff') with open(other_file, 'rb') as diff_file: ps3 = PatchSet(diff_file, encoding='utf-8') self.assertEqual(ps1, ps2) self.assertNotEqual(ps1, ps3) def test_patchset_from_string(self): with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: diff_data = diff_file.read() ps1 = PatchSet.from_string(diff_data) with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: ps2 = PatchSet(diff_file) self.assertEqual(ps1, ps2) def test_patchset_from_bytes_string(self): with codecs.open(self.sample_file, 'rb') as diff_file: diff_data = diff_file.read() ps1 = PatchSet.from_string(diff_data, encoding='utf-8') with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: ps2 = PatchSet(diff_file) self.assertEqual(ps1, ps2) def test_patchset_string_input(self): with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: diff_data = diff_file.read() ps1 = PatchSet(diff_data) with codecs.open(self.sample_file, 'r', encoding='utf-8') as diff_file: ps2 = PatchSet(diff_file) self.assertEqual(ps1, ps2) def test_parse_malformed_diff(self): """Parse malformed file.""" with open(self.sample_bad_file) as diff_file: self.assertRaises(UnidiffParseError, PatchSet, diff_file) def test_parse_malformed_diff_longer_than_expected(self): """Parse malformed file with non-terminated hunk.""" utf8_file = os.path.join(self.samples_dir, 'samples/sample6.diff') with open(utf8_file, 'r') as diff_file: self.assertRaises(UnidiffParseError, PatchSet, diff_file) def test_parse_malformed_diff_shorter_than_expected(self): """Parse malformed file with non-terminated hunk.""" utf8_file = os.path.join(self.samples_dir, 'samples/sample7.diff') with open(utf8_file, 'r') as diff_file: self.assertRaises(UnidiffParseError, PatchSet, diff_file) def test_from_filename_with_cr_in_diff_text_files(self): """Parse git diff text files that contain CR""" utf8_file = os.path.join(self.samples_dir, 'samples/git_cr.diff') self.assertRaises(UnidiffParseError, PatchSet.from_filename, utf8_file) ps1 = PatchSet.from_filename(utf8_file, newline='\n') import io with io.open(utf8_file, 'r', newline='\n') as diff_file: ps2 = PatchSet(diff_file) self.assertEqual(ps1, ps2) def test_parse_diff_with_new_and_modified_binary_files(self): """Parse git diff file with newly added and modified binaries files.""" utf8_file = os.path.join(self.samples_dir, 'samples/sample8.diff') with open(utf8_file, 'r') as diff_file: res = PatchSet(diff_file) # three file in the patch self.assertEqual(len(res), 5) # first empty file is added self.assertFalse(res[0].is_modified_file) self.assertFalse(res[0].is_removed_file) self.assertTrue(res[0].is_added_file) self.assertFalse(res[0].is_binary_file) # second file is added self.assertFalse(res[1].is_modified_file) self.assertFalse(res[1].is_removed_file) self.assertTrue(res[1].is_added_file) self.assertTrue(res[1].is_binary_file) # third file is modified self.assertTrue(res[2].is_modified_file) self.assertFalse(res[2].is_removed_file) self.assertFalse(res[2].is_added_file) self.assertTrue(res[2].is_binary_file) # fourth file is removed self.assertFalse(res[3].is_modified_file) self.assertTrue(res[3].is_removed_file) self.assertFalse(res[3].is_added_file) self.assertTrue(res[3].is_binary_file) # fifth empty file is added self.assertFalse(res[4].is_modified_file) self.assertFalse(res[4].is_removed_file) self.assertTrue(res[4].is_added_file) self.assertFalse(res[4].is_binary_file) def test_parse_round_trip_with_binary_files_in_diff(self): """Parse git diff with binary files though round trip""" utf8_file = os.path.join(self.samples_dir, 'samples/sample8.diff') with open(utf8_file, 'r') as diff_file: res1 = PatchSet(diff_file) res2 = PatchSet(str(res1)) self.assertEqual(res1, res2) def test_parse_diff_git_no_prefix(self): utf8_file = os.path.join(self.samples_dir, 'samples/git_no_prefix.diff') with open(utf8_file, 'r') as diff_file: res = PatchSet(diff_file) self.assertEqual(len(res), 3) self.assertEqual(res[0].source_file, 'file1') self.assertEqual(res[0].target_file, '/dev/null') self.assertTrue(res[0].is_removed_file) self.assertEqual(res[0].path, 'file1') self.assertEqual(res[1].source_file, 'file2') self.assertEqual(res[1].target_file, 'file2') self.assertTrue(res[1].is_modified_file) self.assertEqual(res[1].path, 'file2') self.assertEqual(res[2].source_file, '/dev/null') self.assertEqual(res[2].target_file, 'file3') self.assertTrue(res[2].is_added_file) self.assertEqual(res[2].path, 'file3') def test_parse_filename_with_spaces(self): filename = os.path.join(self.samples_dir, 'samples/git_filenames_with_spaces.diff') with open(filename) as f: res = PatchSet(f) self.assertEqual(len(res), 1) self.assertEqual(res[0].source_file, '/dev/null') self.assertEqual(res[0].target_file, 'b/has spaces/t.sql') self.assertTrue(res[0].is_added_file) self.assertEqual(res[0].path, 'has spaces/t.sql') def test_parse_filename_prefix_with_spaces(self): filename = os.path.join(self.samples_dir, 'samples/git_filenames_with_spaces_prefix.diff') with open(filename) as f: res = PatchSet(f) self.assertEqual(len(res), 1) self.assertEqual(res[0].source_file, '/dev/null') self.assertEqual(res[0].target_file, 'dst://foo bar/baz') self.assertTrue(res[0].is_added_file) self.assertEqual(res[0].path, 'dst://foo bar/baz') def test_deleted_file(self): filename = os.path.join(self.samples_dir, 'samples/git_delete.diff') with open(filename) as f: res = PatchSet(f) self.assertEqual(len(res), 1) self.assertEqual(res[0].source_file, 'a/somefile.c') self.assertEqual(res[0].target_file, '/dev/null') self.assertTrue(res[0].is_removed_file) def test_diff_lines_linenos(self): with open(self.sample_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8') target_line_nos = [] source_line_nos = [] diff_line_nos = [] for diff_file in res: for hunk in diff_file: for line in hunk: target_line_nos.append(line.target_line_no) source_line_nos.append(line.source_line_no) diff_line_nos.append(line.diff_line_no) expected_target_line_nos = [ # File: 1, Hunk: 1 1, 2, 3, 4, 5, 6, 7, 8, 9, # File: 1, Hunk: 2 11, 12, 13, None, None, None, None, None, None, None, 14, 15, 16, None, 17, 18, 19, 20, # File: 1, Hunk: 3 22, 23, 24, 25, 26, 27, 28, # File: 2, Hunk 1 1, 2, 3, 4, 5, 6, 7, 8, 9, # File: 3, Hunk 1 None, None, None, None, None, None, None, None, None, ] expected_source_line_nos = [ # File: 1, Hunk: 1 None, None, None, None, None, None, 1, 2, 3, # File: 1, Hunk: 2 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, None, 15, 16, 17, None, 18, 19, 20, # File: 1, Hunk: 3 22, 23, 24, None, None, None, None, # File: 2, Hunk 1 None, None, None, None, None, None, None, None, None, # File: 3, Hunk 1 1, 2, 3, 4, 5, 6, 7, 8, 9, ] expected_diff_line_nos = [ # File: 1, Hunk: 1 4, 5, 6, 7, 8, 9, 10, 11, 12, # File: 1, Hunk: 2 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, # File: 1, Hunk: 3 33, 34, 35, 36, 37, 38, 39, # File: 2, Hunk 1 43, 44, 45, 46, 47, 48, 49, 50, 51, # File: 3, Hunk 1 55, 56, 57, 58, 59, 60, 61, 62, 63, ] self.assertEqual(target_line_nos, expected_target_line_nos) self.assertEqual(source_line_nos, expected_source_line_nos) self.assertEqual(diff_line_nos, expected_diff_line_nos) def test_diff_hunk_positions(self): with open(self.sample_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8') self.do_test_diff_hunk_positions(res) def test_diff_metadata_only(self): with open(self.sample_file, 'rb') as diff_file: res = PatchSet(diff_file, encoding='utf-8', metadata_only=True) self.do_test_diff_hunk_positions(res) def do_test_diff_hunk_positions(self, res): hunk_positions = [] for diff_file in res: for hunk in diff_file: hunk_positions.append((hunk.source_start, hunk.target_start, hunk.source_length, hunk.target_length)) expected_hunk_positions = [ # File: 1, Hunk: 1 (1, 1, 3, 9), # File: 1, Hunk: 2 (5, 11, 16, 10), # File: 1, Hunk: 3 (22, 22, 3, 7), # File: 2, Hunk: 1 (0, 1, 0, 9), # File: 3, Hunk: 1 (1, 0, 9, 0) ] self.assertEqual(hunk_positions, expected_hunk_positions) def test_binary_patch(self): utf8_file = os.path.join(self.samples_dir, 'samples/binary.diff') with open(utf8_file, 'r') as diff_file: res = PatchSet(diff_file) self.assertEqual(len(res), 1) patch = res[0] self.assertEqual(patch.source_file, '/dev/null') self.assertEqual(patch.target_file, 'b/1x1.png') self.assertTrue(patch.is_binary_file) self.assertTrue(patch.is_added_file) class TestVCSSamples(unittest.TestCase): """Tests for real examples from VCS.""" samples = ['bzr.diff', 'git.diff', 'hg.diff', 'svn.diff'] def test_samples(self): tests_dir = os.path.dirname(os.path.realpath(__file__)) for fname in self.samples: file_path = os.path.join(tests_dir, 'samples', fname) with codecs.open(file_path, 'r', encoding='utf-8') as diff_file: res = PatchSet(diff_file) # 3 files updated by diff self.assertEqual(len(res), 3) # 1 added file added_files = res.added_files self.assertEqual(len(added_files), 1) self.assertEqual(added_files[0].path, 'added_file') # 1 hunk, 4 lines self.assertEqual(len(added_files[0]), 1) self.assertEqual(added_files[0].added, 4) self.assertEqual(added_files[0].removed, 0) # 1 removed file removed_files = res.removed_files self.assertEqual(len(removed_files), 1) self.assertEqual(removed_files[0].path, 'removed_file') # 1 hunk, 3 removed lines self.assertEqual(len(removed_files[0]), 1) self.assertEqual(removed_files[0].added, 0) self.assertEqual(removed_files[0].removed, 3) # 1 modified file modified_files = res.modified_files self.assertEqual(len(modified_files), 1) self.assertEqual(modified_files[0].path, 'modified_file') # 1 hunk, 3 added lines, 1 removed line self.assertEqual(len(modified_files[0]), 1) self.assertEqual(modified_files[0].added, 3) self.assertEqual(modified_files[0].removed, 1) self.assertEqual(res.added, 7) self.assertEqual(res.removed, 4) # check that original diffs and those produced # by unidiff are the same with codecs.open(file_path, 'r', encoding='utf-8') as diff_file: self.assertEqual(diff_file.read(), str(res)) def test_git_renaming(self): tests_dir = os.path.dirname(os.path.realpath(__file__)) file_path = os.path.join(tests_dir, 'samples/git_rename.diff') with codecs.open(file_path, 'r', encoding='utf-8') as diff_file: res = PatchSet(diff_file) self.assertEqual(len(res), 3) self.assertEqual(len(res.modified_files), 3) self.assertEqual(len(res.added_files), 0) self.assertEqual(len(res.removed_files), 0) # renamed and modified files for patch in res[:2]: self.assertTrue(patch.is_rename) self.assertEqual(patch.added, 1) self.assertEqual(patch.removed, 1) # renamed file under sub-path patch = res[2] self.assertTrue(patch.is_rename) self.assertEqual(patch.added, 0) self.assertEqual(patch.removed, 0) # confirm the full path is in source/target filenames self.assertEqual(patch.source_file, 'a/sub/onefile') self.assertEqual(patch.target_file, 'b/sub/otherfile') # check path is the target path self.assertEqual(patch.path, 'sub/otherfile') # check that original diffs and those produced # by unidiff are the same with codecs.open(file_path, 'r', encoding='utf-8') as diff_file: self.assertEqual(diff_file.read(), str(res))