r10k 3.6.0 → 3.9.2

data/spec/unit/action/deploy/module_spec.rb

@@ -4,39 +4,51 @@ require 'r10k/action/deploy/module'
 
 describe R10K::Action::Deploy::Module do
 
-  subject { described_class.new({config: "/some/nonexistent/path"}, []) }
+  subject { described_class.new({config: "/some/nonexistent/path"}, [], {}) }
 
   it_behaves_like "a deploy action that requires a config file"
   it_behaves_like "a deploy action that can be write locked"
 
   describe "initializing" do
     it "accepts an environment option" do
-      described_class.new({environment: "production"}, [])
+      described_class.new({environment: "production"}, [], {})
     end
 
     it "can accept a no-force option" do
-      described_class.new({:'no-force' => true}, [])
+      described_class.new({:'no-force' => true}, [], {})
     end
 
     it 'can accept a generate-types option' do
-      described_class.new({ 'generate-types': true }, [])
+      described_class.new({ 'generate-types': true }, [], {})
     end
 
     it 'can accept a puppet-path option' do
-      described_class.new({ 'puppet-path': '/nonexistent' }, [])
+      described_class.new({ 'puppet-path': '/nonexistent' }, [], {})
+    end
+
+    it 'can accept a puppet-conf option' do
+      described_class.new({ 'puppet-conf': '/nonexistent' }, [], {})
     end
 
     it 'can accept a cachedir option' do
-      described_class.new({ cachedir: '/nonexistent' }, [])
+      described_class.new({ cachedir: '/nonexistent' }, [], {})
+    end
+
+    it 'can accept a private-key option' do
+      described_class.new({ 'private-key': '/nonexistent' }, [], {})
+    end
+
+    it 'can accept a token option' do
+      described_class.new({ 'oauth-token': '/nonexistent' }, [], {})
     end
   end
 
   describe "with no-force" do
 
-    subject { described_class.new({ config: "/some/nonexistent/path", :'no-force' => true}, [] )}
+    subject { described_class.new({ config: "/some/nonexistent/path", :'no-force' => true}, [], {}) }
 
     it "tries to preserve local modifications" do
-      expect(subject.force).to equal(false)
+      expect(subject.settings[:overrides][:modules][:force]).to equal(false)
     end
   end
 
@@ -64,33 +76,33 @@ describe R10K::Action::Deploy::Module do
             config: '/some/nonexistent/path',
             'generate-types': true
           },
-          %w[first]
+          %w[first],
+          {}
         )
       end
 
       before do
+        @modules = []
         allow(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
-          expect(environment.puppetfile).to receive(:modules_by_vcs_cachedir).and_return(
-            {none: [R10K::Module::Local.new(environment.name, '/fakedir', [], environment)]}
-          )
+          mod = R10K::Module::Local.new(environment.name, '/fakedir', {}, environment)
+          if mod.name == 'first'
+            expect(environment).to receive(:generate_types!)
+          else
+            expect(environment).not_to receive(:generate_types!)
+          end
+          @modules << mod
+          expect(environment.puppetfile).to receive(:modules).and_return([mod]).twice
           original.call(environment, &block)
         end
       end
 
       it 'generate_types is true' do
-        expect(subject.instance_variable_get(:@generate_types)).to eq(true)
+        expect(subject.settings[:overrides][:environments][:generate_types]).to eq(true)
       end
 
       it 'only calls puppet generate types on environments with specified module' do
-        expect(subject).to receive(:visit_module).and_wrap_original do |original, mod, &block|
-          if mod.name == 'first'
-            expect(mod.environment).to receive(:generate_types!)
-          else
-            expect(mod.environment).not_to receive(:generate_types!)
-          end
-          original.call(mod, &block)
-        end.twice
         subject.call
+        expect(@modules.length).to be(2)
       end
     end
 
@@ -101,12 +113,13 @@ describe R10K::Action::Deploy::Module do
             config: '/some/nonexistent/path',
             'generate-types': false
           },
-          %w[first]
+          %w[first],
+          {}
         )
       end
 
       it 'generate_types is false' do
-        expect(subject.instance_variable_get(:@generate_types)).to eq(false)
+        expect(subject.settings[:overrides][:environments][:generate_types]).to eq(false)
       end
 
       it 'does not call puppet generate types' do |it|
@@ -121,19 +134,153 @@ describe R10K::Action::Deploy::Module do
 
   describe 'with puppet-path' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-path': '/nonexistent' }, []) }
+    subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-path': '/nonexistent' }, [], {}) }
 
     it 'sets puppet_path' do
       expect(subject.instance_variable_get(:@puppet_path)).to eq('/nonexistent')
     end
   end
 
+  describe 'with puppet-conf' do
+
+    subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-conf': '/nonexistent' }, [], {}) }
+
+    it 'sets puppet_conf' do
+      expect(subject.instance_variable_get(:@puppet_conf)).to eq('/nonexistent')
+    end
+  end
+
   describe 'with cachedir' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', cachedir: '/nonexistent' }, []) }
+    subject { described_class.new({ config: '/some/nonexistent/path', cachedir: '/nonexistent' }, [], {}) }
 
-    it 'sets puppet_path' do
+    it 'sets cachedir' do
       expect(subject.instance_variable_get(:@cachedir)).to eq('/nonexistent')
     end
   end
+
+  describe 'with private-key' do
+
+    subject { described_class.new({ config: '/some/nonexistent/path', 'private-key': '/nonexistent' }, [], {}) }
+
+    it 'sets private_key' do
+      expect(subject.instance_variable_get(:@private_key)).to eq('/nonexistent')
+    end
+  end
+
+  describe 'with oauth-token' do
+
+    subject { described_class.new({ config: '/some/nonexistent/path', 'oauth-token': '/nonexistent' }, [], {}) }
+
+    it 'sets token_path' do
+      expect(subject.instance_variable_get(:@oauth_token)).to eq('/nonexistent')
+    end
+  end
+
+  describe 'with modules' do
+
+    subject { described_class.new({ config: '/some/nonexistent/path' }, ['mod1', 'mod2'], {}) }
+
+    let(:cache) { instance_double("R10K::Git::Cache", 'sanitized_dirname' => 'foo', 'cached?' => true, 'sync' => true) }
+    let(:repo) { instance_double("R10K::Git::StatefulRepository", cache: cache, resolve: 'main') }
+
+    it 'does not sync modules not given' do
+      allow(R10K::Deployment).to receive(:new).and_wrap_original do |original, settings, &block|
+        original.call(settings.merge({
+          sources: {
+            main: {
+              remote: 'git://not/a/remote',
+              basedir: '/not/a/basedir',
+              type: 'git'
+            }
+          }
+        }))
+      end
+
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
+      allow(R10K::Git).to receive_message_chain(:cache, :generate).and_return(cache)
+      allow_any_instance_of(R10K::Source::Git).to receive(:branch_names).and_return([R10K::Environment::Name.new('first', {})])
+
+      expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+        pf = environment.puppetfile
+        expect(pf).to receive(:load) do
+          pf.add_module('mod1', { git: 'git://remote' })
+          pf.add_module('mod2', { git: 'git://remote' })
+          pf.add_module('mod3', { git: 'git://remote' })
+        end
+
+        pf.modules.each do |mod|
+          if ['mod1', 'mod2'].include?(mod.name)
+            expect(mod.should_sync?).to be(true)
+          else
+            expect(mod.should_sync?).to be(false)
+          end
+          expect(mod).to receive(:sync).and_call_original
+        end
+
+        original.call(environment, &block)
+      end
+
+      expect(repo).to receive(:sync).twice
+
+      subject.call
+    end
+  end
+
+  describe 'with environments' do
+    subject { described_class.new({ config: '/some/nonexistent/path', environment: 'first' }, ['mod1'], {}) }
+
+    let(:cache) { instance_double("R10K::Git::Cache", 'sanitized_dirname' => 'foo', 'cached?' => true, 'sync' => true) }
+    let(:repo) { instance_double("R10K::Git::StatefulRepository", cache: cache, resolve: 'main') }
+
+    it 'only syncs to the given environments' do
+      allow(R10K::Deployment).to receive(:new).and_wrap_original do |original, settings, &block|
+        original.call(settings.merge({
+          sources: {
+            main: {
+              remote: 'git://not/a/remote',
+              basedir: '/not/a/basedir',
+              type: 'git'
+            }
+          }
+        }))
+      end
+
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
+      allow(R10K::Git).to receive_message_chain(:cache, :generate).and_return(cache)
+      allow_any_instance_of(R10K::Source::Git).to receive(:branch_names).and_return([R10K::Environment::Name.new('first', {}),
+                                                                                     R10K::Environment::Name.new('second', {})])
+
+      expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+        pf = environment.puppetfile
+
+        if environment.name == 'first'
+          expect(pf).to receive(:load) do
+            pf.add_module('mod1', { git: 'git://remote' })
+            pf.add_module('mod2', { git: 'git://remote' })
+          end
+
+          pf.modules.each do |mod|
+            if mod.name == 'mod1'
+              expect(mod.should_sync?).to be(true)
+            else
+              expect(mod.should_sync?).to be(false)
+            end
+            expect(mod).to receive(:sync).and_call_original
+          end
+        else
+          expect(pf).not_to receive(:load)
+        end
+
+        original.call(environment, &block)
+      end.twice
+
+      expect(repo).to receive(:sync).once
+      expect(subject.logger).to receive(:debug1).with(/Updating modules.*in environment.*first/i)
+      expect(subject.logger).to receive(:debug1).with(/skipping environment.*second/i)
+
+      subject.call
+    end
+  end
 end
+

data/spec/unit/action/puppetfile/check_spec.rb

@@ -11,7 +11,7 @@ describe R10K::Action::Puppetfile::Check do
   end
 
   before(:each) do
-    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, nil).and_return(puppetfile)
+    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: nil}).and_return(puppetfile)
   end
 
   it_behaves_like "a puppetfile action"
@@ -34,7 +34,7 @@ describe R10K::Action::Puppetfile::Check do
   it "respects --puppetfile option" do
     allow($stderr).to receive(:puts)
 
-    expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, "/custom/puppetfile/path").and_return(puppetfile)
+    expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: "/custom/puppetfile/path"}).and_return(puppetfile)
 
     checker({puppetfile: "/custom/puppetfile/path"}).call
   end

data/spec/unit/action/puppetfile/install_spec.rb

@@ -2,8 +2,11 @@ require 'spec_helper'
 require 'r10k/action/puppetfile/install'
 
 describe R10K::Action::Puppetfile::Install do
-  let(:default_opts) { {root: "/some/nonexistent/path"} }
-  let(:puppetfile) { R10K::Puppetfile.new('/some/nonexistent/path', nil, nil) }
+  let(:default_opts) { { root: "/some/nonexistent/path" } }
+  let(:puppetfile) {
+    R10K::Puppetfile.new('/some/nonexistent/path',
+                         {:moduledir => nil, :puppetfile_path => nil, :force => false})
+  }
 
   def installer(opts = {}, argv = [], settings = {})
     opts = default_opts.merge(opts)
@@ -12,7 +15,10 @@ describe R10K::Action::Puppetfile::Install do
 
   before(:each) do
     allow(puppetfile).to receive(:load!).and_return(nil)
-    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, nil, nil, nil).and_return(puppetfile)
+    allow(R10K::Puppetfile).to receive(:new).
+      with("/some/nonexistent/path",
+           {:moduledir => nil, :puppetfile_path => nil, :force => false}).
+      and_return(puppetfile)
   end
 
   it_behaves_like "a puppetfile install action"
@@ -20,12 +26,11 @@ describe R10K::Action::Puppetfile::Install do
   describe "installing modules" do
     let(:modules) do
       (1..4).map do |idx|
-        R10K::Module::Base.new("author/modname#{idx}", "/some/nonexistent/path/modname#{idx}", nil)
+        R10K::Module::Base.new("author/modname#{idx}", "/some/nonexistent/path/modname#{idx}", {})
       end
     end
 
     before do
-      allow(puppetfile).to receive(:purge!)
       allow(puppetfile).to receive(:modules).and_return(modules)
       allow(puppetfile).to receive(:modules_by_vcs_cachedir).and_return({none: modules})
     end
@@ -50,7 +55,15 @@ describe R10K::Action::Puppetfile::Install do
     end
 
     it "purges the moduledir after installation" do
-      expect(puppetfile).to receive(:purge!)
+      mock_cleaner = double("cleaner")
+      allow(puppetfile).to receive(:desired_contents).and_return(["root/foo"])
+      allow(puppetfile).to receive(:managed_directories).and_return(["root"])
+      allow(puppetfile).to receive(:purge_exclusions).and_return(["root/**/**.rb"])
+
+      expect(R10K::Util::Cleaner).to receive(:new).
+        with(["root"], ["root/foo"], ["root/**/**.rb"]).
+        and_return(mock_cleaner)
+      expect(mock_cleaner).to receive(:purge!)
 
       installer.call
     end
@@ -58,13 +71,19 @@ describe R10K::Action::Puppetfile::Install do
 
   describe "using custom paths" do
     it "can use a custom puppetfile path" do
-      expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, "/some/other/path/Puppetfile", nil, nil).and_return(puppetfile)
+      expect(R10K::Puppetfile).to receive(:new).
+        with("/some/nonexistent/path",
+             {:moduledir => nil, :force => false, puppetfile_path: "/some/other/path/Puppetfile"}).
+        and_return(puppetfile)
 
       installer({puppetfile: "/some/other/path/Puppetfile"}).call
     end
 
     it "can use a custom moduledir path" do
-      expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", "/some/other/path/site-modules", nil, nil, nil).and_return(puppetfile)
+      expect(R10K::Puppetfile).to receive(:new).
+        with("/some/nonexistent/path",
+             {:puppetfile_path => nil, :force => false, moduledir: "/some/other/path/site-modules"}).
+        and_return(puppetfile)
 
       installer({moduledir: "/some/other/path/site-modules"}).call
     end
@@ -76,8 +95,10 @@ describe R10K::Action::Puppetfile::Install do
     end
 
     it "can use the force overwrite option" do
-      subject = described_class.new({root: "/some/nonexistent/path", force: true}, [])
-      expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, nil, nil, true).and_return(puppetfile)
+      subject = described_class.new({root: "/some/nonexistent/path", force: true}, [], {})
+      expect(R10K::Puppetfile).to receive(:new).
+        with("/some/nonexistent/path", {:moduledir => nil, :puppetfile_path => nil, :force => true}).
+        and_return(puppetfile)
       subject.call
     end
 

data/spec/unit/action/puppetfile/purge_spec.rb

@@ -3,7 +3,13 @@ require 'r10k/action/puppetfile/purge'
 
 describe R10K::Action::Puppetfile::Purge do
   let(:default_opts) { {root: "/some/nonexistent/path"} }
-  let(:puppetfile) { instance_double('R10K::Puppetfile', :load! => nil) }
+  let(:puppetfile) do
+    instance_double('R10K::Puppetfile',
+                    :load!               => nil,
+                    :managed_directories => %w{foo},
+                    :desired_contents    => %w{bar},
+                    :purge_exclusions    => %w{baz})
+  end
 
   def purger(opts = {}, argv = [], settings = {})
     opts = default_opts.merge(opts)
@@ -11,13 +17,21 @@ describe R10K::Action::Puppetfile::Purge do
   end
 
   before(:each) do
-    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, nil).and_return(puppetfile)
+    allow(R10K::Puppetfile).to receive(:new).
+      with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: nil}).
+      and_return(puppetfile)
   end
 
   it_behaves_like "a puppetfile action"
 
   it "purges unmanaged entries in the Puppetfile moduledir" do
-    expect(puppetfile).to receive(:purge!)
+    mock_cleaner = double("cleaner")
+
+    expect(R10K::Util::Cleaner).to receive(:new).
+      with(["foo"], ["bar"], ["baz"]).
+      and_return(mock_cleaner)
+
+    expect(mock_cleaner).to receive(:purge!)
 
     purger.call
   end
@@ -28,13 +42,19 @@ describe R10K::Action::Puppetfile::Purge do
     end
 
     it "can use a custom puppetfile path" do
-      expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, "/some/other/path/Puppetfile").and_return(puppetfile)
+      expect(R10K::Puppetfile).to receive(:new).
+        with("/some/nonexistent/path",
+             {moduledir: nil, puppetfile_path: "/some/other/path/Puppetfile"}).
+        and_return(puppetfile)
 
       purger({puppetfile: "/some/other/path/Puppetfile"}).call
     end
 
     it "can use a custom moduledir path" do
-      expect(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", "/some/other/path/site-modules", nil).and_return(puppetfile)
+      expect(R10K::Puppetfile).to receive(:new).
+        with("/some/nonexistent/path",
+             {moduledir: "/some/other/path/site-modules", puppetfile_path: nil}).
+        and_return(puppetfile)
 
       purger({moduledir: "/some/other/path/site-modules"}).call
     end

data/spec/unit/action/runner_spec.rb

@@ -10,11 +10,12 @@ describe R10K::Action::Runner do
     Class.new do
       attr_reader :opts
       attr_reader :argv
+      attr_reader :settings
 
       def initialize(opts, argv, settings = {})
         @opts = opts
         @argv = argv
-        @settings = {}
+        @settings = settings
       end
 
       def call
@@ -170,6 +171,52 @@ describe R10K::Action::Runner do
     end
   end
 
+  describe "configuring git credentials" do
+    it 'errors if both token and key paths are passed' do
+      runner = described_class.new({ 'oauth-token': '/nonexistent',
+                                     'private-key': '/also/fake' }, %w[args yes], action_class)
+      expect{ runner.call }.to raise_error(R10K::Error, /Cannot specify both/)
+    end
+
+    it 'saves the sshkey path in settings hash' do
+      runner = described_class.new({ 'private-key': '/my/ssh/key' }, %w[args yes], action_class)
+      runner.call
+      expect(runner.instance.settings[:git][:private_key]).to eq('/my/ssh/key')
+    end
+
+    it 'overrides per-repo sshkey in settings hash' do
+      runner = described_class.new({ config: "spec/fixtures/unit/action/r10k_creds.yaml",
+                                     'private-key': '/my/ssh/key' },
+                                     %w[args yes],
+                                     action_class)
+      runner.call
+      expect(runner.instance.settings[:git][:private_key]).to eq('/my/ssh/key')
+      expect(runner.instance.settings[:git][:repositories].count).to eq(2)
+      runner.instance.settings[:git][:repositories].each do |repo_settings|
+        expect(repo_settings[:private_key]).to eq('/my/ssh/key')
+      end
+    end
+
+    it 'saves the token path in settings hash' do
+      runner = described_class.new({ 'oauth-token': '/my/token/path' }, %w[args yes], action_class)
+      runner.call
+      expect(runner.instance.settings[:git][:oauth_token]).to eq('/my/token/path')
+    end
+
+    it 'overrides per-repo oauth token in settings hash' do
+      runner = described_class.new({ config: "spec/fixtures/unit/action/r10k_creds.yaml",
+                                     'oauth-token': '/my/token' },
+                                     %w[args yes],
+                                     action_class)
+      runner.call
+      expect(runner.instance.settings[:git][:oauth_token]).to eq('/my/token')
+      expect(runner.instance.settings[:git][:repositories].count).to eq(2)
+      runner.instance.settings[:git][:repositories].each do |repo_settings|
+        expect(repo_settings[:oauth_token]).to eq('/my/token')
+      end
+    end
+  end
+
   describe "configuration authorization" do
     context "when license is not present" do
       before(:each) do