178 lines
7.3 KiB
Python
178 lines
7.3 KiB
Python
# SPDX-License-Identifier: LGPL-2.1-or-later
|
|
# ***************************************************************************
|
|
# * *
|
|
# * Copyright (c) 2022 FreeCAD Project Association *
|
|
# * *
|
|
# * This file is part of FreeCAD. *
|
|
# * *
|
|
# * FreeCAD is free software: you can redistribute it and/or modify it *
|
|
# * under the terms of the GNU Lesser General Public License as *
|
|
# * published by the Free Software Foundation, either version 2.1 of the *
|
|
# * License, or (at your option) any later version. *
|
|
# * *
|
|
# * FreeCAD is distributed in the hope that it will be useful, but *
|
|
# * WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
# * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
|
|
# * Lesser General Public License for more details. *
|
|
# * *
|
|
# * You should have received a copy of the GNU Lesser General Public *
|
|
# * License along with FreeCAD. If not, see *
|
|
# * <https://www.gnu.org/licenses/>. *
|
|
# * *
|
|
# ***************************************************************************
|
|
|
|
|
|
import unittest
|
|
import os
|
|
import shutil
|
|
import stat
|
|
import tempfile
|
|
import time
|
|
from zipfile import ZipFile
|
|
import FreeCAD
|
|
|
|
from addonmanager_git import GitManager, NoGitFound, GitFailed
|
|
|
|
try:
|
|
git_manager = GitManager()
|
|
except NoGitFound:
|
|
git_manager = None
|
|
|
|
|
|
@unittest.skipIf(git_manager is None, "No git executable -- not running git-based tests")
|
|
class TestGit(unittest.TestCase):
|
|
|
|
MODULE = "test_git" # file name without extension
|
|
|
|
def setUp(self):
|
|
"""Set up the test case: called by the unit test system"""
|
|
self.cwd = os.getcwd()
|
|
test_data_dir = os.path.join(
|
|
FreeCAD.getHomePath(), "Mod", "AddonManager", "AddonManagerTest", "data"
|
|
)
|
|
git_repo_zip = os.path.join(test_data_dir, "test_repo.zip")
|
|
self.test_dir = os.path.join(
|
|
tempfile.gettempdir(), "FreeCADTesting", "AddonManagerTests", "Git"
|
|
)
|
|
os.makedirs(self.test_dir, exist_ok=True)
|
|
self.test_repo_remote = os.path.join(self.test_dir, "TEST_REPO_REMOTE")
|
|
if os.path.exists(self.test_repo_remote):
|
|
# Make sure any old copy that got left around is deleted
|
|
self._rmdir(self.test_repo_remote)
|
|
|
|
if not os.path.exists(git_repo_zip):
|
|
self.skipTest("Can't find test repo")
|
|
return
|
|
|
|
with ZipFile(git_repo_zip, "r") as zip_repo:
|
|
zip_repo.extractall(self.test_repo_remote)
|
|
self.test_repo_remote = os.path.join(self.test_repo_remote, "test_repo")
|
|
|
|
self.git = git_manager
|
|
|
|
def tearDown(self):
|
|
"""Clean up after the test"""
|
|
os.chdir(self.cwd)
|
|
# self._rmdir(self.test_dir)
|
|
os.rename(self.test_dir, self.test_dir + ".old." + str(time.time()))
|
|
|
|
def test_clone(self):
|
|
"""Test git clone"""
|
|
checkout_dir = self._clone_test_repo()
|
|
self.assertTrue(os.path.exists(checkout_dir))
|
|
self.assertTrue(os.path.exists(os.path.join(checkout_dir, ".git")))
|
|
self.assertEqual(os.getcwd(), self.cwd, "We should be left in the same CWD we started")
|
|
|
|
def test_checkout(self):
|
|
"""Test git checkout"""
|
|
checkout_dir = self._clone_test_repo()
|
|
|
|
self.git.checkout(checkout_dir, "HEAD~1")
|
|
status = self.git.status(checkout_dir).strip()
|
|
expected_status = "## HEAD (no branch)"
|
|
self.assertEqual(status, expected_status)
|
|
|
|
self.assertEqual(os.getcwd(), self.cwd, "We should be left in the same CWD we started")
|
|
|
|
def test_update(self):
|
|
"""Test using git to update the local repo"""
|
|
checkout_dir = self._clone_test_repo()
|
|
|
|
self.git.reset(checkout_dir, ["--hard", "HEAD~1"])
|
|
self.assertTrue(self.git.update_available(checkout_dir))
|
|
self.git.update(checkout_dir)
|
|
self.assertFalse(self.git.update_available(checkout_dir))
|
|
self.assertEqual(os.getcwd(), self.cwd, "We should be left in the same CWD we started")
|
|
|
|
def test_tag_and_branch(self):
|
|
"""Test checking the currently checked-out tag"""
|
|
checkout_dir = self._clone_test_repo()
|
|
|
|
expected_tag = "TestTag"
|
|
self.git.checkout(checkout_dir, expected_tag)
|
|
found_tag = self.git.current_tag(checkout_dir)
|
|
self.assertEqual(found_tag, expected_tag)
|
|
self.assertFalse(self.git.update_available(checkout_dir))
|
|
|
|
expected_branch = "TestBranch"
|
|
self.git.checkout(checkout_dir, expected_branch)
|
|
found_branch = self.git.current_branch(checkout_dir)
|
|
self.assertEqual(found_branch, expected_branch)
|
|
self.assertFalse(self.git.update_available(checkout_dir))
|
|
|
|
expected_branch = "main"
|
|
self.git.checkout(checkout_dir, expected_branch)
|
|
found_branch = self.git.current_branch(checkout_dir)
|
|
self.assertEqual(found_branch, expected_branch)
|
|
self.assertFalse(self.git.update_available(checkout_dir))
|
|
|
|
self.assertEqual(os.getcwd(), self.cwd, "We should be left in the same CWD we started")
|
|
|
|
def test_get_remote(self):
|
|
"""Test getting the remote location"""
|
|
checkout_dir = self._clone_test_repo()
|
|
expected_remote = self.test_repo_remote
|
|
returned_remote = self.git.get_remote(checkout_dir)
|
|
self.assertEqual(expected_remote, returned_remote)
|
|
self.assertEqual(os.getcwd(), self.cwd, "We should be left in the same CWD we started")
|
|
|
|
def test_repair(self):
|
|
"""Test the repair feature (and some exception throwing)"""
|
|
checkout_dir = self._clone_test_repo()
|
|
remote = self.git.get_remote(checkout_dir)
|
|
git_dir = os.path.join(checkout_dir, ".git")
|
|
self.assertTrue(os.path.exists(git_dir))
|
|
self._rmdir(git_dir)
|
|
|
|
# Make sure that we've truly broken the install
|
|
with self.assertRaises(GitFailed):
|
|
self.git.status(checkout_dir)
|
|
|
|
self.git.repair(remote, checkout_dir)
|
|
status = self.git.status(checkout_dir)
|
|
self.assertEqual(status, "## main...origin/main\n")
|
|
self.assertEqual(os.getcwd(), self.cwd, "We should be left in the same CWD we started")
|
|
|
|
def _rmdir(self, path):
|
|
try:
|
|
shutil.rmtree(path, onerror=self._remove_readonly)
|
|
except Exception as e:
|
|
print(e)
|
|
|
|
def _remove_readonly(self, func, path, _) -> None:
|
|
"""Remove a read-only file."""
|
|
|
|
os.chmod(path, stat.S_IWRITE)
|
|
func(path)
|
|
|
|
def _clone_test_repo(self) -> str:
|
|
checkout_dir = os.path.join(self.test_dir, "test_repo")
|
|
try:
|
|
# Git won't clone to an existing directory, so make sure to remove it first
|
|
if os.path.exists(checkout_dir):
|
|
self._rmdir(checkout_dir)
|
|
self.git.clone(self.test_repo_remote, checkout_dir)
|
|
except GitFailed as e:
|
|
self.fail(str(e))
|
|
return checkout_dir
|