r10k 3.9.2 → 3.12.0

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

@@ -3,7 +3,7 @@ require 'r10k/action/puppetfile/check'
 
 describe R10K::Action::Puppetfile::Check do
   let(:default_opts) { {root: "/some/nonexistent/path"} }
-  let(:puppetfile) { instance_double('R10K::Puppetfile', :load! => true) }
+  let(:loader) { instance_double('R10K::ModuleLoader::Puppetfile', :load! => {}) }
 
   def checker(opts = {}, argv = [], settings = {})
     opts = default_opts.merge(opts)
@@ -11,7 +11,11 @@ describe R10K::Action::Puppetfile::Check do
   end
 
   before(:each) do
-    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: nil}).and_return(puppetfile)
+    allow(R10K::ModuleLoader::Puppetfile).
+      to receive(:new).
+      with({
+        basedir: "/some/nonexistent/path",
+      }).and_return(loader)
   end
 
   it_behaves_like "a puppetfile action"
@@ -23,8 +27,11 @@ describe R10K::Action::Puppetfile::Check do
   end
 
   it "prints an error message when validating the Puppetfile syntax raised an error" do
-    allow(puppetfile).to receive(:load!).and_raise(R10K::Error.new("Boom!"))
-    allow(R10K::Errors::Formatting).to receive(:format_exception).with(instance_of(R10K::Error), anything).and_return("Formatted error message")
+    allow(loader).to receive(:load!).and_raise(R10K::Error.new("Boom!"))
+    allow(R10K::Errors::Formatting).
+      to receive(:format_exception).
+      with(instance_of(R10K::Error), anything).
+      and_return("Formatted error message")
 
     expect($stderr).to receive(:puts).with("Formatted error message")
 
@@ -34,7 +41,12 @@ 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", {moduledir: nil, puppetfile_path: "/custom/puppetfile/path"}).and_return(puppetfile)
+    expect(R10K::ModuleLoader::Puppetfile).
+      to receive(:new).
+      with({
+        basedir: "/some/nonexistent/path",
+        puppetfile: "/custom/puppetfile/path"
+      }).and_return(loader)
 
     checker({puppetfile: "/custom/puppetfile/path"}).call
   end

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

@@ -3,9 +3,10 @@ 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',
-                         {:moduledir => nil, :puppetfile_path => nil, :force => false})
+  let(:loader) {
+    R10K::ModuleLoader::Puppetfile.new({
+      basedir: '/some/nonexistent/path',
+      overrides: {force: false}})
   }
 
   def installer(opts = {}, argv = [], settings = {})
@@ -14,11 +15,11 @@ describe R10K::Action::Puppetfile::Install do
   end
 
   before(:each) do
-    allow(puppetfile).to receive(:load!).and_return(nil)
-    allow(R10K::Puppetfile).to receive(:new).
-      with("/some/nonexistent/path",
-           {:moduledir => nil, :puppetfile_path => nil, :force => false}).
-      and_return(puppetfile)
+    allow(loader).to receive(:load!).and_return({})
+    allow(R10K::ModuleLoader::Puppetfile).to receive(:new).
+      with({basedir: "/some/nonexistent/path",
+            overrides: {force: false}}).
+      and_return(loader)
   end
 
   it_behaves_like "a puppetfile install action"
@@ -26,13 +27,19 @@ 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}", {})
+        R10K::Module::Base.new("author/modname#{idx}",
+                               "/some/nonexistent/path/modname#{idx}",
+                               {})
       end
     end
 
     before do
-      allow(puppetfile).to receive(:modules).and_return(modules)
-      allow(puppetfile).to receive(:modules_by_vcs_cachedir).and_return({none: modules})
+      allow(loader).to receive(:load!).and_return({
+        modules: modules,
+        managed_directories: [],
+        desired_contents: [],
+        purge_exclusions: []
+      })
     end
 
     it "syncs each module in the Puppetfile" do
@@ -50,15 +57,15 @@ describe R10K::Action::Puppetfile::Install do
   end
 
   describe "purging" do
-    before do
-      allow(puppetfile).to receive(:modules).and_return([])
-    end
-
     it "purges the moduledir after installation" do
+      allow(loader).to receive(:load!).and_return({
+        modules:             [],
+        desired_contents:    [ 'root/foo' ],
+        managed_directories: [ 'root' ],
+        purge_exclusions:    [ 'root/**/**.rb' ]
+      })
+
       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"]).
@@ -70,35 +77,34 @@ describe R10K::Action::Puppetfile::Install do
   end
 
   describe "using custom paths" do
-    it "can use a custom puppetfile path" do
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path",
-             {:moduledir => nil, :force => false, puppetfile_path: "/some/other/path/Puppetfile"}).
-        and_return(puppetfile)
+    it "can use a custom moduledir path" do
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              overrides: { force: false },
+              puppetfile: "/some/other/path/Puppetfile"}).
+        and_return(loader)
 
       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",
-             {:puppetfile_path => nil, :force => false, moduledir: "/some/other/path/site-modules"}).
-        and_return(puppetfile)
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              overrides: { force: false },
+              moduledir: "/some/other/path/site-modules"}).
+        and_return(loader)
 
       installer({moduledir: "/some/other/path/site-modules"}).call
     end
   end
 
   describe "forcing to overwrite local changes" do
-    before do
-      allow(puppetfile).to receive(:modules).and_return([])
-    end
-
     it "can use the force overwrite option" do
+      allow(loader).to receive(:load!).and_return({ modules: [] })
+
       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)
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              overrides: { force: true }}).
+        and_return(loader)
       subject.call
     end
 

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

@@ -4,11 +4,13 @@ require 'r10k/action/puppetfile/purge'
 describe R10K::Action::Puppetfile::Purge do
   let(:default_opts) { {root: "/some/nonexistent/path"} }
   let(:puppetfile) do
-    instance_double('R10K::Puppetfile',
-                    :load!               => nil,
-                    :managed_directories => %w{foo},
-                    :desired_contents    => %w{bar},
-                    :purge_exclusions    => %w{baz})
+    instance_double('R10K::ModuleLoader::Puppetfile',
+                    :load! => {
+                      :modules             => %w{mod},
+                      :managed_directories => %w{foo},
+                      :desired_contents    => %w{bar},
+                      :purge_exclusions    => %w{baz}
+                    })
   end
 
   def purger(opts = {}, argv = [], settings = {})
@@ -17,8 +19,8 @@ describe R10K::Action::Puppetfile::Purge do
   end
 
   before(:each) do
-    allow(R10K::Puppetfile).to receive(:new).
-      with("/some/nonexistent/path", {moduledir: nil, puppetfile_path: nil}).
+    allow(R10K::ModuleLoader::Puppetfile).to receive(:new).
+      with({basedir: "/some/nonexistent/path"}).
       and_return(puppetfile)
   end
 
@@ -37,23 +39,19 @@ describe R10K::Action::Puppetfile::Purge do
   end
 
   describe "using custom paths" do
-    before(:each) do
-      allow(puppetfile).to receive(:purge!)
-    end
-
     it "can use a custom puppetfile path" do
-      expect(R10K::Puppetfile).to receive(:new).
-        with("/some/nonexistent/path",
-             {moduledir: nil, puppetfile_path: "/some/other/path/Puppetfile"}).
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              puppetfile: "/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",
-             {moduledir: "/some/other/path/site-modules", puppetfile_path: nil}).
+      expect(R10K::ModuleLoader::Puppetfile).to receive(:new).
+        with({basedir: "/some/nonexistent/path",
+              moduledir: "/some/other/path/site-modules"}).
         and_return(puppetfile)
 
       purger({moduledir: "/some/other/path/site-modules"}).call

data/spec/unit/action/runner_spec.rb

@@ -171,6 +171,86 @@ describe R10K::Action::Runner do
     end
   end
 
+  describe "configuring github app credentials" do
+    it 'errors if app id is passed without ssl key' do
+      runner = described_class.new(
+        { 'github-app-id': '/nonexistent', },
+        %w[args yes],
+        action_class
+      )
+      expect{ runner.call }.to raise_error(R10K::Error, /Must specify both id and SSL private key/)
+    end
+
+    it 'errors if ssl key is passed without app id' do
+      runner = described_class.new(
+        { 'github-app-key': '/nonexistent', },
+        %w[args yes],
+        action_class
+      )
+      expect{ runner.call }.to raise_error(R10K::Error, /Must specify both id and SSL private key/)
+    end
+
+    it 'errors if both app id and token paths are passed' do
+      runner = described_class.new(
+        { 'github-app-id': '/nonexistent', 'oauth-token': '/also/fake' },
+        %w[args yes],
+        action_class
+      )
+      expect{ runner.call }.to raise_error(R10K::Error, /Cannot specify both/)
+    end
+
+    it 'errors if both ssl key and token paths are passed' do
+      runner = described_class.new(
+        { 'github-app-key': '/nonexistent', 'oauth-token': '/also/fake' },
+        %w[args yes],
+        action_class
+      )
+      expect{ runner.call }.to raise_error(R10K::Error, /Cannot specify both/)
+    end
+
+    it 'errors if both ssl key and ssh key paths are passed' do
+      runner = described_class.new(
+        { 'github-app-key': '/nonexistent', 'private-key': '/also/fake' },
+        %w[args yes],
+        action_class
+      )
+      expect{ runner.call }.to raise_error(R10K::Error, /Cannot specify both/)
+    end
+
+    it 'errors if both app id and ssh key are passed' do
+      runner = described_class.new(
+        { 'github-app-id': '/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 parameters in settings hash' do
+      runner = described_class.new(
+        { 'github-app-id': '123456', 'github-app-key': '/my/ssl/key', 'github-app-ttl': '600' },
+        %w[args yes],
+        action_class
+      )
+      runner.call
+      expect(runner.instance.settings[:git][:github_app_id]).to eq('123456')
+      expect(runner.instance.settings[:git][:github_app_key]).to eq('/my/ssl/key')
+      expect(runner.instance.settings[:git][:github_app_ttl]).to eq('600')
+    end
+
+    it 'saves the parameters in settings hash without ttl and uses its default value' do
+      runner = described_class.new(
+        { 'github-app-id': '123456', 'github-app-key': '/my/ssl/key', },
+        %w[args yes],
+        action_class
+      )
+      runner.call
+      expect(runner.instance.settings[:git][:github_app_id]).to eq('123456')
+      expect(runner.instance.settings[:git][:github_app_key]).to eq('/my/ssl/key')
+      expect(runner.instance.settings[:git][:github_app_ttl]).to eq('120')
+    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',
@@ -218,42 +298,58 @@ describe R10K::Action::Runner do
   end
 
   describe "configuration authorization" do
-    context "when license is not present" do
-      before(:each) do
-        expect(R10K::Util::License).to receive(:load).and_return(nil)
-      end
-
-      it "does not set authorization header on connection class" do
-        expect(PuppetForge::Connection).not_to receive(:authorization=)
+    context "settings auth" do
+      it "sets the configured token as the forge authorization header" do
+        options = { config: "spec/fixtures/unit/action/r10k_forge_auth.yaml" }
+        runner = described_class.new(options, %w[args yes], action_class)
+
+        expect(PuppetForge).to receive(:host=).with('http://private-forge.com')
+        expect(PuppetForge::Connection).to receive(:authorization=).with('faketoken')
+        expect(PuppetForge::Connection).to receive(:authorization).and_return('faketoken')
+        expect(R10K::Util::License).not_to receive(:load)
+        runner.setup_settings
         runner.setup_authorization
       end
     end
 
-    context "when license is present but invalid" do
-      before(:each) do
-        expect(R10K::Util::License).to receive(:load).and_raise(R10K::Error.new('invalid license'))
-      end
+    context "license auth" do
+      context "when license is not present" do
+        before(:each) do
+          expect(R10K::Util::License).to receive(:load).and_return(nil)
+        end
 
-      it "issues warning to logger" do
-        expect(runner.logger).to receive(:warn).with(/invalid license/)
-        runner.setup_authorization
+        it "does not set authorization header on connection class" do
+          expect(PuppetForge::Connection).not_to receive(:authorization=)
+          runner.setup_authorization
+        end
       end
 
-      it "does not set authorization header on connection class" do
-        expect(PuppetForge::Connection).not_to receive(:authorization=)
-        runner.setup_authorization
-      end
-    end
+      context "when license is present but invalid" do
+        before(:each) do
+          expect(R10K::Util::License).to receive(:load).and_raise(R10K::Error.new('invalid license'))
+        end
+
+        it "issues warning to logger" do
+          expect(runner.logger).to receive(:warn).with(/invalid license/)
+          runner.setup_authorization
+        end
 
-    context "when license is present and valid" do
-      before(:each) do
-        mock_license = double('pe-license', :authorization_token => 'test token')
-        expect(R10K::Util::License).to receive(:load).and_return(mock_license)
+        it "does not set authorization header on connection class" do
+          expect(PuppetForge::Connection).not_to receive(:authorization=)
+          runner.setup_authorization
+        end
       end
 
-      it "sets authorization header on connection class" do
-        expect(PuppetForge::Connection).to receive(:authorization=).with('test token')
-        runner.setup_authorization
+      context "when license is present and valid" do
+        before(:each) do
+          mock_license = double('pe-license', :authorization_token => 'test token')
+          expect(R10K::Util::License).to receive(:load).and_return(mock_license)
+        end
+
+        it "sets authorization header on connection class" do
+          expect(PuppetForge::Connection).to receive(:authorization=).with('test token')
+          runner.setup_authorization
+        end
       end
     end
   end

data/spec/unit/environment/base_spec.rb

@@ -3,10 +3,13 @@ require 'r10k/environment'
 
 describe R10K::Environment::Base do
 
-  subject(:environment) { described_class.new('envname', '/some/imaginary/path', 'env_name', {}) }
+  let(:basepath) { '/some/imaginary/path' }
+  let(:envname) { 'env_name' }
+  let(:path) { File.join(basepath, envname) }
+  subject(:environment) { described_class.new('envname', basepath, envname, {}) }
 
   it "can return the fully qualified path" do
-    expect(environment.path).to eq(Pathname.new('/some/imaginary/path/env_name'))
+    expect(environment.path).to eq(Pathname.new(path))
   end
 
   it "raises an exception when #sync is called" do
@@ -49,45 +52,55 @@ describe R10K::Environment::Base do
   describe "#purge_exclusions" do
     let(:mock_env) { instance_double("R10K::Environment::Base") }
     let(:mock_puppetfile) { instance_double("R10K::Puppetfile", :environment= => true, :environment => mock_env) }
+    let(:loader) do
+      instance_double("R10K::ModuleLoader::Puppetfile",
+                      :environment= => nil,
+                      :load => { :modules => @modules,
+                                  :managed_directories => @managed_dirs,
+                                  :desired_contents => @desired_contents,
+                                  :purge_exclusions => @purge_ex })
+    end
 
     before(:each) do
-      allow(mock_puppetfile).to receive(:managed_directories).and_return([])
-      allow(mock_puppetfile).to receive(:desired_contents).and_return([])
-      allow(R10K::Puppetfile).to receive(:new).and_return(mock_puppetfile)
+      @modules = []
+      @managed_dirs = []
+      @desired_contents = []
+      @purge_exclusions = []
     end
 
     it "excludes .r10k-deploy.json" do
+      allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+      subject.deploy
+
       expect(subject.purge_exclusions).to include(/r10k-deploy\.json/)
     end
 
     it "excludes puppetfile managed directories" do
-      managed_dirs = [
+      @managed_dirs = [
         '/some/imaginary/path/env_name/modules',
         '/some/imaginary/path/env_name/data',
       ]
 
-      expect(mock_puppetfile).to receive(:managed_directories).and_return(managed_dirs)
+      allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+      subject.deploy
 
       exclusions = subject.purge_exclusions
 
-      managed_dirs.each do |dir|
+      @managed_dirs.each do |dir|
         expect(exclusions).to include(dir)
       end
     end
 
     describe "puppetfile desired contents" do
-      let(:desired_contents) do
-        basedir = subject.path.to_s
-
-        [ 'modules/apache', 'data/local/site' ].collect do |c|
-          File.join(basedir, c)
-        end
-      end
 
       before(:each) do
-        allow(File).to receive(:directory?).with(/^\/some\/imaginary\/path/).and_return(true)
+        @desired_contents = [ 'modules/apache', 'data/local/site' ].collect do |c|
+          File.join(path, c)
+        end
 
-        expect(mock_puppetfile).to receive(:desired_contents).and_return(desired_contents)
+        allow(File).to receive(:directory?).and_return true
+        allow(R10K::ModuleLoader::Puppetfile).to receive(:new).and_return(loader)
+        subject.deploy
       end
 
       it "excludes desired directory contents with glob" do