GitPython/git/test/test_refs.py at master · pythonthings/GitPython · GitHub

Repository navigation

History

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

# test_refs.py

# 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)

GitPython/git/test/test_refs.py at master · pythonthings/GitPython · GitHub

Repository navigation

Expand file tree

Breadcrumbs

test_refs.py

Latest commit

History

Breadcrumbs

test_refs.py

File metadata and controls