r10k 3.9.3 → 3.12.1

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

data/spec/unit/environment/git_spec.rb

@@ -78,9 +78,9 @@ describe R10K::Environment::Git do
 
   describe "enumerating modules" do
     it "loads the Puppetfile and returns modules in that puppetfile" do
+      loaded = { desired_contents: [], managed_directories: [], purge_exclusions: [] }
       mod = double('A module', :name => 'dbl')
-      expect(subject.puppetfile).to receive(:load)
-      expect(subject.puppetfile).to receive(:modules).and_return [mod]
+      expect(subject.loader).to receive(:load).and_return(loaded.merge(modules: [mod]))
       expect(subject.modules).to eq([mod])
     end
   end

data/spec/unit/environment/svn_spec.rb

@@ -78,9 +78,10 @@ describe R10K::Environment::SVN do
 
   describe "enumerating modules" do
     it "loads the Puppetfile and returns modules in that puppetfile" do
-      expect(subject.puppetfile).to receive(:load)
-      expect(subject.puppetfile).to receive(:modules).and_return [:modules]
-      expect(subject.modules).to eq([:modules])
+      loaded = { managed_directories: [], desired_contents: [], purge_exclusions: [] }
+      mod = double('A module', :name => 'dbl')
+      expect(subject.loader).to receive(:load).and_return(loaded.merge(modules: [mod]))
+      expect(subject.modules).to eq([mod])
     end
   end
 

data/spec/unit/environment/with_modules_spec.rb

@@ -65,8 +65,9 @@ describe R10K::Environment::WithModules do
 
   describe "modules method" do
     it "returns the configured modules, and Puppetfile modules" do
+      loaded = { managed_directories: [], desired_contents: [], purge_exclusions: [] }
       puppetfile_mod = instance_double('R10K::Module::Base', name: 'zebra')
-      expect(subject.puppetfile).to receive(:modules).and_return [puppetfile_mod]
+      expect(subject.loader).to receive(:load).and_return(loaded.merge(modules: [puppetfile_mod]))
       returned_modules = subject.modules
       expect(returned_modules.map(&:name).sort).to eq(%w[concat exec stdlib zebra])
     end

data/spec/unit/git/cache_spec.rb

@@ -62,4 +62,18 @@ describe R10K::Git::Cache do
       subject.cached?
     end
   end
+
+  describe "dirname sanitization" do
+    it 'sanitizes cache directory name' do
+      expect(subject.sanitized_dirname).to eq('git---some-git-remote')
+    end
+
+    context 'with username and password' do
+      subject { subclass.new('https://"user:pa$$w0rd:@some/git/remote') }
+
+      it 'sanitizes cache directory name' do
+        expect(subject.sanitized_dirname).to eq('https---some-git-remote')
+      end
+    end
+  end
 end

data/spec/unit/git/rugged/credentials_spec.rb

@@ -79,6 +79,35 @@ describe R10K::Git::Rugged::Credentials, :unless => R10K::Util::Platform.jruby?
     end
   end
 
+  describe "generating github app tokens" do
+    it 'errors if app id has invalid characters' do
+      expect { subject.github_app_token("123A567890", "fake", "300")
+      }.to raise_error(R10K::Git::GitError, /App id contains invalid characters/)
+    end
+    it 'errors if app ttl has invalid characters' do
+      expect { subject.github_app_token("123456", "fake", "abc")
+      }.to raise_error(R10K::Git::GitError, /Github App token ttl contains/)
+    end
+    it 'errors if private file does not exist' do
+      R10K::Git.settings[:github_app_key] = "/missing/token/file"
+      expect(File).to receive(:readable?).with(R10K::Git.settings[:github_app_key]).and_return false
+      expect {
+        subject.github_app_token("123456", R10K::Git.settings[:github_app_key], "300")
+      }.to raise_error(R10K::Git::GitError, /App key is missing or unreadable/)
+    end
+    it 'errors if file is not a valid SSL key' do
+      token_file = Tempfile.new('token')
+      token_file.write('my_token')
+      token_file.close
+      R10K::Git.settings[:github_app_key] = token_file.path
+      expect(File).to receive(:readable?).with(token_file.path).and_return true
+      expect {
+        subject.github_app_token("123456", R10K::Git.settings[:github_app_key], "300")
+      }.to raise_error(R10K::Git::GitError, /App key is not a valid SSL key/)
+      token_file.unlink
+    end
+  end
+
   describe "generating token credentials" do
     it 'errors if token file does not exist' do
       R10K::Git.settings[:oauth_token] = "/missing/token/file"

data/spec/unit/git/stateful_repository_spec.rb

@@ -19,6 +19,11 @@ describe R10K::Git::StatefulRepository do
       expect(subject.sync_cache?(ref)).to eq true
     end
 
+    it "is true if the ref is HEAD" do
+      expect(cache).to receive(:exist?).and_return true
+      expect(subject.sync_cache?('HEAD')).to eq true
+    end
+
     it "is true if the ref is unresolvable" do
       expect(cache).to receive(:exist?).and_return true
       expect(cache).to receive(:ref_type).with('0.9.x').and_return(:unknown)