puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/module_tool/applications/checksummer_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'puppet/module_tool/applications'
 
-describe Puppet::ModuleTool::Applications::Checksummer, :unless => Puppet.features.microsoft_windows? do
+describe Puppet::ModuleTool::Applications::Checksummer do
   subject {
     Puppet::ModuleTool::Applications::Checksummer.new(module_install_path)
   }

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -3,22 +3,28 @@ require 'puppet/module_tool/applications'
 require 'puppet_spec/modules'
 require 'semver'
 
-describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features.microsoft_windows? do
+describe Puppet::ModuleTool::Applications::Installer do
   include PuppetSpec::Files
 
-  before do
-    FileUtils.mkdir_p(modpath1)
-    fake_env.modulepath = [modpath1]
-    FileUtils.touch(stdlib_pkg)
-    Puppet.settings[:modulepath] = modpath1
-  end
-
   let(:unpacker)        { stub(:run) }
   let(:installer_class) { Puppet::ModuleTool::Applications::Installer }
-  let(:modpath1)        { File.join(tmpdir("installer"), "modpath1") }
-  let(:stdlib_pkg)      { File.join(modpath1, "pmtacceptance-stdlib-0.0.1.tar.gz") }
-  let(:fake_env)        { Puppet::Node::Environment.new('fake_env') }
-  let(:options)         { { :target_dir => modpath1 } }
+  let(:modpath1) do
+    path = File.join(tmpdir("installer"), "modpath1")
+    FileUtils.mkdir_p(path)
+    path
+  end
+  let(:stdlib_pkg) do
+    mod = File.join(modpath1, "pmtacceptance-stdlib-0.0.1.tar.gz")
+    FileUtils.touch(mod)
+    mod
+  end
+  let(:env)             { Puppet::Node::Environment.create(:env, [modpath1], '') }
+  let(:options)         do
+    {
+      :target_dir => modpath1,
+      :environment_instance => env,
+    }
+  end
 
   let(:forge) do
     forge = mock("Puppet::Forge")
@@ -217,7 +223,7 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
       end
 
       it "should install requested module if the '--force' flag is used" do
-        options = { :force => true, :target_dir => modpath1 }
+        options.merge!(:force => true)
         Puppet::ModuleTool::Applications::Unpacker.expects(:new).
           with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
           returns(unpacker)
@@ -226,7 +232,7 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
       end
 
       it "should not install dependencies if the '--force' flag is used" do
-        options = { :force => true, :target_dir => modpath1 }
+        options.merge!(:force => true)
         Puppet::ModuleTool::Applications::Unpacker.expects(:new).
           with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
           returns(unpacker)
@@ -236,7 +242,7 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
       end
 
       it "should not install dependencies if the '--ignore-dependencies' flag is used" do
-        options = { :ignore_dependencies => true, :target_dir => modpath1 }
+        options.merge!(:ignore_dependencies => true)
         Puppet::ModuleTool::Applications::Unpacker.expects(:new).
           with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
           returns(unpacker)
@@ -246,7 +252,7 @@ describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features
       end
 
       it "should set an error if dependencies can't be resolved" do
-        options = { :version => '0.0.1', :target_dir => modpath1 }
+        options.merge!(:version => '0.0.1')
         oneline = "'pmtacceptance-apollo' (v0.0.1) requested; Invalid dependency cycle"
         multiline = <<-MSG.strip
 Could not install module 'pmtacceptance-apollo' (v0.0.1)
@@ -262,6 +268,37 @@ MSG
         results[:error][:oneline].should == oneline
         results[:error][:multiline].should == multiline
       end
+
+      it "resolves conflicts for each dependency only once" do
+        Puppet::Log.level = :debug
+
+        installed_modules = [
+          Puppet::Module.new('ntp', File.join(modpath1, 'ntp'), env.name),
+          Puppet::Module.new('mysql', File.join(modpath1, 'mysql'), env.name),
+          Puppet::Module.new('apache', File.join(modpath1, 'apache'), env.name)
+        ]
+
+        env.stubs(:modules_by_path).returns({modpath1 => installed_modules})
+
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+          returns(unpacker)
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options).
+          returns(unpacker)
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
+          returns(unpacker)
+
+        installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+
+        modules = @logs.map do |log|
+          data = log.message.match(/Resolving conflicts for (.*)/)
+          data ? data[1] : nil
+        end.compact
+
+        expect(modules).to eq(["pmtacceptance-apollo", "pmtacceptance-java,pmtacceptance-stdlib"])
+      end
     end
 
     context "when there are modules installed" do

data/spec/unit/module_tool/applications/uninstaller_spec.rb

@@ -20,19 +20,19 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
   end
 
   describe "the behavior of the instances" do
-
-    before do
-      @uninstaller = Puppet::ModuleTool::Applications::Uninstaller
-      FileUtils.mkdir_p(modpath1)
-      FileUtils.mkdir_p(modpath2)
-      fake_env.modulepath = [modpath1, modpath2]
+    let(:working_dir) { tmpdir("uninstaller") }
+    let(:modpath1) { create_temp_dir("modpath1") }
+    let(:modpath2) { create_temp_dir("modpath2") }
+    let(:env) { Puppet::Node::Environment.create(:env, [modpath1, modpath2], '') }
+    let(:options)  { { :environment_instance => env } }
+    let(:uninstaller) { Puppet::ModuleTool::Applications::Uninstaller.new("puppetlabs-foo", options) }
+
+    def create_temp_dir(name)
+      path = File.join(working_dir, name)
+      FileUtils.mkdir_p(path)
+      path
     end
 
-    let(:modpath1) { File.join(tmpdir("uninstaller"), "modpath1") }
-    let(:modpath2) { File.join(tmpdir("uninstaller"), "modpath2") }
-    let(:fake_env) { Puppet::Node::Environment.new('fake_env') }
-    let(:options)  { {:environment => "fake_env"} }
-
     let(:foo_metadata) do
       {
         :author       => "puppetlabs",
@@ -57,7 +57,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
 
     context "when the module is not installed" do
       it "should fail" do
-        @uninstaller.new('fakemod_not_installed', options).run[:result].should == :failure
+        Puppet::ModuleTool::Applications::Uninstaller.new('fakemod_not_installed', options).run[:result].should == :failure
       end
     end
 
@@ -66,7 +66,8 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
       it "should uninstall the module" do
         PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-        results = @uninstaller.new("puppetlabs-foo", options).run
+        results = uninstaller.run
+
         results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
       end
 
@@ -74,7 +75,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
         PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
         PuppetSpec::Modules.create('bar', modpath1, :metadata => bar_metadata)
 
-        results = @uninstaller.new("puppetlabs-foo", options).run
+        results = uninstaller.run
         results[:affected_modules].length == 1
         results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
       end
@@ -83,7 +84,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
         PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
         PuppetSpec::Modules.create('foo', modpath2, :metadata => foo_metadata)
 
-        @uninstaller.new('puppetlabs-foo', options).run[:result].should == :failure
+        uninstaller.run[:result].should == :failure
       end
 
       context "when options[:version] is specified" do
@@ -93,7 +94,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
 
           options[:version] = "1.0.0"
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
+          results = uninstaller.run
           results[:affected_modules].length.should == 1
           results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
           results[:affected_modules].first.version.should == "1.0.0"
@@ -104,7 +105,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
 
           options[:version] = "2.0.0"
 
-          @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
+          uninstaller.run[:result].should == :failure
         end
       end
 
@@ -113,17 +114,17 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
         it "should not uninstall the module" do
           PuppetSpec::Modules.create('foo', modpath1)
 
-          @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
+          uninstaller.run[:result].should == :failure
         end
       end
 
       context "when the module has local changes" do
 
         it "should not uninstall the module" do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-          Puppet::Module.any_instance.stubs(:has_local_changes?).returns(true)
+          mod = PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+          Puppet::ModuleTool::Applications::Checksummer.expects(:run).with(mod.path).returns(['change'])
 
-          @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
+          uninstaller.run[:result].should == :failure
         end
 
       end
@@ -133,7 +134,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
         it "should uninstall the module" do
           PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
+          results = uninstaller.run
           results[:affected_modules].length.should == 1
           results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
         end
@@ -156,7 +157,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
             }
           )
 
-          @uninstaller.new("puppetlabs-foo", options).run[:result].should == :failure
+          uninstaller.run[:result].should == :failure
         end
       end
 
@@ -174,7 +175,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
           foo = mkmod("foo", modpath1, foo_metadata)
           options[:force] = true
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
+          results = uninstaller.run
           results[:affected_modules].length.should == 1
           results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
         end
@@ -196,7 +197,7 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
           )
           options[:force] = true
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
+          results = uninstaller.run
           results[:affected_modules].length.should == 1
           results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
         end

data/spec/unit/module_tool/tar_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'puppet/module_tool/tar'
+require 'puppet/module_tool'
 
 describe Puppet::ModuleTool::Tar do
 

data/spec/unit/module_tool_spec.rb

@@ -154,87 +154,20 @@ TREE
   end
 
   describe '.set_option_defaults' do
-    describe 'option :environment' do
-      context 'passed:' do
-        let (:environment) { "ahgkduerh" }
-        let (:options) { {:environment => environment} }
-
-        it 'Puppet[:environment] should be set to the value of the option' do
-          subject.set_option_defaults options
-
-          Puppet[:environment].should == environment
-        end
-
-        it 'the option value should not be overridden' do
-          Puppet[:environment] = :foo
-          subject.set_option_defaults options
-
-          options[:environment].should == environment
-        end
-      end
-
-      context 'NOT passed:' do
-        it 'Puppet[:environment] should NOT be overridden' do
-          Puppet[:environment] = :foo
-
-          subject.set_option_defaults({})
-          Puppet[:environment].should == :foo
-        end
-
-        it 'the option should be set to the value of Puppet[:environment]' do
-          options_to_modify = Hash.new
-          Puppet[:environment] = :abcdefg
-
-          subject.set_option_defaults options_to_modify
-
-          options_to_modify[:environment].should == :abcdefg
-        end
+    let(:options) { {} }
+    let(:modulepath) { [File.expand_path('/env/module/path'), File.expand_path('/global/module/path')] }
+    let(:environment) { Puppet::Node::Environment.create('current', modulepath, '') }
+    around(:each) do |example|
+      Puppet.override(:current_environment => environment) do
+        example.run
       end
     end
 
-    describe 'option :modulepath' do
-      context 'passed:' do
-        let (:modulepath) { PuppetSpec::Files.make_absolute('/bar') }
-        let (:options) { {:modulepath => modulepath} }
-
-        it 'Puppet[:modulepath] should be set to the value of the option' do
-
-          subject.set_option_defaults options
-
-          Puppet[:modulepath].should == modulepath
-        end
-
-        it 'the option value should not be overridden' do
-          Puppet[:modulepath] = "/foo"
-
-          subject.set_option_defaults options
-
-          options[:modulepath].should == modulepath
-        end
-      end
-
-      context 'NOT passed:' do
-        let (:options) { {:environment => :pmttestenv} }
-
-        before(:each) do
-          Puppet[:modulepath] = "/no"
-          Puppet[:environment] = :pmttestenv
-          Puppet.settings.set_value(:modulepath,
-                                    ["/foo", "/bar", "/no"].join(File::PATH_SEPARATOR),
-                                    :pmttestenv)
-        end
-
-        it 'Puppet[:modulepath] should be reset to the module path of the current environment' do
-          subject.set_option_defaults options
-
-          Puppet[:modulepath].should == Puppet.settings.value(:modulepath, :pmttestenv)
-        end
-
-        it 'the option should be set to the module path of the current environment' do
-          subject.set_option_defaults options
-
-          options[:modulepath].should == Puppet.settings.value(:modulepath, :pmttestenv)
-        end
+    describe 'option :environment_instance' do
+      it 'adds an environment_instance to the options hash' do
+        subject.set_option_defaults(options)
+        expect(options[:environment_instance].name).to eq(environment.name)
+        expect(options[:environment_instance].modulepath).to eq(environment.modulepath)
       end
     end
 
@@ -244,32 +177,26 @@ TREE
       context 'passed:' do
         let (:options) { {:target_dir => target_dir} }
 
-        it 'the option value should be prepended to the Puppet[:modulepath]' do
-          Puppet[:modulepath] = "/fuz"
-          original_modulepath = Puppet[:modulepath]
-
+        it 'prepends the target_dir into the environment_instance modulepath' do
           subject.set_option_defaults options
 
-          Puppet[:modulepath].should == options[:target_dir] + File::PATH_SEPARATOR + original_modulepath
+          expect(options[:environment_instance].full_modulepath).
+            to eq([File.expand_path(target_dir)] + modulepath)
         end
 
-        it 'the option value should be turned into an absolute path' do
+        it 'expands the target dir' do
           subject.set_option_defaults options
 
           options[:target_dir].should == File.expand_path(target_dir)
         end
       end
 
-      describe 'NOT passed:' do
-        before :each do
-          Puppet[:modulepath] = 'foo' + File::PATH_SEPARATOR + 'bar'
-        end
-
+      context 'NOT passed:' do
         it 'the option should be set to the first component of Puppet[:modulepath]' do
           options = Hash.new
           subject.set_option_defaults options
 
-          options[:target_dir].should == Puppet[:modulepath].split(File::PATH_SEPARATOR)[0]
+          expect(options[:target_dir]).to eq(environment.full_modulepath.first)
         end
       end
     end

data/spec/unit/network/authconfig_spec.rb

@@ -5,8 +5,7 @@ require 'puppet/network/authconfig'
 
 describe Puppet::Network::AuthConfig do
   before :each do
-    stub_file = stub('file', :stat => stub('stat', :ctime => :now))
-    Puppet::FileSystem::File.stubs(:new).returns stub_file
+    Puppet::FileSystem.stubs(:stat).returns stub('stat', :ctime => :now)
     Time.stubs(:now).returns Time.now
 
     Puppet::Network::AuthConfig.any_instance.stubs(:exists?).returns(true)
@@ -102,9 +101,9 @@ describe Puppet::Network::AuthConfig do
         :authenticated => true
       }
 
-      Puppet::Network::Rights.any_instance.expects(:is_request_forbidden_and_why?).with("path", :save, "to/resource", params)
+      Puppet::Network::Rights.any_instance.expects(:is_request_forbidden_and_why?).with(:save, "/path/to/resource", params)
 
-      described_class.new.check_authorization("path", :save, "to/resource", params)
+      described_class.new.check_authorization(:save, "/path/to/resource", params)
     end
   end
 end

data/spec/unit/network/authentication_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Network::Authentication do
   describe "when warning about upcoming expirations" do
     before do
       Puppet::SSL::CertificateAuthority.stubs(:ca?).returns(false)
-      Puppet::FileSystem::File.stubs(:exist?).returns(false)
+      Puppet::FileSystem.stubs(:exist?).returns(false)
     end
 
     it "should check the expiration of the CA certificate" do
@@ -31,11 +31,25 @@ describe Puppet::Network::Authentication do
       subject.warn_if_near_expiration
     end
 
-    it "should check the expiration of the localhost certificate" do
-      Puppet::SSL::Host.stubs(:localhost).returns(host)
-      cert.expects(:near_expiration?).returns(false)
-      Puppet::FileSystem::File.stubs(:exist?).with(Puppet[:hostcert]).returns(true)
-      subject.warn_if_near_expiration
+    context "when examining the local host" do
+      before do
+        Puppet::SSL::Host.stubs(:localhost).returns(host)
+        Puppet::FileSystem.stubs(:exist?).with(Puppet[:hostcert]).returns(true)
+      end
+
+      it "should not load the localhost certificate if the local CA certificate is missing" do
+        # Redmine-21869: Infinite recursion occurs if CA cert is missing.
+        Puppet::FileSystem.stubs(:exist?).with(Puppet[:localcacert]).returns(false)
+        host.unstub(:certificate)
+        host.expects(:certificate).never
+        subject.warn_if_near_expiration
+      end
+
+      it "should check the expiration of the localhost certificate if the local CA certificate is present" do
+        Puppet::FileSystem.stubs(:exist?).with(Puppet[:localcacert]).returns(true)
+        cert.expects(:near_expiration?).returns(false)
+        subject.warn_if_near_expiration
+      end
     end
 
     it "should check the expiration of any certificates passed in as arguments" do