# test_refs.py

# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors

#

# This module is part of GitPython and is released under

# the BSD License: http://www.opensource.org/licenses/bsd-license.php

from itertools import chain

from git import (

Reference,

Head,

TagReference,

RemoteReference,

Commit,

SymbolicReference,

GitCommandError,

RefLog

)

from git.objects.tag import TagObject

from git.test.lib import (

TestBase,

with_rw_repo

)

from git.util import Actor

import git.refs as refs

import os.path as osp

class TestRefs(TestBase):

def test_from_path(self):

# should be able to create any reference directly

for ref_type in (Reference, Head, TagReference, RemoteReference):

for name in ('rela_name', 'path/rela_name'):

full_path = ref_type.to_full_path(name)

instance = ref_type.from_path(self.rorepo, full_path)

assert isinstance(instance, ref_type)

# END for each name

# END for each type

# invalid path

self.failUnlessRaises(ValueError, TagReference, self.rorepo, "refs/invalid/tag")

# works without path check

TagReference(self.rorepo, "refs/invalid/tag", check_path=False)

def test_tag_base(self):

tag_object_refs = []

for tag in self.rorepo.tags:

assert "refs/tags" in tag.path

assert tag.name

assert isinstance(tag.commit, Commit)

if tag.tag is not None:

tag_object_refs.append(tag)

tagobj = tag.tag

# have no dict

self.failUnlessRaises(AttributeError, setattr, tagobj, 'someattr', 1)

assert isinstance(tagobj, TagObject)

assert tagobj.tag == tag.name

assert isinstance(tagobj.tagger, Actor)

assert isinstance(tagobj.tagged_date, int)

assert isinstance(tagobj.tagger_tz_offset, int)

assert tagobj.message

assert tag.object == tagobj

# can't assign the object

self.failUnlessRaises(AttributeError, setattr, tag, 'object', tagobj)

# END if we have a tag object

# END for tag in repo-tags

assert tag_object_refs

assert isinstance(self.rorepo.tags['0.1.5'], TagReference)

def test_tags_author(self):

tag = self.rorepo.tags[0]

tagobj = tag.tag

assert isinstance(tagobj.tagger, Actor)

tagger_name = tagobj.tagger.name

assert tagger_name == 'Michael Trier'

def test_tags(self):

# tag refs can point to tag objects or to commits

s = set()

ref_count = 0

for ref in chain(self.rorepo.tags, self.rorepo.heads):

ref_count += 1

assert isinstance(ref, refs.Reference)

assert str(ref) == ref.name

assert repr(ref)

assert ref == ref

assert not ref != ref

s.add(ref)

# END for each ref

assert len(s) == ref_count

assert len(s | s) == ref_count

@with_rw_repo('HEAD', bare=False)

def test_heads(self, rwrepo):

for head in rwrepo.heads:

assert head.name

assert head.path

assert "refs/heads" in head.path

prev_object = head.object

cur_object = head.object

assert prev_object == cur_object # represent the same git object

assert prev_object is not cur_object # but are different instances

with head.config_writer() as writer:

tv = "testopt"

writer.set_value(tv, 1)

assert writer.get_value(tv) == 1

assert head.config_reader().get_value(tv) == 1

with head.config_writer() as writer:

writer.remove_option(tv)

# after the clone, we might still have a tracking branch setup

head.set_tracking_branch(None)

assert head.tracking_branch() is None

remote_ref = rwrepo.remotes[0].refs[0]

assert head.set_tracking_branch(remote_ref) is head

assert head.tracking_branch() == remote_ref

head.set_tracking_branch(None)

assert head.tracking_branch() is None

special_name = 'feature#123'

special_name_remote_ref = SymbolicReference.create(rwrepo, 'refs/remotes/origin/%s' % special_name)

gp_tracking_branch = rwrepo.create_head('gp_tracking#123')

special_name_remote_ref = rwrepo.remotes[0].refs[special_name] # get correct type

gp_tracking_branch.set_tracking_branch(special_name_remote_ref)

assert gp_tracking_branch.tracking_branch().path == special_name_remote_ref.path

git_tracking_branch = rwrepo.create_head('git_tracking#123')

rwrepo.git.branch('-u', special_name_remote_ref.name, git_tracking_branch.name)

assert git_tracking_branch.tracking_branch().name == special_name_remote_ref.name

# END for each head

# verify REFLOG gets altered

head = rwrepo.head

cur_head = head.ref

cur_commit = cur_head.commit

pcommit = cur_head.commit.parents[0].parents[0]

hlog_len = len(head.log())

blog_len = len(cur_head.log())

assert head.set_reference(pcommit, 'detached head') is head

# one new log-entry

thlog = head.log()

assert len(thlog) == hlog_len + 1

assert thlog[-1].oldhexsha == cur_commit.hexsha

assert thlog[-1].newhexsha == pcommit.hexsha

# the ref didn't change though

assert len(cur_head.log()) == blog_len

# head changes once again, cur_head doesn't change

head.set_reference(cur_head, 'reattach head')

assert len(head.log()) == hlog_len + 2

assert len(cur_head.log()) == blog_len

# adjusting the head-ref also adjust the head, so both reflogs are

# altered

cur_head.set_commit(pcommit, 'changing commit')

assert len(cur_head.log()) == blog_len + 1

assert len(head.log()) == hlog_len + 3

# with automatic dereferencing

assert head.set_commit(cur_commit, 'change commit once again') is head

assert len(head.log()) == hlog_len + 4

assert len(cur_head.log()) == blog_len + 2

# a new branch has just a single entry

other_head = Head.create(rwrepo, 'mynewhead', pcommit, logmsg='new head created')

log = other_head.log()

assert len(log) == 1

assert log[0].oldhexsha == pcommit.NULL_HEX_SHA

assert log[0].newhexsha == pcommit.hexsha

def test_refs(self):

types_found = set()

for ref in self.rorepo.refs:

types_found.add(type(ref))

assert len(types_found) >= 3

def test_is_valid(self):

assert not Reference(self.rorepo, 'refs/doesnt/exist').is_valid()

assert self.rorepo.head.is_valid()

assert self.rorepo.head.reference.is_valid()

assert not SymbolicReference(self.rorepo, 'hellothere').is_valid()

def test_orig_head(self):

assert type(self.rorepo.head.orig_head()) == SymbolicReference

@with_rw_repo('0.1.6')

def test_head_checkout_detached_head(self, rw_repo):

res = rw_repo.remotes.origin.refs.master.checkout()

assert isinstance(res, SymbolicReference)

assert res.name == 'HEAD'

@with_rw_repo('0.1.6')

def test_head_reset(self, rw_repo):

cur_head = rw_repo.head

old_head_commit = cur_head.commit

new_head_commit = cur_head.ref.commit.parents[0]

cur_head.reset(new_head_commit, index=True) # index only

assert cur_head.reference.commit == new_head_commit

self.failUnlessRaises(ValueError, cur_head.reset, new_head_commit, index=False, working_tree=True)

new_head_commit = new_head_commit.parents[0]

cur_head.reset(new_head_commit, index=True, working_tree=True) # index + wt

assert cur_head.reference.commit == new_head_commit

# paths - make sure we have something to do

rw_repo.index.reset(old_head_commit.parents[0])

cur_head.reset(cur_head, paths="test")

cur_head.reset(new_head_commit, paths="lib")

# hard resets with paths don't work, its all or nothing

self.failUnlessRaises(GitCommandError, cur_head.reset, new_head_commit, working_tree=True, paths="lib")

# we can do a mixed reset, and then checkout from the index though

cur_head.reset(new_head_commit)

rw_repo.index.checkout(["lib"], force=True)

# now that we have a write write repo, change the HEAD reference - its

# like git-reset --soft

heads = rw_repo.heads

assert heads

for head in heads:

cur_head.reference = head

assert cur_head.reference == head

assert isinstance(cur_head.reference, Head)

assert cur_head.commit == head.commit

assert not cur_head.is_detached

# END for each head

# detach

active_head = heads[0]

curhead_commit = active_head.commit

cur_head.reference = curhead_commit

assert cur_head.commit == curhead_commit

assert cur_head.is_detached

self.failUnlessRaises(TypeError, getattr, cur_head, "reference")

# tags are references, hence we can point to them

some_tag = rw_repo.tags[0]

cur_head.reference = some_tag

assert not cur_head.is_detached

assert cur_head.commit == some_tag.commit

assert isinstance(cur_head.reference, TagReference)

# put HEAD back to a real head, otherwise everything else fails

cur_head.reference = active_head

# type check

self.failUnlessRaises(ValueError, setattr, cur_head, "reference", "that")

# head handling

commit = 'HEAD'

prev_head_commit = cur_head.commit

for count, new_name in enumerate(("my_new_head", "feature/feature1")):

actual_commit = commit + "^" * count

new_head = Head.create(rw_repo, new_name, actual_commit)

assert new_head.is_detached

assert cur_head.commit == prev_head_commit

assert isinstance(new_head, Head)

# already exists, but has the same value, so its fine

Head.create(rw_repo, new_name, new_head.commit)

# its not fine with a different value

self.failUnlessRaises(OSError, Head.create, rw_repo, new_name, new_head.commit.parents[0])

# force it

new_head = Head.create(rw_repo, new_name, actual_commit, force=True)

old_path = new_head.path

old_name = new_head.name

assert new_head.rename("hello").name == "hello"

assert new_head.rename("hello/world").name == "hello/world"

assert new_head.rename(old_name).name == old_name and new_head.path == old_path

# rename with force

tmp_head = Head.create(rw_repo, "tmphead")

self.failUnlessRaises(GitCommandError, tmp_head.rename, new_head)

tmp_head.rename(new_head, force=True)

assert tmp_head == new_head and tmp_head.object == new_head.object

logfile = RefLog.path(tmp_head)

assert osp.isfile(logfile)

Head.delete(rw_repo, tmp_head)

# deletion removes the log as well

assert not osp.isfile(logfile)

heads = rw_repo.heads

assert tmp_head not in heads and new_head not in heads

# force on deletion testing would be missing here, code looks okay though ;)

# END for each new head name

self.failUnlessRaises(TypeError, RemoteReference.create, rw_repo, "some_name")

# tag ref

tag_name = "5.0.2"

TagReference.create(rw_repo, tag_name)

self.failUnlessRaises(GitCommandError, TagReference.create, rw_repo, tag_name)

light_tag = TagReference.create(rw_repo, tag_name, "HEAD~1", force=True)

assert isinstance(light_tag, TagReference)

assert light_tag.name == tag_name

assert light_tag.commit == cur_head.commit.parents[0]

assert light_tag.tag is None

# tag with tag object

other_tag_name = "releases/1.0.2RC"

msg = "my mighty tag\nsecond line"

obj_tag = TagReference.create(rw_repo, other_tag_name, message=msg)

assert isinstance(obj_tag, TagReference)

assert obj_tag.name == other_tag_name

assert obj_tag.commit == cur_head.commit

assert obj_tag.tag is not None

TagReference.delete(rw_repo, light_tag, obj_tag)

tags = rw_repo.tags

assert light_tag not in tags and obj_tag not in tags

# remote deletion

remote_refs_so_far = 0

remotes = rw_repo.remotes

assert remotes

for remote in remotes:

refs = remote.refs

# If a HEAD exists, it must be deleted first. Otherwise it might

# end up pointing to an invalid ref it the ref was deleted before.

remote_head_name = "HEAD"

if remote_head_name in refs:

RemoteReference.delete(rw_repo, refs[remote_head_name])

del(refs[remote_head_name])

# END handle HEAD deletion

RemoteReference.delete(rw_repo, *refs)

remote_refs_so_far += len(refs)

for ref in refs:

assert ref.remote_name == remote.name

# END for each ref to delete

assert remote_refs_so_far

for remote in remotes:

# remotes without references should produce an empty list

self.assertEqual(remote.refs, [])

# END for each remote

# change where the active head points to

if cur_head.is_detached:

cur_head.reference = rw_repo.heads[0]

head = cur_head.reference

old_commit = head.commit

head.commit = old_commit.parents[0]

assert head.commit == old_commit.parents[0]

assert head.commit == cur_head.commit

head.commit = old_commit

# setting a non-commit as commit fails, but succeeds as object

head_tree = head.commit.tree

self.failUnlessRaises(ValueError, setattr, head, 'commit', head_tree)

assert head.commit == old_commit # and the ref did not change

# we allow heds to point to any object

head.object = head_tree

assert head.object == head_tree

# cannot query tree as commit

self.failUnlessRaises(TypeError, getattr, head, 'commit')

# set the commit directly using the head. This would never detach the head

assert not cur_head.is_detached

head.object = old_commit

cur_head.reference = head.commit

assert cur_head.is_detached

parent_commit = head.commit.parents[0]

assert cur_head.is_detached

cur_head.commit = parent_commit

assert cur_head.is_detached and cur_head.commit == parent_commit

cur_head.reference = head

assert not cur_head.is_detached

cur_head.commit = parent_commit

assert not cur_head.is_detached

assert head.commit == parent_commit

# test checkout

active_branch = rw_repo.active_branch

for head in rw_repo.heads:

checked_out_head = head.checkout()

assert checked_out_head == head

# END for each head to checkout

# checkout with branch creation

new_head = active_branch.checkout(b="new_head")

assert active_branch != rw_repo.active_branch

assert new_head == rw_repo.active_branch

# checkout with force as we have a changed a file

# clear file

open(new_head.commit.tree.blobs[-1].abspath, 'w').close()

assert len(new_head.commit.diff(None))

# create a new branch that is likely to touch the file we changed

far_away_head = rw_repo.create_head("far_head", 'HEAD~100')

self.failUnlessRaises(GitCommandError, far_away_head.checkout)

assert active_branch == active_branch.checkout(force=True)

assert rw_repo.head.reference != far_away_head

# test reference creation

partial_ref = 'sub/ref'

full_ref = 'refs/%s' % partial_ref

ref = Reference.create(rw_repo, partial_ref)

assert ref.path == full_ref

assert ref.object == rw_repo.head.commit

self.failUnlessRaises(OSError, Reference.create, rw_repo, full_ref, 'HEAD~20')

# it works if it is at the same spot though and points to the same reference

assert Reference.create(rw_repo, full_ref, 'HEAD').path == full_ref

Reference.delete(rw_repo, full_ref)

# recreate the reference using a full_ref

ref = Reference.create(rw_repo, full_ref)

assert ref.path == full_ref

assert ref.object == rw_repo.head.commit

# recreate using force

ref = Reference.create(rw_repo, partial_ref, 'HEAD~1', force=True)

assert ref.path == full_ref

assert ref.object == rw_repo.head.commit.parents[0]

# rename it

orig_obj = ref.object

for name in ('refs/absname', 'rela_name', 'feature/rela_name'):

ref_new_name = ref.rename(name)

assert isinstance(ref_new_name, Reference)

assert name in ref_new_name.path

assert ref_new_name.object == orig_obj

assert ref_new_name == ref

# END for each name type

# References that don't exist trigger an error if we want to access them

self.failUnlessRaises(ValueError, getattr, Reference(rw_repo, "refs/doesntexist"), 'commit')

# exists, fail unless we force

ex_ref_path = far_away_head.path

self.failUnlessRaises(OSError, ref.rename, ex_ref_path)

# if it points to the same commit it works

far_away_head.commit = ref.commit

ref.rename(ex_ref_path)

assert ref.path == ex_ref_path and ref.object == orig_obj

assert ref.rename(ref.path).path == ex_ref_path # rename to same name

# create symbolic refs

symref_path = "symrefs/sym"

symref = SymbolicReference.create(rw_repo, symref_path, cur_head.reference)

assert symref.path == symref_path

assert symref.reference == cur_head.reference

self.failUnlessRaises(OSError, SymbolicReference.create, rw_repo, symref_path, cur_head.reference.commit)

# it works if the new ref points to the same reference

SymbolicReference.create(rw_repo, symref.path, symref.reference).path == symref.path # @NoEffect

SymbolicReference.delete(rw_repo, symref)

# would raise if the symref wouldn't have been deletedpbl

symref = SymbolicReference.create(rw_repo, symref_path, cur_head.reference)

# test symbolic references which are not at default locations like HEAD

# or FETCH_HEAD - they may also be at spots in refs of course

symbol_ref_path = "refs/symbol_ref"

symref = SymbolicReference(rw_repo, symbol_ref_path)

assert symref.path == symbol_ref_path

symbol_ref_abspath = osp.join(rw_repo.git_dir, symref.path)

# set it

symref.reference = new_head

assert symref.reference == new_head

assert osp.isfile(symbol_ref_abspath)

assert symref.commit == new_head.commit

for name in ('absname', 'folder/rela_name'):

symref_new_name = symref.rename(name)

assert isinstance(symref_new_name, SymbolicReference)

assert name in symref_new_name.path

assert symref_new_name.reference == new_head

assert symref_new_name == symref

assert not symref.is_detached

# END for each ref

# create a new non-head ref just to be sure we handle it even if packed

Reference.create(rw_repo, full_ref)

# test ref listing - assure we have packed refs

rw_repo.git.pack_refs(all=True, prune=True)

heads = rw_repo.heads

assert heads

assert new_head in heads

assert active_branch in heads

assert rw_repo.tags

# we should be able to iterate all symbolic refs as well - in that case

# we should expect only symbolic references to be returned

for symref in SymbolicReference.iter_items(rw_repo):

assert not symref.is_detached

# when iterating references, we can get references and symrefs

# when deleting all refs, I'd expect them to be gone ! Even from

# the packed ones

# For this to work, we must not be on any branch

rw_repo.head.reference = rw_repo.head.commit

deleted_refs = set()

for ref in Reference.iter_items(rw_repo):

if ref.is_detached:

ref.delete(rw_repo, ref)

deleted_refs.add(ref)

# END delete ref

# END for each ref to iterate and to delete

assert deleted_refs

for ref in Reference.iter_items(rw_repo):

if ref.is_detached:

assert ref not in deleted_refs

# END for each ref

# reattach head - head will not be returned if it is not a symbolic

# ref

rw_repo.head.reference = Head.create(rw_repo, "master")

# At least the head should still exist

assert osp.isfile(osp.join(rw_repo.git_dir, 'HEAD'))

refs = list(SymbolicReference.iter_items(rw_repo))

assert len(refs) == 1

# test creation of new refs from scratch

for path in ("basename", "dir/somename", "dir2/subdir/basename"):

# REFERENCES

############

fpath = Reference.to_full_path(path)

ref_fp = Reference.from_path(rw_repo, fpath)

assert not ref_fp.is_valid()

ref = Reference(rw_repo, fpath)

assert ref == ref_fp

# can be created by assigning a commit

ref.commit = rw_repo.head.commit

assert ref.is_valid()

# if the assignment raises, the ref doesn't exist

Reference.delete(ref.repo, ref.path)

assert not ref.is_valid()

self.failUnlessRaises(ValueError, setattr, ref, 'commit', "nonsense")

assert not ref.is_valid()

# I am sure I had my reason to make it a class method at first, but

# now it doesn't make so much sense anymore, want an instance method as well

# See http://byronimo.lighthouseapp.com/projects/51787-gitpython/tickets/27

Reference.delete(ref.repo, ref.path)

assert not ref.is_valid()

ref.object = rw_repo.head.commit

assert ref.is_valid()

Reference.delete(ref.repo, ref.path)

assert not ref.is_valid()

self.failUnlessRaises(ValueError, setattr, ref, 'object', "nonsense")

assert not ref.is_valid()

# END for each path

def test_dereference_recursive(self):

# for now, just test the HEAD

assert SymbolicReference.dereference_recursive(self.rorepo, 'HEAD')

def test_reflog(self):

assert isinstance(self.rorepo.heads.master.log(), RefLog)