mirror of
https://gerrit.googlesource.com/git-repo
synced 2024-12-21 07:16:21 +00:00
a6413f5d88
In order to better analyze and track repo errors, repo command failures need to be tied to specific errors in repo source code. Additionally a new GitCommandError was added to differentiate between general git related errors to failed git commands. Git commands that opt into verification will raise a GitCommandError if the command failed. The first step in this process is a general error refactoring Bug: b/293344017 Change-Id: I46944b1825ce892757c8dd3f7e2fab7e460760c0 Reviewed-on: https://gerrit-review.googlesource.com/c/git-repo/+/380994 Commit-Queue: Jason Chang <jasonnc@google.com> Reviewed-by: Aravind Vasudevan <aravindvasudev@google.com> Tested-by: Jason Chang <jasonnc@google.com> Reviewed-by: Joanna Wang <jojwang@google.com>
216 lines
7.0 KiB
Python
216 lines
7.0 KiB
Python
# Copyright 2019 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
"""Unittests for the git_command.py module."""
|
|
|
|
import re
|
|
import os
|
|
import subprocess
|
|
import unittest
|
|
|
|
try:
|
|
from unittest import mock
|
|
except ImportError:
|
|
import mock
|
|
|
|
import git_command
|
|
import wrapper
|
|
|
|
|
|
class GitCommandTest(unittest.TestCase):
|
|
"""Tests the GitCommand class (via git_command.git)."""
|
|
|
|
def setUp(self):
|
|
def realpath_mock(val):
|
|
return val
|
|
|
|
mock.patch.object(
|
|
os.path, "realpath", side_effect=realpath_mock
|
|
).start()
|
|
|
|
def tearDown(self):
|
|
mock.patch.stopall()
|
|
|
|
def test_alternative_setting_when_matching(self):
|
|
r = git_command._build_env(
|
|
objdir=os.path.join("zap", "objects"), gitdir="zap"
|
|
)
|
|
|
|
self.assertIsNone(r.get("GIT_ALTERNATE_OBJECT_DIRECTORIES"))
|
|
self.assertEqual(
|
|
r.get("GIT_OBJECT_DIRECTORY"), os.path.join("zap", "objects")
|
|
)
|
|
|
|
def test_alternative_setting_when_different(self):
|
|
r = git_command._build_env(
|
|
objdir=os.path.join("wow", "objects"), gitdir="zap"
|
|
)
|
|
|
|
self.assertEqual(
|
|
r.get("GIT_ALTERNATE_OBJECT_DIRECTORIES"),
|
|
os.path.join("zap", "objects"),
|
|
)
|
|
self.assertEqual(
|
|
r.get("GIT_OBJECT_DIRECTORY"), os.path.join("wow", "objects")
|
|
)
|
|
|
|
|
|
class GitCommandWaitTest(unittest.TestCase):
|
|
"""Tests the GitCommand class .Wait()"""
|
|
|
|
def setUp(self):
|
|
class MockPopen(object):
|
|
rc = 0
|
|
|
|
def communicate(
|
|
self, input: str = None, timeout: float = None
|
|
) -> [str, str]:
|
|
"""Mock communicate fn."""
|
|
return ["", ""]
|
|
|
|
def wait(self, timeout=None):
|
|
return self.rc
|
|
|
|
self.popen = popen = MockPopen()
|
|
|
|
def popen_mock(*args, **kwargs):
|
|
return popen
|
|
|
|
def realpath_mock(val):
|
|
return val
|
|
|
|
mock.patch.object(subprocess, "Popen", side_effect=popen_mock).start()
|
|
|
|
mock.patch.object(
|
|
os.path, "realpath", side_effect=realpath_mock
|
|
).start()
|
|
|
|
def tearDown(self):
|
|
mock.patch.stopall()
|
|
|
|
def test_raises_when_verify_non_zero_result(self):
|
|
self.popen.rc = 1
|
|
r = git_command.GitCommand(None, ["status"], verify_command=True)
|
|
with self.assertRaises(git_command.GitCommandError):
|
|
r.Wait()
|
|
|
|
def test_returns_when_no_verify_non_zero_result(self):
|
|
self.popen.rc = 1
|
|
r = git_command.GitCommand(None, ["status"], verify_command=False)
|
|
self.assertEqual(1, r.Wait())
|
|
|
|
def test_default_returns_non_zero_result(self):
|
|
self.popen.rc = 1
|
|
r = git_command.GitCommand(None, ["status"])
|
|
self.assertEqual(1, r.Wait())
|
|
|
|
|
|
class GitCallUnitTest(unittest.TestCase):
|
|
"""Tests the _GitCall class (via git_command.git)."""
|
|
|
|
def test_version_tuple(self):
|
|
"""Check git.version_tuple() handling."""
|
|
ver = git_command.git.version_tuple()
|
|
self.assertIsNotNone(ver)
|
|
|
|
# We don't dive too deep into the values here to avoid having to update
|
|
# whenever git versions change. We do check relative to this min
|
|
# version as this is what `repo` itself requires via MIN_GIT_VERSION.
|
|
MIN_GIT_VERSION = (2, 10, 2)
|
|
self.assertTrue(isinstance(ver.major, int))
|
|
self.assertTrue(isinstance(ver.minor, int))
|
|
self.assertTrue(isinstance(ver.micro, int))
|
|
|
|
self.assertGreater(ver.major, MIN_GIT_VERSION[0] - 1)
|
|
self.assertGreaterEqual(ver.micro, 0)
|
|
self.assertGreaterEqual(ver.major, 0)
|
|
|
|
self.assertGreaterEqual(ver, MIN_GIT_VERSION)
|
|
self.assertLess(ver, (9999, 9999, 9999))
|
|
|
|
self.assertNotEqual("", ver.full)
|
|
|
|
|
|
class UserAgentUnitTest(unittest.TestCase):
|
|
"""Tests the UserAgent function."""
|
|
|
|
def test_smoke_os(self):
|
|
"""Make sure UA OS setting returns something useful."""
|
|
os_name = git_command.user_agent.os
|
|
# We can't dive too deep because of OS/tool differences, but we can
|
|
# check the general form.
|
|
m = re.match(r"^[^ ]+$", os_name)
|
|
self.assertIsNotNone(m)
|
|
|
|
def test_smoke_repo(self):
|
|
"""Make sure repo UA returns something useful."""
|
|
ua = git_command.user_agent.repo
|
|
# We can't dive too deep because of OS/tool differences, but we can
|
|
# check the general form.
|
|
m = re.match(r"^git-repo/[^ ]+ ([^ ]+) git/[^ ]+ Python/[0-9.]+", ua)
|
|
self.assertIsNotNone(m)
|
|
|
|
def test_smoke_git(self):
|
|
"""Make sure git UA returns something useful."""
|
|
ua = git_command.user_agent.git
|
|
# We can't dive too deep because of OS/tool differences, but we can
|
|
# check the general form.
|
|
m = re.match(r"^git/[^ ]+ ([^ ]+) git-repo/[^ ]+", ua)
|
|
self.assertIsNotNone(m)
|
|
|
|
|
|
class GitRequireTests(unittest.TestCase):
|
|
"""Test the git_require helper."""
|
|
|
|
def setUp(self):
|
|
self.wrapper = wrapper.Wrapper()
|
|
ver = self.wrapper.GitVersion(1, 2, 3, 4)
|
|
mock.patch.object(
|
|
git_command.git, "version_tuple", return_value=ver
|
|
).start()
|
|
|
|
def tearDown(self):
|
|
mock.patch.stopall()
|
|
|
|
def test_older_nonfatal(self):
|
|
"""Test non-fatal require calls with old versions."""
|
|
self.assertFalse(git_command.git_require((2,)))
|
|
self.assertFalse(git_command.git_require((1, 3)))
|
|
self.assertFalse(git_command.git_require((1, 2, 4)))
|
|
self.assertFalse(git_command.git_require((1, 2, 3, 5)))
|
|
|
|
def test_newer_nonfatal(self):
|
|
"""Test non-fatal require calls with newer versions."""
|
|
self.assertTrue(git_command.git_require((0,)))
|
|
self.assertTrue(git_command.git_require((1, 0)))
|
|
self.assertTrue(git_command.git_require((1, 2, 0)))
|
|
self.assertTrue(git_command.git_require((1, 2, 3, 0)))
|
|
|
|
def test_equal_nonfatal(self):
|
|
"""Test require calls with equal values."""
|
|
self.assertTrue(git_command.git_require((1, 2, 3, 4), fail=False))
|
|
self.assertTrue(git_command.git_require((1, 2, 3, 4), fail=True))
|
|
|
|
def test_older_fatal(self):
|
|
"""Test fatal require calls with old versions."""
|
|
with self.assertRaises(SystemExit) as e:
|
|
git_command.git_require((2,), fail=True)
|
|
self.assertNotEqual(0, e.code)
|
|
|
|
def test_older_fatal_msg(self):
|
|
"""Test fatal require calls with old versions and message."""
|
|
with self.assertRaises(SystemExit) as e:
|
|
git_command.git_require((2,), fail=True, msg="so sad")
|
|
self.assertNotEqual(0, e.code)
|