r10k 3.9.0 → 3.9.1

data/spec/r10k-mocks/mock_source.rb

@@ -8,6 +8,6 @@ class R10K::Source::Mock < R10K::Source::Base
     corrected_environment_names = @options[:environments].map do |env|
       R10K::Environment::Name.new(env, :prefix => @prefix, :invalid => 'correct_and_warn')
     end
-    corrected_environment_names.map { |env| R10K::Environment::Mock.new(env.name, @basedir, env.dirname) }
+    corrected_environment_names.map { |env| R10K::Environment::Mock.new(env.name, @basedir, env.dirname, { overrides: @options[:overrides] }) }
   end
 end

data/spec/shared-examples/puppetfile-action.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 shared_examples_for "a puppetfile action" do
   describe "initializing" do
     it "accepts the :root option" do
-      described_class.new({root: "/some/nonexistent/path"}, [])
+      described_class.new({root: "/some/nonexistent/path"}, [], {})
     end
 
     it "accepts the :puppetfile option" do
-      described_class.new({puppetfile: "/some/nonexistent/path/Puppetfile"}, [])
+      described_class.new({puppetfile: "/some/nonexistent/path/Puppetfile"}, [], {})
     end
 
     it "accepts the :moduledir option" do
-      described_class.new({moduledir: "/some/nonexistent/path/modules"}, [])
+      described_class.new({moduledir: "/some/nonexistent/path/modules"}, [], {})
     end
 
   end
@@ -20,19 +20,19 @@ end
 shared_examples_for "a puppetfile install action" do
   describe "initializing" do
     it "accepts the :root option" do
-      described_class.new({root: "/some/nonexistent/path"}, [])
+      described_class.new({root: "/some/nonexistent/path"}, [], {})
     end
 
     it "accepts the :puppetfile option" do
-      described_class.new({puppetfile: "/some/nonexistent/path/Puppetfile"}, [])
+      described_class.new({puppetfile: "/some/nonexistent/path/Puppetfile"}, [], {})
     end
 
     it "accepts the :moduledir option" do
-      described_class.new({moduledir: "/some/nonexistent/path/modules"}, [])
+      described_class.new({moduledir: "/some/nonexistent/path/modules"}, [], {})
     end
 
     it "accepts the :force option" do
-      described_class.new({force: true}, [])
+      described_class.new({force: true}, [], {})
     end
 
   end

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

@@ -5,31 +5,57 @@ require 'r10k/action/deploy/display'
 describe R10K::Action::Deploy::Display do
   describe "initializing" do
     it "accepts a puppetfile option" do
-      described_class.new({puppetfile: true}, [])
+      described_class.new({puppetfile: true}, [], {})
     end
 
     it "accepts a modules option" do
-      described_class.new({modules: true}, [])
+      described_class.new({modules: true}, [], {})
     end
 
     it "accepts a detail option" do
-      described_class.new({detail: true}, [])
+      described_class.new({detail: true}, [], {})
     end
 
     it "accepts a format option" do
-      described_class.new({format: "json"}, [])
+      described_class.new({format: "json"}, [], {})
     end
 
     it "accepts a fetch option" do
-      described_class.new({fetch: true}, [])
+      described_class.new({fetch: true}, [], {})
     end
   end
 
-  subject { described_class.new({config: "/some/nonexistent/path"}, []) }
+  subject { described_class.new({config: "/some/nonexistent/path"}, [], {}) }
 
   before do
     allow(subject).to receive(:puts)
   end
 
   it_behaves_like "a deploy action that requires a config file"
+
+  describe "collecting info" do
+    subject { described_class.new({config: "/some/nonexistent/path", format: 'json', puppetfile: true, detail: true}, ['first'], {}) }
+
+    let(:mock_config) do
+      R10K::Deployment::MockConfig.new(
+        :sources => {
+          :control => {
+            :type => :mock,
+            :basedir => '/some/nonexistent/path/control',
+            :environments => %w[first second third env-that/will-be-corrected],
+            :prefix => 'PREFIX'
+          }
+        }
+      )
+    end
+
+    let(:deployment) { R10K::Deployment.new(mock_config) }
+
+    it "gathers environment info" do
+      source_info = subject.send(:source_info, deployment.sources.first, ['first'])
+      expect(source_info[:name]).to eq(:control)
+      expect(source_info[:environments].length).to eq(1)
+      expect(source_info[:environments][0][:name]).to eq('first')
+    end
+  end
 end

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

@@ -5,46 +5,46 @@ require 'r10k/action/deploy/environment'
 
 describe R10K::Action::Deploy::Environment do
 
-  subject { described_class.new({config: "/some/nonexistent/path"}, []) }
+  subject { described_class.new({config: "/some/nonexistent/path"}, [], {}) }
 
   it_behaves_like "a deploy action that can be write locked"
   it_behaves_like "a deploy action that requires a config file"
 
   describe "initializing" do
     it "can accept a cachedir option" do
-      described_class.new({cachedir: "/some/nonexistent/cachedir"}, [])
+      described_class.new({cachedir: "/some/nonexistent/cachedir"}, [], {})
     end
 
     it "can accept a puppetfile option" do
-      described_class.new({puppetfile: true}, [])
+      described_class.new({puppetfile: true}, [], {})
     end
 
     it "can accept a modules option" do
-      described_class.new({modules: true}, [])
+      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'}, [])
+      described_class.new({:'default-branch-override' => 'default_branch_override_name'}, [], {})
     end
 
     it "can accept a no-force option" do
-      described_class.new({:'no-force' => true}, [])
+      described_class.new({:'no-force' => true}, [], {})
     end
 
     it 'can accept a generate-types option' do
-      described_class.new({ 'generate-types': true }, [])
+      described_class.new({ 'generate-types': true }, [], {})
     end
 
     it 'can accept a puppet-path option' do
-      described_class.new({ 'puppet-path': '/nonexistent' }, [])
+      described_class.new({ 'puppet-path': '/nonexistent' }, [], {})
     end
 
     it 'can accept a private-key option' do
-      described_class.new({ 'private-key': '/nonexistent' }, [])
+      described_class.new({ 'private-key': '/nonexistent' }, [], {})
     end
 
     it 'can accept a token option' do
-      described_class.new({ 'oauth-token': '/nonexistent' }, [])
+      described_class.new({ 'oauth-token': '/nonexistent' }, [], {})
     end
 
     describe "initializing errors" do
@@ -83,14 +83,14 @@ describe R10K::Action::Deploy::Environment do
       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}, [])
+        expect(puppetfile).to receive(:sync)
+        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}, [])
+        expect(puppetfile).to receive(:sync)
+        action = described_class.new({config: "/some/nonexistent/path", modules: true}, [], {})
         action.call
       end
 
@@ -105,7 +105,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"}, %w[not_an_environment]) }
+      subject { described_class.new({config: "/some/nonexistent/path"}, %w[not_an_environment], {}) }
 
       it "logs that the environments can't be deployed and returns false" do
         expect(subject.logger).to receive(:error).with("Environment(s) 'not_an_environment' cannot be found in any source and will not be deployed.")
@@ -115,10 +115,10 @@ describe R10K::Action::Deploy::Environment do
     end
 
     describe "with no-force" do
-      subject { described_class.new({ config: "/some/nonexistent/path", modules: 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)
+        expect(subject.settings[:overrides][:modules][:force]).to equal(false)
       end
     end
 
@@ -206,21 +206,13 @@ describe R10K::Action::Deploy::Environment do
       end
     end
 
-    describe 'extracting credentials' do
-      let(:deployment) do
-        R10K::Deployment.new(mock_config)
-      end
-
-    end
-
     describe "Purging white/allowlist" do
 
       let(:settings) { { deploy: { purge_levels: [:environment], purge_allowlist: ['coolfile', 'coolfile2'] } } }
-
+      let(:overrides) { { environments: {}, modules: {}, purging: { purge_levels: [:environment], purge_allowlist: ['coolfile', 'coolfile2'] } } }
       let(:deployment) do
-        R10K::Deployment.new(mock_config.merge(settings))
+        R10K::Deployment.new(mock_config.merge(overrides))
       end
-
       before do
         expect(R10K::Deployment).to receive(:new).and_return(deployment)
       end
@@ -229,7 +221,7 @@ describe R10K::Action::Deploy::Environment do
 
       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'])
+        expect(subject.settings[:overrides][:purging][:purge_allowlist]).to eq(['coolfile', 'coolfile2'])
         subject.call
       end
 
@@ -238,7 +230,7 @@ describe R10K::Action::Deploy::Environment do
 
         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'])
+          expect(subject.settings[:overrides][:purging][:purge_allowlist]).to eq(['coolfile', 'coolfile2'])
           subject.call
         end
       end
@@ -246,9 +238,22 @@ describe R10K::Action::Deploy::Environment do
 
     describe "purge_levels" do
       let(:settings) { { deploy: { purge_levels: purge_levels } } }
+      let(:overrides) do
+        {
+          environments: {
+            requested_environments: ['PREFIX_first']
+          },
+          modules: {
+            deploy_modules: true
+          },
+          purging: {
+            purge_levels: purge_levels
+          }
+        }
+      end
 
       let(:deployment) do
-        R10K::Deployment.new(mock_config.merge(settings))
+        R10K::Deployment.new(mock_config.merge({ overrides: overrides }))
       end
 
       before do
@@ -261,9 +266,13 @@ describe R10K::Action::Deploy::Environment do
         let(:purge_levels) { [:deployment] }
 
         it "only logs about purging deployment" do
+          expect(subject).to receive(:visit_environment).and_wrap_original do |original, env, &block|
+            expect(env.logger).to_not receive(:debug).with(/purging unmanaged puppetfile content/i)
+            original.call(env)
+          end.at_least(:once)
+
           expect(subject.logger).to receive(:debug).with(/purging unmanaged environments for deployment/i)
           expect(subject.logger).to_not receive(:debug).with(/purging unmanaged content for environment/i)
-          expect(subject.logger).to_not receive(:debug).with(/purging unmanaged puppetfile content/i)
 
           subject.call
         end
@@ -273,15 +282,23 @@ describe R10K::Action::Deploy::Environment do
         let(:purge_levels) { [:environment] }
 
         it "only logs about purging environment" do
+          expect(subject).to receive(:visit_environment).and_wrap_original do |original, env, &block|
+            expect(env.logger).to_not receive(:debug).with(/purging unmanaged puppetfile content/i)
+            original.call(env)
+          end.at_least(:once)
           expect(subject.logger).to receive(:debug).with(/purging unmanaged content for environment/i)
           expect(subject.logger).to_not receive(:debug).with(/purging unmanaged environments for deployment/i)
-          expect(subject.logger).to_not receive(:debug).with(/purging unmanaged puppetfile content/i)
 
           subject.call
         end
 
         it "logs that environment was not purged if deploy failed" do
-          expect(subject).to receive(:visit_puppetfile) { subject.instance_variable_set(:@visit_ok, false) }
+          expect(subject).to receive(:visit_environment).and_wrap_original do |original, env, &block|
+            if env.name =~ /first/
+              expect(env).to receive(:deploy) { subject.instance_variable_set(:@visit_ok, false) }
+            end
+            original.call(env)
+          end.at_least(:once)
 
           expect(subject.logger).to receive(:debug).with(/not purging unmanaged content for environment/i)
 
@@ -293,7 +310,13 @@ describe R10K::Action::Deploy::Environment do
         let(:purge_levels) { [:puppetfile] }
 
         it "only logs about purging puppetfile" do
-          expect(subject.logger).to receive(:debug).with(/purging unmanaged puppetfile content/i)
+          expect(subject).to receive(:visit_environment).and_wrap_original do |original, env, &block|
+            if env.name =~ /first/
+              expect(env.logger).to receive(:debug).with(/purging unmanaged puppetfile content/i)
+            end
+            original.call(env)
+          end.at_least(:once)
+
           expect(subject.logger).to_not receive(:debug).with(/purging unmanaged environments for deployment/i)
           expect(subject.logger).to_not receive(:debug).with(/purging unmanaged content for environment/i)
 
@@ -334,16 +357,19 @@ describe R10K::Action::Deploy::Environment do
               modules: true,
               'generate-types': true
             },
-            %w[first second]
+            %w[first second],
+            {}
           )
         end
 
         it 'generate_types is true' do
-          expect(subject.instance_variable_get(:@generate_types)).to eq(true)
+          expect(subject.settings[:overrides][:environments][:generate_types]).to eq(true)
         end
 
         it 'only calls puppet generate types on specified environment' do
-          subject.instance_variable_set(:@argv, %w[first])
+          settings = subject.instance_variable_get(:@settings)
+          settings[:overrides][:environments][:requested_environments] = %w{first}
+          subject.instance_variable_set(:@settings, settings)
           expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
             if environment.dirname == 'first'
               expect(environment).to receive(:generate_types!)
@@ -356,8 +382,8 @@ describe R10K::Action::Deploy::Environment do
         end
 
         it 'does not call puppet generate types on puppetfile failure' do
-          allow(subject).to receive(:visit_puppetfile) { subject.instance_variable_set(:@visit_ok, false) }
           expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+            allow(environment).to receive(:deploy) { subject.instance_variable_set(:@visit_ok, false) }
             expect(environment).not_to receive(:generate_types!)
             original.call(environment, &block)
           end.twice
@@ -365,10 +391,11 @@ describe R10K::Action::Deploy::Environment do
         end
 
         it 'calls puppet generate types on previous puppetfile failure' do
-          allow(subject).to receive(:visit_puppetfile) do |puppetfile|
-            subject.instance_variable_set(:@visit_ok, false) if puppetfile.environment.dirname == 'first'
-          end
           expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+            allow(environment).to receive(:deploy) do
+              subject.instance_variable_set(:@visit_ok, false) if environment.dirname == 'first'
+            end
+
             if environment.dirname == 'second'
               expect(environment).to receive(:generate_types!)
             else
@@ -388,12 +415,13 @@ describe R10K::Action::Deploy::Environment do
               modules: true,
               'generate-types': false
             },
-            %w[first]
+            %w[first],
+            {}
           )
         end
 
         it 'generate_types is false' do
-          expect(subject.instance_variable_get(:@generate_types)).to eq(false)
+          expect(subject.settings[:overrides][:environments][:generate_types]).to eq(false)
         end
 
         it 'does not call puppet generate types' do
@@ -408,7 +436,7 @@ describe R10K::Action::Deploy::Environment do
 
     describe 'with puppet-path' do
 
-      subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-path': '/nonexistent' }, []) }
+      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')
@@ -417,7 +445,7 @@ describe R10K::Action::Deploy::Environment do
 
     describe 'with puppet-conf' do
 
-      subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-conf': '/nonexistent' }, []) }
+      subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-conf': '/nonexistent' }, [], {}) }
 
       it 'sets puppet_conf' do
         expect(subject.instance_variable_get(:@puppet_conf)).to eq('/nonexistent')
@@ -426,7 +454,7 @@ describe R10K::Action::Deploy::Environment do
 
     describe 'with private-key' do
 
-      subject { described_class.new({ config: '/some/nonexistent/path', 'private-key': '/nonexistent' }, []) }
+      subject { described_class.new({ config: '/some/nonexistent/path', 'private-key': '/nonexistent' }, [], {}) }
 
       it 'sets private_key' do
         expect(subject.instance_variable_get(:@private_key)).to eq('/nonexistent')
@@ -435,7 +463,7 @@ describe R10K::Action::Deploy::Environment do
 
     describe 'with oauth-token' do
 
-      subject { described_class.new({ config: '/some/nonexistent/path', 'oauth-token': '/nonexistent' }, []) }
+      subject { described_class.new({ config: '/some/nonexistent/path', 'oauth-token': '/nonexistent' }, [], {}) }
 
       it 'sets oauth_token' do
         expect(subject.instance_variable_get(:@oauth_token)).to eq('/nonexistent')
@@ -453,7 +481,7 @@ describe R10K::Action::Deploy::Environment do
       def initialize(path, info)
         @path = path
         @info = info
-        @puppetfile = R10K::Puppetfile.new
+        @puppetfile = R10K::Puppetfile.new("", {})
       end
     end
 

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

@@ -4,51 +4,51 @@ require 'r10k/action/deploy/module'
 
 describe R10K::Action::Deploy::Module do
 
-  subject { described_class.new({config: "/some/nonexistent/path"}, []) }
+  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"}, [])
+      described_class.new({environment: "production"}, [], {})
     end
 
     it "can accept a no-force option" do
-      described_class.new({:'no-force' => true}, [])
+      described_class.new({:'no-force' => true}, [], {})
     end
 
     it 'can accept a generate-types option' do
-      described_class.new({ 'generate-types': true }, [])
+      described_class.new({ 'generate-types': true }, [], {})
     end
 
     it 'can accept a puppet-path option' do
-      described_class.new({ 'puppet-path': '/nonexistent' }, [])
+      described_class.new({ 'puppet-path': '/nonexistent' }, [], {})
     end
 
     it 'can accept a puppet-conf option' do
-      described_class.new({ 'puppet-conf': '/nonexistent' }, [])
+      described_class.new({ 'puppet-conf': '/nonexistent' }, [], {})
     end
 
     it 'can accept a cachedir option' do
-      described_class.new({ cachedir: '/nonexistent' }, [])
+      described_class.new({ cachedir: '/nonexistent' }, [], {})
     end
 
     it 'can accept a private-key option' do
-      described_class.new({ 'private-key': '/nonexistent' }, [])
+      described_class.new({ 'private-key': '/nonexistent' }, [], {})
     end
 
     it 'can accept a token option' do
-      described_class.new({ 'oauth-token': '/nonexistent' }, [])
+      described_class.new({ 'oauth-token': '/nonexistent' }, [], {})
     end
   end
 
   describe "with no-force" do
 
-    subject { described_class.new({ config: "/some/nonexistent/path", :'no-force' => true}, [] )}
+    subject { described_class.new({ config: "/some/nonexistent/path", :'no-force' => true}, [], {}) }
 
     it "tries to preserve local modifications" do
-      expect(subject.force).to equal(false)
+      expect(subject.settings[:overrides][:modules][:force]).to equal(false)
     end
   end
 
@@ -76,33 +76,33 @@ describe R10K::Action::Deploy::Module do
             config: '/some/nonexistent/path',
             'generate-types': true
           },
-          %w[first]
+          %w[first],
+          {}
         )
       end
 
       before do
+        @modules = []
         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)]
-          )
+          mod = R10K::Module::Local.new(environment.name, '/fakedir', {}, environment)
+          if mod.name == 'first'
+            expect(environment).to receive(:generate_types!)
+          else
+            expect(environment).not_to receive(:generate_types!)
+          end
+          @modules << mod
+          expect(environment.puppetfile).to receive(:modules).and_return([mod]).twice
           original.call(environment, &block)
         end
       end
 
       it 'generate_types is true' do
-        expect(subject.instance_variable_get(:@generate_types)).to eq(true)
+        expect(subject.settings[:overrides][:environments][: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
+        expect(@modules.length).to be(2)
       end
     end
 
@@ -113,12 +113,13 @@ describe R10K::Action::Deploy::Module do
             config: '/some/nonexistent/path',
             'generate-types': false
           },
-          %w[first]
+          %w[first],
+          {}
         )
       end
 
       it 'generate_types is false' do
-        expect(subject.instance_variable_get(:@generate_types)).to eq(false)
+        expect(subject.settings[:overrides][:environments][:generate_types]).to eq(false)
       end
 
       it 'does not call puppet generate types' do |it|
@@ -133,7 +134,7 @@ describe R10K::Action::Deploy::Module do
 
   describe 'with puppet-path' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-path': '/nonexistent' }, []) }
+    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')
@@ -142,7 +143,7 @@ describe R10K::Action::Deploy::Module do
 
   describe 'with puppet-conf' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-conf': '/nonexistent' }, []) }
+    subject { described_class.new({ config: '/some/nonexistent/path', 'puppet-conf': '/nonexistent' }, [], {}) }
 
     it 'sets puppet_conf' do
       expect(subject.instance_variable_get(:@puppet_conf)).to eq('/nonexistent')
@@ -151,7 +152,7 @@ describe R10K::Action::Deploy::Module do
 
   describe 'with cachedir' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', cachedir: '/nonexistent' }, []) }
+    subject { described_class.new({ config: '/some/nonexistent/path', cachedir: '/nonexistent' }, [], {}) }
 
     it 'sets cachedir' do
       expect(subject.instance_variable_get(:@cachedir)).to eq('/nonexistent')
@@ -160,7 +161,7 @@ describe R10K::Action::Deploy::Module do
 
   describe 'with private-key' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', 'private-key': '/nonexistent' }, []) }
+    subject { described_class.new({ config: '/some/nonexistent/path', 'private-key': '/nonexistent' }, [], {}) }
 
     it 'sets private_key' do
       expect(subject.instance_variable_get(:@private_key)).to eq('/nonexistent')
@@ -169,10 +170,117 @@ describe R10K::Action::Deploy::Module do
 
   describe 'with oauth-token' do
 
-    subject { described_class.new({ config: '/some/nonexistent/path', 'oauth-token': '/nonexistent' }, []) }
+    subject { described_class.new({ config: '/some/nonexistent/path', 'oauth-token': '/nonexistent' }, [], {}) }
 
     it 'sets token_path' do
       expect(subject.instance_variable_get(:@oauth_token)).to eq('/nonexistent')
     end
   end
+
+  describe 'with modules' do
+
+    subject { described_class.new({ config: '/some/nonexistent/path' }, ['mod1', 'mod2'], {}) }
+
+    let(:cache) { instance_double("R10K::Git::Cache", 'sanitized_dirname' => 'foo', 'cached?' => true, 'sync' => true) }
+    let(:repo) { instance_double("R10K::Git::StatefulRepository", cache: cache, resolve: 'main') }
+
+    it 'does not sync modules not given' do
+      allow(R10K::Deployment).to receive(:new).and_wrap_original do |original, settings, &block|
+        original.call(settings.merge({
+          sources: {
+            main: {
+              remote: 'git://not/a/remote',
+              basedir: '/not/a/basedir',
+              type: 'git'
+            }
+          }
+        }))
+      end
+
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
+      allow(R10K::Git).to receive_message_chain(:cache, :generate).and_return(cache)
+      allow_any_instance_of(R10K::Source::Git).to receive(:branch_names).and_return([R10K::Environment::Name.new('first', {})])
+
+      expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+        pf = environment.puppetfile
+        expect(pf).to receive(:load) do
+          pf.add_module('mod1', { git: 'git://remote' })
+          pf.add_module('mod2', { git: 'git://remote' })
+          pf.add_module('mod3', { git: 'git://remote' })
+        end
+
+        pf.modules.each do |mod|
+          if ['mod1', 'mod2'].include?(mod.name)
+            expect(mod.should_sync?).to be(true)
+          else
+            expect(mod.should_sync?).to be(false)
+          end
+          expect(mod).to receive(:sync).and_call_original
+        end
+
+        original.call(environment, &block)
+      end
+
+      expect(repo).to receive(:sync).twice
+
+      subject.call
+    end
+  end
+
+  describe 'with environments' do
+    subject { described_class.new({ config: '/some/nonexistent/path', environment: 'first' }, ['mod1'], {}) }
+
+    let(:cache) { instance_double("R10K::Git::Cache", 'sanitized_dirname' => 'foo', 'cached?' => true, 'sync' => true) }
+    let(:repo) { instance_double("R10K::Git::StatefulRepository", cache: cache, resolve: 'main') }
+
+    it 'only syncs to the given environments' do
+      allow(R10K::Deployment).to receive(:new).and_wrap_original do |original, settings, &block|
+        original.call(settings.merge({
+          sources: {
+            main: {
+              remote: 'git://not/a/remote',
+              basedir: '/not/a/basedir',
+              type: 'git'
+            }
+          }
+        }))
+      end
+
+      allow(R10K::Git::StatefulRepository).to receive(:new).and_return(repo)
+      allow(R10K::Git).to receive_message_chain(:cache, :generate).and_return(cache)
+      allow_any_instance_of(R10K::Source::Git).to receive(:branch_names).and_return([R10K::Environment::Name.new('first', {}),
+                                                                                     R10K::Environment::Name.new('second', {})])
+
+      expect(subject).to receive(:visit_environment).and_wrap_original do |original, environment, &block|
+        pf = environment.puppetfile
+
+        if environment.name == 'first'
+          expect(pf).to receive(:load) do
+            pf.add_module('mod1', { git: 'git://remote' })
+            pf.add_module('mod2', { git: 'git://remote' })
+          end
+
+          pf.modules.each do |mod|
+            if mod.name == 'mod1'
+              expect(mod.should_sync?).to be(true)
+            else
+              expect(mod.should_sync?).to be(false)
+            end
+            expect(mod).to receive(:sync).and_call_original
+          end
+        else
+          expect(pf).not_to receive(:load)
+        end
+
+        original.call(environment, &block)
+      end.twice
+
+      expect(repo).to receive(:sync).once
+      expect(subject.logger).to receive(:debug1).with(/Updating modules.*in environment.*first/i)
+      expect(subject.logger).to receive(:debug1).with(/skipping environment.*second/i)
+
+      subject.call
+    end
+  end
 end
+