tests/test_GitRepository.py

   1 # vim: set fileencoding=utf-8 :
   2
   3 """
   4 Test L{gbp.git.GitRepository}
   5
   6 This testcase creates several repositores:
   7
   8     - A repository at L{repo_dir} called I{repo}
   9     - A bare repository at L{bare_dir} called I{bare}
  10     - A clone of I{repo} below L{clone_dir} called I{clone}
  11     - A mirror of I{repo} below L{mirror_clone_dir} called I{mirror}
  12 """
  13
  14 from . import context
  15
  16 import gbp.log
  17
  18 gbp.log.setup(color=False, verbose=True)
  19
  20 repo_dir, bare_dir, clone_dir, mirror_clone_dir = map(
  21     lambda x, tmpdir=context.new_tmpdir(__name__): tmpdir.join(x),
  22     ['repo', 'bare', 'clone', 'mirror_clone'])
  23
  24 def test_create():
  25     """
  26     Create a repository
  27
  28     Methods tested:
  29          - L{gbp.git.GitRepository.create}
  30
  31     Properties tested:
  32          - L{gbp.git.GitRepository.path}
  33          - L{gbp.git.GitRepository.git_dir}
  34
  35     >>> import os, gbp.git
  36     >>> repo = gbp.git.GitRepository.create(repo_dir)
  37     >>> repo.path == repo_dir
  38     True
  39     >>> repo.git_dir == os.path.join(repo_dir, '.git')
  40     True
  41     >>> type(repo) == gbp.git.GitRepository
  42     True
  43     """
  44
  45
  46 def test_empty():
  47     """
  48     Empty repos have no branch
  49
  50     Methods tested:
  51          - L{gbp.git.GitRepository.get_branch}
  52          - L{gbp.git.GitRepository.is_empty}
  53
  54     >>> import gbp.git
  55     >>> repo = gbp.git.GitRepository(repo_dir)
  56     >>> repo.get_branch()
  57     >>> repo.branch
  58     >>> repo.is_empty()
  59     True
  60     """
  61
  62
  63 def test_add_files():
  64     """
  65     Add some dummy data
  66
  67     Methods tested:
  68          - L{gbp.git.GitRepository.add_files}
  69          - L{gbp.git.GitRepository.commit_all}
  70          - L{gbp.git.GitRepository.is_clean}
  71
  72     Properties tested:
  73          - L{gbp.git.GitRepository.head}
  74
  75     >>> import gbp.git, shutil, os
  76     >>> repo = gbp.git.GitRepository(repo_dir)
  77     >>> shutil.copy(os.path.join(repo.path, ".git/HEAD"), \
  78                                  os.path.join(repo.path, "testfile"))
  79     >>> repo.is_clean()[0]
  80     False
  81     >>> repo.is_clean(ignore_untracked=True)[0]
  82     True
  83     >>> repo.add_files(repo.path, force=True)
  84     >>> repo.commit_all(msg="foo")
  85     >>> repo.is_clean()[0]
  86     True
  87     >>> h = repo.head
  88     >>> len(h)
  89     40
  90     """
  91
  92
  93 def test_branch_master():
  94     """
  95     First branch is called I{master}
  96
  97     Methods tested:
  98          - L{gbp.git.GitRepository.get_branch}
  99     >>> import gbp.git, shutil
 100     >>> repo = gbp.git.GitRepository(repo_dir)
 101     >>> repo.get_branch()
 102     'master'
 103     >>> repo.branch
 104     'master'
 105     """
 106
 107
 108 def test_create_branch():
 109     """
 110     Create a branch name I{foo}
 111
 112     Methods tested:
 113          - L{gbp.git.GitRepository.create_branch}
 114          - L{gbp.git.GitRepository.branch_contains}
 115
 116     >>> import gbp.git, shutil
 117     >>> repo = gbp.git.GitRepository(repo_dir)
 118     >>> repo.create_branch("foo")
 119     >>> repo.branch_contains("foo", 'HEAD')
 120     True
 121     >>> repo.branch_contains("doesnotexist", 'HEAD', remote=True)
 122     False
 123     """
 124
 125 def test_delete_branch():
 126     """
 127     Create a branch named I{foo2} and delete it
 128
 129     Methods tested:
 130          - L{gbp.git.GitRepository.create_branch}
 131          - L{gbp.git.GitRepository.delete_branch}
 132
 133     >>> import gbp.git, shutil
 134     >>> repo = gbp.git.GitRepository(repo_dir)
 135     >>> repo.create_branch("bar")
 136     >>> repo.delete_branch("bar")
 137     >>> repo.delete_branch("master")
 138     Traceback (most recent call last):
 139     ...
 140     GitRepositoryError: Can't delete the branch you're on
 141     """
 142
 143 def test_set_branch():
 144     """
 145     Switch to branch named I{foo}
 146
 147     Methods tested:
 148          - L{gbp.git.GitRepository.set_branch}
 149          - L{gbp.git.GitRepository.get_branch}
 150          - L{gbp.git.GitRepository.branch}
 151
 152     >>> import gbp.git
 153     >>> repo = gbp.git.GitRepository(repo_dir)
 154     >>> repo.set_branch("foo")
 155     >>> repo.get_branch() == "foo"
 156     True
 157     >>> repo.branch == "foo"
 158     True
 159     """
 160
 161
 162 def test_rename_branch():
 163     """
 164     Create branch named I{baz}, rename it to I{bax} and finally delete it
 165
 166     Methods tested:
 167          - L{gbp.git.GitRepository.create_branch}
 168          - L{gbp.git.GitRepository.rename_branch}
 169          - L{gbp.git.GitRepository.delete_branch}
 170
 171     >>> import gbp.git
 172     >>> repo = gbp.git.GitRepository(repo_dir)
 173     >>> repo.create_branch("baz")
 174     >>> repo.rename_branch("baz", "bax")
 175     >>> repo.delete_branch("bax")
 176     """
 177
 178
 179 def test_set_upstream_branch():
 180     """
 181     Set upstream branch master -> origin/master
 182
 183     >>> import os, shutil
 184     >>> import gbp.git
 185     >>> repo = gbp.git.GitRepository(repo_dir)
 186     >>> os.makedirs(os.path.join(repo.git_dir, 'refs/remotes/origin'))
 187     >>> shutil.copy(os.path.join(repo.git_dir, 'refs/heads/master'), \
 188                     os.path.join(repo.git_dir, 'refs/remotes/origin/'))
 189     >>> repo.add_remote_repo('origin', 'git://git.example.com/git/origin')
 190     >>> repo.set_upstream_branch('master', 'origin/master')
 191     >>> repo.get_upstream_branch('master')
 192     'origin/master'
 193     >>> repo.set_upstream_branch('bla', 'origin/master')
 194     Traceback (most recent call last):
 195     GitRepositoryError: Branch bla doesn't exist!
 196     >>> repo.set_upstream_branch('foo', 'origin/bla')
 197     Traceback (most recent call last):
 198     GitRepositoryError: Branch origin/bla doesn't exist!
 199     """
 200
 201 def test_get_upstream_branch():
 202     """
 203     Get info about upstream branches set in test_set_upstream_branch
 204
 205     >>> import gbp.git
 206     >>> repo = gbp.git.GitRepository(repo_dir)
 207     >>> repo.get_upstream_branch('master')
 208     'origin/master'
 209     >>> repo.get_upstream_branch('foo')
 210     ''
 211     >>> repo.get_upstream_branch('bla')
 212     Traceback (most recent call last):
 213     GitRepositoryError: Branch bla doesn't exist!
 214     """
 215
 216 def test_tag():
 217     """
 218     Create a tag named I{tag} and check it's existance
 219
 220     Methods tested:
 221          - L{gbp.git.GitRepository.create_tag}
 222          - L{gbp.git.GitRepository.verify_tag}
 223          - L{gbp.git.GitRepository.has_tag}
 224          - L{gbp.git.GitRepository.get_tags}
 225
 226     >>> import gbp.git
 227     >>> repo = gbp.git.GitRepository(repo_dir)
 228     >>> repo.create_tag("tag")
 229     >>> repo.has_tag("tag")
 230     True
 231     >>> repo.has_tag("unknown")
 232     False
 233     >>> repo.create_tag("tag2", msg="foo")
 234     >>> repo.has_tag("tag2")
 235     True
 236     >>> repo.verify_tag("tag2")
 237     False
 238     >>> repo.get_tags()
 239     ['tag', 'tag2']
 240     >>> repo.tags
 241     ['tag', 'tag2']
 242     """
 243
 244 def test_describe():
 245     """
 246     Describe commit-ish
 247
 248     Methods tested:
 249          - L{gbp.git.GitRepository.describe}
 250
 251     >>> import gbp.git
 252     >>> repo = gbp.git.GitRepository(repo_dir)
 253     >>> sha = repo.rev_parse('HEAD')
 254     >>> repo.describe('HEAD')
 255     'tag2'
 256     >>> repo.describe('HEAD', longfmt=True) == 'tag2-0-g%s' % sha[:7]
 257     True
 258     >>> repo.describe('HEAD', pattern='foo*')
 259     Traceback (most recent call last):
 260     ...
 261     GitRepositoryError: Can't describe HEAD. Git error: fatal: No names found, cannot describe anything.
 262     >>> repo.describe('HEAD', pattern='foo*', always=True) == sha[:7]
 263     True
 264     >>> repo.describe('HEAD', always=True, abbrev=16)
 265     'tag2'
 266     >>> repo.describe('HEAD', pattern='foo*', always=True, abbrev=16) == sha[:16]
 267     True
 268     >>> tag = repo.describe('HEAD', longfmt=True, abbrev=16) == 'tag2-0-g%s' % sha[:16]
 269     >>> repo.delete_tag('tag2')
 270     >>> repo.describe('HEAD', tags=True)
 271     'tag'
 272     >>> repo.describe('HEAD', tags=True, exact_match=True)
 273     'tag'
 274     >>> repo.create_tag('tag2', msg='foo')
 275     """
 276
 277 def test_find_tag():
 278     """
 279     Find tags
 280
 281     Methods tested:
 282          - L{gbp.git.GitRepository.find_tag}
 283
 284     >>> import gbp.git
 285     >>> repo = gbp.git.GitRepository(repo_dir)
 286     >>> repo.find_tag('HEAD')
 287     'tag2'
 288     >>> repo.find_tag('HEAD', pattern='foo*')
 289     Traceback (most recent call last):
 290     ...
 291     GitRepositoryError: Can't describe HEAD. Git error: fatal: No names found, cannot describe anything.
 292     """
 293
 294 def test_move_tag():
 295     """
 296     Move a tag
 297
 298     Methods tested:
 299          - L{gbp.git.GitRepository.move_tag}
 300          - L{gbp.git.GitRepository.has_tag}
 301
 302     >>> import gbp.git
 303     >>> repo = gbp.git.GitRepository(repo_dir)
 304     >>> repo.move_tag("tag", "moved")
 305     >>> repo.has_tag("tag")
 306     False
 307     >>> repo.has_tag("moved")
 308     True
 309     """
 310
 311 def test_delete_tag():
 312     """
 313     Delete tags
 314
 315     Methods tested:
 316          - L{gbp.git.GitRepository.delete_tag}
 317          - L{gbp.git.GitRepository.has_tag}
 318
 319     >>> import gbp.git
 320     >>> repo = gbp.git.GitRepository(repo_dir)
 321     >>> repo.has_tag("moved")
 322     True
 323     >>> repo.delete_tag("moved")
 324     >>> repo.has_tag("moved")
 325     False
 326     """
 327
 328 def test_get_obj_type():
 329     """
 330     Find commit SHA1 related to tags
 331
 332     Methods tested:
 333          - L{gbp.git.GitRepository.create_tag}
 334          - L{gbp.git.GitRepository.get_obj_type}
 335          - L{gbp.git.GitRepository.delete_tag}
 336
 337     >>> import gbp.git
 338     >>> repo = gbp.git.GitRepository(repo_dir)
 339     >>> repo.create_tag("tag3", "tag msg")
 340     >>> repo.get_obj_type("tag3")
 341     'tag'
 342     >>> repo.get_obj_type("HEAD")
 343     'commit'
 344     >>> repo.get_obj_type("HEAD:testfile")
 345     'blob'
 346     >>> repo.delete_tag("tag3")
 347     """
 348
 349 def test_list_files():
 350     """
 351     List files in the index
 352
 353     Methods tested:
 354          - L{gbp.git.GitRepository.list_files}
 355          - L{gbp.git.GitRepository.add_files}
 356          - L{gbp.git.GitRepository.commit_staged}
 357          - L{gbp.git.GitRepository.commit_files}
 358          - L{gbp.git.GitRepository.force_head}
 359
 360     >>> import gbp.git, os, shutil
 361     >>> repo = gbp.git.GitRepository(repo_dir)
 362     >>> src = os.path.join(repo.path, ".git/HEAD")
 363     >>> dst = os.path.join(repo.path, "testfile")
 364     >>> repo.list_files()
 365     ['testfile']
 366     >>> repo.list_files(['modified'])
 367     []
 368     >>> repo.list_files(['modified', 'deleted'])
 369     []
 370     >>> repo.list_files(['modified', 'deleted', 'cached'])
 371     ['testfile']
 372     >>> shutil.copy(src, dst)
 373     >>> repo.list_files(['modified'])
 374     ['testfile']
 375     >>> repo.add_files(dst)
 376     >>> repo.commit_staged(msg="foo")
 377     >>> repo.list_files(['modified'])
 378     []
 379     >>> repo.list_files(['foo'])
 380     Traceback (most recent call last):
 381     ...
 382     GitRepositoryError: Unknown type 'foo'
 383     >>> repo.force_head('HEAD^', hard=True)
 384     >>> repo.list_files(['modified'])
 385     []
 386     >>> shutil.copy(src, dst)
 387     >>> repo.list_files(['modified'])
 388     ['testfile']
 389     >>> repo.commit_files(dst, msg="foo")
 390     >>> repo.list_files(['modified'])
 391     []
 392     """
 393
 394 def test_get_commits():
 395     """
 396     Test listing commits
 397
 398     Methods tested:
 399          - L{gbp.git.GitRepository.get_commits}
 400
 401     >>> import gbp.git
 402     >>> repo = gbp.git.GitRepository(repo_dir)
 403     >>> commits = repo.get_commits()
 404     >>> type(commits) == list and len(commits) == 2
 405     True
 406     >>> len(repo.get_commits(num=1)) == 1
 407     True
 408     >>> commits2 = repo.get_commits(since='HEAD~1')
 409     >>> len(commits2) == 1
 410     True
 411     >>> commits2[0] == commits[0]
 412     True
 413     >>> commits2 = repo.get_commits(until='HEAD~1')
 414     >>> len(commits2) == 1
 415     True
 416     >>> commits2[0] == commits[-1]
 417     True
 418     >>> repo.get_commits(paths=['foo', 'bar'])
 419     []
 420     >>> repo.get_commits(paths=['testfile']) == commits
 421     True
 422     """
 423
 424
 425 def test_get_commit_info():
 426     """
 427     Test inspecting commits
 428
 429     Methods tested:
 430          - L{gbp.git.GitRepository.get_commit_info}
 431
 432     >>> import gbp.git
 433     >>> from datetime import datetime
 434     >>> repo = gbp.git.GitRepository(repo_dir)
 435     >>> info = repo.get_commit_info('HEAD')
 436     >>> info['id']
 437     'HEAD'
 438     >>> info['body']
 439     ''
 440     >>> info['subject']
 441     'foo'
 442     >>> '@' in info['author'].email
 443     True
 444     >>> '@' in info['committer'].email
 445     True
 446     >>> now = datetime.now()
 447     >>> (now - datetime.fromtimestamp(int(info['author'].date.split()[0]))).seconds < 10
 448     True
 449     >>> (now - datetime.fromtimestamp(int(info['committer'].date.split()[0]))).seconds < 10
 450     True
 451     >>> info['patchname']
 452     'foo'
 453     >>> info['files']
 454     defaultdict(<type 'list'>, {'M': ['testfile']})
 455     >>> repo.get_subject('HEAD')
 456     'foo'
 457     """
 458
 459 def test_diff():
 460     """
 461     Test git-diff
 462
 463     Methods tested:
 464          - L{gbp.git.GitRepository.diff}
 465
 466     >>> import gbp.git
 467     >>> repo = gbp.git.GitRepository(repo_dir)
 468     >>> len(repo.diff('HEAD~1', 'HEAD')) > 3
 469     True
 470     >>> len(repo.diff('HEAD~1', 'HEAD', 'testfile')) > 3
 471     True
 472     >>> len(repo.diff('HEAD~1', 'HEAD', 'filenotexist')) == 0
 473     True
 474     """
 475
 476 def test_mirror_clone():
 477     """
 478     Mirror a repository
 479
 480     Methods tested:
 481          - L{gbp.git.GitRepository.clone}
 482          - L{gbp.git.GitRepository.is_empty}
 483          - L{gbp.git.GitRepository.set_branch}
 484          - L{gbp.git.GitRepository.has_branch}
 485          - L{gbp.git.GitRepository.branch}
 486
 487     >>> import gbp.git
 488     >>> repo = gbp.git.GitRepository(repo_dir)
 489     >>> repo.set_branch('master')
 490     >>> mirror = gbp.git.GitRepository.clone(mirror_clone_dir, repo.path, mirror=True)
 491     >>> mirror.is_empty()
 492     False
 493     >>> mirror.branch
 494     'master'
 495     >>> mirror.has_branch('foo')
 496     True
 497     >>> mirror.has_branch('bar')
 498     False
 499     >>> mirror.set_branch('foo')
 500     >>> mirror.branch
 501     'foo'
 502     >>> mirror.force_head('foo^')
 503     """
 504
 505 def test_clone():
 506     """
 507     Clone a repository
 508
 509     Methods tested:
 510          - L{gbp.git.GitRepository.clone}
 511          - L{gbp.git.GitRepository.is_empty}
 512          - L{gbp.git.GitRepository.set_branch}
 513          - L{gbp.git.GitRepository.branch}
 514          - L{gbp.git.GitRepository.get_merge_branch}
 515          - L{gbp.git.GitRepository.get_remote_branches}
 516          - L{gbp.git.GitRepository.get_local_branches}
 517          - L{gbp.git.GitRepository.get_remote_repos}
 518          - L{gbp.git.GitRepository.has_remote_repo}
 519
 520     >>> import gbp.git
 521     >>> repo = gbp.git.GitRepository(repo_dir)
 522     >>> repo.set_branch('master')
 523     >>> clone = gbp.git.GitRepository.clone(clone_dir, repo.path)
 524     >>> clone.is_empty()
 525     False
 526     >>> clone.branch
 527     'master'
 528     >>> clone.get_remote_branches()
 529     ['origin/HEAD', 'origin/foo', 'origin/master']
 530     >>> clone.get_local_branches()
 531     ['master']
 532     >>> clone.get_merge_branch('master')
 533     'origin/master'
 534     >>> clone.create_branch('foo', 'origin/foo')
 535     >>> clone.get_merge_branch('foo')
 536     'origin/foo'
 537     >>> clone.create_branch('bar')
 538     >>> clone.get_merge_branch('bar') # None if no merge branch exists
 539     >>> clone.get_local_branches()
 540     ['bar', 'foo', 'master']
 541     >>> clone.get_remote_repos()
 542     ['origin']
 543     >>> clone.has_remote_repo('origin')
 544     True
 545     >>> clone.has_branch('origin/master', remote=True)
 546     True
 547     >>> clone.has_remote_repo('godiug')
 548     False
 549     """
 550
 551 def test_merge():
 552     """
 553     Merge a branch
 554
 555     Methods tested:
 556          - L{gbp.git.GitRepository.merge}
 557          - L{gbp.git.GitRepository.set_branch}
 558
 559     >>> import gbp.git
 560     >>> repo = gbp.git.GitRepository(repo_dir)
 561     >>> repo.set_branch('master')
 562     >>> repo.merge('foo')
 563     """
 564
 565 def test_pull():
 566     """
 567     Pull from a remote repository
 568
 569     Methods tested:
 570          - L{gbp.git.GitRepository.set_branch}
 571          - L{gbp.git.GitRepository.pull}
 572
 573     >>> import gbp.git, os
 574     >>> d = os.path.join(clone_dir, 'repo')
 575     >>> clone = gbp.git.GitRepository(d)
 576     >>> clone.set_branch('master')
 577     >>> clone.pull()
 578     """
 579
 580 def test_fetch():
 581     """
 582     Fetch from a remote repository
 583
 584     Methods tested:
 585          - L{gbp.git.GitRepository.fetch}
 586          - L{gbp.git.GitRepository.push}
 587          - L{gbp.git.GitRepository.push_tag}
 588          - L{gbp.git.GitRepository.add_remote_repo}
 589          - L{gbp.git.GitRepository.remove_remote_repo}
 590
 591     >>> import gbp.git, os
 592     >>> d = os.path.join(clone_dir, 'repo')
 593     >>> clone = gbp.git.GitRepository(d)
 594     >>> clone.fetch()
 595     >>> clone.push()
 596     >>> clone.push('origin')
 597     >>> clone.push('origin', 'master')
 598     >>> clone.create_tag('tag3')
 599     >>> clone.push_tag('origin', 'tag3')
 600     >>> clone.add_remote_repo('foo', repo_dir)
 601     >>> clone.fetch('foo')
 602     >>> clone.fetch('foo', tags=True)
 603     >>> clone.fetch('foo', refspec='refs/heads/master')
 604     >>> clone.fetch(all_remotes=True)
 605     >>> clone.remove_remote_repo('foo')
 606     """
 607
 608 def test_create_bare():
 609     """
 610     Create a bare repository
 611
 612     Methods tested:
 613          - L{gbp.git.GitRepository.create}
 614          - L{gbp.git.GitRepository.is_empty}
 615
 616     >>> import gbp.git
 617     >>> bare = gbp.git.GitRepository.create(bare_dir, bare=True, description="msg")
 618     >>> bare.path == bare_dir
 619     True
 620     >>> bare.git_dir[:-1] == bare_dir
 621     True
 622     >>> type(bare) == gbp.git.GitRepository
 623     True
 624     >>> bare.is_empty()
 625     True
 626     >>> bare.is_clean()
 627     (True, '')
 628     """
 629
 630 def test_nonexistant():
 631     """
 632     Check that accessing a non existant repository fails.
 633
 634     Methods tested:
 635          - L{gbp.git.GitRepository.__init__}
 636
 637     >>> import gbp.git
 638     >>> bare = gbp.git.GitRepository("/does/not/exist")
 639     Traceback (most recent call last):
 640     ...
 641     GitRepositoryError: No Git repository at '/does/not/exist'
 642     """
 643
 644 def test_create_noperm():
 645     """
 646     Check that creating a repository at a path that isn't writeable fails
 647
 648     Methods tested:
 649          - L{gbp.git.GitRepository.create}
 650
 651     >>> import gbp.git
 652     >>> gbp.git.GitRepository.create("/does/not/exist")
 653     Traceback (most recent call last):
 654     ...
 655     GitRepositoryError: Cannot create Git repository at '/does/not/exist': Permission denied
 656     """
 657
 658 def test_checkout():
 659     """
 660     Checkout treeishs
 661
 662     Methods tested:
 663          - L{gbp.git.GitRepository.checkout}
 664          - L{gbp.git.GitRepository.get_branch}
 665          - L{gbp.git.GitRepository.set_branch}
 666          - L{gbp.git.GitRepository.rev_parse}
 667
 668     Properties tested:
 669          - L{gbp.git.GitRepository.branch}
 670          - L{gbp.git.GitRepository.tags}
 671
 672     >>> import gbp.git
 673     >>> repo = gbp.git.GitRepository(repo_dir)
 674     >>> repo.checkout('master')
 675     >>> repo.branch
 676     'master'
 677     >>> repo.rev_parse('doesnotexist')
 678     Traceback (most recent call last):
 679     ...
 680     GitRepositoryError: revision 'doesnotexist' not found
 681     >>> sha1 = repo.rev_parse('master', short=10)
 682     >>> len(sha1)
 683     10
 684     >>> sha1 = repo.rev_parse('master')
 685     >>> len(sha1)
 686     40
 687     >>> repo.checkout(sha1)
 688     >>> repo.branch
 689     >>> repo.get_branch()
 690     Traceback (most recent call last):
 691     ...
 692     GitRepositoryError: Currently not on a branch
 693     >>> tag = repo.tags[0]
 694     >>> repo.checkout(tag)
 695     >>> repo.branch
 696     """
 697
 698 def test_gc():
 699     """
 700     Test garbace collection
 701
 702     Methods tested:
 703          - L{gbp.git.GitRepository.collect_garbage}
 704
 705     >>> import gbp.git
 706     >>> repo = gbp.git.GitRepository(repo_dir)
 707     >>> repo.collect_garbage()
 708     """
 709
 710 def test_grep_log():
 711     """
 712     Test grepping through commit messages
 713
 714     Methods tested:
 715         - L{gbp.git.GitRepository.grep_log}
 716
 717     >>> import gbp.git
 718     >>> repo = gbp.git.GitRepository(repo_dir)
 719     >>> repo.set_branch('master')
 720     >>> len(repo.grep_log('foo')) == 2
 721     True
 722     >>> len(repo.grep_log('foo', 'master')) == 2
 723     True
 724     >>> repo.grep_log('blafasel')
 725     []
 726     >>> repo.grep_log('foo', 'doesnotexist')
 727     Traceback (most recent call last):
 728     ...
 729     GitRepositoryError: Error grepping log for foo: fatal: bad revision 'doesnotexist'
 730     """
 731
 732 def test_is_ff():
 733     """
 734     Test if branch is fast forwardable
 735
 736     Methods tested:
 737         - L{gbp.git.GitRepository.is_fast_forward}
 738
 739     >>> import gbp.git
 740     >>> repo = gbp.git.GitRepository(repo_dir)
 741     >>> repo.is_fast_forward('master', 'foo')
 742     (True, True)
 743     >>> repo.create_branch('ff', 'HEAD^')
 744     >>> repo.is_fast_forward('ff', 'master')
 745     (True, False)
 746     >>> repo.is_fast_forward('master', 'ff')
 747     (False, True)
 748     """
 749
 750 def test_update_ref():
 751     """
 752     Test updating a reference
 753
 754     Methods tested:
 755         - L{gbp.git.GitRepository.update_ref}
 756
 757     >>> import gbp.git, os
 758     >>> repo = gbp.git.GitRepository(repo_dir)
 759     >>> repo.update_ref('new_ref', 'master', msg='update')
 760     >>> os.path.exists(os.path.join(repo.git_dir, 'new_ref'))
 761     True
 762     """
 763
 764
 765 def test_make_tree():
 766     """
 767     Test git-mk-tree
 768
 769     Methods tested:
 770         - L{gbp.git.GitRepository.write_file}
 771         - L{gbp.git.GitRepository.list_tree}
 772         - L{gbp.git.GitRepository.make_tree}
 773
 774     >>> import gbp.git
 775     >>> repo = gbp.git.GitRepository(repo_dir)
 776     >>> sha1 = repo.write_file('testfile')
 777     >>> sha1
 778     '19af7398c894bc5e86e17259317e4db519e9241f'
 779     >>> head = repo.list_tree('HEAD')
 780     >>> head
 781     [['100644', 'blob', '19af7398c894bc5e86e17259317e4db519e9241f', 'testfile']]
 782     >>> head.append(['100644', 'blob', '19af7398c894bc5e86e17259317e4db519e9241f', 'testfile2'])
 783     >>> repo.make_tree(head)
 784     '745951810c9e22fcc6de9b23f05efd6ab5512123'
 785     """
 786
 787
 788 def test_update_submodules():
 789     """
 790     Updating submodules if we don't have any is a noop
 791
 792     Methods tested:
 793         - L{gbp.git.GitRepository.has_submodules}
 794         - L{gbp.git.GitRepository.update_submodules}
 795
 796     >>> import gbp.git
 797     >>> repo = gbp.git.GitRepository(repo_dir)
 798     >>> repo.has_submodules()
 799     False
 800     >>> repo.update_submodules()
 801     """
 802
 803 def test_get_merge_base():
 804     """
 805     Find the common ancestor of two objects
 806
 807     Methods tested:
 808         - L{gbp.git.GitRepository.get_merge_base}
 809
 810     >>> import gbp.git
 811     >>> repo = gbp.git.GitRepository(repo_dir)
 812     >>> sha1 = repo.get_merge_base('master', 'foo')
 813     >>> len(sha1)
 814     40
 815     >>> repo.get_merge_base('master', 'doesnotexist')
 816     Traceback (most recent call last):
 817     ...
 818     GitRepositoryError: Failed to get common ancestor: fatal: Not a valid object name doesnotexist
 819     """
 820
 821 def test_cmd_has_feature():
 822     r"""
 823     Methods tested:
 824         - L{gbp.git.GitRepository._cmd_has_feature}
 825
 826     >>> import gbp.git
 827     >>> repo = gbp.git.GitRepository(repo_dir)
 828     >>> repo._cmd_has_feature("commit", "a")
 829     True
 830     >>> repo._cmd_has_feature("commit", "reuse-message")
 831     True
 832     >>> repo._cmd_has_feature("merge", "n")
 833     True
 834     >>> repo._cmd_has_feature("merge", "stat")
 835     True
 836     >>> repo._cmd_has_feature("format-patch", "cc")
 837     True
 838     >>> repo._cmd_has_feature("merge", "foobaroption")
 839     False
 840     >>> repo._cmd_has_feature("foobarcmd", "foobaroption")
 841     Traceback (most recent call last):
 842     ...
 843     GitRepositoryError: Invalid git command 'foobarcmd': No manual entry for gitfoobarcmd
 844     >>> repo._cmd_has_feature("show", "standard-notes")
 845     True
 846     >>> repo._cmd_has_feature("show", "no-standard-notes")
 847     True
 848     """
 849
 850 def test_teardown():
 851     """
 852     Perform the teardown
 853
 854     >>> context.teardown()
 855     """
 856
 857 # vim:et:ts=4:sw=4:et:sts=4:ai:set list listchars=tab\:»·,trail\:·: