Refactoring: Remove more legacy from release scripts.

tools/push-to-trunk/test_scripts.py

 #!/usr/bin/env python
 # Copyright 2013 the V8 project authors. 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
@@ skipping 42 matching lines @@
 from bump_up_version import LastChangeBailout
 from bump_up_version import LKGRVersionUpToDateBailout
 from auto_tag import AutoTag
 
 
 TEST_CONFIG = {
   "DEFAULT_CWD": None,
   BRANCHNAME: "test-prepare-push",
   TRUNKBRANCH: "test-trunk-push",
   PERSISTFILE_BASENAME: "/tmp/test-v8-push-to-trunk-tempfile",
-  VERSION_FILE: None,
   CHANGELOG_FILE: None,
   CHANGELOG_ENTRY_FILE: "/tmp/test-v8-push-to-trunk-tempfile-changelog-entry",
   PATCH_FILE: "/tmp/test-v8-push-to-trunk-tempfile-patch",
   COMMITMSG_FILE: "/tmp/test-v8-push-to-trunk-tempfile-commitmsg",
   CHROMIUM: "/tmp/test-v8-push-to-trunk-tempfile-chromium",
   SETTINGS_LOCATION: None,
   ALREADY_MERGING_SENTINEL_FILE:
       "/tmp/test-merge-to-branch-tempfile-already-merging",
   COMMIT_HASHES_FILE: "/tmp/test-merge-to-branch-tempfile-PATCH_COMMIT_HASHES",
   TEMPORARY_PATCH_FILE: "/tmp/test-merge-to-branch-tempfile-temporary-patch",
@@ skipping 281 matching lines @@
     self._tmp_files.append(name)
     return name
 
   def MakeEmptyTempDirectory(self):
     name = tempfile.mkdtemp()
     self._tmp_files.append(name)
     return name
 
 
   def WriteFakeVersionFile(self, minor=22, build=4, patch=0):
-    with open(TEST_CONFIG[VERSION_FILE], "w") as f:
+    version_file = os.path.join(TEST_CONFIG["DEFAULT_CWD"], VERSION_FILE)
+    if not os.path.exists(os.path.dirname(version_file)):
+      os.makedirs(os.path.dirname(version_file))
+    with open(version_file, "w") as f:
       f.write("  // Some line...\n")
       f.write("\n")
       f.write("#define MAJOR_VERSION    3\n")
       f.write("#define MINOR_VERSION    %s\n" % minor)
       f.write("#define BUILD_NUMBER     %s\n" % build)
       f.write("#define PATCH_LEVEL      %s\n" % patch)
       f.write("  // Some line...\n")
       f.write("#define IS_CANDIDATE_VERSION 0\n")
 
   def MakeStep(self):
@@ skipping 108 matching lines @@
 
   def testInitialEnvironmentChecks(self):
     TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
     os.environ["EDITOR"] = "vi"
     self.Expect([
       Cmd("which vi", "/usr/bin/vi"),
     ])
     self.MakeStep().InitialEnvironmentChecks(TEST_CONFIG["DEFAULT_CWD"])
 
   def testReadAndPersistVersion(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile(build=5)
     step = self.MakeStep()
     step.ReadAndPersistVersion()
     self.assertEquals("3", step["major"])
     self.assertEquals("22", step["minor"])
     self.assertEquals("5", step["build"])
     self.assertEquals("0", step["patch"])
 
   def testRegex(self):
     self.assertEqual("(issue 321)",
@@ skipping 19 matching lines @@
   def testPreparePushRevision(self):
     # Tests the default push hash used when the --revision option is not set.
     self.Expect([
       Cmd("git log -1 --format=%H HEAD", "push_hash")
     ])
 
     self.RunStep(PushToTrunk, PreparePushRevision)
     self.assertEquals("push_hash", self._state["push_hash"])
 
   def testPrepareChangeLog(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile()
     TEST_CONFIG[CHANGELOG_ENTRY_FILE] = self.MakeEmptyTempFile()
 
     self.Expect([
       Cmd("git log --format=%H 1234..push_hash", "rev1\nrev2\nrev3\nrev4"),
       Cmd("git log -1 --format=%s rev1", "Title text 1"),
       Cmd("git log -1 --format=%B rev1", "Title\n\nBUG=\nLOG=y\n"),
       Cmd("git log -1 --format=%an rev1", "author1@chromium.org"),
       Cmd("git log -1 --format=%s rev2", "Title text 2."),
       Cmd("git log -1 --format=%B rev2", "Title\n\nBUG=123\nLOG= \n"),
@@ skipping 55 matching lines @@
     ])
 
     self.RunStep(PushToTrunk, EditChangeLog)
 
     self.assertEquals("New\n        Lines",
                       FileToText(TEST_CONFIG[CHANGELOG_ENTRY_FILE]))
 
   # Version on trunk: 3.22.4.0. Version on master (bleeding_edge): 3.22.6.
   # Make sure that the increment is 3.22.7.0.
   def testIncrementVersion(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile()
     self._state["last_push_trunk"] = "hash1"
     self._state["latest_build"] = "6"
     self._state["latest_version"] = "3.22.6.0"
 
     self.Expect([
-      Cmd("git checkout -f hash1 -- %s" % TEST_CONFIG[VERSION_FILE], ""),
-      Cmd(("git checkout -f svn/bleeding_edge -- %s" %
-           TEST_CONFIG[VERSION_FILE]),
+      Cmd("git checkout -f hash1 -- src/version.cc", ""),
+      Cmd("git checkout -f svn/bleeding_edge -- src/version.cc",
           "", cb=lambda: self.WriteFakeVersionFile(22, 6)),
       RL("Y"),  # Increment build number.
     ])
 
     self.RunStep(PushToTrunk, IncrementVersion)
 
     self.assertEquals("3", self._state["new_major"])
     self.assertEquals("22", self._state["new_minor"])
     self.assertEquals("7", self._state["new_build"])
     self.assertEquals("0", self._state["new_patch"])
@@ skipping 48 matching lines @@
   def testSquashCommitsQuotationMarks(self):
     change_log = """Line with "quotation marks".\n"""
     commit_msg = """Line with "quotation marks"."""
     self._TestSquashCommits(change_log, commit_msg)
 
   def _PushToTrunk(self, force=False, manual=False):
     TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
 
     # The version file on bleeding edge has build level 5, while the version
     # file from trunk has build level 4.
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile(build=5)
 
     TEST_CONFIG[CHANGELOG_ENTRY_FILE] = self.MakeEmptyTempFile()
     TEST_CONFIG[CHANGELOG_FILE] = self.MakeEmptyTempFile()
     bleeding_edge_change_log = "2014-03-17: Sentinel\n"
     TextToFile(bleeding_edge_change_log, TEST_CONFIG[CHANGELOG_FILE])
     os.environ["EDITOR"] = "vi"
 
     def ResetChangeLog():
       """On 'git co -b new_branch svn/trunk', and 'git checkout -- ChangeLog',
       the ChangLog will be reset to its content on trunk."""
       trunk_change_log = """1999-04-05: Version 3.22.4
 
         Performance and stability improvements on all platforms.\n"""
       TextToFile(trunk_change_log, TEST_CONFIG[CHANGELOG_FILE])
 
     def ResetToTrunk():
       ResetChangeLog()
       self.WriteFakeVersionFile()
 
     def CheckSVNCommit():
       commit = FileToText(TEST_CONFIG[COMMITMSG_FILE])
       self.assertEquals(
 """Version 3.22.5 (based on bleeding_edge revision r123455)
 
 Log text 1 (issue 321).
 
 Performance and stability improvements on all platforms.""", commit)
-      version = FileToText(TEST_CONFIG[VERSION_FILE])
+      version = FileToText(
+          os.path.join(TEST_CONFIG["DEFAULT_CWD"], VERSION_FILE))
       self.assertTrue(re.search(r"#define MINOR_VERSION\s+22", version))
       self.assertTrue(re.search(r"#define BUILD_NUMBER\s+5", version))
       self.assertFalse(re.search(r"#define BUILD_NUMBER\s+6", version))
       self.assertTrue(re.search(r"#define PATCH_LEVEL\s+0", version))
       self.assertTrue(re.search(r"#define IS_CANDIDATE_VERSION\s+0", version))
 
       # Check that the change log on the trunk branch got correctly modified.
       change_log = FileToText(TEST_CONFIG[CHANGELOG_FILE])
       self.assertEquals(
 """1999-07-31: Version 3.22.5
@@ skipping 25 matching lines @@
            "\"^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]* (based\" "
            "svn/trunk"), "hash2\n"),
       Cmd("git log -1 hash2", "Log message\n"),
     ]
     if manual:
       expectations.append(RL("Y"))  # Confirm last push.
     expectations += [
       Cmd("git log -1 --format=%s hash2",
        "Version 3.4.5 (based on bleeding_edge revision r1234)\n"),
       Cmd("git svn find-rev r1234", "hash3\n"),
-      Cmd(("git checkout -f svn/bleeding_edge -- %s" %
-           TEST_CONFIG[VERSION_FILE]),
+      Cmd("git checkout -f svn/bleeding_edge -- src/version.cc",
           "", cb=self.WriteFakeVersionFile),
-      Cmd("git checkout -f hash2 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f hash2 -- src/version.cc", "",
           cb=self.WriteFakeVersionFile),
     ]
     if manual:
       expectations.append(RL(""))  # Increment build number.
     expectations += [
       Cmd("git log --format=%H hash3..push_hash", "rev1\n"),
       Cmd("git log -1 --format=%s rev1", "Log text 1.\n"),
       Cmd("git log -1 --format=%B rev1", "Text\nLOG=YES\nBUG=v8:321\nText\n"),
       Cmd("git log -1 --format=%an rev1", "author1@chromium.org\n"),
     ]
     if manual:
       expectations.append(RL(""))  # Open editor.
     if not force:
       expectations.append(Cmd("vi %s" % TEST_CONFIG[CHANGELOG_ENTRY_FILE], ""))
     expectations += [
       Cmd("git svn fetch", "fetch result\n"),
       Cmd("git checkout -f svn/bleeding_edge", ""),
       Cmd("git diff svn/trunk push_hash", "patch content\n"),
       Cmd("git svn find-rev push_hash", "123455\n"),
       Cmd("git checkout -b %s svn/trunk" % TEST_CONFIG[TRUNKBRANCH], "",
           cb=ResetToTrunk),
       Cmd("git apply --index --reject \"%s\"" % TEST_CONFIG[PATCH_FILE], ""),
       Cmd("git checkout -f svn/trunk -- %s" % TEST_CONFIG[CHANGELOG_FILE], "",
           cb=ResetChangeLog),
-      Cmd("git checkout -f svn/trunk -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f svn/trunk -- src/version.cc", "",
           cb=self.WriteFakeVersionFile),
       Cmd("git commit -aF \"%s\"" % TEST_CONFIG[COMMITMSG_FILE], "",
           cb=CheckSVNCommit),
     ]
     if manual:
       expectations.append(RL("Y"))  # Sanity check.
     expectations += [
       Cmd("git svn dcommit 2>&1",
           "Some output\nCommitted r123456\nSome output\n"),
       Cmd("git svn tag 3.22.5 -m \"Tagging version 3.22.5\"", ""),
@@ skipping 234 matching lines @@
       Cmd("git log -1 --format=%B abcd123455", self.C_V8_123455_LOG),
     ])
 
     result = auto_roll.AutoRoll(TEST_CONFIG, self).Run(
         AUTO_PUSH_ARGS + ["-c", TEST_CONFIG[CHROMIUM], "--roll"])
     self.assertEquals(0, result)
 
   def testMergeToBranch(self):
     TEST_CONFIG[ALREADY_MERGING_SENTINEL_FILE] = self.MakeEmptyTempFile()
     TextToFile("", os.path.join(TEST_CONFIG["DEFAULT_CWD"], ".git"))
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile(build=5)
     os.environ["EDITOR"] = "vi"
     extra_patch = self.MakeEmptyTempFile()
 
     def VerifyPatch(patch):
       return lambda: self.assertEquals(patch,
           FileToText(TEST_CONFIG[TEMPORARY_PATCH_FILE]))
 
     msg = """Version 3.22.5.1 (merged r12345, r23456, r34567, r45678, r56789)
 
 Title4
 
 Title2
 
 Title3
 
 Title1
 
 Revert "Something"
 
 BUG=123,234,345,456,567,v8:123
 LOG=N
 """
 
     def VerifySVNCommit():
       commit = FileToText(TEST_CONFIG[COMMITMSG_FILE])
       self.assertEquals(msg, commit)
-      version = FileToText(TEST_CONFIG[VERSION_FILE])
+      version = FileToText(
+          os.path.join(TEST_CONFIG["DEFAULT_CWD"], VERSION_FILE))
       self.assertTrue(re.search(r"#define MINOR_VERSION\s+22", version))
       self.assertTrue(re.search(r"#define BUILD_NUMBER\s+5", version))
       self.assertTrue(re.search(r"#define PATCH_LEVEL\s+1", version))
       self.assertTrue(re.search(r"#define IS_CANDIDATE_VERSION\s+0", version))
 
     self.Expect([
       Cmd("git status -s -uno", ""),
       Cmd("git status -s -b -uno", "## some_branch\n"),
       Cmd("git svn fetch", ""),
       Cmd("git branch", "  branch1\n* branch2\n"),
@@ skipping 131 matching lines @@
 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@4567 0039-1c4b
 
 """
     c_hash3_commit_log = """Simple.
 
 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@3456 0039-1c4b
 
 """
     json_output = self.MakeEmptyTempFile()
     csv_output = self.MakeEmptyTempFile()
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile()
 
     TEST_CONFIG[CHROMIUM] = self.MakeEmptyTempDirectory()
     chrome_dir = TEST_CONFIG[CHROMIUM]
     chrome_v8_dir = os.path.join(chrome_dir, "v8")
     os.makedirs(chrome_v8_dir)
     def WriteDEPS(revision):
       TextToFile("Line\n   \"v8_revision\": \"%s\",\n  line\n" % revision,
                  os.path.join(chrome_dir, "DEPS"))
     WriteDEPS(567)
 
     def ResetVersion(minor, build, patch=0):
       return lambda: self.WriteFakeVersionFile(minor=minor,
                                                build=build,
                                                patch=patch)
 
     def ResetDEPS(revision):
       return lambda: WriteDEPS(revision)
 
     self.Expect([
       Cmd("git status -s -uno", ""),
       Cmd("git status -s -b -uno", "## some_branch\n"),
       Cmd("git svn fetch", ""),
       Cmd("git branch", "  branch1\n* branch2\n"),
       Cmd("git checkout -b %s" % TEST_CONFIG[BRANCHNAME], ""),
       Cmd("git branch -r", "  svn/3.21\n  svn/3.3\n"),
       Cmd("git reset --hard svn/3.3", ""),
       Cmd("git log --format=%H", "hash1\nhash2"),
       Cmd("git diff --name-only hash1 hash1^", ""),
-      Cmd("git diff --name-only hash2 hash2^", TEST_CONFIG[VERSION_FILE]),
-      Cmd("git checkout -f hash2 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git diff --name-only hash2 hash2^", VERSION_FILE),
+      Cmd("git checkout -f hash2 -- %s" % VERSION_FILE, "",
           cb=ResetVersion(3, 1, 1)),
       Cmd("git log -1 --format=%B hash2",
           "Version 3.3.1.1 (merged 12)\n\nReview URL: fake.com\n"),
       Cmd("git log -1 --format=%s hash2", ""),
       Cmd("git svn find-rev hash2", "234"),
       Cmd("git log -1 --format=%ci hash2", "18:15"),
-      Cmd("git checkout -f HEAD -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
           cb=ResetVersion(22, 5)),
       Cmd("git reset --hard svn/3.21", ""),
       Cmd("git log --format=%H", "hash3\nhash4\nhash5\n"),
-      Cmd("git diff --name-only hash3 hash3^", TEST_CONFIG[VERSION_FILE]),
-      Cmd("git checkout -f hash3 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git diff --name-only hash3 hash3^", VERSION_FILE),
+      Cmd("git checkout -f hash3 -- %s" % VERSION_FILE, "",
           cb=ResetVersion(21, 2)),
       Cmd("git log -1 --format=%B hash3", ""),
       Cmd("git log -1 --format=%s hash3", ""),
       Cmd("git svn find-rev hash3", "123"),
       Cmd("git log -1 --format=%ci hash3", "03:15"),
-      Cmd("git checkout -f HEAD -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
           cb=ResetVersion(22, 5)),
       Cmd("git reset --hard svn/trunk", ""),
       Cmd("git log --format=%H", "hash6\n"),
-      Cmd("git diff --name-only hash6 hash6^", TEST_CONFIG[VERSION_FILE]),
-      Cmd("git checkout -f hash6 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git diff --name-only hash6 hash6^", VERSION_FILE),
+      Cmd("git checkout -f hash6 -- %s" % VERSION_FILE, "",
           cb=ResetVersion(22, 3)),
       Cmd("git log -1 --format=%B hash6", ""),
       Cmd("git log -1 --format=%s hash6", ""),
       Cmd("git svn find-rev hash6", "345"),
       Cmd("git log -1 --format=%ci hash6", ""),
-      Cmd("git checkout -f HEAD -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
           cb=ResetVersion(22, 5)),
       Cmd("git reset --hard svn/bleeding_edge", ""),
       Cmd("svn log https://v8.googlecode.com/svn/tags -v --limit 20",
           tag_response_text),
       Cmd("git svn find-rev r22626", "hash_22626"),
       Cmd("git svn find-rev hash_22626", "22626"),
       Cmd("git log -1 --format=%ci hash_22626", "01:23"),
       Cmd("git svn find-rev r22624", "hash_22624"),
       Cmd("git svn find-rev hash_22624", "22624"),
       Cmd("git log -1 --format=%ci hash_22624", "02:34"),
@@ skipping 67 matching lines @@
        "revision_link": "https://code.google.com/p/v8/source/detail?r=123"},
       {"patches_merged": "12", "bleeding_edge": "", "version": "3.3.1.1",
        "chromium_revision": "", "branch": "3.3", "revision": "234",
        "review_link": "fake.com", "date": "18:15", "chromium_branch": "",
        "revision_link": "https://code.google.com/p/v8/source/detail?r=234"},
     ]
     self.assertEquals(expected_json, json.loads(FileToText(json_output)))
 
 
   def _bumpUpVersion(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile()
 
     def ResetVersion(minor, build, patch=0):
       return lambda: self.WriteFakeVersionFile(minor=minor,
                                                build=build,
                                                patch=patch)
 
     return [
       Cmd("git status -s -uno", ""),
       Cmd("git checkout -f bleeding_edge", "", cb=ResetVersion(11, 4)),
@@ skipping 53 matching lines @@
       Cmd("git branch -D auto-bump-up-version", ""),
     ]
     self.Expect(expectations)
 
     BumpUpVersion(TEST_CONFIG, self).Run(
         ["-a", "author@chromium.org",
          "--svn", "[SVN_ROOT]",
          "--svn-config", "[CONFIG_DIR]"])
 
   def testAutoTag(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self.WriteFakeVersionFile()
 
     def ResetVersion(minor, build, patch=0):
       return lambda: self.WriteFakeVersionFile(minor=minor,
                                                build=build,
                                                patch=patch)
 
     self.Expect([
       Cmd("git status -s -uno", ""),
       Cmd("git status -s -b -uno", "## some_branch\n"),
       Cmd("git svn fetch", ""),
       Cmd("git branch", "  branch1\n* branch2\n"),
       Cmd("git checkout -f master", ""),
       Cmd("git svn rebase", ""),
       Cmd("git checkout -b %s" % TEST_CONFIG[BRANCHNAME], "",
           cb=ResetVersion(4, 5)),
       Cmd("git branch -r",
           "svn/tags/3.4.2\nsvn/tags/3.2.1.0\nsvn/branches/3.4"),
       Cmd(("git log --format=%H --grep="
            "\"\\[Auto\\-roll\\] Bump up version to\""),
           "hash125\nhash118\nhash111\nhash101"),
-      Cmd("git checkout -f hash125 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f hash125 -- %s" % VERSION_FILE, "",
           cb=ResetVersion(4, 4)),
-      Cmd("git checkout -f HEAD -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
           cb=ResetVersion(4, 5)),
-      Cmd("git checkout -f hash118 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f hash118 -- %s" % VERSION_FILE, "",
           cb=ResetVersion(4, 3)),
-      Cmd("git checkout -f HEAD -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
           cb=ResetVersion(4, 5)),
-      Cmd("git checkout -f hash111 -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f hash111 -- %s" % VERSION_FILE, "",
           cb=ResetVersion(4, 2)),
-      Cmd("git checkout -f HEAD -- %s" % TEST_CONFIG[VERSION_FILE], "",
+      Cmd("git checkout -f HEAD -- %s" % VERSION_FILE, "",
           cb=ResetVersion(4, 5)),
       URL("https://v8-status.appspot.com/revisions?format=json",
           "[{\"revision\": \"126\", \"status\": true},"
            "{\"revision\": \"123\", \"status\": true},"
            "{\"revision\": \"112\", \"status\": true}]"),
       Cmd("git svn find-rev hash118", "118"),
       Cmd("git svn find-rev hash125", "125"),
       Cmd("git svn find-rev r123", "hash123"),
       Cmd("git log -1 --format=%at hash123", "1"),
       Cmd("git reset --hard hash123", ""),
       Cmd("git svn tag 3.4.3 -m \"Tagging version 3.4.3\"", ""),
       Cmd("git checkout -f some_branch", ""),
       Cmd("git branch -D %s" % TEST_CONFIG[BRANCHNAME], ""),
     ])
 
     AutoTag(TEST_CONFIG, self).Run(["-a", "author@chromium.org"])
 
   # Test that we bail out if the last change was a version change.
   def testBumpUpVersionBailout1(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self._state["latest"] = "latest_hash"
 
     self.Expect([
-      Cmd("git diff --name-only latest_hash latest_hash^",
-          TEST_CONFIG[VERSION_FILE]),
+      Cmd("git diff --name-only latest_hash latest_hash^", VERSION_FILE),
     ])
 
     self.assertEquals(0,
         self.RunStep(BumpUpVersion, LastChangeBailout, ["--dry_run"]))
 
   # Test that we bail out if the lkgr was a version change.
   def testBumpUpVersionBailout2(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self._state["lkgr"] = "lkgr_hash"
 
     self.Expect([
-      Cmd("git diff --name-only lkgr_hash lkgr_hash^",
-          TEST_CONFIG[VERSION_FILE]),
+      Cmd("git diff --name-only lkgr_hash lkgr_hash^", VERSION_FILE),
     ])
 
     self.assertEquals(0,
         self.RunStep(BumpUpVersion, LKGRVersionUpToDateBailout, ["--dry_run"]))
 
   # Test that we bail out if the last version is already newer than the lkgr's
   # version.
   def testBumpUpVersionBailout3(self):
-    TEST_CONFIG[VERSION_FILE] = self.MakeEmptyTempFile()
     self._state["lkgr"] = "lkgr_hash"
     self._state["lkgr_version"] = "3.22.4.0"
     self._state["latest_version"] = "3.22.5.0"
 
     self.Expect([
       Cmd("git diff --name-only lkgr_hash lkgr_hash^", ""),
     ])
 
     self.assertEquals(0,
         self.RunStep(BumpUpVersion, LKGRVersionUpToDateBailout, ["--dry_run"]))
@@ skipping 13 matching lines @@
 
 Review URL: https://codereview.chromium.org/83173002
 
 ------------------------------------------------------------------------""")
     self.assertEquals(
 """Prepare push to trunk.  Now working on version 3.23.11.
 
 R=danno@chromium.org
 
 Committed: https://code.google.com/p/v8/source/detail?r=17997""", body)