| # Copyright (C) 2009 Google Inc. All rights reserved. |
| # Copyright (C) 2009 Apple Inc. All rights reserved. |
| # Copyright (C) 2011 Daniel Bates (dbates@intudata.com). All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * Redistributions in binary form must reproduce the above |
| # copyright notice, this list of conditions and the following disclaimer |
| # in the documentation and/or other materials provided with the |
| # distribution. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| import atexit |
| import os |
| import shutil |
| import unittest |
| |
| from webkitpy.common.system.executive import Executive, ScriptError |
| from webkitpy.common.system.executive_mock import MockExecutive |
| from webkitpy.common.system.filesystem import FileSystem |
| from webkitpy.common.system.filesystem_mock import MockFileSystem |
| from webkitpy.common.checkout.scm.detection import detect_scm_system |
| from webkitpy.common.checkout.scm.git import Git, AmbiguousCommitError |
| from webkitpy.common.checkout.scm.scm import SCM |
| from webkitpy.common.checkout.scm.svn import SVN |
| |
| |
| # We cache the mock SVN repo so that we don't create it again for each call to an SVNTest or GitTest test_ method. |
| # We store it in a global variable so that we can delete this cached repo on exit(3). |
| original_cwd = None |
| cached_svn_repo_path = None |
| |
| @atexit.register |
| def delete_cached_svn_repo_at_exit(): |
| if cached_svn_repo_path: |
| os.chdir(original_cwd) |
| shutil.rmtree(cached_svn_repo_path) |
| |
| |
| class SCMTestBase(unittest.TestCase): |
| def __init__(self, *args, **kwargs): |
| super(SCMTestBase, self).__init__(*args, **kwargs) |
| self.scm = None |
| self.executive = None |
| self.fs = None |
| self.original_cwd = None |
| |
| def setUp(self): |
| self.executive = Executive() |
| self.fs = FileSystem() |
| self.original_cwd = self.fs.getcwd() |
| |
| def tearDown(self): |
| self._chdir(self.original_cwd) |
| |
| def _join(self, *comps): |
| return self.fs.join(*comps) |
| |
| def _chdir(self, path): |
| self.fs.chdir(path) |
| |
| def _mkdir(self, path): |
| assert not self.fs.exists(path) |
| self.fs.maybe_make_directory(path) |
| |
| def _mkdtemp(self, **kwargs): |
| return str(self.fs.mkdtemp(**kwargs)) |
| |
| def _remove(self, path): |
| self.fs.remove(path) |
| |
| def _rmtree(self, path): |
| self.fs.rmtree(path) |
| |
| def _run(self, *args, **kwargs): |
| return self.executive.run_command(*args, **kwargs) |
| |
| def _run_silent(self, args, **kwargs): |
| self.executive.run_command(args, **kwargs) |
| |
| def _write_text_file(self, path, contents): |
| self.fs.write_text_file(path, contents) |
| |
| def _write_binary_file(self, path, contents): |
| self.fs.write_binary_file(path, contents) |
| |
| def _make_diff(self, command, *args): |
| # We use this wrapper to disable output decoding. diffs should be treated as |
| # binary files since they may include text files of multiple differnet encodings. |
| return self._run([command, "diff"] + list(args), decode_output=False) |
| |
| def _svn_diff(self, *args): |
| return self._make_diff("svn", *args) |
| |
| def _git_diff(self, *args): |
| return self._make_diff("git", *args) |
| |
| def _svn_add(self, path): |
| self._run(["svn", "add", path]) |
| |
| def _svn_commit(self, message): |
| self._run(["svn", "commit", "--quiet", "--message", message]) |
| |
| # This is a hot function since it's invoked by unittest before calling each test_ method in SVNTest and |
| # GitTest. We create a mock SVN repo once and then perform an SVN checkout from a filesystem copy of |
| # it since it's expensive to create the mock repo. |
| def _set_up_svn_checkout(self): |
| global cached_svn_repo_path |
| global original_cwd |
| if not cached_svn_repo_path: |
| cached_svn_repo_path = self._set_up_svn_repo() |
| original_cwd = self.original_cwd |
| |
| self.temp_directory = self._mkdtemp(suffix="svn_test") |
| self.svn_repo_path = self._join(self.temp_directory, "repo") |
| self.svn_repo_url = "file://%s" % self.svn_repo_path |
| self.svn_checkout_path = self._join(self.temp_directory, "checkout") |
| shutil.copytree(cached_svn_repo_path, self.svn_repo_path) |
| self._run(['svn', 'checkout', '--quiet', self.svn_repo_url + "/trunk", self.svn_checkout_path]) |
| |
| def _set_up_svn_repo(self): |
| svn_repo_path = self._mkdtemp(suffix="svn_test_repo") |
| svn_repo_url = "file://%s" % svn_repo_path # Not sure this will work on windows |
| # git svn complains if we don't pass --pre-1.5-compatible, not sure why: |
| # Expected FS format '2'; found format '3' at /usr/local/libexec/git-core//git-svn line 1477 |
| self._run(['svnadmin', 'create', '--pre-1.5-compatible', svn_repo_path]) |
| |
| # Create a test svn checkout |
| svn_checkout_path = self._mkdtemp(suffix="svn_test_checkout") |
| self._run(['svn', 'checkout', '--quiet', svn_repo_url, svn_checkout_path]) |
| |
| # Create and checkout a trunk dir to match the standard svn configuration to match git-svn's expectations |
| self._chdir(svn_checkout_path) |
| self._mkdir('trunk') |
| self._svn_add('trunk') |
| # We can add tags and branches as well if we ever need to test those. |
| self._svn_commit('add trunk') |
| |
| self._rmtree(svn_checkout_path) |
| self._chdir(self.original_cwd) |
| |
| self._set_up_svn_test_commits(svn_repo_url + "/trunk") |
| return svn_repo_path |
| |
| def _set_up_svn_test_commits(self, svn_repo_url): |
| svn_checkout_path = self._mkdtemp(suffix="svn_test_checkout") |
| self._run(['svn', 'checkout', '--quiet', svn_repo_url, svn_checkout_path]) |
| |
| # Add some test commits |
| self._chdir(svn_checkout_path) |
| |
| self._write_text_file("test_file", "test1") |
| self._svn_add("test_file") |
| self._svn_commit("initial commit") |
| |
| self._write_text_file("test_file", "test1test2") |
| # This used to be the last commit, but doing so broke |
| # GitTest.test_apply_git_patch which use the inverse diff of the last commit. |
| # svn-apply fails to remove directories in Git, see: |
| # https://bugs.webkit.org/show_bug.cgi?id=34871 |
| self._mkdir("test_dir") |
| # Slash should always be the right path separator since we use cygwin on Windows. |
| test_file3_path = "test_dir/test_file3" |
| self._write_text_file(test_file3_path, "third file") |
| self._svn_add("test_dir") |
| self._svn_commit("second commit") |
| |
| self._write_text_file("test_file", "test1test2test3\n") |
| self._write_text_file("test_file2", "second file") |
| self._svn_add("test_file2") |
| self._svn_commit("third commit") |
| |
| # This 4th commit is used to make sure that our patch file handling |
| # code correctly treats patches as binary and does not attempt to |
| # decode them assuming they're utf-8. |
| self._write_binary_file("test_file", u"latin1 test: \u00A0\n".encode("latin-1")) |
| self._write_binary_file("test_file2", u"utf-8 test: \u00A0\n".encode("utf-8")) |
| self._svn_commit("fourth commit") |
| |
| # svn does not seem to update after commit as I would expect. |
| self._run(['svn', 'update']) |
| self._rmtree(svn_checkout_path) |
| self._chdir(self.original_cwd) |
| |
| def _tear_down_svn_checkout(self): |
| self._rmtree(self.temp_directory) |
| |
| def _shared_test_add_recursively(self): |
| self._mkdir("added_dir") |
| self._write_text_file("added_dir/added_file", "new stuff") |
| self.scm.add("added_dir/added_file") |
| self.assertIn("added_dir/added_file", self.scm._added_files()) |
| |
| def _shared_test_delete_recursively(self): |
| self._mkdir("added_dir") |
| self._write_text_file("added_dir/added_file", "new stuff") |
| self.scm.add("added_dir/added_file") |
| self.assertIn("added_dir/added_file", self.scm._added_files()) |
| self.scm.delete("added_dir/added_file") |
| self.assertNotIn("added_dir", self.scm._added_files()) |
| |
| def _shared_test_delete_recursively_or_not(self): |
| self._mkdir("added_dir") |
| self._write_text_file("added_dir/added_file", "new stuff") |
| self._write_text_file("added_dir/another_added_file", "more new stuff") |
| self.scm.add("added_dir/added_file") |
| self.scm.add("added_dir/another_added_file") |
| self.assertIn("added_dir/added_file", self.scm._added_files()) |
| self.assertIn("added_dir/another_added_file", self.scm._added_files()) |
| self.scm.delete("added_dir/added_file") |
| self.assertIn("added_dir/another_added_file", self.scm._added_files()) |
| |
| def _shared_test_exists(self, scm, commit_function): |
| self._chdir(scm.checkout_root) |
| self.assertFalse(scm.exists('foo.txt')) |
| self._write_text_file('foo.txt', 'some stuff') |
| self.assertFalse(scm.exists('foo.txt')) |
| scm.add('foo.txt') |
| commit_function('adding foo') |
| self.assertTrue(scm.exists('foo.txt')) |
| scm.delete('foo.txt') |
| commit_function('deleting foo') |
| self.assertFalse(scm.exists('foo.txt')) |
| |
| def _shared_test_move(self): |
| self._write_text_file('added_file', 'new stuff') |
| self.scm.add('added_file') |
| self.scm.move('added_file', 'moved_file') |
| self.assertIn('moved_file', self.scm._added_files()) |
| |
| def _shared_test_move_recursive(self): |
| self._mkdir("added_dir") |
| self._write_text_file('added_dir/added_file', 'new stuff') |
| self._write_text_file('added_dir/another_added_file', 'more new stuff') |
| self.scm.add('added_dir') |
| self.scm.move('added_dir', 'moved_dir') |
| self.assertIn('moved_dir/added_file', self.scm._added_files()) |
| self.assertIn('moved_dir/another_added_file', self.scm._added_files()) |
| |
| |
| class SVNTest(SCMTestBase): |
| def setUp(self): |
| super(SVNTest, self).setUp() |
| self._set_up_svn_checkout() |
| self._chdir(self.svn_checkout_path) |
| self.scm = detect_scm_system(self.svn_checkout_path) |
| self.scm.svn_server_realm = None |
| |
| def tearDown(self): |
| super(SVNTest, self).tearDown() |
| self._tear_down_svn_checkout() |
| |
| def test_detect_scm_system_relative_url(self): |
| scm = detect_scm_system(".") |
| # I wanted to assert that we got the right path, but there was some |
| # crazy magic with temp folder names that I couldn't figure out. |
| self.assertTrue(scm.checkout_root) |
| |
| def test_detection(self): |
| self.assertEqual(self.scm.display_name(), "svn") |
| self.assertEqual(self.scm.supports_local_commits(), False) |
| |
| def test_add_recursively(self): |
| self._shared_test_add_recursively() |
| |
| def test_delete(self): |
| self._chdir(self.svn_checkout_path) |
| self.scm.delete("test_file") |
| self.assertIn("test_file", self.scm._deleted_files()) |
| |
| def test_delete_list(self): |
| self._chdir(self.svn_checkout_path) |
| self.scm.delete_list(["test_file", "test_file2"]) |
| self.assertIn("test_file", self.scm._deleted_files()) |
| self.assertIn("test_file2", self.scm._deleted_files()) |
| |
| def test_delete_recursively(self): |
| self._shared_test_delete_recursively() |
| |
| def test_delete_recursively_or_not(self): |
| self._shared_test_delete_recursively_or_not() |
| |
| def test_move(self): |
| self._shared_test_move() |
| |
| def test_move_recursive(self): |
| self._shared_test_move_recursive() |
| |
| |
| class GitTest(SCMTestBase): |
| def setUp(self): |
| super(GitTest, self).setUp() |
| self._set_up_git_checkouts() |
| |
| def tearDown(self): |
| super(GitTest, self).tearDown() |
| self._tear_down_git_checkouts() |
| |
| def _set_up_git_checkouts(self): |
| """Sets up fresh git repository with one commit. Then sets up a second git repo that tracks the first one.""" |
| |
| self.untracking_checkout_path = self._mkdtemp(suffix="git_test_checkout2") |
| self._run(['git', 'init', self.untracking_checkout_path]) |
| |
| self._chdir(self.untracking_checkout_path) |
| self._write_text_file('foo_file', 'foo') |
| self._run(['git', 'add', 'foo_file']) |
| self._run(['git', 'commit', '-am', 'dummy commit']) |
| self.untracking_scm = detect_scm_system(self.untracking_checkout_path) |
| |
| self.tracking_git_checkout_path = self._mkdtemp(suffix="git_test_checkout") |
| self._run(['git', 'clone', '--quiet', self.untracking_checkout_path, self.tracking_git_checkout_path]) |
| self._chdir(self.tracking_git_checkout_path) |
| self.tracking_scm = detect_scm_system(self.tracking_git_checkout_path) |
| |
| def _tear_down_git_checkouts(self): |
| self._run(['rm', '-rf', self.tracking_git_checkout_path]) |
| self._run(['rm', '-rf', self.untracking_checkout_path]) |
| |
| def test_remote_branch_ref(self): |
| self.assertEqual(self.tracking_scm._remote_branch_ref(), 'refs/remotes/origin/master') |
| self._chdir(self.untracking_checkout_path) |
| self.assertRaises(ScriptError, self.untracking_scm._remote_branch_ref) |
| |
| def test_multiple_remotes(self): |
| self._run(['git', 'config', '--add', 'svn-remote.svn.fetch', 'trunk:remote1']) |
| self._run(['git', 'config', '--add', 'svn-remote.svn.fetch', 'trunk:remote2']) |
| self.assertEqual(self.tracking_scm._remote_branch_ref(), 'remote1') |
| |
| def test_create_patch(self): |
| self._write_text_file('test_file_commit1', 'contents') |
| self._run(['git', 'add', 'test_file_commit1']) |
| scm = self.tracking_scm |
| scm.commit_locally_with_message('message') |
| |
| patch = scm.create_patch() |
| self.assertNotRegexpMatches(patch, r'Subversion Revision:') |
| |
| def test_exists(self): |
| scm = self.untracking_scm |
| self._shared_test_exists(scm, scm.commit_locally_with_message) |
| |
| def test_rename_files(self): |
| scm = self.tracking_scm |
| scm.move('foo_file', 'bar_file') |
| scm.commit_locally_with_message('message') |
| |
| |
| class GitSVNTest(SCMTestBase): |
| def setUp(self): |
| super(GitSVNTest, self).setUp() |
| self._set_up_svn_checkout() |
| self._set_up_gitsvn_checkout() |
| self.scm = detect_scm_system(self.git_checkout_path) |
| self.scm.svn_server_realm = None |
| |
| def tearDown(self): |
| super(GitSVNTest, self).tearDown() |
| self._tear_down_svn_checkout() |
| self._tear_down_gitsvn_checkout() |
| |
| def _set_up_gitsvn_checkout(self): |
| self.git_checkout_path = self._mkdtemp(suffix="git_test_checkout") |
| # --quiet doesn't make git svn silent |
| self._run_silent(['git', 'svn', 'clone', '-T', 'trunk', self.svn_repo_url, self.git_checkout_path]) |
| self._chdir(self.git_checkout_path) |
| self.git_v2 = self._run(['git', '--version']).startswith('git version 2') |
| if self.git_v2: |
| # The semantics of 'git svn clone -T' changed in v2 (apparently), so the branch names are different. |
| # This works around it, for compatibility w/ v1. |
| self._run_silent(['git', 'branch', 'trunk', 'origin/trunk']) |
| |
| def _tear_down_gitsvn_checkout(self): |
| self._rmtree(self.git_checkout_path) |
| |
| def test_detection(self): |
| self.assertEqual(self.scm.display_name(), "git") |
| self.assertEqual(self.scm.supports_local_commits(), True) |
| |
| def test_read_git_config(self): |
| key = 'test.git-config' |
| value = 'git-config value' |
| self._run(['git', 'config', key, value]) |
| self.assertEqual(self.scm.read_git_config(key), value) |
| |
| def test_local_commits(self): |
| test_file = self._join(self.git_checkout_path, 'test_file') |
| self._write_text_file(test_file, 'foo') |
| self._run(['git', 'commit', '-a', '-m', 'local commit']) |
| |
| self.assertEqual(len(self.scm._local_commits()), 1) |
| |
| def test_discard_local_commits(self): |
| test_file = self._join(self.git_checkout_path, 'test_file') |
| self._write_text_file(test_file, 'foo') |
| self._run(['git', 'commit', '-a', '-m', 'local commit']) |
| |
| self.assertEqual(len(self.scm._local_commits()), 1) |
| self.scm._discard_local_commits() |
| self.assertEqual(len(self.scm._local_commits()), 0) |
| |
| def test_delete_branch(self): |
| new_branch = 'foo' |
| |
| self._run(['git', 'checkout', '-b', new_branch]) |
| self.assertEqual(self._run(['git', 'symbolic-ref', 'HEAD']).strip(), 'refs/heads/' + new_branch) |
| |
| self._run(['git', 'checkout', '-b', 'bar']) |
| self.scm.delete_branch(new_branch) |
| |
| self.assertNotRegexpMatches(self._run(['git', 'branch']), r'foo') |
| |
| def test_rebase_in_progress(self): |
| svn_test_file = self._join(self.svn_checkout_path, 'test_file') |
| self._write_text_file(svn_test_file, "svn_checkout") |
| self._run(['svn', 'commit', '--message', 'commit to conflict with git commit'], cwd=self.svn_checkout_path) |
| |
| git_test_file = self._join(self.git_checkout_path, 'test_file') |
| self._write_text_file(git_test_file, "git_checkout") |
| self._run(['git', 'commit', '-a', '-m', 'commit to be thrown away by rebase abort']) |
| |
| # Should fail due to a conflict leaving us mid-rebase. |
| # we use self._run_slient because --quiet doesn't actually make git svn silent. |
| self.assertRaises(ScriptError, self._run_silent, ['git', 'svn', '--quiet', 'rebase']) |
| |
| self.assertTrue(self.scm._rebase_in_progress()) |
| |
| # Make sure our cleanup works. |
| self.scm._discard_working_directory_changes() |
| self.assertFalse(self.scm._rebase_in_progress()) |
| |
| # Make sure cleanup doesn't throw when no rebase is in progress. |
| self.scm._discard_working_directory_changes() |
| |
| def _local_commit(self, filename, contents, message): |
| self._write_text_file(filename, contents) |
| self._run(['git', 'add', filename]) |
| self.scm.commit_locally_with_message(message) |
| |
| def _one_local_commit(self): |
| self._local_commit('test_file_commit1', 'more test content', 'another test commit') |
| |
| def _one_local_commit_plus_working_copy_changes(self): |
| self._one_local_commit() |
| self._write_text_file('test_file_commit2', 'still more test content') |
| self._run(['git', 'add', 'test_file_commit2']) |
| |
| def _second_local_commit(self): |
| self._local_commit('test_file_commit2', 'still more test content', 'yet another test commit') |
| |
| def _two_local_commits(self): |
| self._one_local_commit() |
| self._second_local_commit() |
| |
| def _three_local_commits(self): |
| self._local_commit('test_file_commit0', 'more test content', 'another test commit') |
| self._two_local_commits() |
| |
| def test_locally_commit_all_working_copy_changes(self): |
| self._local_commit('test_file', 'test content', 'test commit') |
| self._write_text_file('test_file', 'changed test content') |
| self.assertTrue(self.scm.has_working_directory_changes()) |
| self.scm.commit_locally_with_message('all working copy changes') |
| self.assertFalse(self.scm.has_working_directory_changes()) |
| |
| def test_locally_commit_no_working_copy_changes(self): |
| self._local_commit('test_file', 'test content', 'test commit') |
| self._write_text_file('test_file', 'changed test content') |
| self.assertTrue(self.scm.has_working_directory_changes()) |
| self.assertRaises(ScriptError, self.scm.commit_locally_with_message, 'no working copy changes', False) |
| |
| def _test_upstream_branch(self): |
| self._run(['git', 'checkout', '-t', '-b', 'my-branch']) |
| self._run(['git', 'checkout', '-t', '-b', 'my-second-branch']) |
| self.assertEqual(self.scm._upstream_branch(), 'my-branch') |
| |
| def test_remote_branch_ref(self): |
| remote_branch_ref = self.scm._remote_branch_ref() |
| if self.git_v2: |
| self.assertEqual(remote_branch_ref, 'refs/remotes/origin/trunk') |
| else: |
| self.assertEqual(remote_branch_ref, 'refs/remotes/trunk') |
| |
| def test_create_patch_local_plus_working_copy(self): |
| self._one_local_commit_plus_working_copy_changes() |
| patch = self.scm.create_patch() |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| |
| def test_create_patch(self): |
| self._one_local_commit_plus_working_copy_changes() |
| patch = self.scm.create_patch() |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| self.assertRegexpMatches(patch, r'Subversion Revision: 5') |
| |
| def test_create_patch_after_merge(self): |
| self._run(['git', 'checkout', '-b', 'dummy-branch', 'trunk~3']) |
| self._one_local_commit() |
| self._run(['git', 'merge', 'trunk']) |
| |
| patch = self.scm.create_patch() |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| self.assertRegexpMatches(patch, r'Subversion Revision: 5') |
| |
| def test_create_patch_with_changed_files(self): |
| self._one_local_commit_plus_working_copy_changes() |
| patch = self.scm.create_patch(changed_files=['test_file_commit2']) |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| |
| def test_create_patch_with_rm_and_changed_files(self): |
| self._one_local_commit_plus_working_copy_changes() |
| self._remove('test_file_commit1') |
| patch = self.scm.create_patch() |
| patch_with_changed_files = self.scm.create_patch(changed_files=['test_file_commit1', 'test_file_commit2']) |
| self.assertEqual(patch, patch_with_changed_files) |
| |
| def test_create_patch_git_commit(self): |
| self._two_local_commits() |
| patch = self.scm.create_patch(git_commit="HEAD^") |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| self.assertNotRegexpMatches(patch, r'test_file_commit2') |
| |
| def test_create_patch_git_commit_range(self): |
| self._three_local_commits() |
| patch = self.scm.create_patch(git_commit="HEAD~2..HEAD") |
| self.assertNotRegexpMatches(patch, r'test_file_commit0') |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| |
| def test_create_patch_working_copy_only(self): |
| self._one_local_commit_plus_working_copy_changes() |
| patch = self.scm.create_patch(git_commit="HEAD....") |
| self.assertNotRegexpMatches(patch, r'test_file_commit1') |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| |
| def test_create_patch_multiple_local_commits(self): |
| self._two_local_commits() |
| patch = self.scm.create_patch() |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| |
| def test_create_patch_not_synced(self): |
| self._run(['git', 'checkout', '-b', 'my-branch', 'trunk~3']) |
| self._two_local_commits() |
| patch = self.scm.create_patch() |
| self.assertNotRegexpMatches(patch, r'test_file2') |
| self.assertRegexpMatches(patch, r'test_file_commit2') |
| self.assertRegexpMatches(patch, r'test_file_commit1') |
| |
| def test_create_binary_patch(self): |
| # Create a git binary patch and check the contents. |
| test_file_name = 'binary_file' |
| test_file_path = self.fs.join(self.git_checkout_path, test_file_name) |
| file_contents = ''.join(map(chr, range(256))) |
| self._write_binary_file(test_file_path, file_contents) |
| self._run(['git', 'add', test_file_name]) |
| patch = self.scm.create_patch() |
| self.assertRegexpMatches(patch, r'\nliteral 0\n') |
| self.assertRegexpMatches(patch, r'\nliteral 256\n') |
| |
| # Check if we can create a patch from a local commit. |
| self._write_binary_file(test_file_path, file_contents) |
| self._run(['git', 'add', test_file_name]) |
| self._run(['git', 'commit', '-m', 'binary diff']) |
| |
| patch_from_local_commit = self.scm.create_patch('HEAD') |
| self.assertRegexpMatches(patch_from_local_commit, r'\nliteral 0\n') |
| self.assertRegexpMatches(patch_from_local_commit, r'\nliteral 256\n') |
| |
| |
| def test_changed_files_local_plus_working_copy(self): |
| self._one_local_commit_plus_working_copy_changes() |
| files = self.scm.changed_files() |
| self.assertIn('test_file_commit1', files) |
| self.assertIn('test_file_commit2', files) |
| |
| # working copy should *not* be in the list. |
| files = self.scm.changed_files('trunk..') |
| self.assertIn('test_file_commit1', files) |
| self.assertNotIn('test_file_commit2', files) |
| |
| # working copy *should* be in the list. |
| files = self.scm.changed_files('trunk....') |
| self.assertIn('test_file_commit1', files) |
| self.assertIn('test_file_commit2', files) |
| |
| def test_changed_files_git_commit(self): |
| self._two_local_commits() |
| files = self.scm.changed_files(git_commit="HEAD^") |
| self.assertIn('test_file_commit1', files) |
| self.assertNotIn('test_file_commit2', files) |
| |
| def test_changed_files_git_commit_range(self): |
| self._three_local_commits() |
| files = self.scm.changed_files(git_commit="HEAD~2..HEAD") |
| self.assertNotIn('test_file_commit0', files) |
| self.assertIn('test_file_commit1', files) |
| self.assertIn('test_file_commit2', files) |
| |
| def test_changed_files_working_copy_only(self): |
| self._one_local_commit_plus_working_copy_changes() |
| files = self.scm.changed_files(git_commit="HEAD....") |
| self.assertNotIn('test_file_commit1', files) |
| self.assertIn('test_file_commit2', files) |
| |
| def test_changed_files_multiple_local_commits(self): |
| self._two_local_commits() |
| files = self.scm.changed_files() |
| self.assertIn('test_file_commit2', files) |
| self.assertIn('test_file_commit1', files) |
| |
| def test_changed_files_not_synced(self): |
| self._run(['git', 'checkout', '-b', 'my-branch', 'trunk~3']) |
| self._two_local_commits() |
| files = self.scm.changed_files() |
| self.assertNotIn('test_file2', files) |
| self.assertIn('test_file_commit2', files) |
| self.assertIn('test_file_commit1', files) |
| |
| def test_changed_files_upstream(self): |
| self._run(['git', 'checkout', '-t', '-b', 'my-branch']) |
| self._one_local_commit() |
| self._run(['git', 'checkout', '-t', '-b', 'my-second-branch']) |
| self._second_local_commit() |
| self._write_text_file('test_file_commit0', 'more test content') |
| self._run(['git', 'add', 'test_file_commit0']) |
| |
| # equivalent to 'git diff my-branch..HEAD, should not include working changes |
| files = self.scm.changed_files(git_commit='UPSTREAM..') |
| self.assertNotIn('test_file_commit1', files) |
| self.assertIn('test_file_commit2', files) |
| self.assertNotIn('test_file_commit0', files) |
| |
| # equivalent to 'git diff my-branch', *should* include working changes |
| files = self.scm.changed_files(git_commit='UPSTREAM....') |
| self.assertNotIn('test_file_commit1', files) |
| self.assertIn('test_file_commit2', files) |
| self.assertIn('test_file_commit0', files) |
| |
| def test_add_recursively(self): |
| self._shared_test_add_recursively() |
| |
| def test_delete(self): |
| self._two_local_commits() |
| self.scm.delete('test_file_commit1') |
| self.assertIn("test_file_commit1", self.scm._deleted_files()) |
| |
| def test_delete_list(self): |
| self._two_local_commits() |
| self.scm.delete_list(["test_file_commit1", "test_file_commit2"]) |
| self.assertIn("test_file_commit1", self.scm._deleted_files()) |
| self.assertIn("test_file_commit2", self.scm._deleted_files()) |
| |
| def test_delete_recursively(self): |
| self._shared_test_delete_recursively() |
| |
| def test_delete_recursively_or_not(self): |
| self._shared_test_delete_recursively_or_not() |
| |
| def test_move(self): |
| self._shared_test_move() |
| |
| def test_move_recursive(self): |
| self._shared_test_move_recursive() |
| |
| def test_exists(self): |
| self._shared_test_exists(self.scm, self.scm.commit_locally_with_message) |
| |
| |
| class GitTestWithMock(SCMTestBase): |
| def make_scm(self): |
| scm = Git(cwd=".", executive=MockExecutive(), filesystem=MockFileSystem()) |
| scm.read_git_config = lambda *args, **kw: "MOCKKEY:MOCKVALUE" |
| return scm |
| |
| def test_timestamp_of_revision(self): |
| scm = self.make_scm() |
| scm.find_checkout_root = lambda path: '' |
| scm._run_git = lambda args: 'Date: 2013-02-08 08:05:49 +0000' |
| self.assertEqual(scm.timestamp_of_revision('some-path', '12345'), '2013-02-08T08:05:49Z') |
| |
| scm._run_git = lambda args: 'Date: 2013-02-08 01:02:03 +0130' |
| self.assertEqual(scm.timestamp_of_revision('some-path', '12345'), '2013-02-07T23:32:03Z') |
| |
| scm._run_git = lambda args: 'Date: 2013-02-08 01:55:21 -0800' |
| self.assertEqual(scm.timestamp_of_revision('some-path', '12345'), '2013-02-08T09:55:21Z') |
