r10k 3.8.0 → 3.9.0

data/r10k.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
   s.license  = 'Apache-2.0'
 
   s.add_dependency 'colored2',   '3.1.2'
-  s.add_dependency 'cri', ['>= 2.15.10', '< 3.0.0']
+  s.add_dependency 'cri', '2.15.10'
 
   s.add_dependency 'log4r',     '1.1.10'
   s.add_dependency 'multi_json', '~> 1.10'

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

@@ -8,6 +8,10 @@ describe R10K::Action::Deploy::Display do
       described_class.new({puppetfile: true}, [])
     end
 
+    it "accepts a modules option" do
+      described_class.new({modules: true}, [])
+    end
+
     it "accepts a detail option" do
       described_class.new({detail: true}, [])
     end

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

@@ -19,6 +19,10 @@ describe R10K::Action::Deploy::Environment do
       described_class.new({puppetfile: true}, [])
     end
 
+    it "can accept a modules option" do
+      described_class.new({modules: true}, [])
+    end
+
     it "can accept a default_branch_override option" do
       described_class.new({:'default-branch-override' => 'default_branch_override_name'}, [])
     end
@@ -42,6 +46,17 @@ describe R10K::Action::Deploy::Environment do
     it 'can accept a token option' do
       described_class.new({ 'oauth-token': '/nonexistent' }, [])
     end
+
+    describe "initializing errors" do
+      let (:settings) { { deploy: { purge_levels: [:environment],
+                                    purge_whitelist: ['coolfile', 'coolfile2'],
+                                    purge_allowlist: ['anothercoolfile']}}}
+
+      subject { described_class.new({config: "/some/nonexistent/path"}, [], settings)}
+      it 'errors out when both purge_whitelist and purge_allowlist are set' do
+        expect{subject}.to raise_error(R10K::Error, /Values found for both purge_whitelist and purge_allowlist./)
+    end
+   end
   end
 
   describe "when called" do
@@ -58,6 +73,29 @@ describe R10K::Action::Deploy::Environment do
       )
     end
 
+    describe "with puppetfile or modules flag" do
+      let(:deployment) { R10K::Deployment.new(mock_config) }
+      let(:puppetfile) { instance_double("R10K::Puppetfile", modules: []).as_null_object }
+
+      before do
+        expect(R10K::Deployment).to receive(:new).and_return(deployment)
+        expect(R10K::Puppetfile).to receive(:new).and_return(puppetfile).at_least(:once)
+      end
+
+      it "syncs the puppetfile when given the puppetfile flag" do
+        expect(puppetfile).to receive(:accept).and_return([])
+        action = described_class.new({config: "/some/nonexistent/path", puppetfile: true}, [])
+        action.call
+      end
+
+      it "syncs the puppetfile when given the modules flag" do
+        expect(puppetfile).to receive(:accept).and_return([])
+        action = described_class.new({config: "/some/nonexistent/path", modules: true}, [])
+        action.call
+      end
+
+    end
+
     describe "with an environment that doesn't exist" do
       let(:deployment) do
         R10K::Deployment.new(mock_config)
@@ -77,7 +115,7 @@ describe R10K::Action::Deploy::Environment do
     end
 
     describe "with no-force" do
-      subject { described_class.new({ config: "/some/nonexistent/path", puppetfile: true, :'no-force' => true}, %w[first]) }
+      subject { described_class.new({ config: "/some/nonexistent/path", modules: true, :'no-force' => true}, %w[first]) }
 
       it "tries to preserve local modifications" do
         expect(subject.force).to equal(false)
@@ -175,6 +213,37 @@ describe R10K::Action::Deploy::Environment do
 
     end
 
+    describe "Purging white/allowlist" do
+
+      let(:settings) { { deploy: { purge_levels: [:environment], purge_allowlist: ['coolfile', 'coolfile2'] } } }
+
+      let(:deployment) do
+        R10K::Deployment.new(mock_config.merge(settings))
+      end
+
+      before do
+        expect(R10K::Deployment).to receive(:new).and_return(deployment)
+      end
+
+      subject { described_class.new({ config: "/some/nonexistent/path", modules: true }, %w[PREFIX_first], settings) }
+
+      it "reads in the purge_allowlist setting and purges accordingly" do
+        expect(subject.logger).to receive(:debug).with(/purging unmanaged content for environment/i)
+        expect(subject.instance_variable_get(:@user_purge_allowlist)).to eq(['coolfile', 'coolfile2'])
+        subject.call
+      end
+
+      describe "purge_whitelist" do
+        let (:settings) { { deploy: { purge_levels: [:environment], purge_whitelist: ['coolfile', 'coolfile2'] } } }
+
+        it "reads in the purge_whitelist setting and still sets it to purge_allowlist and purges accordingly" do
+          expect(subject.logger).to receive(:debug).with(/purging unmanaged content for environment/i)
+          expect(subject.instance_variable_get(:@user_purge_allowlist)).to eq(['coolfile', 'coolfile2'])
+          subject.call
+        end
+      end
+    end
+
     describe "purge_levels" do
       let(:settings) { { deploy: { purge_levels: purge_levels } } }
 
@@ -186,7 +255,7 @@ describe R10K::Action::Deploy::Environment do
         expect(R10K::Deployment).to receive(:new).and_return(deployment)
       end
 
-      subject { described_class.new({ config: "/some/nonexistent/path", puppetfile: true }, %w[PREFIX_first], settings) }
+      subject { described_class.new({ config: "/some/nonexistent/path", modules: true }, %w[PREFIX_first], settings) }
 
       describe "deployment purge level" do
         let(:purge_levels) { [:deployment] }
@@ -262,7 +331,7 @@ describe R10K::Action::Deploy::Environment do
           described_class.new(
             {
               config: '/some/nonexistent/path',
-              puppetfile: true,
+              modules: true,
               'generate-types': true
             },
             %w[first second]
@@ -316,7 +385,7 @@ describe R10K::Action::Deploy::Environment do
           described_class.new(
             {
               config: '/some/nonexistent/path',
-              puppetfile: true,
+              modules: true,
               'generate-types': false
             },
             %w[first]
@@ -390,9 +459,25 @@ describe R10K::Action::Deploy::Environment do
 
     let(:mock_stateful_repo_1) { instance_double("R10K::Git::StatefulRepository", :head => "123456") }
     let(:mock_stateful_repo_2) { instance_double("R10K::Git::StatefulRepository", :head => "654321") }
-    let(:mock_git_module_1) { instance_double("R10K::Module::Git", :name => "my_cool_module", :version => "1.0", :repo => mock_stateful_repo_1) }
-    let(:mock_git_module_2) { instance_double("R10K::Module::Git", :name => "my_lame_module", :version => "0.0.1", :repo => mock_stateful_repo_2) }
-    let(:mock_forge_module_1) { double(:name => "their_shiny_module", :version => "2.0.0") }
+    let(:mock_git_module_1) do
+      instance_double("R10K::Module::Git",
+                      :name       => "my_cool_module",
+                      :properties => {
+                        :type     => :git,
+                        :expected => "1.0",
+                        :actual   => mock_stateful_repo_1.head
+                      })
+    end
+    let(:mock_git_module_2) do
+      instance_double("R10K::Module::Git",
+                      :name       => "my_uncool_module",
+                      :properties => {
+                        :type     => :git,
+                        :expected => "0.0.1",
+                        :actual   => mock_stateful_repo_2.head
+                      })
+    end
+    let(:mock_forge_module_1) { double(:name => "their_shiny_module", :properties => { :expected => "2.0.0" }) }
     let(:mock_puppetfile) { instance_double("R10K::Puppetfile", :modules => [mock_git_module_1, mock_git_module_2, mock_forge_module_1]) }
 
     before(:all) do
@@ -405,9 +490,8 @@ describe R10K::Action::Deploy::Environment do
       Dir.delete(@tmp_path)
     end
 
-    it "writes the .r10k-deploy file correctly" do
+    it "writes the .r10k-deploy file correctly if all goes well" do
       allow(R10K::Puppetfile).to receive(:new).and_return(mock_puppetfile)
-      allow(mock_forge_module_1).to receive(:repo).and_raise(NoMethodError)
 
       fake_env = Fake_Environment.new(@tmp_path, {:name => "my_cool_environment", :signature => "pablo picasso"})
       allow(fake_env).to receive(:modules).and_return(mock_puppetfile.modules)
@@ -424,13 +508,30 @@ describe R10K::Action::Deploy::Environment do
       expect(r10k_deploy['module_deploys'][0]['name']).to eq("my_cool_module")
       expect(r10k_deploy['module_deploys'][0]['version']).to eq("1.0")
       expect(r10k_deploy['module_deploys'][0]['sha']).to eq("123456")
-      expect(r10k_deploy['module_deploys'][1]['name']).to eq("my_lame_module")
+      expect(r10k_deploy['module_deploys'][1]['name']).to eq("my_uncool_module")
       expect(r10k_deploy['module_deploys'][1]['version']).to eq("0.0.1")
       expect(r10k_deploy['module_deploys'][1]['sha']).to eq("654321")
       expect(r10k_deploy['module_deploys'][2]['name']).to eq("their_shiny_module")
       expect(r10k_deploy['module_deploys'][2]['version']).to eq("2.0.0")
       expect(r10k_deploy['module_deploys'][2]['sha']).to eq(nil)
+    end
 
+    it "writes the .r10k-deploy file correctly if there's a failure" do
+      allow(R10K::Puppetfile).to receive(:new).and_return(mock_puppetfile)
+
+      fake_env = Fake_Environment.new(@tmp_path, {:name => "my_cool_environment", :signature => "pablo picasso"})
+      allow(fake_env).to receive(:modules).and_return(mock_puppetfile.modules)
+      allow(mock_forge_module_1).to receive(:properties).and_raise(StandardError)
+      subject.send(:write_environment_info!, fake_env, "2019-01-01 23:23:22 +0000", true)
+
+      file_contents = File.read("#{@tmp_path}/.r10k-deploy.json")
+      r10k_deploy = JSON.parse(file_contents)
+
+      expect(r10k_deploy['name']).to eq("my_cool_environment")
+      expect(r10k_deploy['signature']).to eq("pablo picasso")
+      expect(r10k_deploy['started_at']).to eq("2019-01-01 23:23:22 +0000")
+      expect(r10k_deploy['deploy_success']).to eq(true)
+      expect(r10k_deploy['module_deploys'].length).to eq(0)
     end
   end
 end

data/spec/unit/environment/git_spec.rb

@@ -15,6 +15,22 @@ describe R10K::Environment::Git do
     )
   end
 
+  describe "initializing" do
+    subject do
+      described_class.new('name', '/dir', 'ref', {
+        :remote          => 'url',
+        :ref             => 'value',
+        :puppetfile_name => 'Puppetfile',
+        :moduledir       => 'modules',
+        :modules         => { },
+      })
+    end
+
+    it "accepts valid base class initialization arguments" do
+      expect(subject.name).to eq 'name'
+    end
+  end
+
   describe "storing attributes" do
     it "can return the environment name" do
       expect(subject.name).to eq 'myenv'

data/spec/unit/environment/name_spec.rb

@@ -2,6 +2,34 @@ require 'spec_helper'
 require 'r10k/environment/name'
 
 describe R10K::Environment::Name do
+  describe "strip_component" do
+    it "does not modify the given name when no strip_component is given" do
+      bn = described_class.new('myenv', source: 'source', prefix: false)
+      expect(bn.dirname).to eq 'myenv'
+    end
+
+    it "removes the first occurance of a regex match when a regex is given" do
+      bn = described_class.new('myenv', source: 'source', prefix: false, strip_component: '/env/')
+      expect(bn.dirname).to eq 'my'
+    end
+
+    it "does not modify the given name when there is no regex match" do
+      bn = described_class.new('myenv', source: 'source', prefix: false, strip_component: '/bar/')
+      expect(bn.dirname).to eq 'myenv'
+    end
+
+    it "removes the given name's prefix when it matches strip_component" do
+      bn = described_class.new('env/prod', source: 'source', prefix: false, strip_component: 'env/')
+      expect(bn.dirname).to eq 'prod'
+    end
+
+    it "raises an error when given an integer" do
+      expect {
+        described_class.new('env/prod', source: 'source', prefix: false, strip_component: 4)
+      }.to raise_error(%r{Improper.*"4"})
+    end
+  end
+
   describe "prefixing" do
     it "uses the branch name as the dirname when prefixing is off" do
       bn = described_class.new('mybranch', :source => 'source', :prefix => false)

data/spec/unit/environment/svn_spec.rb

@@ -16,6 +16,18 @@ describe R10K::Environment::SVN do
 
   let(:working_dir) { subject.working_dir }
 
+  describe "initializing" do
+    subject do
+      described_class.new('name', '/dir', 'ref', {
+        :puppetfile_name => 'Puppetfile',
+      })
+    end
+
+    it "accepts valid base class initialization arguments" do
+      expect(subject.name).to eq 'name'
+    end
+  end
+
   describe "storing attributes" do
     it "can return the environment name" do
       expect(subject.name).to eq 'myenv'

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

@@ -143,6 +143,16 @@ describe R10K::Git::Rugged::Credentials, :unless => R10K::Util::Platform.jruby?
       expect(creds.instance_variable_get(:@password)).to eq("my_token")
       expect(creds.instance_variable_get(:@username)).to eq("x-oauth-token")
     end
+
+    it 'only reads the token in once' do
+      expect($stdin).to receive(:read).and_return("my_token").once
+      R10K::Git.settings[:oauth_token] = '-'
+      R10K::Git.settings[:repositories] = [{remote: "https://tessier-ashpool.freeside/repo.git"}]
+      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
+      expect(creds.instance_variable_get(:@password)).to eq("my_token")
+      creds = subject.get_plaintext_credentials("https://tessier-ashpool.freeside/repo.git", nil)
+      expect(creds.instance_variable_get(:@password)).to eq("my_token")
+    end
   end
 
   describe "generating default credentials" do

data/spec/unit/module/forge_spec.rb

@@ -23,6 +23,12 @@ describe R10K::Module::Forge do
     end
   end
 
+  describe "implementing the standard options interface" do
+    it "should implement {type: forge}" do
+      expect(described_class).to be_implement('branan-eight_hundred', {type: 'forge', version: '8.0.0', source: 'not implemented'})
+    end
+  end
+
   describe "setting attributes" do
     subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
 

data/spec/unit/module/git_spec.rb

@@ -123,7 +123,7 @@ describe R10K::Module::Git do
       let(:opts) { { unrecognized: true } }
 
       it "raises an error" do
-        expect { test_module(opts) }.to raise_error(ArgumentError, /unhandled options.*unrecognized/i)
+        expect { test_module(opts) }.to raise_error(ArgumentError, /cannot handle option 'unrecognized'/)
       end
     end
 

data/spec/unit/module_spec.rb

@@ -3,20 +3,70 @@ require 'r10k/module'
 
 describe R10K::Module do
   describe 'delegating to R10K::Module::Git' do
-    it "accepts args {:git => 'git url}" do
-      obj = R10K::Module.new('foo', '/modulepath', :git => 'git url')
-      expect(obj).to be_a_kind_of(R10K::Module::Git)
+    [ {git: 'git url'},
+      {type: 'git', source: 'git url'},
+    ].each do |scenario|
+      it "accepts a name matching 'test' and args #{scenario.inspect}" do
+        obj = R10K::Module.new('test', '/modulepath', scenario)
+        expect(obj).to be_a_kind_of(R10K::Module::Git)
+        expect(obj.send(:instance_variable_get, :'@remote')).to eq('git url')
+      end
+    end
+  end
+
+  describe 'delegating to R10K::Module::Svn' do
+    [ {svn: 'svn url'},
+      {type: 'svn', source: 'svn url'},
+    ].each do |scenario|
+      it "accepts a name matching 'test' and args #{scenario.inspect}" do
+        obj = R10K::Module.new('test', '/modulepath', scenario)
+        expect(obj).to be_a_kind_of(R10K::Module::SVN)
+        expect(obj.send(:instance_variable_get, :'@url')).to eq('svn url')
+      end
     end
   end
 
   describe 'delegating to R10K::Module::Forge' do
-    [
-      ['bar/quux', nil],
-      ['bar-quux', nil],
-      ['bar/quux', '8.0.0'],
+    [ 'bar/quux',
+      'bar-quux',
     ].each do |scenario|
-      it "accepts a name matching #{scenario[0]} and args #{scenario[1].inspect}" do
-        expect(R10K::Module.new(scenario[0], '/modulepath', scenario[1])).to be_a_kind_of(R10K::Module::Forge)
+      it "accepts a name matching #{scenario} and args nil" do
+        obj = R10K::Module.new(scenario, '/modulepath', nil)
+        expect(obj).to be_a_kind_of(R10K::Module::Forge)
+      end
+    end
+    [ '8.0.0',
+      {type: 'forge', version: '8.0.0'},
+    ].each do |scenario|
+      it "accepts a name matching bar-quux and args #{scenario.inspect}" do
+        obj = R10K::Module.new('bar-quux', '/modulepath', scenario)
+        expect(obj).to be_a_kind_of(R10K::Module::Forge)
+        expect(obj.send(:instance_variable_get, :'@expected_version')).to eq('8.0.0')
+      end
+    end
+
+    describe 'when the module is ostensibly on disk' do
+      before do
+        owner = 'theowner'
+        module_name = 'themodulename'
+        @title = "#{owner}-#{module_name}"
+        metadata = <<~METADATA
+          {
+            "name": "#{@title}",
+            "version": "1.2.0"
+          }
+        METADATA
+        @dirname = Dir.mktmpdir
+        module_path = File.join(@dirname, module_name)
+        FileUtils.mkdir(module_path)
+        File.open("#{module_path}/metadata.json", 'w') do |file|
+           file.write(metadata)
+        end
+      end
+
+      it 'sets the expected version to what is found in the metadata' do
+        obj = R10K::Module.new(@title, @dirname, nil)
+        expect(obj.send(:instance_variable_get, :'@expected_version')).to eq('1.2.0')
       end
     end
   end

data/spec/unit/util/setopts_spec.rb

@@ -10,7 +10,10 @@ describe R10K::Util::Setopts do
 
       def initialize(opts = {})
         setopts(opts, {
-          :valid => :self, :alsovalid => :self, :truthyvalid => true,
+          :valid => :self,
+          :duplicate => :valid,
+          :alsovalid => :self,
+          :truthyvalid => true,
           :validalias => :valid,
           :ignoreme => nil
         })
@@ -53,7 +56,28 @@ describe R10K::Util::Setopts do
     }.to raise_error(ArgumentError, /cannot handle option 'notvalid'/)
   end
 
+  it "warns when given an unhandled option and raise_on_unhandled=false" do
+    test = Class.new { include R10K::Util::Setopts }.new
+    allow(test).to receive(:logger).and_return(spy)
+
+    test.send(:setopts, {valid: :value, invalid: :value},
+                        {valid: :self},
+                        raise_on_unhandled: false)
+
+    expect(test.logger).to have_received(:warn).with(%r{cannot handle option 'invalid'})
+  end
+
   it "ignores values that are marked as unhandled" do
     klass.new(:ignoreme => "IGNORE ME!")
   end
+
+  it "warns when given conflicting options" do
+    test = Class.new { include R10K::Util::Setopts }.new
+    allow(test).to receive(:logger).and_return(spy)
+
+    test.send(:setopts, {valid: :one, duplicate: :two},
+                        {valid: :arg, duplicate: :arg})
+
+    expect(test.logger).to have_received(:warn).with(%r{valid.*duplicate.*conflict.*not both})
+  end
 end