r10k 3.9.2 → 3.12.0

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)

data/spec/unit/module/base_spec.rb

@@ -4,39 +4,85 @@ require 'r10k/module/base'
 describe R10K::Module::Base do
   describe "parsing the title" do
     it "parses titles with no owner" do
-      m = described_class.new('eight_hundred', '/moduledir', [])
+      m = described_class.new('eight_hundred', '/moduledir', {})
       expect(m.name).to eq 'eight_hundred'
       expect(m.owner).to be_nil
     end
 
     it "parses forward slash separated titles" do
-      m = described_class.new('branan/eight_hundred', '/moduledir', [])
+      m = described_class.new('branan/eight_hundred', '/moduledir', {})
       expect(m.name).to eq 'eight_hundred'
       expect(m.owner).to eq 'branan'
     end
 
     it "parses hyphen separated titles" do
-      m = described_class.new('branan-eight_hundred', '/moduledir', [])
+      m = described_class.new('branan-eight_hundred', '/moduledir', {})
       expect(m.name).to eq 'eight_hundred'
       expect(m.owner).to eq 'branan'
     end
 
     it "raises an error when the title is not correctly formatted" do
       expect {
-        described_class.new('branan!eight_hundred', '/moduledir', [])
+        described_class.new('branan!eight_hundred', '/moduledir', {})
       }.to raise_error(ArgumentError, "Module name (branan!eight_hundred) must match either 'modulename' or 'owner/modulename'")
     end
   end
 
+  describe 'deleting the spec dir' do
+    let(:module_org) { "coolorg" }
+    let(:module_name) { "coolmod" }
+    let(:title) { "#{module_org}-#{module_name}" }
+    let(:dirname) { Pathname.new(Dir.mktmpdir) }
+    let(:spec_path) { dirname + module_name + 'spec' }
+
+    before(:each) do
+      logger = double("logger")
+      allow_any_instance_of(described_class).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:debug2).with(any_args)
+      allow(logger).to receive(:info).with(any_args)
+    end
+
+    it 'does not remove the spec directory by default' do
+      FileUtils.mkdir_p(spec_path)
+      m = described_class.new(title, dirname, {})
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(spec_path)).to eq true
+    end
+
+    it 'detects a symlink and deletes the target' do
+      Dir.mkdir(dirname + module_name)
+      target_dir = Dir.mktmpdir
+      FileUtils.ln_s(target_dir, spec_path)
+      m = described_class.new(title, dirname, {exclude_spec: true})
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(target_dir)).to eq false
+    end
+
+    it 'removes the spec directory if exclude_spec is set' do
+      FileUtils.mkdir_p(spec_path)
+      m = described_class.new(title, dirname, {exclude_spec: true})
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(spec_path)).to eq false
+    end
+
+    it 'does not remove the spec directory if spec_deletable is false' do
+      FileUtils.mkdir_p(spec_path)
+      m = described_class.new(title, dirname, {})
+      m.spec_deletable = false
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(spec_path)).to eq true
+    end
+  end
+
   describe "path variables" do
     it "uses the module name as the name" do
-      m = described_class.new('eight_hundred', '/moduledir', [])
+      m = described_class.new('eight_hundred', '/moduledir', {})
       expect(m.dirname).to eq '/moduledir'
       expect(m.path).to eq(Pathname.new('/moduledir/eight_hundred'))
     end
 
     it "does not include the owner in the path" do
-      m = described_class.new('branan/eight_hundred', '/moduledir', [])
+      m = described_class.new('branan/eight_hundred', '/moduledir', {})
       expect(m.dirname).to eq '/moduledir'
       expect(m.path).to eq(Pathname.new('/moduledir/eight_hundred'))
     end
@@ -44,7 +90,7 @@ describe R10K::Module::Base do
 
   describe "with alternate variable names" do
     subject do
-      described_class.new('branan/eight_hundred', '/moduledir', [])
+      described_class.new('branan/eight_hundred', '/moduledir', {})
     end
 
     it "aliases full_name to title" do
@@ -61,7 +107,7 @@ describe R10K::Module::Base do
   end
 
   describe "accepting a visitor" do
-    subject { described_class.new('branan-eight_hundred', '/moduledir', []) }
+    subject { described_class.new('branan-eight_hundred', '/moduledir', {}) }
 
     it "passes itself to the visitor" do
       visitor = spy('visitor')

data/spec/unit/module/forge_spec.rb

@@ -9,6 +9,28 @@ describe R10K::Module::Forge do
   let(:fixture_modulepath) { File.expand_path('spec/fixtures/module/forge', PROJECT_ROOT) }
   let(:empty_modulepath) { File.expand_path('spec/fixtures/empty', PROJECT_ROOT) }
 
+  describe "statically determined version support" do
+    it 'returns explicitly released forge versions' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: '8.0.0' })
+      expect(static_version).to eq('8.0.0')
+    end
+
+    it 'returns explicit pre-released forge versions' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: '8.0.0-pre1' })
+      expect(static_version).to eq('8.0.0-pre1')
+    end
+
+    it 'retuns nil for latest versions' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: :latest })
+      expect(static_version).to eq(nil)
+    end
+
+    it 'retuns nil for undefined versions' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: nil })
+      expect(static_version).to eq(nil)
+    end
+  end
+
   describe "implementing the Puppetfile spec" do
     it "should implement 'branan/eight_hundred', '8.0.0'" do
       expect(described_class).to be_implement('branan/eight_hundred', { version: '8.0.0' })
@@ -78,6 +100,7 @@ describe R10K::Module::Forge do
       allow_any_instance_of(described_class).to receive(:logger).and_return(logger_dbl)
 
       allow(logger_dbl).to receive(:info).with(/Deploying module to.*/)
+      allow(logger_dbl).to receive(:debug2).with(/No spec dir detected/)
       expect(logger_dbl).to receive(:warn).with(/puppet forge module.*puppetlabs-corosync.*has been deprecated/i)
 
       subject.sync
@@ -90,6 +113,7 @@ describe R10K::Module::Forge do
       allow_any_instance_of(described_class).to receive(:logger).and_return(logger_dbl)
 
       allow(logger_dbl).to receive(:info).with(/Deploying module to.*/)
+      allow(logger_dbl).to receive(:debug2).with(/No spec dir detected/)
       expect(logger_dbl).to_not receive(:warn).with(/puppet forge module.*puppetlabs-corosync.*has been deprecated/i)
 
       subject.sync
@@ -104,9 +128,16 @@ describe R10K::Module::Forge do
 
     it "uses the latest version from the forge when the version is :latest" do
       subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: :latest })
-      expect(subject.v3_module).to receive_message_chain(:current_release, :version).and_return('8.8.8')
+      release = double("Module Release", version: '8.8.8')
+      expect(subject.v3_module).to receive(:current_release).and_return(release).twice
       expect(subject.expected_version).to eq '8.8.8'
     end
+
+    it "throws when there are no available versions" do
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: :latest })
+      expect(subject.v3_module).to receive(:current_release).and_return(nil)
+      expect { subject.expected_version }.to raise_error(PuppetForge::ReleaseNotFound)
+    end
   end
 
   describe "determining the status" do
@@ -158,31 +189,54 @@ describe R10K::Module::Forge do
   describe "#sync" do
     subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
 
+    context "syncing the repo" do
+      let(:module_org) { "coolorg" }
+      let(:module_name) { "coolmod" }
+      let(:title) { "#{module_org}-#{module_name}" }
+      let(:dirname) { Pathname.new(Dir.mktmpdir) }
+      let(:spec_path) { dirname + module_name + 'spec' }
+      subject { described_class.new(title, dirname, {}) }
+
+      it 'defaults to keeping the spec dir' do
+        FileUtils.mkdir_p(spec_path)
+        expect(subject).to receive(:status).and_return(:absent)
+        expect(subject).to receive(:install)
+        subject.sync
+        expect(Dir.exist?(spec_path)).to eq true
+      end
+    end
+
     it 'does nothing when the module is in sync' do
       allow(subject).to receive(:status).and_return :insync
 
       expect(subject).to receive(:install).never
       expect(subject).to receive(:upgrade).never
       expect(subject).to receive(:reinstall).never
-      subject.sync
+      expect(subject.sync).to be false
     end
 
     it 'reinstalls the module when it is mismatched' do
       allow(subject).to receive(:status).and_return :mismatched
       expect(subject).to receive(:reinstall)
-      subject.sync
+      expect(subject.sync).to be true
     end
 
     it 'upgrades the module when it is outdated' do
       allow(subject).to receive(:status).and_return :outdated
       expect(subject).to receive(:upgrade)
-      subject.sync
+      expect(subject.sync).to be true
     end
 
     it 'installs the module when it is absent' do
       allow(subject).to receive(:status).and_return :absent
       expect(subject).to receive(:install)
-      subject.sync
+      expect(subject.sync).to be true
+    end
+
+    it 'returns false if `should_sync?` is false' do
+      # modules do not sync if they are not requested
+      mod = described_class.new('my_org/my_mod', '/path/to/mod', { overrides: { modules: { requested_modules: ['other_mod'] } } })
+      expect(mod.sync).to be false
     end
   end
 

data/spec/unit/module/git_spec.rb

@@ -10,15 +10,41 @@ describe R10K::Module::Git do
     allow(R10K::Git::StatefulRepository).to receive(:new).and_return(mock_repo)
   end
 
+
+  describe "statically determined version support" do
+    it 'returns a given commit' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', commit: '123adf' })
+      expect(static_version).to eq('123adf')
+    end
+
+    it 'returns a given tag' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', tag: 'v1.2.3' })
+      expect(static_version).to eq('v1.2.3')
+    end
+
+    it 'returns a ref if it looks like a full commit sha' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', ref: '1234567890abcdef1234567890abcdef12345678' })
+      expect(static_version).to eq('1234567890abcdef1234567890abcdef12345678')
+    end
+
+    it 'returns nil for any non-sha-like ref' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', ref: 'refs/heads/main' })
+      expect(static_version).to eq(nil)
+    end
+
+    it 'returns nil for branches' do
+      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', branch: 'main' })
+      expect(static_version).to eq(nil)
+    end
+  end
+
   describe "setting the owner and name" do
     describe "with a title of 'branan/eight_hundred'" do
       subject do
         described_class.new(
           'branan/eight_hundred',
           '/moduledir',
-          {
-            :git => 'git://git-server.site/branan/puppet-eight_hundred',
-          }
+          { :git => 'git://git-server.site/branan/puppet-eight_hundred' }
         )
       end
 
@@ -40,9 +66,7 @@ describe R10K::Module::Git do
         described_class.new(
           'eight_hundred',
           '/moduledir',
-          {
-            :git => 'git://git-server.site/branan/puppet-eight_hundred',
-          }
+          { :git => 'git://git-server.site/branan/puppet-eight_hundred' }
         )
       end
 
@@ -89,14 +113,48 @@ describe R10K::Module::Git do
     end
   end
 
+  describe 'syncing the repo' do
+    let(:module_org) { "coolorg" }
+    let(:module_name) { "coolmod" }
+    let(:title) { "#{module_org}-#{module_name}" }
+    let(:dirname) { Pathname.new(Dir.mktmpdir) }
+    let(:spec_path) { dirname + module_name + 'spec' }
+    subject { described_class.new(title, dirname, {}) }
+
+    before(:each) do
+      allow(mock_repo).to receive(:resolve).with('master').and_return('abc123')
+    end
+
+    it 'defaults to keeping the spec dir' do
+      FileUtils.mkdir_p(spec_path)
+      allow(mock_repo).to receive(:sync)
+      subject.sync
+      expect(Dir.exist?(spec_path)).to eq true
+    end
+
+    it 'returns true if repo was updated' do
+      expect(mock_repo).to receive(:sync).and_return(true)
+      expect(subject.sync).to be true
+    end
+
+    it 'returns false if repo was not updated (in-sync)' do
+      expect(mock_repo).to receive(:sync).and_return(false)
+      expect(subject.sync).to be false
+    end
+
+    it 'returns false if `should_sync?` is false' do
+      # modules do not sync if they are not requested
+      mod = described_class.new(title, dirname, { overrides: { modules: { requested_modules: ['other_mod'] } } })
+      expect(mod.sync).to be false
+    end
+  end
+
   describe "determining the status" do
     subject do
       described_class.new(
         'boolean',
         '/moduledir',
-        {
-          :git => 'git://git.example.com/adrienthebo/puppet-boolean'
-        }
+        { :git => 'git://git.example.com/adrienthebo/puppet-boolean' }
       )
     end
 
@@ -119,14 +177,6 @@ describe R10K::Module::Git do
       allow(mock_repo).to receive(:head).and_return('abc123')
     end
 
-    context "when option is unrecognized" do
-      let(:opts) { { unrecognized: true } }
-
-      it "raises an error" do
-        expect { test_module(opts) }.to raise_error(ArgumentError, /cannot handle option 'unrecognized'/)
-      end
-    end
-
     describe "desired ref" do
       context "when no desired ref is given" do
         it "defaults to master" do