r10k 1.1.4 → 1.2.0rc1

data/spec/system/module/svn/update_spec.rb

@@ -0,0 +1,38 @@
+require 'system/spec_helper'
+
+describe 'updating modules from SVN' do
+
+  extend SystemProvisioning::EL
+
+  before(:all) { yum_install 'subversion' }
+  after(:all) { shell %[yum -y remove subversion] }
+
+
+  it "reinstalls the module when the installed module isn't an svn repo"
+  it "reinstalls the module when the svn url doesn't match the installed module"
+
+  describe 'updating to a specific revision' do
+
+    include_context 'system module installation'
+
+    before(:all) do
+      shell %[echo "mod 'gitolite', :svn => 'https://github.com/nvalentine-puppetlabs/puppet-gitolite/trunk', :rev => '10'" > ./Puppetfile]
+      shell %[r10k puppetfile install]
+      shell %[echo "mod 'gitolite', :svn => 'https://github.com/nvalentine-puppetlabs/puppet-gitolite/trunk', :rev => '20'" > ./Puppetfile]
+    end
+
+    it "installs the module successfully" do
+      shell %[r10k puppetfile install] do |sh|
+        expect(sh.exit_code).to eq 0
+      end
+    end
+
+    it "checks out the specific revision" do
+      expect(command('cd modules/gitolite; svn info')).to return_stdout /Revision: 20/
+    end
+  end
+
+  describe 'when the installed revision is newer than the requested version' do
+    it 'downgrades the module'
+  end
+end

data/spec/system/spec_helper.rb

@@ -0,0 +1,60 @@
+require 'rspec-system/spec_helper'
+require 'rspec-system-serverspec/helpers'
+
+require 'system/system-helpers'
+
+require 'system-provisioning/el'
+
+require 'rspec-system-r10k/tmpdir'
+require 'rspec-system-r10k/puppetfile'
+
+RSpec.configure do |c|
+
+  include SystemProvisioning::EL
+
+  def install_deps
+    install_epel_release
+    install_puppetlabs_release
+
+    yum_install %w[ruby rubygems]
+    yum_install %w[puppet]
+  end
+
+  def build_artifact
+    require 'r10k/version'
+
+    desc = %x{git describe}.chomp
+    artifact_name = "r10k-#{desc}.gem"
+
+    system('gem build r10k.gemspec')
+    FileUtils.mv "r10k-#{R10K::VERSION}.gem", artifact_name
+
+    artifact_name
+  end
+
+  def upload_artifact(name)
+    rcp :sp => "./#{name}", :dp => '/root'
+    FileUtils.rm name
+  end
+
+  def install_artifact(name)
+    shell "gem install --no-rdoc --no-ri /root/#{name}"
+    shell "rm /root/#{name}"
+  end
+
+  def purge_gems
+    shell 'gem list | cut -d" " -f1 | xargs gem uninstall -aIx'
+  end
+
+  def purge_r10k
+    shell 'gem uninstall -aIx r10k'
+  end
+
+  c.before(:suite) do
+    purge_r10k
+    install_deps
+    name = build_artifact
+    upload_artifact(name)
+    install_artifact(name)
+  end
+end

data/spec/system/system-helpers.rb

@@ -0,0 +1,4 @@
+shared_context 'system module installation' do
+  before(:all) { shell 'rm -rf modules' }
+  after(:all) { shell 'rm -rf modules' }
+end

data/spec/system/version_spec.rb

@@ -0,0 +1,7 @@
+require 'system/spec_helper'
+
+describe 'printing the version' do
+  describe command('r10k version') do
+    it { should return_stdout /1.1/ }
+  end
+end

data/spec/system-provisioning/el.rb

@@ -0,0 +1,38 @@
+module SystemProvisioning
+  module EL
+    def install_epel_release
+      rpm_install(
+        'epel-release',
+        'http://dl.fedoraproject.org/pub/epel/5/x86_64/epel-release-5-4.noarch.rpm'
+      )
+    end
+
+    def install_puppetlabs_release
+      rpm_install(
+        'puppetlabs-release',
+      'http://yum.puppetlabs.com/puppetlabs-release-el-5.noarch.rpm'
+      )
+    end
+
+    def yum_install(*pkgs)
+      pkgs = Array(*pkgs)
+
+      pkgs.each do |pkg|
+
+        check_cmd = shell "rpm -q --filesbypkg #{pkg}"
+        if check_cmd.exit_code != 0
+          shell "yum -y install #{pkg}"
+        end
+      end
+    end
+
+    def rpm_install(name, install_name = nil)
+      install_name ||= name
+
+      check_cmd = shell "rpm -q --filesbypkg #{name}"
+      if check_cmd.exit_code != 0
+        shell "rpm -Uvh #{install_name}"
+      end
+    end
+  end
+end

data/spec/unit/deployment/source_spec.rb

@@ -6,7 +6,7 @@ describe R10K::Deployment::Source do
   let(:remote) { 'git://github.com/adrienthebo/r10k-fixture-repo' }
   let(:basedir)    { '/tmp' }
 
-  describe 'environments' do
+  describe 'environments', :integration => true do
     it 'uses the name as a prefix when told' do
       subject = described_class.new(name, remote, basedir, true)
       subject.fetch_remote()

data/spec/unit/git/cache_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'r10k/git/cache'
+
+describe R10K::Git::Cache do
+
+  subject(:cache) { described_class.new('git://some/git/remote') }
+
+  before do
+    expect(cache).to receive(:execute).never
+  end
+
+  describe "updating the cache" do
+    it "only updates the cache once" do
+      expect(cache).to receive(:sync!).exactly(1).times
+      cache.sync
+      cache.sync
+    end
+  end
+
+
+  describe "enumerating branches" do
+    let(:refs) do
+      %w[
+        refs/heads/master
+        refs/heads/next
+        refs/heads/next-fetch-errors
+        refs/heads/next-update-forge-modules
+      ].map { |line| line + "\n" }.join
+    end
+
+    it "lists local branches using git for-each-ref" do
+      expect(cache).to receive(:git).with(%w[for-each-ref refs/heads --format %(refname)], anything).and_return refs
+
+      expect(cache.branches).to eq %w[master next next-fetch-errors next-update-forge-modules]
+    end
+  end
+
+end

data/spec/unit/git/commit_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'r10k/git'
+
+describe R10K::Git::Commit do
+
+  let(:ref) { '96eeaba8c5069e31400a3dfcbeb37d016c1b1980' }
+  let(:repo) { double('git repository') }
+  subject { described_class.new(ref) }
+
+
+  describe "determining if the commit can be resolved" do
+    before do
+      subject.repository = repo
+    end
+
+    it "is true if the commit can be rev-parsed" do
+      expect(repo).to receive(:rev_parse).with(ref).and_return ref
+      expect(subject).to be_resolvable
+    end
+
+    it "is true if the commit cannot be rev-parsed" do
+      expect(repo).to receive(:rev_parse).with(ref).and_raise(R10K::Git::UnresolvableRefError, :ref => ref)
+      expect(subject).to_not be_resolvable
+    end
+  end
+
+  it "can be converted to a string" do
+    expect(subject.to_s).to eq ref
+  end
+
+  it_behaves_like "a git ref"
+  it_behaves_like "an immutable git ref"
+end

data/spec/unit/git/head_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'r10k/git'
+
+describe R10K::Git::Head do
+
+  let(:ref) { 'git/branch' }
+  let(:repo) { double('git repository') }
+  subject { described_class.new(ref) }
+
+
+  describe "determining if the head can be resolved" do
+    it "is always false"
+  end
+
+  describe "determining if the head needs to be fetched" do
+    it "is always true" do
+      expect(subject.fetch?).to be_true
+    end
+  end
+
+  it "can be converted to a string" do
+    expect(subject.to_s).to eq ref
+  end
+
+  it_behaves_like "a git ref"
+end
+

data/spec/unit/git/ref_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'r10k/git'
+
+describe R10K::Git::Ref do
+
+  let(:ref) { 'master' }
+  let(:repo) { double('git repository') }
+  subject { described_class.new(ref) }
+
+  describe "fetching the SHA1" do
+    it "raises an error if there is not a linked repository" do
+      expect {
+        subject.sha1
+      }.to raise_error(ArgumentError, /Cannot resolve .*#{ref}.*: no associated git repository/)
+    end
+
+    it "raises an error if the SHA1 could not be resolved" do
+      subject.repository = repo
+      expect(repo).to receive(:rev_parse).with(ref).and_raise(R10K::Git::UnresolvableRefError)
+
+      expect {
+        subject.sha1
+      }.to raise_error(R10K::Git::UnresolvableRefError)
+    end
+
+    it "looks up the ref against the linked repository" do
+      subject.repository = repo
+      expect(repo).to receive(:rev_parse).with(ref).and_return 'hash'
+      expect(subject.sha1).to eq 'hash'
+    end
+
+    it "invokes the #ref method" do
+      subject.repository = repo
+      expect(repo).to receive(:rev_parse).with(ref).and_return 'hash'
+      expect(subject).to receive(:ref).and_return ref
+      expect(subject.sha1).to eq 'hash'
+    end
+  end
+
+  describe "determining if the ref can be resolved" do
+    describe "and the ref is a head" do
+      it "is always false"
+    end
+
+    describe "and the ref is a tag" do
+      it "is true if the tag has been fetched"
+      it "is false if the tag cannot be resolved"
+    end
+
+    describe "and the ref is a commit" do
+      it "is true if the commit has been fetched"
+      it "is false if the commit cannot be resolved"
+    end
+  end
+
+  describe "determining if the ref needs to be fetched" do
+    it "uses the result of #resolvable? if the ref is a tag"
+    it "uses the result of #resolvable? if the ref is a commit"
+
+    it "is true if the ref is a head"
+  end
+
+  it "can be converted to a string" do
+    expect(subject.to_s).to eq ref
+  end
+
+  it_behaves_like "a git ref"
+end

data/spec/unit/git/tag_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'r10k/git'
+
+describe R10K::Git::Tag do
+
+  let(:ref) { '0.1.0' }
+  let(:repo) { double('git repository') }
+  subject { described_class.new(ref) }
+
+
+  describe "determining if the tag can be resolved" do
+    it "is true if the tag has been fetched" do
+      expect(repo).to receive(:rev_parse).with(ref).and_return('32f8ec692906783ee60e02e4a4154bc3a87dfeb6')
+      subject.repository = repo
+      expect(subject).to be_resolvable
+    end
+
+    it "is false if the tag cannot be resolved" do
+      expect(repo).to receive(:rev_parse).with(ref).and_raise(R10K::Git::UnresolvableRefError, :ref => ref)
+      subject.repository = repo
+      expect(subject).to_not be_resolvable
+    end
+  end
+
+  it "can be converted to a string" do
+    expect(subject.to_s).to eq ref
+  end
+
+  it_behaves_like "a git ref"
+  it_behaves_like "an immutable git ref"
+end

data/spec/unit/module/forge_spec.rb

@@ -3,26 +3,24 @@ require 'r10k/semver'
 require 'spec_helper'
 
 describe R10K::Module::Forge do
-  before :each do
-    allow_any_instance_of(Object).to receive(:systemu).and_raise "Tests should never invoke system calls"
-  end
 
-  before :each do
-    log = double('stub logger').as_null_object
-    described_class.any_instance.stub(:logger).and_return log
-  end
+  include_context 'stub logging'
+  include_context 'fail on execution'
+
+  let(:fixture_modulepath) { File.expand_path('spec/fixtures/module/forge', PROJECT_ROOT) }
+  let(:empty_modulepath) { File.expand_path('spec/fixtures/empty', PROJECT_ROOT) }
 
   describe "implementing the Puppetfile spec" do
     it "should implement 'branan/eight_hundred', '8.0.0'" do
-      described_class.should be_implement('branan/eight_hundred', '8.0.0')
+      expect(described_class).to be_implement('branan/eight_hundred', '8.0.0')
     end
 
     it "should fail with an invalid full name" do
-      described_class.should_not be_implement('branan-eight_hundred', '8.0.0')
+      expect(described_class).to_not be_implement('branan-eight_hundred', '8.0.0')
     end
 
     it "should fail with an invalid version" do
-      described_class.should_not be_implement('branan-eight_hundred', 'not a semantic version')
+      expect(described_class).to_not be_implement('branan-eight_hundred', 'not a semantic version')
     end
   end
 
@@ -30,61 +28,183 @@ describe R10K::Module::Forge do
     subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
 
     its(:name) { should eq 'eight_hundred' }
-    its(:owner) { should eq 'branan' }
+    its(:author) { should eq 'branan' }
     its(:full_name) { should eq 'branan/eight_hundred' }
     its(:basedir) { should eq '/moduledir' }
     its(:full_path) { should eq '/moduledir/eight_hundred' }
   end
 
   describe "when syncing" do
-    let(:fixture_modulepath) { File.expand_path('spec/fixtures/module/forge', PROJECT_ROOT) }
-    let(:empty_modulepath) { File.expand_path('spec/fixtures/empty', PROJECT_ROOT) }
+    let(:metadata) do
+      double('metadata',
+             :exist? => true,
+             :author => 'branan',
+             :version => R10K::SemVer.new('8.0.0'))
+    end
+
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
+
+    before { allow(R10K::Module::Metadata).to receive(:new).and_return metadata }
 
     describe "and the module is in sync" do
-      subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
+      before do
+        allow(subject).to receive(:status).and_return :insync
+      end
 
-      it { should be_insync }
-      its(:version) { should eq '8.0.0' }
+      it "is in sync" do
+        expect(subject).to be_insync
+      end
+
+      it "doesn't act when syncing anything" do
+        expect(subject).to receive(:install).never
+        expect(subject).to receive(:upgrade).never
+        expect(subject).to receive(:reinstall).never
+        subject.sync
+      end
     end
 
-    describe "and the desired version is newer than the installed version" do
-      subject { described_class.new('branan/eight_hundred', fixture_modulepath, '80.0.0') }
+    describe "and the module is mismatched" do
+      before do
+        allow(subject).to receive(:status).and_return :mismatched
+      end
+
+      it "is not in sync" do
+        expect(subject).to_not be_insync
+      end
+
+      it "reinstalls the module" do
+        expect(subject).to receive(:reinstall)
+        subject.sync
+      end
 
-      it { should_not be_insync }
-      its(:version) { should eq 'v8.0.0' }
+      it "reinstalls by removing the existing directory and calling the module tool" do
+        expect(FileUtils).to receive(:rm_rf)
+        expect(subject).to receive(:pmt) do |args|
+          expect(args).to include 'install'
+          expect(args).to include '--version=8.0.0'
+          expect(args).to include 'branan/eight_hundred'
+        end
 
-      it "should try to upgrade the module" do
-        expected = %w{upgrade --version=80.0.0 --ignore-dependencies branan/eight_hundred}
-        expect(subject).to receive(:pmt).with(expected)
         subject.sync
       end
     end
 
-    describe "and the desired version is older than the installed version" do
-      subject { described_class.new('branan/eight_hundred', fixture_modulepath, '7.0.0') }
+    describe "and the module is outdated" do
+      before do
+        allow(subject).to receive(:status).and_return :outdated
+      end
+
+      it "is not in sync" do
+        expect(subject).to_not be_insync
+      end
+
+      it "upgrades the module" do
+        expect(subject).to receive(:upgrade)
+        subject.sync
+      end
 
-      it { should_not be_insync }
-      its(:version) { should eq '8.0.0' }
+      it "upgrades by calling the module tool" do
+        expect(subject).to receive(:pmt) do |args|
+          expect(args).to include 'upgrade'
+          expect(args).to include '--version=8.0.0'
+          expect(args).to include 'branan/eight_hundred'
+        end
 
-      it "should try to downgrade the module" do
-        # Again with the magical "v" prefix to the version.
-        expected = %w{upgrade --version=7.0.0 --ignore-dependencies branan/eight_hundred}
-        expect(subject).to receive(:pmt).with(expected)
         subject.sync
       end
     end
 
     describe "and the module is not installed" do
-      subject { described_class.new('branan/eight_hundred', empty_modulepath, '8.0.0') }
+      before do
+        allow(subject).to receive(:status).and_return :absent
+      end
 
-      it { should_not be_insync }
-      its(:version) { should eq R10K::SemVer::MIN }
+      it "is not in sync" do
+        expect(subject).to_not be_insync
+      end
 
-      it "should try to install the module" do
-        expected = %w{install --version=8.0.0 --ignore-dependencies branan/eight_hundred}
-        expect(subject).to receive(:pmt).with(expected)
+      it "installs the module" do
+        expect(subject).to receive(:uninstall).never
+        expect(subject).to receive(:install)
         subject.sync
       end
+
+      it "installs by calling the module tool" do
+        expect(subject).to receive(:pmt) do |args|
+          expect(args).to include 'install'
+          expect(args).to include '--version=8.0.0'
+          expect(args).to include 'branan/eight_hundred'
+        end
+
+        subject.sync
+      end
+    end
+  end
+
+  describe "determining the status" do
+
+    let(:metadata) { double 'metadata', :version => R10K::SemVer.new('8.0.0'), :author => 'branan', :exist? => true, :read => nil }
+
+    subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
+
+    before do
+      allow(R10K::Module::Metadata).to receive(:new).and_return metadata
+    end
+
+    it "is :absent if the module directory is absent" do
+      allow(subject).to receive(:exist?).and_return false
+      expect(subject.status).to eq :absent
+    end
+
+    it "is :mismatched if there is no module metadata" do
+      allow(subject).to receive(:exist?).and_return true
+      allow(metadata).to receive(:exist?).and_return false
+
+      expect(subject.status).to eq :mismatched
+    end
+
+    it "is :mismatched if the metadata author doesn't match the expected author" do
+      allow(subject).to receive(:exist?).and_return true
+
+      allow(metadata).to receive(:author).and_return 'blargh'
+
+      expect(subject.status).to eq :mismatched
+    end
+
+    it "is :outdated if the metadata version doesn't match the expected version" do
+      allow(subject).to receive(:exist?).and_return true
+
+      allow(metadata).to receive(:version).and_return R10K::SemVer.new('7.0.0')
+
+      expect(subject.status).to eq :outdated
+    end
+
+    it "is :insync if the version and the author are in sync" do
+      allow(subject).to receive(:exist?).and_return true
+
+      expect(subject.status).to eq :insync
+    end
+  end
+
+  describe "and the expected version is :latest", :vcr => true, :unless => (RUBY_VERSION == '1.8.7') do
+    subject { described_class.new('branan/eight_hundred', '/moduledir', :latest) }
+
+    let(:_metadata) do
+      double('metadata',
+             :version => R10K::SemVer.new('7.0.0'),
+             :author => 'branan',
+             :exist? => true,
+             :read   => nil)
+    end
+
+    before do
+      allow(R10K::Module::Metadata).to receive(:new).and_return _metadata
+    end
+
+    it "sets the expected version based on the latest forge version" do
+      allow(subject).to receive(:exist?).and_return true
+      expect(subject.status).to eq :outdated
+      expect(subject.expected_version).to eq R10K::SemVer.new('8.0.0')
     end
   end
 end