r10k 3.5.2

data/spec/unit/module/git_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+require 'r10k/module/git'
+
+describe R10K::Module::Git do
+  let(:mock_repo) do
+    instance_double("R10K::Git::StatefulRepository")
+  end
+
+  before(:each) do
+    allow(R10K::Git::StatefulRepository).to receive(:new).and_return(mock_repo)
+  end
+
+  describe "setting the owner and name" do
+    describe "with a title of 'branan/eight_hundred'" do
+      subject do
+        described_class.new(
+          'branan/eight_hundred',
+          '/moduledir',
+          {
+            :git => 'git://git-server.site/branan/puppet-eight_hundred',
+          }
+        )
+      end
+
+      it "sets the owner to 'branan'" do
+        expect(subject.owner).to eq 'branan'
+      end
+
+      it "sets the name to 'eight_hundred'" do
+        expect(subject.name).to eq 'eight_hundred'
+      end
+
+      it "sets the path to '/moduledir/eight_hundred'" do
+        expect(subject.path).to eq(Pathname.new('/moduledir/eight_hundred'))
+      end
+    end
+
+    describe "with a title of 'modulename'" do
+      subject do
+        described_class.new(
+          'eight_hundred',
+          '/moduledir',
+          {
+            :git => 'git://git-server.site/branan/puppet-eight_hundred',
+          }
+        )
+      end
+
+      it "sets the owner to nil" do
+        expect(subject.owner).to be_nil
+      end
+
+      it "sets the name to 'eight_hundred'" do
+        expect(subject.name).to eq 'eight_hundred'
+      end
+
+      it "sets the path to '/moduledir/eight_hundred'" do
+        expect(subject.path).to eq(Pathname.new('/moduledir/eight_hundred'))
+      end
+    end
+  end
+
+  describe "properties" do
+    subject do
+      described_class.new('boolean', '/moduledir', {:git => 'git://git.example.com/adrienthebo/puppet-boolean'})
+    end
+
+    before(:each) do
+      allow(mock_repo).to receive(:resolve).with('master').and_return('abc123')
+      allow(mock_repo).to receive(:head).and_return('abc123')
+    end
+
+    it "sets the module type to :git" do
+      expect(subject.properties).to include(:type => :git)
+    end
+
+    it "sets the expected version" do
+      expect(subject.properties).to include(:expected => 'master')
+    end
+
+    it "sets the actual version to the revision when the revision is available" do
+      expect(mock_repo).to receive(:head).and_return('35d3517e67ceeb4b485b56d4a14d38fb95516c92')
+      expect(subject.properties).to include(:actual => '35d3517e67ceeb4b485b56d4a14d38fb95516c92')
+    end
+
+    it "sets the actual version to (unresolvable) when the revision is unavailable" do
+      expect(mock_repo).to receive(:head).and_return(nil)
+      expect(subject.properties).to include(:actual => '(unresolvable)')
+    end
+  end
+
+  describe "determining the status" do
+    subject do
+      described_class.new(
+        'boolean',
+        '/moduledir',
+        {
+          :git => 'git://git.example.com/adrienthebo/puppet-boolean'
+        }
+      )
+    end
+
+    it "delegates to the repo" do
+      expect(subject).to receive(:version).and_return 'master'
+      expect(mock_repo).to receive(:status).with('master').and_return :some_status
+
+      expect(subject.status).to eq(:some_status)
+    end
+  end
+
+  describe "option parsing" do
+    def test_module(extra_opts, env=nil)
+      described_class.new('boolean', '/moduledir', base_opts.merge(extra_opts), env)
+    end
+
+    let(:base_opts) { { git: 'git://git.example.com/adrienthebo/puppet-boolean' } }
+
+    before(:each) do
+      allow(mock_repo).to receive(:head).and_return('abc123')
+    end
+
+    context "when option is unrecognized" do
+      let(:opts) { { unrecognized: true } }
+
+      it "raises an error" do
+        expect { test_module(opts) }.to raise_error(ArgumentError, /unhandled options.*unrecognized/i)
+      end
+    end
+
+    describe "desired ref" do
+      context "when no desired ref is given" do
+        it "defaults to master" do
+          expect(mock_repo).to receive(:resolve).with('master').and_return('abc123')
+
+          expect(test_module({}).properties).to include(expected: 'master')
+        end
+      end
+
+      context "specifying a static desired branch" do
+        let(:opts) { { branch: 'banana' } }
+
+        it "sets expected to specified branch name" do
+          expect(mock_repo).to receive(:resolve).with('banana').and_return('def456')
+
+          mod = test_module(opts)
+          expect(mod.properties).to include(expected: 'banana')
+        end
+      end
+
+      context "specifying a static desired tag" do
+        let(:opts) { { tag: '1.2.3' } }
+
+        it "sets expected to specified tag" do
+          expect(mock_repo).to receive(:resolve).with('1.2.3').and_return('def456')
+
+          mod = test_module(opts)
+          expect(mod.properties).to include(expected: '1.2.3')
+        end
+      end
+
+      context "specifying a static desired commit sha" do
+        let(:opts) { { commit: 'ace789' } }
+
+        it "sets expected to specified commit sha" do
+          expect(mock_repo).to receive(:resolve).with('ace789').and_return('ace789')
+
+          mod = test_module(opts)
+          expect(mod.properties).to include(expected: 'ace789')
+        end
+      end
+
+      context "specifying a static desired ref" do
+        before(:each) do
+          expect(mock_repo).to receive(:resolve).and_return('abc123')
+        end
+
+        it "accepts a branch name" do
+          mod = test_module(ref: 'banana')
+          expect(mod.properties).to include(expected: 'banana')
+        end
+
+        it "accepts a tag name" do
+          mod = test_module(ref: '1.2.3')
+          expect(mod.properties).to include(expected: '1.2.3')
+        end
+
+        it "accepts a commit sha" do
+          mod = test_module(ref: 'abc123')
+          expect(mod.properties).to include(expected: 'abc123')
+        end
+      end
+
+      context "specifying branch to :control_branch" do
+        let(:mock_env) { instance_double("R10K::Environment::Git", ref: 'env_branch') }
+
+        context "when module belongs to an environment and matching branch is resolvable" do
+          before(:each) do
+            expect(mock_repo).to receive(:resolve).with(mock_env.ref).and_return('abc123')
+          end
+
+          it "tracks environment branch" do
+            mod = test_module({branch: :control_branch}, mock_env)
+            expect(mod.properties).to include(expected: mock_env.ref)
+          end
+        end
+
+        context "when module does not belong to an environment" do
+          it "leaves desired_ref unchanged" do
+            mod = test_module(branch: :control_branch)
+            expect(mod.desired_ref).to eq(:control_branch)
+          end
+
+          context "when default ref is provided and resolvable" do
+            it "uses default ref" do
+              expect(mock_repo).to receive(:resolve).with('default').and_return('abc123')
+              mod = test_module({branch: :control_branch, default_branch: 'default'})
+
+              expect(mod.properties).to include(expected: 'default')
+            end
+          end
+
+          context "when default ref is provided and not resolvable" do
+            it "raises appropriate error" do
+              expect(mock_repo).to receive(:resolve).with('default').and_return(nil)
+              mod = test_module({branch: :control_branch, default_branch: 'default'})
+
+              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve control repo branch.*or resolve default/i)
+            end
+          end
+
+          context "when default ref is not provided" do
+            it "raises appropriate error" do
+              mod = test_module({branch: :control_branch})
+
+              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve control repo branch.*no default provided/i)
+            end
+          end
+        end
+
+        context "when module does not have matching branch" do
+          before(:each) do
+            allow(mock_repo).to receive(:resolve).with(mock_env.ref).and_return(nil)
+          end
+
+          context "when default ref is provided and resolvable" do
+            it "uses default ref" do
+              expect(mock_repo).to receive(:resolve).with('default').and_return('abc123')
+              mod = test_module({branch: :control_branch, default_branch: 'default'}, mock_env)
+
+              expect(mod.properties).to include(expected: 'default')
+            end
+          end
+
+          context "when default ref is provided and not resolvable" do
+            it "raises appropriate error" do
+              expect(mock_repo).to receive(:resolve).with('default').and_return(nil)
+              mod = test_module({branch: :control_branch, default_branch: 'default'}, mock_env)
+
+              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve desired.*or resolve default/i)
+            end
+          end
+
+          context "when default ref is not provided" do
+            it "raises appropriate error" do
+              mod = test_module({branch: :control_branch}, mock_env)
+
+              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*no default provided/i)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/module/metadata_file_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe R10K::Module::MetadataFile do
+
+  let(:path) { double 'pathname' }
+
+  subject(:metadata_file) { described_class.new(path) }
+
+  describe "determining if the metadata file exists" do
+    it "doesn't exist if the given path isn't a file" do
+      allow(path).to receive(:file?).and_return false
+      expect(metadata_file).to_not be_exist
+    end
+
+    it "doesn't exist if the given path is an unreadable file" do
+      allow(path).to receive(:file?).and_return true
+      allow(path).to receive(:readable?).and_return false
+
+      expect(metadata_file).to_not be_exist
+    end
+
+    it "exists if the given path exists and is readable" do
+      allow(path).to receive(:file?).and_return true
+      allow(path).to receive(:readable?).and_return true
+
+      expect(metadata_file).to be_exist
+    end
+  end
+
+  describe "parsing a metadata file" do
+    let(:fixture_path) do
+      fixture_path = Pathname.new(File.expand_path('spec/fixtures/module/forge/eight_hundred/metadata.json', PROJECT_ROOT))
+    end
+
+    before do
+      a_metadata_file = R10K::Module::MetadataFile.new(fixture_path)
+      @metadata = a_metadata_file.read
+    end
+
+    it "extracts the module name" do
+      expect(@metadata.name).to eq 'eight_hundred'
+    end
+
+    it "extracts the full module name" do
+      expect(@metadata.full_module_name).to eq 'branan-eight_hundred'
+    end
+
+    it "extracts the module author" do
+      expect(@metadata.author).to eq 'Branan Purvine-Riley'
+    end
+
+    it "extracts the module version" do
+      expect(@metadata.version).to eq '8.0.0'
+    end
+  end
+
+  describe "parsing an invalid metadata file" do
+    let(:fixture_path) do
+      fixture_path = Pathname.new(File.expand_path('spec/fixtures/module/forge/bad_module/metadata.json', PROJECT_ROOT))
+    end
+
+    it "raises an error" do
+      a_metadata_file = R10K::Module::MetadataFile.new(fixture_path)
+      expect {a_metadata_file.read}.to raise_error(R10K::Error, "Could not read metadata.json")
+    end
+  end
+
+end

data/spec/unit/module/svn_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+require 'r10k/module/svn'
+
+describe R10K::Module::SVN do
+
+  include_context 'fail on execution'
+
+  describe "determining it implements a Puppetfile mod" do
+    it "implements mods with the :svn hash key" do
+      implements = described_class.implement?('r10k-fixture-repo', :svn => 'https://github.com/adrienthebo/r10k-fixture-repo')
+      expect(implements).to eq true
+    end
+  end
+
+  describe "path variables" do
+    it "uses the module name as the name" do
+      svn = described_class.new('foo', '/moduledir', :rev => 'r10')
+      expect(svn.name).to eq 'foo'
+      expect(svn.owner).to be_nil
+      expect(svn.dirname).to eq '/moduledir'
+      expect(svn.path).to eq Pathname.new('/moduledir/foo')
+    end
+
+    it "does not include the owner in the path" do
+      svn = described_class.new('bar/foo', '/moduledir', :rev => 'r10')
+      expect(svn.name).to eq 'foo'
+      expect(svn.owner).to eq 'bar'
+      expect(svn.dirname).to eq '/moduledir'
+      expect(svn.path).to eq Pathname.new('/moduledir/foo')
+    end
+  end
+
+
+  describe "instantiating based on Puppetfile configuration" do
+    it "can specify a revision with the :rev key" do
+      svn = described_class.new('foo', '/moduledir', :rev => 'r10')
+      expect(svn.expected_revision).to eq 'r10'
+    end
+
+    it "can specify a revision with the :revision key" do
+      svn = described_class.new('foo', '/moduledir', :revision => 'r10')
+      expect(svn.expected_revision).to eq 'r10'
+    end
+  end
+
+  describe "properties" do
+    subject { described_class.new('foo', '/moduledir', :svn => 'https://github.com/adrienthebo/r10k-fixture-repo', :rev => 123) }
+
+    it "sets the module type to :svn" do
+      expect(subject.properties).to include(:type => :svn)
+    end
+
+    it "sets the expected version" do
+      expect(subject.properties).to include(:expected => 123)
+    end
+
+    it "sets the actual version to the revision when the revision is available" do
+      expect(subject.working_dir).to receive(:revision).and_return(12)
+      expect(subject.properties).to include(:actual => 12)
+    end
+
+    it "sets the actual version (unresolvable) when the revision is unavailable" do
+      expect(subject.working_dir).to receive(:revision).and_raise(ArgumentError)
+      expect(subject.properties).to include(:actual => "(unresolvable)")
+    end
+  end
+
+  describe "determining the status" do
+    subject { described_class.new('foo', '/moduledir', :svn => 'https://github.com/adrienthebo/r10k-fixture-repo', :rev => 123) }
+
+    let(:working_dir) { double 'working_dir' }
+
+    before do
+      allow(R10K::SVN::WorkingDir).to receive(:new).and_return working_dir
+    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 the directory is present but not an SVN repo" do
+      allow(subject).to receive(:exist?).and_return true
+
+      allow(working_dir).to receive(:is_svn?).and_return false
+
+      expect(subject.status).to eq :mismatched
+    end
+
+    it "is mismatched when the wrong SVN URL is checked out" do
+      allow(subject).to receive(:exist?).and_return true
+
+      allow(working_dir).to receive(:is_svn?).and_return true
+      allow(working_dir).to receive(:url).and_return 'svn://nope/trunk'
+
+      expect(subject.status).to eq :mismatched
+    end
+
+    it "is :outdated when the expected rev doesn't match the actual rev" do
+      allow(subject).to receive(:exist?).and_return true
+
+      allow(working_dir).to receive(:is_svn?).and_return true
+      allow(working_dir).to receive(:url).and_return 'https://github.com/adrienthebo/r10k-fixture-repo'
+      allow(working_dir).to receive(:revision).and_return 99
+
+      expect(subject.status).to eq :outdated
+    end
+
+    it "is :insync if all other conditions are satisfied" do
+      allow(subject).to receive(:exist?).and_return true
+
+      allow(working_dir).to receive(:is_svn?).and_return true
+      allow(working_dir).to receive(:url).and_return 'https://github.com/adrienthebo/r10k-fixture-repo'
+      allow(working_dir).to receive(:revision).and_return 123
+
+      expect(subject.status).to eq :insync
+    end
+  end
+
+  describe "synchronizing" do
+
+    subject { described_class.new('foo', '/moduledir', :svn => 'https://github.com/adrienthebo/r10k-fixture-repo', :rev => 123) }
+
+    before do
+      allow(File).to receive(:directory?).with('/moduledir').and_return true
+    end
+
+    describe "and the state is :absent" do
+      before { allow(subject).to receive(:status).and_return :absent }
+
+      it "installs the SVN module" do
+        expect(subject).to receive(:install)
+        subject.sync
+      end
+    end
+
+    describe "and the state is :mismatched" do
+      before { allow(subject).to receive(:status).and_return :mismatched }
+
+      it "reinstalls the module" do
+        expect(subject).to receive(:reinstall)
+
+        subject.sync
+      end
+
+      it "removes the existing directory" do
+        expect(subject.path).to receive(:rmtree)
+        allow(subject).to receive(:install)
+
+        subject.sync
+      end
+    end
+
+    describe "and the state is :outdated" do
+      before { allow(subject).to receive(:status).and_return :outdated }
+
+      it "upgrades the repository" do
+        expect(subject).to receive(:update)
+
+        subject.sync
+      end
+    end
+
+    describe "and the state is :insync" do
+      before { allow(subject).to receive(:status).and_return :insync }
+
+      it "doesn't change anything" do
+        expect(subject).to receive(:install).never
+        expect(subject).to receive(:reinstall).never
+        expect(subject).to receive(:update).never
+
+        subject.sync
+      end
+    end
+  end
+end