# Copyright (C) 2009 Google Inc. All rights reserved.

# Copyright (C) 2009 Apple Inc. 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.

from __future__ import with_statement

import base64

import codecs

import getpass

import os

import os.path

import re

import stat

import subprocess

import tempfile

import unittest

import urllib

import shutil

from datetime import date

from webkitpy.common.checkout.api import Checkout

from webkitpy.common.checkout.scm import detect_scm_system, SCM, SVN, CheckoutNeedsUpdate, commit_error_handler, AuthenticationError, AmbiguousCommitError

from webkitpy.common.config.committers import Committer  # FIXME: This should not be needed

from webkitpy.common.net.bugzilla import Attachment # FIXME: This should not be needed

from webkitpy.common.system.executive import Executive, run_command, ScriptError

# Eventually we will want to write tests which work for both scms. (like update_webkit, changed_files, etc.)

# Perhaps through some SCMTest base-class which both SVNTest and GitTest inherit from.

# FIXME: This should be unified into one of the executive.py commands!

# Callers could use run_and_throw_if_fail(args, cwd=cwd, quiet=True)

def run_silent(args, cwd=None):

    # Note: Not thread safe: http://bugs.python.org/issue2320

    process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd)

    process.communicate() # ignore output

    exit_code = process.wait()

    if exit_code:

        raise ScriptError('Failed to run "%s"  exit_code: %d  cwd: %s' % (args, exit_code, cwd))

def write_into_file_at_path(file_path, contents, encoding="utf-8"):

    if encoding:

        with codecs.open(file_path, "w", encoding) as file:

            file.write(contents)

    else:

        with open(file_path, "w") as file:

            file.write(contents)

def read_from_path(file_path, encoding="utf-8"):

    with codecs.open(file_path, "r", encoding) as file:

        return file.read()

def _make_diff(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 run_command([command, "diff"] + list(args), decode_output=False)

def _svn_diff(*args):

    return _make_diff("svn", *args)

def _git_diff(*args):

    return _make_diff("git", *args)

# Exists to share svn repository creation code between the git and svn tests

class SVNTestRepository:

    @classmethod

    def _svn_add(cls, path):

        run_command(["svn", "add", path])

    @classmethod

    def _svn_commit(cls, message):

        run_command(["svn", "commit", "--quiet", "--message", message])

    @classmethod

    def _setup_test_commits(cls, test_object):

        # Add some test commits

        os.chdir(test_object.svn_checkout_path)

        write_into_file_at_path("test_file", "test1")

        cls._svn_add("test_file")

        cls._svn_commit("initial commit")

        write_into_file_at_path("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

        os.mkdir("test_dir")

        # Slash should always be the right path separator since we use cygwin on Windows.

        test_file3_path = "test_dir/test_file3"

        write_into_file_at_path(test_file3_path, "third file")

        cls._svn_add("test_dir")

        cls._svn_commit("second commit")

        write_into_file_at_path("test_file", "test1test2test3\n")

        write_into_file_at_path("test_file2", "second file")

        cls._svn_add("test_file2")

        cls._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.

        write_into_file_at_path("test_file", u"latin1 test: \u00A0\n", "latin1")

        write_into_file_at_path("test_file2", u"utf-8 test: \u00A0\n", "utf-8")

        cls._svn_commit("fourth commit")

        # svn does not seem to update after commit as I would expect.

        run_command(['svn', 'update'])

    @classmethod

    def setup(cls, test_object):

        # Create an test SVN repository

        test_object.svn_repo_path = tempfile.mkdtemp(suffix="svn_test_repo")

        test_object.svn_repo_url = "file://%s" % test_object.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

        run_command(['svnadmin', 'create', '--pre-1.5-compatible', test_object.svn_repo_path])

        # Create a test svn checkout

        test_object.svn_checkout_path = tempfile.mkdtemp(suffix="svn_test_checkout")

        run_command(['svn', 'checkout', '--quiet', test_object.svn_repo_url, test_object.svn_checkout_path])

        # Create and checkout a trunk dir to match the standard svn configuration to match git-svn's expectations

        os.chdir(test_object.svn_checkout_path)

        os.mkdir('trunk')

        cls._svn_add('trunk')

        # We can add tags and branches as well if we ever need to test those.

        cls._svn_commit('add trunk')

        # Change directory out of the svn checkout so we can delete the checkout directory.

        # _setup_test_commits will CD back to the svn checkout directory.

        os.chdir('/')

        run_command(['rm', '-rf', test_object.svn_checkout_path])

        run_command(['svn', 'checkout', '--quiet', test_object.svn_repo_url + '/trunk', test_object.svn_checkout_path])

        cls._setup_test_commits(test_object)

    @classmethod

    def tear_down(cls, test_object):

        run_command(['rm', '-rf', test_object.svn_repo_path])

        run_command(['rm', '-rf', test_object.svn_checkout_path])

        # Now that we've deleted the checkout paths, cwddir may be invalid

        # Change back to a valid directory so that later calls to os.getcwd() do not fail.

        os.chdir(detect_scm_system(os.path.dirname(__file__)).checkout_root)

# For testing the SCM baseclass directly.

class SCMClassTests(unittest.TestCase):

    def setUp(self):

        self.dev_null = open(os.devnull, "w") # Used to make our Popen calls quiet.

    def tearDown(self):

        self.dev_null.close()

    def test_run_command_with_pipe(self):

        input_process = subprocess.Popen(['echo', 'foo\nbar'], stdout=subprocess.PIPE, stderr=self.dev_null)

        self.assertEqual(run_command(['grep', 'bar'], input=input_process.stdout), "bar\n")

        # Test the non-pipe case too:

        self.assertEqual(run_command(['grep', 'bar'], input="foo\nbar"), "bar\n")

        command_returns_non_zero = ['/bin/sh', '--invalid-option']

        # Test when the input pipe process fails.

        input_process = subprocess.Popen(command_returns_non_zero, stdout=subprocess.PIPE, stderr=self.dev_null)

        self.assertTrue(input_process.poll() != 0)

        self.assertRaises(ScriptError, run_command, ['grep', 'bar'], input=input_process.stdout)

        # Test when the run_command process fails.

        input_process = subprocess.Popen(['echo', 'foo\nbar'], stdout=subprocess.PIPE, stderr=self.dev_null) # grep shows usage and calls exit(2) when called w/o arguments.

        self.assertRaises(ScriptError, run_command, command_returns_non_zero, input=input_process.stdout)

    def test_error_handlers(self):

        git_failure_message="Merge conflict during commit: Your file or directory 'WebCore/ChangeLog' is probably out-of-date: resource out of date; try updating at /usr/local/libexec/git-core//git-svn line 469"

        svn_failure_message="""svn: Commit failed (details follow):

svn: File or directory 'ChangeLog' is out of date; try updating

svn: resource out of date; try updating

"""

        command_does_not_exist = ['does_not_exist', 'invalid_option']

        self.assertRaises(OSError, run_command, command_does_not_exist)

        self.assertRaises(OSError, run_command, command_does_not_exist, error_handler=Executive.ignore_error)

        command_returns_non_zero = ['/bin/sh', '--invalid-option']

        self.assertRaises(ScriptError, run_command, command_returns_non_zero)

        # Check if returns error text:

        self.assertTrue(run_command(command_returns_non_zero, error_handler=Executive.ignore_error))

        self.assertRaises(CheckoutNeedsUpdate, commit_error_handler, ScriptError(output=git_failure_message))

        self.assertRaises(CheckoutNeedsUpdate, commit_error_handler, ScriptError(output=svn_failure_message))

        self.assertRaises(ScriptError, commit_error_handler, ScriptError(output='blah blah blah'))

# GitTest and SVNTest inherit from this so any test_ methods here will be run once for this class and then once for each subclass.

class SCMTest(unittest.TestCase):

    def _create_patch(self, patch_contents):

        # FIXME: This code is brittle if the Attachment API changes.

        attachment = Attachment({"bug_id": 12345}, None)

        attachment.contents = lambda: patch_contents

        joe_cool = Committer(name="Joe Cool", email_or_emails=None)

        attachment.reviewer = lambda: joe_cool

        return attachment

    def _setup_webkittools_scripts_symlink(self, local_scm):

        webkit_scm = detect_scm_system(os.path.dirname(os.path.abspath(__file__)))

        webkit_scripts_directory = webkit_scm.scripts_directory()

        local_scripts_directory = local_scm.scripts_directory()

        os.mkdir(os.path.dirname(local_scripts_directory))

        os.symlink(webkit_scripts_directory, local_scripts_directory)

    # Tests which both GitTest and SVNTest should run.

    # FIXME: There must be a simpler way to add these w/o adding a wrapper method to both subclasses

    def _shared_test_changed_files(self):

        write_into_file_at_path("test_file", "changed content")

        self.assertEqual(self.scm.changed_files(), ["test_file"])

        write_into_file_at_path("test_dir/test_file3", "new stuff")

        self.assertEqual(self.scm.changed_files(), ["test_dir/test_file3", "test_file"])

        old_cwd = os.getcwd()

        os.chdir("test_dir")

        # Validate that changed_files does not change with our cwd, see bug 37015.

        self.assertEqual(self.scm.changed_files(), ["test_dir/test_file3", "test_file"])

        os.chdir(old_cwd)

    def _shared_test_added_files(self):

        write_into_file_at_path("test_file", "changed content")

        self.assertEqual(self.scm.added_files(), [])

        write_into_file_at_path("added_file", "new stuff")

        self.scm.add("added_file")

        os.mkdir("added_dir")

        write_into_file_at_path("added_dir/added_file2", "new stuff")

        self.scm.add("added_dir")

        # SVN reports directory changes, Git does not.

        added_files = self.scm.added_files()

        if "added_dir" in added_files:

            added_files.remove("added_dir")

        self.assertEqual(added_files, ["added_dir/added_file2", "added_file"])

        # Test also to make sure clean_working_directory removes added files

        self.scm.clean_working_directory()

        self.assertEqual(self.scm.added_files(), [])

        self.assertFalse(os.path.exists("added_file"))

        self.assertFalse(os.path.exists("added_dir"))

    def _shared_test_changed_files_for_revision(self):

        # SVN reports directory changes, Git does not.

        changed_files = self.scm.changed_files_for_revision(3)

        if "test_dir" in changed_files:

            changed_files.remove("test_dir")

        self.assertEqual(changed_files, ["test_dir/test_file3", "test_file"])

        self.assertEqual(sorted(self.scm.changed_files_for_revision(4)), sorted(["test_file", "test_file2"]))  # Git and SVN return different orders.

        self.assertEqual(self.scm.changed_files_for_revision(2), ["test_file"])

    def _shared_test_contents_at_revision(self):

        self.assertEqual(self.scm.contents_at_revision("test_file", 3), "test1test2")

        self.assertEqual(self.scm.contents_at_revision("test_file", 4), "test1test2test3\n")

        # Verify that contents_at_revision returns a byte array, aka str():

        self.assertEqual(self.scm.contents_at_revision("test_file", 5), u"latin1 test: \u00A0\n".encode("latin1"))

        self.assertEqual(self.scm.contents_at_revision("test_file2", 5), u"utf-8 test: \u00A0\n".encode("utf-8"))

        self.assertEqual(self.scm.contents_at_revision("test_file2", 4), "second file")

        # Files which don't exist:

        # Currently we raise instead of returning None because detecting the difference between

        # "file not found" and any other error seems impossible with svn (git seems to expose such through the return code).

        self.assertRaises(ScriptError, self.scm.contents_at_revision, "test_file2", 2)

        self.assertRaises(ScriptError, self.scm.contents_at_revision, "does_not_exist", 2)

    def _shared_test_committer_email_for_revision(self):

        self.assertEqual(self.scm.committer_email_for_revision(3), getpass.getuser())  # Committer "email" will be the current user

    def _shared_test_reverse_diff(self):

        self._setup_webkittools_scripts_symlink(self.scm) # Git's apply_reverse_diff uses resolve-ChangeLogs

        # Only test the simple case, as any other will end up with conflict markers.

        self.scm.apply_reverse_diff('5')

        self.assertEqual(read_from_path('test_file'), "test1test2test3\n")

    def _shared_test_diff_for_revision(self):

        # Patch formats are slightly different between svn and git, so just regexp for things we know should be there.

        r3_patch = self.scm.diff_for_revision(4)

        self.assertTrue(re.search('test3', r3_patch))

        self.assertFalse(re.search('test4', r3_patch))

        self.assertTrue(re.search('test2', r3_patch))

        self.assertTrue(re.search('test2', self.scm.diff_for_revision(3)))

    def _shared_test_svn_apply_git_patch(self):

        self._setup_webkittools_scripts_symlink(self.scm)

        git_binary_addition = """diff --git a/fizzbuzz7.gif b/fizzbuzz7.gif

new file mode 100644

index 0000000000000000000000000000000000000000..64a9532e7794fcd791f6f12157406d90

60151690

GIT binary patch

literal 512

zcmZ?wbhEHbRAx|MU|?iW{Kxc~?KofD;ckY;H+&5HnHl!!GQMD7h+sU{_)e9f^V3c?

zhJP##HdZC#4K}7F68@!1jfWQg2daCm-gs#3|JREDT>c+pG4L<_2;w##WMO#ysPPap

zLqpAf1OE938xAsSp4!5f-o><?VKe(#0jEcwfHGF4%M1^kRs14oVBp2ZEL{E1N<-zJ

zsfLmOtKta;2_;2c#^S1-8cf<nb!QnGl>c!Xe6RXvrEtAWBvSDTgTO1j3vA31Puw!A

zs(87q)j_mVDTqBo-P+03-P5mHCEnJ+x}YdCuS7#bCCyePUe(ynK+|4b-3qK)T?Z&)

zYG+`tl4h?GZv_$t82}X4*DTE|$;{DEiPyF@)U-1+FaX++T9H{&%cag`W1|zVP@`%b

zqiSkp6{BTpWTkCr!=<C6Q=?#~R8^JfrliAF6Q^gV9Iup8RqCXqqhqC`qsyhk<-nlB

z00f{QZvfK&|Nm#oZ0TQl`Yr$BIa6A@16O26ud7H<QM=xl`toLKnz-3h@9c9q&wm|X

z{89I|WPyD!*M?gv?q`;L=2YFeXrJQNti4?}s!zFo=5CzeBxC69xA<zrjP<wUcCRh4

ptUl-ZG<%a~#LwkIWv&q!KSCH7tQ8cJDiw+|GV?MN)RjY50RTb-xvT&H

literal 0

HcmV?d00001

"""

        self.checkout.apply_patch(self._create_patch(git_binary_addition))

        added = read_from_path('fizzbuzz7.gif', encoding=None)

        self.assertEqual(512, len(added))

        self.assertTrue(added.startswith('GIF89a'))

        self.assertTrue('fizzbuzz7.gif' in self.scm.changed_files())

        # The file already exists.

        self.assertRaises(ScriptError, self.checkout.apply_patch, self._create_patch(git_binary_addition))

        git_binary_modification = """diff --git a/fizzbuzz7.gif b/fizzbuzz7.gif

index 64a9532e7794fcd791f6f12157406d9060151690..323fae03f4606ea9991df8befbb2fca7

GIT binary patch

literal 7

OcmYex&reD$;sO8*F9L)B

literal 512

zcmZ?wbhEHbRAx|MU|?iW{Kxc~?KofD;ckY;H+&5HnHl!!GQMD7h+sU{_)e9f^V3c?

zhJP##HdZC#4K}7F68@!1jfWQg2daCm-gs#3|JREDT>c+pG4L<_2;w##WMO#ysPPap

zLqpAf1OE938xAsSp4!5f-o><?VKe(#0jEcwfHGF4%M1^kRs14oVBp2ZEL{E1N<-zJ

zsfLmOtKta;2_;2c#^S1-8cf<nb!QnGl>c!Xe6RXvrEtAWBvSDTgTO1j3vA31Puw!A

zs(87q)j_mVDTqBo-P+03-P5mHCEnJ+x}YdCuS7#bCCyePUe(ynK+|4b-3qK)T?Z&)

zYG+`tl4h?GZv_$t82}X4*DTE|$;{DEiPyF@)U-1+FaX++T9H{&%cag`W1|zVP@`%b

zqiSkp6{BTpWTkCr!=<C6Q=?#~R8^JfrliAF6Q^gV9Iup8RqCXqqhqC`qsyhk<-nlB

z00f{QZvfK&|Nm#oZ0TQl`Yr$BIa6A@16O26ud7H<QM=xl`toLKnz-3h@9c9q&wm|X

z{89I|WPyD!*M?gv?q`;L=2YFeXrJQNti4?}s!zFo=5CzeBxC69xA<zrjP<wUcCRh4

ptUl-ZG<%a~#LwkIWv&q!KSCH7tQ8cJDiw+|GV?MN)RjY50RTb-xvT&H

"""

        self.checkout.apply_patch(self._create_patch(git_binary_modification))

        modified = read_from_path('fizzbuzz7.gif', encoding=None)

        self.assertEqual('foobar\n', modified)

        self.assertTrue('fizzbuzz7.gif' in self.scm.changed_files())

        # Applying the same modification should fail.

        self.assertRaises(ScriptError, self.checkout.apply_patch, self._create_patch(git_binary_modification))

        git_binary_deletion = """diff --git a/fizzbuzz7.gif b/fizzbuzz7.gif

deleted file mode 100644

index 323fae0..0000000

GIT binary patch

literal 0

HcmV?d00001

literal 7

OcmYex&reD$;sO8*F9L)B

"""

        self.checkout.apply_patch(self._create_patch(git_binary_deletion))

        self.assertFalse(os.path.exists('fizzbuzz7.gif'))

        self.assertFalse('fizzbuzz7.gif' in self.scm.changed_files())

        # Cannot delete again.

        self.assertRaises(ScriptError, self.checkout.apply_patch, self._create_patch(git_binary_deletion))

    def _shared_test_add_recursively(self):

        os.mkdir("added_dir")

        write_into_file_at_path("added_dir/added_file", "new stuff")

        self.scm.add("added_dir/added_file")

        self.assertTrue("added_dir/added_file" in self.scm.added_files())

class SVNTest(SCMTest):

    @staticmethod

    def _set_date_and_reviewer(changelog_entry):

        # Joe Cool matches the reviewer set in SCMTest._create_patch

        changelog_entry = changelog_entry.replace('REVIEWER_HERE', 'Joe Cool')

        # svn-apply will update ChangeLog entries with today's date.

        return changelog_entry.replace('DATE_HERE', date.today().isoformat())

    def test_svn_apply(self):

        first_entry = """2009-10-26  Eric Seidel  <eric@webkit.org>

        Reviewed by Foo Bar.

        Most awesome change ever.

        * scm_unittest.py:

"""

        intermediate_entry = """2009-10-27  Eric Seidel  <eric@webkit.org>

        Reviewed by Baz Bar.

        A more awesomer change yet!

        * scm_unittest.py:

"""

        one_line_overlap_patch = """Index: ChangeLog

===================================================================

--- ChangeLog	(revision 5)

+++ ChangeLog	(working copy)

@@ -1,5 +1,13 @@

 2009-10-26  Eric Seidel  <eric@webkit.org>

+        Reviewed by NOBODY (OOPS!).

+

+        Second most awesome change ever.

+

+        * scm_unittest.py:

+

+2009-10-26  Eric Seidel  <eric@webkit.org>

+

         Reviewed by Foo Bar.

         Most awesome change ever.

"""

        one_line_overlap_entry = """DATE_HERE  Eric Seidel  <eric@webkit.org>

        Reviewed by REVIEWER_HERE.

        Second most awesome change ever.

        * scm_unittest.py:

"""

        two_line_overlap_patch = """Index: ChangeLog

===================================================================

--- ChangeLog	(revision 5)

+++ ChangeLog	(working copy)

@@ -2,6 +2,14 @@

         Reviewed by Foo Bar.

+        Second most awesome change ever.

+

+        * scm_unittest.py:

+

+2009-10-26  Eric Seidel  <eric@webkit.org>

+

+        Reviewed by Foo Bar.

+

         Most awesome change ever.

         * scm_unittest.py:

"""

        two_line_overlap_entry = """DATE_HERE  Eric Seidel  <eric@webkit.org>

        Reviewed by Foo Bar.

        Second most awesome change ever.

        * scm_unittest.py:

"""

        write_into_file_at_path('ChangeLog', first_entry)

        run_command(['svn', 'add', 'ChangeLog'])

        run_command(['svn', 'commit', '--quiet', '--message', 'ChangeLog commit'])

        # Patch files were created against just 'first_entry'.

        # Add a second commit to make svn-apply have to apply the patches with fuzz.

        changelog_contents = "%s\n%s" % (intermediate_entry, first_entry)

        write_into_file_at_path('ChangeLog', changelog_contents)

        run_command(['svn', 'commit', '--quiet', '--message', 'Intermediate commit'])

        self._setup_webkittools_scripts_symlink(self.scm)

        self.checkout.apply_patch(self._create_patch(one_line_overlap_patch))

        expected_changelog_contents = "%s\n%s" % (self._set_date_and_reviewer(one_line_overlap_entry), changelog_contents)

        self.assertEquals(read_from_path('ChangeLog'), expected_changelog_contents)

        self.scm.revert_files(['ChangeLog'])

        self.checkout.apply_patch(self._create_patch(two_line_overlap_patch))

        expected_changelog_contents = "%s\n%s" % (self._set_date_and_reviewer(two_line_overlap_entry), changelog_contents)

        self.assertEquals(read_from_path('ChangeLog'), expected_changelog_contents)

    def setUp(self):

        SVNTestRepository.setup(self)

        os.chdir(self.svn_checkout_path)

        self.scm = detect_scm_system(self.svn_checkout_path)

        # For historical reasons, we test some checkout code here too.

        self.checkout = Checkout(self.scm)

    def tearDown(self):

        SVNTestRepository.tear_down(self)

    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_create_patch_is_full_patch(self):

        test_dir_path = os.path.join(self.svn_checkout_path, "test_dir2")

        os.mkdir(test_dir_path)

        test_file_path = os.path.join(test_dir_path, 'test_file2')

        write_into_file_at_path(test_file_path, 'test content')

        run_command(['svn', 'add', 'test_dir2'])

        # create_patch depends on 'svn-create-patch', so make a dummy version.

        scripts_path = os.path.join(self.svn_checkout_path, 'WebKitTools', 'Scripts')

        os.makedirs(scripts_path)