# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
#
# This module is part of GitPython and is released under the
# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
import gc
import os.path as osp
from pathlib import Path
import random
import sys
import tempfile
from unittest import skipIf
import pytest
from git import (
Commit,
FetchInfo,
GitCommandError,
Head,
PushInfo,
Reference,
Remote,
RemoteProgress,
RemoteReference,
SymbolicReference,
TagReference,
)
from git.cmd import Git
from git.exc import UnsafeOptionError, UnsafeProtocolError
from git.util import HIDE_WINDOWS_FREEZE_ERRORS, IterableList, rmtree
from test.lib import (
GIT_DAEMON_PORT,
TestBase,
fixture,
with_rw_and_rw_remote_repo,
with_rw_repo,
)
# Make sure we have repeatable results.
random.seed(0)
class TestRemoteProgress(RemoteProgress):
__slots__ = ("_seen_lines", "_stages_per_op", "_num_progress_messages")
def __init__(self):
super().__init__()
self._seen_lines = []
self._stages_per_op = {}
self._num_progress_messages = 0
def _parse_progress_line(self, line):
# We may remove the line later if it is dropped.
# Keep it for debugging.
self._seen_lines.append(line)
rval = super()._parse_progress_line(line)
return rval
def line_dropped(self, line):
try:
self._seen_lines.remove(line)
except ValueError:
pass
def update(self, op_code, cur_count, max_count=None, message=""):
# Check each stage only comes once.
op_id = op_code & self.OP_MASK
assert op_id in (self.COUNTING, self.COMPRESSING, self.WRITING)
if op_code & self.WRITING > 0:
if op_code & self.BEGIN > 0:
assert not message, "should not have message when remote begins writing"
elif op_code & self.END > 0:
assert message
assert not message.startswith(", "), "Sanitize progress messages: '%s'" % message
assert not message.endswith(", "), "Sanitize progress messages: '%s'" % message
self._stages_per_op.setdefault(op_id, 0)
self._stages_per_op[op_id] = self._stages_per_op[op_id] | (op_code & self.STAGE_MASK)
if op_code & (self.WRITING | self.END) == (self.WRITING | self.END):
assert message
# END check we get message
self._num_progress_messages += 1
def make_assertion(self):
# We don't always receive messages.
if not self._seen_lines:
return
# Sometimes objects are not compressed which is okay.
assert len(self._seen_ops) in (2, 3), len(self._seen_ops)
assert self._stages_per_op
# Must have seen all stages.
for _op, stages in self._stages_per_op.items():
assert stages & self.STAGE_MASK == self.STAGE_MASK
# END for each op/stage
def assert_received_message(self):
assert self._num_progress_messages
class TestRemote(TestBase):
def tearDown(self):
gc.collect()
def _print_fetchhead(self, repo):
with open(osp.join(repo.git_dir, "FETCH_HEAD")):
pass
def _do_test_fetch_result(self, results, remote):
# self._print_fetchhead(remote.repo)
self.assertGreater(len(results), 0)
self.assertIsInstance(results[0], FetchInfo)
for info in results:
self.assertIsInstance(info.note, str)
if isinstance(info.ref, Reference):
self.assertTrue(info.flags)
# END reference type flags handling
self.assertIsInstance(info.ref, (SymbolicReference, Reference))
if info.flags & (info.FORCED_UPDATE | info.FAST_FORWARD):
self.assertIsInstance(info.old_commit, Commit)
else:
self.assertIsNone(info.old_commit)
# END forced update checking
# END for each info
def _do_test_push_result(self, results, remote):
self.assertIsInstance(results, list)
self.assertIsInstance(results, IterableList)
self.assertGreater(len(results), 0)
self.assertIsInstance(results[0], PushInfo)
for info in results:
self.assertTrue(info.flags)
self.assertIsInstance(info.summary, str)
if info.old_commit is not None:
self.assertIsInstance(info.old_commit, Commit)
if info.flags & info.ERROR:
has_one = False
for bitflag in (
info.REJECTED,
info.REMOTE_REJECTED,
info.REMOTE_FAILURE,
):
has_one |= bool(info.flags & bitflag)
# END for each bitflag
self.assertTrue(has_one)
else:
# There must be a remote commit.
if info.flags & info.DELETED == 0:
self.assertIsInstance(info.local_ref, Reference)
else:
self.assertIsNone(info.local_ref)
self.assertIn(type(info.remote_ref), (TagReference, RemoteReference))
# END error checking
# END for each info
if any(info.flags & info.ERROR for info in results):
self.assertRaises(GitCommandError, results.raise_if_error)
else:
# No errors, so this should do nothing.
results.raise_if_error()
def _do_test_fetch_info(self, repo):
self.assertRaises(ValueError, FetchInfo._from_line, repo, "nonsense", "")
self.assertRaises(
ValueError,
FetchInfo._from_line,
repo,
"? [up to date] 0.1.7RC -> origin/0.1.7RC",
"",
)
def _commit_random_file(self, repo):
"""Create a file with a random name and random data and commit it to a repo.
:return: The committed absolute file path.
"""
index = repo.index
new_file = self._make_file(osp.basename(tempfile.mktemp()), str(random.random()), repo)
index.add([new_file])
index.commit("Committing %s" % new_file)
return new_file
def _do_test_fetch(self, remote, rw_repo, remote_repo, **kwargs):
"""Specialized fetch testing to de-clutter the main test."""
self._do_test_fetch_info(rw_repo)
def fetch_and_test(remote, **kwargs):
progress = TestRemoteProgress()
kwargs["progress"] = progress
res = remote.fetch(**kwargs)
progress.make_assertion()
self._do_test_fetch_result(res, remote)
return res
# END fetch and check
def get_info(res, remote, name):
return res["%s/%s" % (remote, name)]
# Put remote head to master as it is guaranteed to exist.
remote_repo.head.reference = remote_repo.heads.master
res = fetch_and_test(remote, **kwargs)
# All up to date.
for info in res:
self.assertTrue(info.flags & info.HEAD_UPTODATE)
# Rewind remote head to trigger rejection.
# index must be false as remote is a bare repo.
rhead = remote_repo.head
remote_commit = rhead.commit
rhead.reset("HEAD~2", index=False)
res = fetch_and_test(remote)
mkey = "%s/%s" % (remote, "master")
master_info = res[mkey]
self.assertTrue(master_info.flags & FetchInfo.FORCED_UPDATE)
self.assertIsNotNone(master_info.note)
# Normal fast forward - set head back to previous one.
rhead.commit = remote_commit
res = fetch_and_test(remote)
self.assertTrue(res[mkey].flags & FetchInfo.FAST_FORWARD)
# New remote branch.
new_remote_branch = Head.create(remote_repo, "new_branch")
res = fetch_and_test(remote)
new_branch_info = get_info(res, remote, new_remote_branch)
self.assertTrue(new_branch_info.flags & FetchInfo.NEW_HEAD)
# Remote branch rename (causes creation of a new one locally).
new_remote_branch.rename("other_branch_name")
res = fetch_and_test(remote)
other_branch_info = get_info(res, remote, new_remote_branch)
self.assertEqual(other_branch_info.ref.commit, new_branch_info.ref.commit)
# Remove new branch.
Head.delete(new_remote_branch.repo, new_remote_branch)
res = fetch_and_test(remote)
# Deleted remote will not be fetched.
self.assertRaises(IndexError, get_info, res, remote, new_remote_branch)
# Prune stale tracking branches.
stale_refs = remote.stale_refs
self.assertEqual(len(stale_refs), 2)
self.assertIsInstance(stale_refs[0], RemoteReference)
RemoteReference.delete(rw_repo, *stale_refs)
# Test single branch fetch with refspec including target remote.
res = fetch_and_test(remote, refspec="master:refs/remotes/%s/master" % remote)
self.assertEqual(len(res), 1)
self.assertTrue(get_info(res, remote, "master"))
# ...with respec and no target.
res = fetch_and_test(remote, refspec="master")
self.assertEqual(len(res), 1)
# ...multiple refspecs...works, but git command returns with error if one ref is
# wrong without doing anything. This is new in later binaries.
# res = fetch_and_test(remote, refspec=['master', 'fred'])
# self.assertEqual(len(res), 1)
# Add new tag reference.
rtag = TagReference.create(remote_repo, "1.0-RV_hello.there")
res = fetch_and_test(remote, tags=True)
tinfo = res[str(rtag)]
self.assertIsInstance(tinfo.ref, TagReference)
self.assertEqual(tinfo.ref.commit, rtag.commit)
self.assertTrue(tinfo.flags & tinfo.NEW_TAG)
# Adjust the local tag commit.
Reference.set_object(rtag, rhead.commit.parents[0].parents[0])
# As of git 2.20 one cannot clobber local tags that have changed without
# specifying --force, and the test assumes you can clobber, so...
force = None
if rw_repo.git.version_info[:2] >= (2, 20):
force = True
res = fetch_and_test(remote, tags=True, force=force)
tinfo = res[str(rtag)]
self.assertEqual(tinfo.commit, rtag.commit)
self.assertTrue(tinfo.flags & tinfo.TAG_UPDATE)
# Delete remote tag - local one will stay.
TagReference.delete(remote_repo, rtag)
res = fetch_and_test(remote, tags=True)
self.assertRaises(IndexError, get_info, res, remote, str(rtag))
# Provoke to receive actual objects to see what kind of output we have to
# expect. For that we need a remote transport protocol.
# Create a new UN-shared repo and fetch into it after we pushed a change to the
# shared repo.
other_repo_dir = tempfile.mktemp("other_repo")
# Must clone with a local path for the repo implementation not to freak out as
# it wants local paths only (which I can understand).
other_repo = remote_repo.clone(other_repo_dir, shared=False)
remote_repo_url = osp.basename(remote_repo.git_dir) # git-daemon runs with appropriate `--base-path`.
remote_repo_url = Git.polish_url("git://localhost:%s/%s" % (GIT_DAEMON_PORT, remote_repo_url))
# Put origin to git-url.
other_origin = other_repo.remotes.origin
with other_origin.config_writer as cw:
cw.set("url", remote_repo_url)
# It automatically creates alternates as remote_repo is shared as well.
# It will use the transport though and ignore alternates when fetching.
# assert not other_repo.alternates # this would fail
# Ensure we are in the right state.
rw_repo.head.reset(remote.refs.master, working_tree=True)
try:
self._commit_random_file(rw_repo)
remote.push(rw_repo.head.reference)
# Here I would expect to see remote-information about packing objects and so
# on. Unfortunately, this does not happen if we are redirecting the output -
# git explicitly checks for this and only provides progress information to
# ttys.
res = fetch_and_test(other_origin)
finally:
rmtree(other_repo_dir)
# END test and cleanup
def _assert_push_and_pull(self, remote, rw_repo, remote_repo):
# Push our changes.
lhead = rw_repo.head
# Ensure we are on master and it is checked out where the remote is.
try:
lhead.reference = rw_repo.heads.master
except AttributeError:
# If the author is on a non-master branch, the clones might not have a local
# master yet. We simply create it.
lhead.reference = rw_repo.create_head("master")
# END master handling
lhead.reset(remote.refs.master, working_tree=True)
# Push without spec should fail (without further configuration)
# well, works nicely
# self.assertRaises(GitCommandError, remote.push)
# Simple file push.
self._commit_random_file(rw_repo)
progress = TestRemoteProgress()
res = remote.push(lhead.reference, progress)
self.assertIsInstance(res, list)
self._do_test_push_result(res, remote)
progress.make_assertion()
# Rejected - undo last commit.
lhead.reset("HEAD~1")
res = remote.push(lhead.reference)
self.assertTrue(res[0].flags & PushInfo.ERROR)
self.assertTrue(res[0].flags & PushInfo.REJECTED)
self._do_test_push_result(res, remote)
# Force rejected pull.
res = remote.push("+%s" % lhead.reference)
self.assertEqual(res[0].flags & PushInfo.ERROR, 0)
self.assertTrue(res[0].flags & PushInfo.FORCED_UPDATE)
self._do_test_push_result(res, remote)
# Invalid refspec.
self.assertRaises(GitCommandError, remote.push, "hellothere")
# Push new tags.
progress = TestRemoteProgress()
to_be_updated = "my_tag.1.0RV"
new_tag = TagReference.create(rw_repo, to_be_updated) # @UnusedVariable
other_tag = TagReference.create(rw_repo, "my_obj_tag.2.1aRV", logmsg="my message")
res = remote.push(progress=progress, tags=True)
self.assertTrue(res[-1].flags & PushInfo.NEW_TAG)
progress.make_assertion()
self._do_test_push_result(res, remote)
# Update push new tags.
# Rejection is default.
new_tag = TagReference.create(rw_repo, to_be_updated, reference="HEAD~1", force=True)
res = remote.push(tags=True)
self._do_test_push_result(res, remote)
self.assertTrue(res[-1].flags & PushInfo.REJECTED)
self.assertTrue(res[-1].flags & PushInfo.ERROR)
# Force push this tag.
res = remote.push("+%s" % new_tag.path)
self.assertEqual(res[-1].flags & PushInfo.ERROR, 0)
self.assertTrue(res[-1].flags & PushInfo.FORCED_UPDATE)
# Delete tag - have to do it using refspec.
res = remote.push(":%s" % new_tag.path)
self._do_test_push_result(res, remote)
self.assertTrue(res[0].flags & PushInfo.DELETED)
# Currently progress is not properly transferred, especially not using
# the git daemon.
# progress.assert_received_message()
# Push new branch.
new_head = Head.create(rw_repo, "my_new_branch")
progress = TestRemoteProgress()
res = remote.push(new_head, progress)
self.assertGreater(len(res), 0)
self.assertTrue(res[0].flags & PushInfo.NEW_HEAD)
progress.make_assertion()
self._do_test_push_result(res, remote)
# Rejected stale delete.
force_with_lease = "%s:0000000000000000000000000000000000000000" % new_head.path
res = remote.push(":%s" % new_head.path, force_with_lease=force_with_lease)
self.assertTrue(res[0].flags & PushInfo.ERROR)
self.assertTrue(res[0].flags & PushInfo.REJECTED)
self.assertIsNone(res[0].local_ref)
self._do_test_push_result(res, remote)
# Delete new branch on the remote end and locally.
res = remote.push(":%s" % new_head.path)
self._do_test_push_result(res, remote)
Head.delete(rw_repo, new_head)
self.assertTrue(res[-1].flags & PushInfo.DELETED)
# --all
res = remote.push(all=True)
self._do_test_push_result(res, remote)
remote.pull("master", kill_after_timeout=10.0)
# Cleanup - delete created tags and branches as we are in an inner loop on
# the same repository.
TagReference.delete(rw_repo, new_tag, other_tag)
remote.push(":%s" % other_tag.path, kill_after_timeout=10.0)
@skipIf(HIDE_WINDOWS_FREEZE_ERRORS, "FIXME: Freezes!")
@with_rw_and_rw_remote_repo("0.1.6")
def test_base(self, rw_repo, remote_repo):
num_remotes = 0
remote_set = set()
ran_fetch_test = False
for remote in rw_repo.remotes:
num_remotes += 1
self.assertEqual(remote, remote)
self.assertNotEqual(str(remote), repr(remote))
remote_set.add(remote)
remote_set.add(remote) # Should already exist.
# REFS
refs = remote.refs
self.assertTrue(refs)
for ref in refs:
self.assertEqual(ref.remote_name, remote.name)
self.assertTrue(ref.remote_head)
# END for each ref
# OPTIONS
# Cannot use 'fetch' key anymore as it is now a method.
for opt in ("url",):
val = getattr(remote, opt)
reader = remote.config_reader
assert reader.get(opt) == val
assert reader.get_value(opt, None) == val
# Unable to write with a reader.
self.assertRaises(IOError, reader.set, opt, "test")
# Change value.
with remote.config_writer as writer:
new_val = "myval"
writer.set(opt, new_val)
assert writer.get(opt) == new_val
writer.set(opt, val)
assert writer.get(opt) == val
assert getattr(remote, opt) == val
# END for each default option key
# RENAME
other_name = "totally_other_name"
prev_name = remote.name
self.assertEqual(remote.rename(other_name), remote)
self.assertNotEqual(prev_name, remote.name)
# Multiple times.
for _ in range(2):
self.assertEqual(remote.rename(prev_name).name, prev_name)
# END for each rename ( back to prev_name )
# PUSH/PULL TESTING
self._assert_push_and_pull(remote, rw_repo, remote_repo)
# FETCH TESTING
# Only for remotes - local cases are the same or less complicated as
# additional progress information will never be emitted.
if remote.name == "daemon_origin":
self._do_test_fetch(remote, rw_repo, remote_repo, kill_after_timeout=10.0)
ran_fetch_test = True
# END fetch test
remote.update()
# END for each remote
self.assertTrue(ran_fetch_test)
self.assertTrue(num_remotes)
self.assertEqual(num_remotes, len(remote_set))
origin = rw_repo.remote("origin")
assert origin == rw_repo.remotes.origin
# Verify we can handle prunes when fetching.
# stderr lines look like this: x [deleted] (none) -> origin/experiment-2012
# These should just be skipped.
# If we don't have a manual checkout, we can't actually assume there are any
# non-master branches.
remote_repo.create_head("myone_for_deletion")
# Get the branch - to be pruned later
origin.fetch()
num_deleted = False
for branch in remote_repo.heads:
if branch.name != "master":
branch.delete(remote_repo, branch, force=True)
num_deleted += 1
# END for each branch
self.assertGreater(num_deleted, 0)
self.assertEqual(
len(rw_repo.remotes.origin.fetch(prune=True)),
1,
"deleted everything but master",
)
@with_rw_repo("HEAD", bare=True)
def test_creation_and_removal(self, bare_rw_repo):
new_name = "test_new_one"
arg_list = (new_name, "git@server:hello.git")
remote = Remote.create(bare_rw_repo, *arg_list)
self.assertEqual(remote.name, "test_new_one")
self.assertIn(remote, bare_rw_repo.remotes)
self.assertTrue(remote.exists())
# Create same one again.
self.assertRaises(GitCommandError, Remote.create, bare_rw_repo, *arg_list)
Remote.remove(bare_rw_repo, new_name)
self.assertTrue(remote.exists()) # We still have a cache that doesn't know we were deleted by name.
remote._clear_cache()
assert not remote.exists() # Cache should be renewed now. This is an issue...
for remote in bare_rw_repo.remotes:
if remote.name == new_name:
raise AssertionError("Remote removal failed")
# END if deleted remote matches existing remote's name
# END for each remote
# Issue #262 - the next call would fail if bug wasn't fixed.
bare_rw_repo.create_remote("bogus", "/bogus/path", mirror="push")
def test_fetch_info(self):
# Ensure we can handle remote-tracking branches.
fetch_info_line_fmt = "c437ee5deb8d00cf02f03720693e4c802e99f390 not-for-merge %s '0.3' of "
fetch_info_line_fmt += "git://github.com/gitpython-developers/GitPython"
remote_info_line_fmt = "* [new branch] nomatter -> %s"
self.assertRaises(
ValueError,
FetchInfo._from_line,
self.rorepo,
remote_info_line_fmt % "refs/something/branch",
"269c498e56feb93e408ed4558c8138d750de8893\t\t/Users/ben/test/foo\n",
)
fi = FetchInfo._from_line(
self.rorepo,
remote_info_line_fmt % "local/master",
fetch_info_line_fmt % "remote-tracking branch",
)
assert not fi.ref.is_valid()
self.assertEqual(fi.ref.name, "local/master")
# Handles non-default refspecs: One can specify a different path in refs/remotes
# or a special path just in refs/something for instance.
fi = FetchInfo._from_line(
self.rorepo,
remote_info_line_fmt % "subdir/tagname",
fetch_info_line_fmt % "tag",
)
self.assertIsInstance(fi.ref, TagReference)
assert fi.ref.path.startswith("refs/tags"), fi.ref.path
# It could be in a remote directory though.
fi = FetchInfo._from_line(
self.rorepo,
remote_info_line_fmt % "remotename/tags/tagname",
fetch_info_line_fmt % "tag",
)
self.assertIsInstance(fi.ref, TagReference)
assert fi.ref.path.startswith("refs/remotes/"), fi.ref.path
# It can also be anywhere!
tag_path = "refs/something/remotename/tags/tagname"
fi = FetchInfo._from_line(self.rorepo, remote_info_line_fmt % tag_path, fetch_info_line_fmt % "tag")
self.assertIsInstance(fi.ref, TagReference)
self.assertEqual(fi.ref.path, tag_path)
# Branches default to refs/remotes.
fi = FetchInfo._from_line(
self.rorepo,
remote_info_line_fmt % "remotename/branch",
fetch_info_line_fmt % "branch",
)
self.assertIsInstance(fi.ref, RemoteReference)
self.assertEqual(fi.ref.remote_name, "remotename")
# But you can force it anywhere, in which case we only have a references.
fi = FetchInfo._from_line(
self.rorepo,
remote_info_line_fmt % "refs/something/branch",
fetch_info_line_fmt % "branch",
)
assert type(fi.ref) is Reference, type(fi.ref)
self.assertEqual(fi.ref.path, "refs/something/branch")
def test_uncommon_branch_names(self):
stderr_lines = fixture("uncommon_branch_prefix_stderr").decode("ascii").splitlines()
fetch_lines = fixture("uncommon_branch_prefix_FETCH_HEAD").decode("ascii").splitlines()
# The contents of the files above must be fetched with a custom refspec:
# +refs/pull/*:refs/heads/pull/*
res = [
FetchInfo._from_line("ShouldntMatterRepo", stderr, fetch_line)
for stderr, fetch_line in zip(stderr_lines, fetch_lines)
]
self.assertGreater(len(res), 0)
self.assertEqual(res[0].remote_ref_path, "refs/pull/1/head")
self.assertEqual(res[0].ref.path, "refs/heads/pull/1/head")
self.assertIsInstance(res[0].ref, Head)
@with_rw_repo("HEAD", bare=False)
def test_multiple_urls(self, rw_repo):
# Test addresses.
test1 = "https://github.com/gitpython-developers/GitPython"
test2 = "https://github.com/gitpython-developers/gitdb"
test3 = "https://github.com/gitpython-developers/smmap"
remote = rw_repo.remotes[0]
# Test setting a single URL.
remote.set_url(test1)
self.assertEqual(list(remote.urls), [test1])
# Test replacing that single URL.
remote.set_url(test1)
self.assertEqual(list(remote.urls), [test1])
# Test adding new URLs.
remote.set_url(test2, add=True)
self.assertEqual(list(remote.urls), [test1, test2])
remote.set_url(test3, add=True)
self.assertEqual(list(remote.urls), [test1, test2, test3])
# Test removing a URL.
remote.set_url(test2, delete=True)
self.assertEqual(list(remote.urls), [test1, test3])
# Test changing a URL.
remote.set_url(test2, test3)
self.assertEqual(list(remote.urls), [test1, test2])
# will raise: fatal: --add --delete doesn't make sense
self.assertRaises(GitCommandError, remote.set_url, test2, add=True, delete=True)
# Test on another remote, with the add/delete URL.
remote = rw_repo.create_remote("another", url=test1)
remote.add_url(test2)
self.assertEqual(list(remote.urls), [test1, test2])
remote.add_url(test3)
self.assertEqual(list(remote.urls), [test1, test2, test3])
# Test removing all the URLs.
remote.delete_url(test2)
self.assertEqual(list(remote.urls), [test1, test3])
remote.delete_url(test1)
self.assertEqual(list(remote.urls), [test3])
# Will raise fatal: Will not delete all non-push URLs.
self.assertRaises(GitCommandError, remote.delete_url, test3)
def test_fetch_error(self):
rem = self.rorepo.remote("origin")
with self.assertRaisesRegex(GitCommandError, "[Cc]ouldn't find remote ref __BAD_REF__"):
rem.fetch("__BAD_REF__")
@with_rw_repo("0.1.6", bare=False)
def test_push_error(self, repo):
rem = repo.remote("origin")
with self.assertRaisesRegex(GitCommandError, "src refspec __BAD_REF__ does not match any"):
rem.push("__BAD_REF__")
@with_rw_repo("HEAD")
def test_set_unsafe_url(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
with self.assertRaises(UnsafeProtocolError):
remote.set_url(url)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_set_unsafe_url_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
remote.set_url(url, allow_unsafe_protocols=True)
assert list(remote.urls)[-1] == url
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_add_unsafe_url(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
with self.assertRaises(UnsafeProtocolError):
remote.add_url(url)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_add_unsafe_url_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
remote.add_url(url, allow_unsafe_protocols=True)
assert list(remote.urls)[-1] == url
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_create_remote_unsafe_url(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
with self.assertRaises(UnsafeProtocolError):
Remote.create(rw_repo, "origin", url)
assert not tmp_file.exists()
@pytest.mark.xfail(
sys.platform == "win32",
reason=R"Multiple '\' instead of '/' in remote.url make it differ from expected value",
raises=AssertionError,
)
@with_rw_repo("HEAD")
def test_create_remote_unsafe_url_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for i, url in enumerate(urls):
remote = Remote.create(rw_repo, f"origin{i}", url, allow_unsafe_protocols=True)
assert remote.url == url
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_fetch_unsafe_url(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
with self.assertRaises(UnsafeProtocolError):
remote.fetch(url)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_fetch_unsafe_url_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
# The URL will be allowed into the command, but the command will fail
# since we don't have that protocol enabled in the Git config file.
with self.assertRaises(GitCommandError):
remote.fetch(url, allow_unsafe_protocols=True)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_fetch_unsafe_options(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
remote = rw_repo.remote("origin")
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
unsafe_options = [{"upload-pack": f"touch {tmp_file}"}]
for unsafe_option in unsafe_options:
with self.assertRaises(UnsafeOptionError):
remote.fetch(**unsafe_option)
assert not tmp_file.exists()
@pytest.mark.xfail(
sys.platform == "win32",
reason=(
"File not created. A separate Windows command may be needed. This and the "
"currently passing test test_fetch_unsafe_options must be adjusted in the "
"same way. Until then, test_fetch_unsafe_options is unreliable on Windows."
),
raises=AssertionError,
)
@with_rw_repo("HEAD")
def test_fetch_unsafe_options_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
remote = rw_repo.remote("origin")
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
unsafe_options = [{"upload-pack": f"touch {tmp_file}"}]
for unsafe_option in unsafe_options:
# The options will be allowed, but the command will fail.
assert not tmp_file.exists()
with self.assertRaises(GitCommandError):
remote.fetch(**unsafe_option, allow_unsafe_options=True)
assert tmp_file.exists()
tmp_file.unlink()
@with_rw_repo("HEAD")
def test_pull_unsafe_url(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
with self.assertRaises(UnsafeProtocolError):
remote.pull(url)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_pull_unsafe_url_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
# The URL will be allowed into the command, but the command will fail
# since we don't have that protocol enabled in the Git config file.
with self.assertRaises(GitCommandError):
remote.pull(url, allow_unsafe_protocols=True)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_pull_unsafe_options(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
remote = rw_repo.remote("origin")
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
unsafe_options = [{"upload-pack": f"touch {tmp_file}"}]
for unsafe_option in unsafe_options:
with self.assertRaises(UnsafeOptionError):
remote.pull(**unsafe_option)
assert not tmp_file.exists()
@pytest.mark.xfail(
sys.platform == "win32",
reason=(
"File not created. A separate Windows command may be needed. This and the "
"currently passing test test_pull_unsafe_options must be adjusted in the "
"same way. Until then, test_pull_unsafe_options is unreliable on Windows."
),
raises=AssertionError,
)
@with_rw_repo("HEAD")
def test_pull_unsafe_options_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
remote = rw_repo.remote("origin")
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
unsafe_options = [{"upload-pack": f"touch {tmp_file}"}]
for unsafe_option in unsafe_options:
# The options will be allowed, but the command will fail.
assert not tmp_file.exists()
with self.assertRaises(GitCommandError):
remote.pull(**unsafe_option, allow_unsafe_options=True)
assert tmp_file.exists()
tmp_file.unlink()
@with_rw_repo("HEAD")
def test_push_unsafe_url(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
with self.assertRaises(UnsafeProtocolError):
remote.push(url)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_push_unsafe_url_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
remote = rw_repo.remote("origin")
urls = [
f"ext::sh -c touch% {tmp_file}",
"fd::17/foo",
]
for url in urls:
# The URL will be allowed into the command, but the command will fail
# since we don't have that protocol enabled in the Git config file.
with self.assertRaises(GitCommandError):
remote.push(url, allow_unsafe_protocols=True)
assert not tmp_file.exists()
@with_rw_repo("HEAD")
def test_push_unsafe_options(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
remote = rw_repo.remote("origin")
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
unsafe_options = [
{
"receive-pack": f"touch {tmp_file}",
"exec": f"touch {tmp_file}",
}
]
for unsafe_option in unsafe_options:
assert not tmp_file.exists()
with self.assertRaises(UnsafeOptionError):
remote.push(**unsafe_option)
assert not tmp_file.exists()
@pytest.mark.xfail(
sys.platform == "win32",
reason=(
"File not created. A separate Windows command may be needed. This and the "
"currently passing test test_push_unsafe_options must be adjusted in the "
"same way. Until then, test_push_unsafe_options is unreliable on Windows."
),
raises=AssertionError,
)
@with_rw_repo("HEAD")
def test_push_unsafe_options_allowed(self, rw_repo):
with tempfile.TemporaryDirectory() as tdir:
remote = rw_repo.remote("origin")
tmp_dir = Path(tdir)
tmp_file = tmp_dir / "pwn"
unsafe_options = [
{
"receive-pack": f"touch {tmp_file}",
"exec": f"touch {tmp_file}",
}
]
for unsafe_option in unsafe_options:
# The options will be allowed, but the command will fail.
assert not tmp_file.exists()
with self.assertRaises(GitCommandError):
remote.push(**unsafe_option, allow_unsafe_options=True)
assert tmp_file.exists()
tmp_file.unlink()
@with_rw_and_rw_remote_repo("0.1.6")
def test_fetch_unsafe_branch_name(self, rw_repo, remote_repo):
# Create branch with a name containing a NBSP
bad_branch_name = f"branch_with_{chr(160)}_nbsp"
Head.create(remote_repo, bad_branch_name)
# Fetch and get branches
remote = rw_repo.remote("origin")
branches = remote.fetch()
# Test for truncated branch name in branches
assert f"origin/{bad_branch_name}" in [b.name for b in branches]
# Cleanup branch
Head.delete(remote_repo, bad_branch_name)
class TestTimeouts(TestBase):
@with_rw_repo("HEAD", bare=False)
def test_timeout_funcs(self, repo):
# Force error code to prevent a race condition if the python thread is slow.
default = Git.AutoInterrupt._status_code_if_terminate
Git.AutoInterrupt._status_code_if_terminate = -15
for function in ["pull", "fetch"]: # Can't get push to time out.
f = getattr(repo.remotes.origin, function)
assert f is not None # Make sure these functions exist.
_ = f() # Make sure the function runs.
with pytest.raises(GitCommandError, match="kill_after_timeout=0 s"):
f(kill_after_timeout=0)
Git.AutoInterrupt._status_code_if_terminate = default