r10k 3.5.2

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

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+require 'r10k/action/deploy/module'
+
+describe R10K::Action::Deploy::Module do
+
+  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"}, [])
+    end
+
+    it "can accept a no-force option" do
+      described_class.new({:'no-force' => true}, [])
+    end
+
+    it 'can accept a generate-types option' do
+      described_class.new({ 'generate-types': true }, [])
+    end
+
+    it 'can accept a puppet-path option' do
+      described_class.new({ 'puppet-path': '/nonexistent' }, [])
+    end
+
+    it 'can accept a cachedir option' do
+      described_class.new({ cachedir: '/nonexistent' }, [])
+    end
+  end
+
+  describe "with no-force" do
+
+    subject { described_class.new({ config: "/some/nonexistent/path", :'no-force' => true}, [] )}
+
+    it "tries to preserve local modifications" do
+      expect(subject.force).to equal(false)
+    end
+  end
+
+  describe 'generate-types' do
+    let(:deployment) do
+      R10K::Deployment.new(
+        sources: {
+          control: {
+            type: :mock,
+            basedir: '/some/nonexistent/path/control',
+            environments: %w[first second]
+          }
+        }
+      )
+    end
+
+    before do
+      allow(R10K::Deployment).to receive(:new).and_return(deployment)
+    end
+
+    context 'with generate-types enabled' do
+      subject do
+        described_class.new(
+          {
+            config: '/some/nonexistent/path',
+            'generate-types': true
+          },
+          %w[first]
+        )
+      end
+
+      before do
+        allow(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+          expect(environment.puppetfile).to receive(:modules).and_return(
+            [R10K::Module::Local.new(environment.name, '/fakedir', [], environment)]
+          )
+          original.call(environment, &block)
+        end
+      end
+
+      it 'generate_types is true' do
+        expect(subject.instance_variable_get(:@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
+      end
+    end
+
+    context 'with generate-types disabled' do
+      subject do
+        described_class.new(
+          {
+            config: '/some/nonexistent/path',
+            'generate-types': false
+          },
+          %w[first]
+        )
+      end
+
+      it 'generate_types is false' do
+        expect(subject.instance_variable_get(:@generate_types)).to eq(false)
+      end
+
+      it 'does not call puppet generate types' do |it|
+        expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+          expect(environment).not_to receive(:generate_types!)
+          original.call(environment, &block)
+        end.twice
+        subject.call
+      end
+    end
+  end
+
+  describe 'with puppet-path' do
+
+    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 cachedir' do
+
+    subject { described_class.new({ config: '/some/nonexistent/path', cachedir: '/nonexistent' }, []) }
+
+    it 'sets puppet_path' do
+      expect(subject.instance_variable_get(:@cachedir)).to eq('/nonexistent')
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+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) }
+
+  def checker(opts = {}, argv = [], settings = {})
+    opts = default_opts.merge(opts)
+    return described_class.new(opts, argv, settings)
+  end
+
+  before(:each) do
+    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, nil).and_return(puppetfile)
+  end
+
+  it_behaves_like "a puppetfile action"
+
+  it "prints 'Syntax OK' when the Puppetfile syntax could be validated" do
+    expect($stderr).to receive(:puts).with("Syntax OK")
+
+    checker.call
+  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")
+
+    expect($stderr).to receive(:puts).with("Formatted error message")
+
+    checker.call
+  end
+
+  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)
+
+    checker({puppetfile: "/custom/puppetfile/path"}).call
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'r10k/action/puppetfile/cri_runner'
+
+describe R10K::Action::Puppetfile::CriRunner do
+
+  let(:action_class) do
+    Class.new do
+      attr_reader :opts
+      attr_reader :argv
+
+      def initialize(opts, argv)
+        @opts = opts
+        @argv = argv
+      end
+
+      def call
+        @opts[:runok]
+      end
+    end
+  end
+
+  subject(:cri_runner) { described_class.wrap(action_class)  }
+
+  let(:opts) { {:value => :yep} }
+  let(:argv) { %w[value yes] }
+
+  describe "handling options" do
+    it "sets the root to the current wd" do
+      expect(cri_runner).to receive(:wd).and_return('/some/nonexistent')
+      expect(cri_runner.handle_opts({})).to include(:root => '/some/nonexistent')
+    end
+
+    describe "for the moduledir" do
+      it "sets the option from the cli option if given" do
+        opts = {:moduledir => '/some/other/nonexistent/modules'}
+        expect(cri_runner.handle_opts(opts)).to include(:moduledir => '/some/other/nonexistent/modules')
+      end
+    end
+
+    describe "for the puppetfile path" do
+      it "sets the option from the cli option if given" do
+        opts = {:puppetfile => '/some/other/nonexistent/modules'}
+        expect(cri_runner.handle_opts(opts)).to include(:puppetfile => '/some/other/nonexistent/modules')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+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) }
+
+  def installer(opts = {}, argv = [], settings = {})
+    opts = default_opts.merge(opts)
+    return described_class.new(opts, argv, settings)
+  end
+
+  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)
+  end
+
+  it_behaves_like "a puppetfile install action"
+
+  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)
+      end
+    end
+
+    before do
+      allow(puppetfile).to receive(:purge!)
+      allow(puppetfile).to receive(:modules).and_return(modules)
+    end
+
+    it "syncs each module in the Puppetfile" do
+      modules.each { |m| expect(m).to receive(:sync) }
+
+      expect(installer.call).to eq true
+    end
+
+    it "returns false if a module failed to install" do
+      modules[0..2].each { |m| expect(m).to receive(:sync) }
+      expect(modules[3]).to receive(:sync).and_raise
+
+      expect(installer.call).to eq false
+    end
+  end
+
+  describe "purging" do
+    before do
+      allow(puppetfile).to receive(:modules).and_return([])
+    end
+
+    it "purges the moduledir after installation" do
+      expect(puppetfile).to receive(:purge!)
+
+      installer.call
+    end
+  end
+
+  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)
+
+      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)
+
+      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
+      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.call
+    end
+
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'spec_helper'
+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) }
+
+  def purger(opts = {}, argv = [], settings = {})
+    opts = default_opts.merge(opts)
+    return described_class.new(opts, argv, settings)
+  end
+
+  before(:each) do
+    allow(R10K::Puppetfile).to receive(:new).with("/some/nonexistent/path", nil, 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!)
+
+    purger.call
+  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", nil, "/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)
+
+      purger({moduledir: "/some/other/path/site-modules"}).call
+    end
+  end
+end

data/spec/unit/action/runner_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+require 'r10k/action/base'
+require 'puppet_forge/connection'
+
+require 'r10k/action/runner'
+
+describe R10K::Action::Runner do
+
+  let(:action_class) do
+    Class.new do
+      attr_reader :opts
+      attr_reader :argv
+
+      def initialize(opts, argv, settings = {})
+        @opts = opts
+        @argv = argv
+        @settings = {}
+      end
+
+      def call
+        @argv.map(&:upcase)
+      end
+    end
+  end
+
+  subject(:runner) { described_class.new({:opts => :yep}, %w[args yes], action_class) }
+
+  before(:each) do
+    expect(runner.logger).not_to receive(:error)
+  end
+
+  describe "instantiating the wrapped class" do
+    it "creates an instance of the class" do
+      expect(runner.instance).to be_a_kind_of action_class
+    end
+
+    it "passes the opts and argv to the instance" do
+      expect(runner.instance.opts).to eq(:opts => :yep)
+      expect(runner.instance.argv).to eq(%w[args yes])
+    end
+
+    it "strips out options that the runner handles" do
+      runner = described_class.new({:opts => :yep, :loglevel => 'FATAL'}, %w[args yes], action_class)
+      expect(runner.instance.opts).to eq(:opts => :yep)
+    end
+  end
+
+  describe "calling" do
+    it "configures logging" do
+      expect(runner).to receive(:setup_logging)
+      runner.call
+    end
+
+    it "configures settings" do
+      expect(runner).to receive(:setup_settings)
+      runner.call
+    end
+
+    it "configures forge authorization" do
+      expect(runner).to receive(:setup_authorization)
+      runner.call
+    end
+
+    it "returns the result of the wrapped class #call method" do
+      expect(runner.call).to eq %w[ARGS YES]
+    end
+  end
+
+  describe "configuring settings" do
+    subject(:runner) { described_class.new(options, %w[args yes], action_class) }
+
+    let(:global_settings) { R10K::Settings.global_settings }
+
+    before(:each) do
+      expect(R10K::Settings).to receive(:global_settings).and_return(global_settings)
+      allow(File).to receive(:executable?).and_return(true)
+    end
+
+    opts = {
+      cachedir:       nil,
+      puppet_path:    :deploy,
+      generate_types: :deploy,
+    }
+
+    opts.each do |opt, conf_path|
+      context "with #{opt} config setting" do
+        let(:options) { { config: "spec/fixtures/unit/action/r10k_#{opt}.yaml" } }
+
+        context "when not overridden" do
+          it "uses the config value" do
+            override = { "#{opt}": "/config_#{opt}" }
+            overrides = if conf_path.nil?
+                          override
+                        else
+                          { "#{conf_path}": override }
+                        end
+            expect(global_settings).to receive(:evaluate).with(hash_including(overrides)).and_call_original
+            runner.call
+          end
+        end
+
+        context "when overridden" do
+          let(:options) { super().merge("#{opt.to_s.sub('_','-')}": "/overridden_#{opt}") }
+
+          it "uses the overridden value" do
+            override = { "#{opt}": "/overridden_#{opt}" }
+            overrides = if conf_path.nil?
+                          override
+                        else
+                          { "#{conf_path}": override }
+                        end
+            expect(global_settings).to receive(:evaluate).with(hash_including(overrides)).and_call_original
+            runner.call
+          end
+        end
+      end
+
+      context "with complete config" do
+        let(:options) { { config: "spec/fixtures/unit/action/r10k.yaml" } }
+        let(:config) do
+          config = {}
+          opts.each do |o, path|
+            if path.nil?
+              config[o] = "/config_#{o}"
+            else
+              config[path] ||= {}
+              config[path][o] = "/config_#{o}"
+            end
+          end
+          config
+        end
+
+        context "when not overridden" do
+          it "uses the config value" do
+            expect(global_settings).to receive(:evaluate).with(config).and_call_original
+            runner.call
+          end
+        end
+
+        context "when overridden" do
+          let(:options) {
+            super().merge("#{opt.to_s.sub('_','-')}": "/overridden_#{opt}")
+          }
+
+          it "uses the overridden value" do
+            with_overrides = config
+            if conf_path.nil?
+              with_overrides[opt] = "/overridden_#{opt}"
+            else
+              with_overrides[conf_path][opt] = "/overridden_#{opt}"
+            end
+            expect(global_settings).to receive(:evaluate).with(with_overrides).and_call_original
+            runner.call
+          end
+        end
+      end
+    end
+  end
+
+  describe "configuring logging" do
+    it "sets the log level if :loglevel is provided" do
+      runner = described_class.new({:opts => :yep, :loglevel => 'FATAL'}, %w[args yes], action_class)
+      expect(R10K::Logging).to receive(:level=).with('FATAL')
+      runner.call
+    end
+
+    it "does not modify the loglevel if :loglevel is not provided" do
+      expect(R10K::Logging).to_not receive(:level=)
+      runner.call
+    end
+  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=)
+        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
+
+      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 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