spec/acceptance/clone_repo_spec.rb

   1 require 'spec_helper_acceptance'
   2
   3 tmpdir = default.tmpdir('vcsrepo')
   4
   5 describe 'clones a remote repo' do
   6   before(:all) do
   7     my_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
   8     shell("mkdir -p #{tmpdir}") # win test
   9     scp_to(default, "#{my_root}/acceptance/files/create_git_repo.sh", tmpdir)
  10     shell("cd #{tmpdir} && ./create_git_repo.sh")
  11   end
  12
  13   after(:all) do
  14     shell("rm -rf #{tmpdir}/testrepo.git")
  15   end
  16
  17   context 'get the current master HEAD' do
  18     it 'clones a repo' do
  19       pp = <<-EOS
  20       vcsrepo { "#{tmpdir}/testrepo":
  21         ensure => present,
  22         provider => git,
  23         source => "file://#{tmpdir}/testrepo.git",
  24       }
  25       EOS
  26
  27       # Run it twice and test for idempotency
  28       apply_manifest(pp, :catch_failures => true)
  29       apply_manifest(pp, :catch_changes => true)
  30     end
  31
  32     describe file("#{tmpdir}/testrepo/.git") do
  33       it { should be_directory }
  34     end
  35
  36     describe file("#{tmpdir}/testrepo/.git/HEAD") do
  37       it { should contain 'ref: refs/heads/master' }
  38     end
  39   end
  40
  41   context 'using a commit SHA' do
  42     let (:sha) do
  43       shell("git --git-dir=#{tmpdir}/testrepo.git rev-list HEAD | tail -1").stdout.chomp
  44     end
  45
  46     after(:all) do
  47       shell("rm -rf #{tmpdir}/testrepo_sha")
  48     end
  49
  50     it 'clones a repo' do
  51       pp = <<-EOS
  52       vcsrepo { "#{tmpdir}/testrepo_sha":
  53         ensure => present,
  54         provider => git,
  55         source => "file://#{tmpdir}/testrepo.git",
  56         revision => "#{sha}",
  57       }
  58       EOS
  59
  60       # Run it twice and test for idempotency
  61       apply_manifest(pp, :catch_failures => true)
  62       apply_manifest(pp, :catch_changes => true)
  63     end
  64
  65     describe file("#{tmpdir}/testrepo_sha/.git") do
  66       it { should be_directory }
  67     end
  68
  69     describe file("#{tmpdir}/testrepo_sha/.git/HEAD") do
  70       it { should contain sha }
  71     end
  72   end
  73
  74   context 'using a tag' do
  75     it 'clones a repo' do
  76       pp = <<-EOS
  77       vcsrepo { "#{tmpdir}/testrepo_tag":
  78         ensure => present,
  79         provider => git,
  80         source => "file://#{tmpdir}/testrepo.git",
  81         revision => '0.0.2',
  82       }
  83       EOS
  84
  85       # Run it twice and test for idempotency
  86       apply_manifest(pp, :catch_failures => true)
  87       apply_manifest(pp, :catch_changes => true)
  88     end
  89
  90     describe file("#{tmpdir}/testrepo_tag/.git") do
  91       it { should be_directory }
  92     end
  93
  94     it 'should have the tag as the HEAD' do
  95       shell("git --git-dir=#{tmpdir}/testrepo_tag/.git name-rev HEAD | grep '0.0.2'")
  96     end
  97   end
  98
  99   context 'using a branch name' do
 100     it 'clones a repo' do
 101       pp = <<-EOS
 102       vcsrepo { "#{tmpdir}/testrepo_branch":
 103         ensure => present,
 104         provider => git,
 105         source => "file://#{tmpdir}/testrepo.git",
 106         revision => 'a_branch',
 107       }
 108       EOS
 109
 110       # Run it twice and test for idempotency
 111       apply_manifest(pp, :catch_failures => true)
 112       apply_manifest(pp, :catch_changes => true)
 113     end
 114
 115     describe file("#{tmpdir}/testrepo_branch/.git") do
 116       it { should be_directory }
 117     end
 118
 119     describe file("#{tmpdir}/testrepo_branch/.git/HEAD") do
 120       it { should contain 'ref: refs/heads/a_branch' }
 121     end
 122   end
 123
 124   context 'ensure latest with branch specified' do
 125     it 'clones a repo' do
 126       pp = <<-EOS
 127       vcsrepo { "#{tmpdir}/testrepo_latest":
 128         ensure => latest,
 129         provider => git,
 130         source => "file://#{tmpdir}/testrepo.git",
 131         revision => 'a_branch',
 132       }
 133       EOS
 134
 135       # Run it twice and test for idempotency
 136       apply_manifest(pp, :catch_failures => true)
 137       apply_manifest(pp, :catch_changes => true)
 138     end
 139
 140     it 'verifies the HEAD commit SHA on remote and local match' do
 141       remote_commit = shell("git ls-remote file://#{tmpdir}/testrepo_latest HEAD | head -1").stdout
 142       local_commit = shell("git --git-dir=#{tmpdir}/testrepo_latest/.git rev-parse HEAD").stdout.chomp
 143       expect(remote_commit).to include(local_commit)
 144     end
 145   end
 146
 147   context 'ensure latest with branch unspecified' do
 148     it 'clones a repo' do
 149       pp = <<-EOS
 150       vcsrepo { "#{tmpdir}/testrepo_latest":
 151         ensure => latest,
 152         provider => git,
 153         source => "file://#{tmpdir}/testrepo.git",
 154       }
 155       EOS
 156
 157       # Run it twice and test for idempotency
 158       apply_manifest(pp, :catch_failures => true)
 159       apply_manifest(pp, :catch_changes => true)
 160     end
 161
 162     it 'verifies the HEAD commit SHA on remote and local match' do
 163       remote_commit = shell("git ls-remote file://#{tmpdir}/testrepo_latest HEAD | head -1").stdout
 164       local_commit = shell("git --git-dir=#{tmpdir}/testrepo_latest/.git rev-parse HEAD").stdout.chomp
 165       expect(remote_commit).to include(local_commit)
 166     end
 167   end
 168
 169   context 'with shallow clone' do
 170     it 'does a shallow clone' do
 171       pp = <<-EOS
 172       vcsrepo { "#{tmpdir}/testrepo_shallow":
 173         ensure => present,
 174         provider => git,
 175         source => "file://#{tmpdir}/testrepo.git",
 176         depth => '1',
 177       }
 178       EOS
 179
 180       # Run it twice and test for idempotency
 181       apply_manifest(pp, :catch_failures => true)
 182       apply_manifest(pp, :catch_changes => true)
 183     end
 184
 185     describe file("#{tmpdir}/testrepo_shallow/.git/shallow") do
 186       it { should be_file }
 187     end
 188   end
 189
 190   context 'path is not empty and not a repository' do
 191     before(:all) do
 192       shell("mkdir #{tmpdir}/not_a_repo", :acceptable_exit_codes => [0,1])
 193       shell("touch #{tmpdir}/not_a_repo/file1.txt", :acceptable_exit_codes => [0,1])
 194     end
 195
 196     it 'should raise an exception' do
 197       pp = <<-EOS
 198       vcsrepo { "#{tmpdir}/not_a_repo":
 199         ensure => present,
 200         provider => git
 201         source => "file://#{tmpdir}/testrepo.git",
 202       }
 203       EOS
 204       apply_manifest(pp, :expect_failures => true)
 205     end
 206   end
 207
 208   context 'with an owner' do
 209     pp = <<-EOS
 210     user { 'vagrant':
 211       ensure => present,
 212     }
 213     EOS
 214
 215     apply_manifest(pp, :catch_failures => true)
 216     it 'clones a repo' do
 217       pp = <<-EOS
 218       vcsrepo { "#{tmpdir}/testrepo_owner":
 219         ensure => present,
 220         provider => git,
 221         source => "file://#{tmpdir}/testrepo.git",
 222         owner => 'vagrant',
 223       }
 224       EOS
 225
 226       # Run it twice and test for idempotency
 227       apply_manifest(pp, :catch_failures => true)
 228       apply_manifest(pp, :catch_changes => true)
 229     end
 230
 231     describe file("#{tmpdir}/testrepo_owner") do
 232       it { should be_directory }
 233       it { should be_owned_by 'vagrant' }
 234     end
 235   end
 236
 237   context 'with a group' do
 238     pp = <<-EOS
 239     group { 'vagrant':
 240       ensure => present,
 241     }
 242     EOS
 243
 244     apply_manifest(pp, :catch_failures => true)
 245
 246     it 'clones a repo' do
 247       pp = <<-EOS
 248       vcsrepo { "/#{tmpdir}/testrepo_group":
 249         ensure => present,
 250         provider => git,
 251         source => "file://#{tmpdir}/testrepo.git",
 252         group => 'vagrant',
 253       }
 254       EOS
 255
 256       # Run it twice and test for idempotency
 257       apply_manifest(pp, :catch_failures => true)
 258       apply_manifest(pp, :catch_changes => true)
 259     end
 260
 261     describe file("#{tmpdir}/testrepo_group") do
 262       it { should be_directory }
 263       it { should be_grouped_into 'vagrant' }
 264     end
 265   end
 266
 267   context 'with excludes' do
 268     it 'clones a repo' do
 269       pp = <<-EOS
 270       vcsrepo { "#{tmpdir}/testrepo_excludes":
 271         ensure => present,
 272         provider => git,
 273         source => "file://#{tmpdir}/testrepo.git",
 274         excludes => ['exclude1.txt', 'exclude2.txt'],
 275       }
 276       EOS
 277
 278       # Run it twice and test for idempotency
 279       apply_manifest(pp, :catch_failures => true)
 280       apply_manifest(pp, :catch_changes => true)
 281     end
 282
 283     describe file("#{tmpdir}/testrepo_excludes/.git/info/exclude") do
 284       its(:content) { should match /exclude1.txt/ }
 285       its(:content) { should match /exclude2.txt/ }
 286     end
 287   end
 288
 289   context 'with force' do
 290     before(:all) do
 291       shell("mkdir -p #{tmpdir}/testrepo_force/folder")
 292       shell("touch #{tmpdir}/testrepo_force/temp.txt")
 293     end
 294
 295     it 'applies the manifest' do
 296       pp = <<-EOS
 297       vcsrepo { "#{tmpdir}/testrepo_force":
 298         ensure => present,
 299         provider => git,
 300         source => "file://#{tmpdir}/testrepo.git",
 301         force => true,
 302       }
 303       EOS
 304
 305       # Run it twice and test for idempotency
 306       apply_manifest(pp, :catch_failures => true)
 307       apply_manifest(pp, :catch_changes => true)
 308     end
 309
 310     describe file("#{tmpdir}/testrepo_force/folder") do
 311       it { should_not be_directory }
 312     end
 313
 314     describe file("#{tmpdir}/testrepo_force/temp.txt") do
 315       it { should_not be_file }
 316     end
 317
 318     describe file("#{tmpdir}/testrepo_force/.git") do
 319       it { should be_directory }
 320     end
 321
 322     context 'and noop' do
 323       let(:repo_name) do
 324         'testrepo_already_exists'
 325       end
 326       before(:all) do
 327         shell("mkdir #{tmpdir}/#{repo_name}")
 328         shell("cd #{tmpdir}/#{repo_name} && git init")
 329         shell("cd #{tmpdir}/#{repo_name} && touch a && git add a && git commit -m 'a'")
 330       end
 331       after(:all) do
 332         shell("rm -rf #{tmpdir}/#{repo_name}")
 333       end
 334
 335       it 'applies the manifest' do
 336         pp = <<-EOS
 337         vcsrepo { "#{tmpdir}/#{repo_name}":
 338           ensure   => present,
 339           source   => "file://#{tmpdir}/testrepo.git",
 340           provider => git,
 341           force    => true,
 342           noop     => true,
 343         }
 344         EOS
 345
 346         apply_manifest_on(host, pp, :catch_changes => true) do |r|
 347           expect(r.stdout).to match(/Noop Mode/)
 348         end
 349       end
 350     end
 351   end
 352
 353   context 'as a user' do
 354     before(:all) do
 355       shell("chmod 707 #{tmpdir}")
 356       pp = <<-EOS
 357       group { 'testuser':
 358         ensure => present,
 359       }
 360       user { 'testuser':
 361         ensure => present,
 362         groups => 'testuser',
 363       }
 364       EOS
 365
 366       apply_manifest(pp, :catch_failures => true)
 367     end
 368
 369     it 'applies the manifest' do
 370       pp = <<-EOS
 371       vcsrepo { "#{tmpdir}/testrepo_user":
 372         ensure => present,
 373         provider => git,
 374         source => "file://#{tmpdir}/testrepo.git",
 375         user => 'testuser',
 376       }
 377       EOS
 378
 379       # Run it twice and test for idempotency
 380       apply_manifest(pp, :catch_failures => true)
 381       apply_manifest(pp, :catch_changes => true)
 382     end
 383
 384     describe file("#{tmpdir}/testrepo_user") do
 385       it { should be_directory }
 386       it { should be_owned_by 'testuser' }
 387     end
 388
 389     describe file("#{tmpdir}/testrepo_user") do
 390       it { should be_directory }
 391       it { should be_grouped_into 'testuser' }
 392     end
 393   end
 394
 395   context 'non-origin remote name' do
 396     it 'applies the manifest' do
 397       pp = <<-EOS
 398       vcsrepo { "#{tmpdir}/testrepo_remote":
 399         ensure => present,
 400         provider => git,
 401         source => "file://#{tmpdir}/testrepo.git",
 402         remote => 'testorigin',
 403       }
 404       EOS
 405
 406       # Run it twice and test for idempotency
 407       apply_manifest(pp, :catch_failures => true)
 408       apply_manifest(pp, :catch_changes => true)
 409     end
 410
 411     it 'remote name is "testorigin"' do
 412       shell("git --git-dir=#{tmpdir}/testrepo_remote/.git remote | grep 'testorigin'")
 413     end
 414
 415     after(:all) do
 416       pp = 'user { "testuser": ensure => absent }'
 417       apply_manifest(pp, :catch_failures => true)
 418     end
 419   end
 420
 421   context 'as a user with ssh' do
 422     before(:all) do
 423       # create user
 424       pp = <<-EOS
 425       group { 'testuser-ssh':
 426         ensure => present,
 427       }
 428       user { 'testuser-ssh':
 429         ensure => present,
 430         groups => 'testuser-ssh',
 431         managehome => true,
 432       }
 433       EOS
 434       apply_manifest(pp, :catch_failures => true)
 435
 436       # create ssh keys
 437       shell('mkdir -p /home/testuser-ssh/.ssh')
 438       shell('ssh-keygen -q -t rsa -f /home/testuser-ssh/.ssh/id_rsa -N ""')
 439
 440       # copy public key to authorized_keys
 441       shell('cat /home/testuser-ssh/.ssh/id_rsa.pub > /home/testuser-ssh/.ssh/authorized_keys')
 442       shell('echo -e "Host localhost\n\tStrictHostKeyChecking no\n" > /home/testuser-ssh/.ssh/config')
 443       shell('chown -R testuser-ssh:testuser-ssh /home/testuser-ssh/.ssh')
 444     end
 445
 446     it 'applies the manifest' do
 447       pp = <<-EOS
 448       vcsrepo { "#{tmpdir}/testrepo_user_ssh":
 449         ensure => present,
 450         provider => git,
 451         source => "testuser-ssh@localhost:#{tmpdir}/testrepo.git",
 452         user => 'testuser-ssh',
 453       }
 454       EOS
 455
 456       # Run it twice and test for idempotency
 457       apply_manifest(pp, :catch_failures => true)
 458       apply_manifest(pp, :catch_changes => true)
 459     end
 460
 461     after(:all) do
 462       pp = <<-EOS
 463       user { 'testuser-ssh':
 464         ensure => absent,
 465         managehome => true,
 466       }
 467       EOS
 468       apply_manifest(pp, :catch_failures => true)
 469     end
 470   end
 471
 472   context 'using an identity file' do
 473     before(:all) do
 474       # create user
 475       pp = <<-EOS
 476       user { 'testuser-ssh':
 477         ensure => present,
 478         managehome => true,
 479       }
 480       EOS
 481       apply_manifest(pp, :catch_failures => true)
 482
 483       # create ssh keys
 484       shell('mkdir -p /home/testuser-ssh/.ssh')
 485       shell('ssh-keygen -q -t rsa -f /home/testuser-ssh/.ssh/id_rsa -N ""')
 486
 487       # copy public key to authorized_keys
 488       shell('cat /home/testuser-ssh/.ssh/id_rsa.pub > /home/testuser-ssh/.ssh/authorized_keys')
 489       shell('echo -e "Host localhost\n\tStrictHostKeyChecking no\n" > /home/testuser-ssh/.ssh/config')
 490       shell('chown -R testuser-ssh:testuser-ssh /home/testuser-ssh/.ssh')
 491     end
 492
 493     it 'applies the manifest' do
 494       pp = <<-EOS
 495       vcsrepo { "#{tmpdir}/testrepo_user_ssh_id":
 496         ensure => present,
 497         provider => git,
 498         source => "testuser-ssh@localhost:#{tmpdir}/testrepo.git",
 499         identity => '/home/testuser-ssh/.ssh/id_rsa',
 500       }
 501       EOS
 502
 503       # Run it twice and test for idempotency
 504       apply_manifest(pp, :catch_failures => true)
 505       apply_manifest(pp, :catch_changes => true)
 506     end
 507   end
 508 end