r10k 3.11.0 → 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

@@ -310,14 +310,6 @@ describe R10K::Action::Runner do
         runner.setup_settings
         runner.setup_authorization
       end
-
-      it 'errors if no custom forge URL is set' do
-        options = { config: "spec/fixtures/unit/action/r10k_forge_auth_no_url.yaml" }
-        runner = described_class.new(options, %w[args yes], action_class)
-        expect(PuppetForge::Connection).not_to receive(:authorization=).with('faketoken')
-
-        expect { runner.setup_settings }.to raise_error(R10K::Error, /Cannot specify a Forge auth/)
-      end
     end
 
     context "license auth" do

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/module/base_spec.rb

@@ -4,26 +4,26 @@ 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
@@ -76,13 +76,13 @@ describe R10K::Module::Base do
 
   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
@@ -90,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
@@ -107,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' })
@@ -190,25 +212,31 @@ describe R10K::Module::Forge do
       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