puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

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

@@ -6,7 +6,7 @@ describe Puppet::ModuleTool::Applications::Searcher do
   include PuppetSpec::Files
 
   describe "when searching" do
-    let(:forge) { mock 'forge' }
+    let(:forge) { mock 'forge', :host => 'http://nowhe.re' }
     let(:searcher) do
       described_class.new('search_term', forge)
     end

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

@@ -1,205 +1,141 @@
 require 'spec_helper'
 require 'puppet/module_tool'
 require 'tmpdir'
-require 'puppet_spec/modules'
+require 'puppet_spec/module_tool/shared_functions'
+require 'puppet_spec/module_tool/stub_source'
 
 describe Puppet::ModuleTool::Applications::Uninstaller do
+  include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
 
-  def mkmod(name, path, metadata=nil)
-    modpath = File.join(path, name)
-    FileUtils.mkdir_p(modpath)
-
-    if metadata
-      File.open(File.join(modpath, 'metadata.json'), 'w') do |f|
-        f.write(metadata.to_pson)
-      end
-    end
+  before do
+    FileUtils.mkdir_p(primary_dir)
+    FileUtils.mkdir_p(secondary_dir)
+  end
 
-    modpath
+  let(:environment) do
+    Puppet.lookup(:current_environment).override_with(
+      :vardir     => vardir,
+      :modulepath => [ primary_dir, secondary_dir ]
+    )
   end
 
-  describe "the behavior of the instances" do
-    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(:vardir)   { tmpdir('uninstaller') }
+  let(:primary_dir) { File.join(vardir, "primary") }
+  let(:secondary_dir) { File.join(vardir, "secondary") }
+  let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
 
-    let(:foo_metadata) do
-      {
-        :author       => "puppetlabs",
-        :name         => "puppetlabs/foo",
-        :version      => "1.0.0",
-        :source       => "http://dummyurl/foo",
-        :license      => "Apache2",
-        :dependencies => [],
-      }
-    end
+  let(:module) { 'module-not_installed' }
+  let(:application) do
+    opts = options
+    Puppet::ModuleTool.set_option_defaults(opts)
+    Puppet::ModuleTool::Applications::Uninstaller.new(self.module, opts)
+  end
 
-    let(:bar_metadata) do
-      {
-        :author       => "puppetlabs",
-        :name         => "puppetlabs/bar",
-        :version      => "1.0.0",
-        :source       => "http://dummyurl/bar",
-        :license      => "Apache2",
-        :dependencies => [],
-      }
-    end
+  def options
+    { :environment => environment }
+  end
 
-    context "when the module is not installed" do
-      it "should fail" do
-        Puppet::ModuleTool::Applications::Uninstaller.new('fakemod_not_installed', options).run[:result].should == :failure
-      end
+  subject { application.run }
+
+  context "when the module is not installed" do
+    it "should fail" do
+      subject.should include :result => :failure
     end
+  end
 
-    context "when the module is installed" do
+  context "when the module is installed" do
+    let(:module) { 'pmtacceptance-stdlib' }
 
-      it "should uninstall the module" do
-        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+    before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+    before { preinstall('pmtacceptance-apache', '0.0.4') }
 
-        results = uninstaller.run
+    it "should uninstall the module" do
+      subject[:affected_modules].first.forge_name.should == "pmtacceptance/stdlib"
+    end
 
-        results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-      end
+    it "should only uninstall the requested module" do
+      subject[:affected_modules].length == 1
+    end
 
-      it "should only uninstall the requested module" do
-        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-        PuppetSpec::Modules.create('bar', modpath1, :metadata => bar_metadata)
+    context 'in two modulepaths' do
+      before { preinstall('pmtacceptance-stdlib', '2.0.0', :into => secondary_dir) }
 
-        results = uninstaller.run
-        results[:affected_modules].length == 1
-        results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+      it "should fail if a module exists twice in the modpath" do
+        subject.should include :result => :failure
       end
+    end
 
-      it "should uninstall fail if a module exists twice in the modpath" do
-        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-        PuppetSpec::Modules.create('foo', modpath2, :metadata => foo_metadata)
-
-        uninstaller.run[:result].should == :failure
+    context "when options[:version] is specified" do
+      def options
+        super.merge(:version => '1.0.0')
       end
 
-      context "when options[:version] is specified" do
-
-        it "should uninstall the module if the version matches" do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-
-          options[:version] = "1.0.0"
+      it "should uninstall the module if the version matches" do
+        subject[:affected_modules].length.should == 1
+        subject[:affected_modules].first.version.should == "1.0.0"
+      end
 
-          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"
+      context 'but not matched' do
+        def options
+          super.merge(:version => '2.0.0')
         end
 
         it "should not uninstall the module if the version does not match" do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-
-          options[:version] = "2.0.0"
-
-          uninstaller.run[:result].should == :failure
+          subject.should include :result => :failure
         end
       end
+    end
 
-      context "when the module metadata is missing" do
-
-        it "should not uninstall the module" do
-          PuppetSpec::Modules.create('foo', modpath1)
+    context "when the module metadata is missing" do
+      before { File.unlink(File.join(primary_dir, 'stdlib', 'metadata.json')) }
 
-          uninstaller.run[:result].should == :failure
-        end
+      it "should not uninstall the module" do
+        application.run[:result].should == :failure
       end
+    end
 
-      context "when the module has local changes" do
-
-        it "should not uninstall the module" do
-          mod = PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-          Puppet::ModuleTool::Applications::Checksummer.expects(:run).with(mod.path).returns(['change'])
-
-          uninstaller.run[:result].should == :failure
-        end
-
+    context "when the module has local changes" do
+      before do
+        mark_changed(File.join(primary_dir, 'stdlib'))
       end
 
-      context "when the module does not have local changes" do
+      it "should not uninstall the module" do
+        subject.should include :result => :failure
+      end
+    end
 
-        it "should uninstall the module" do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+    context "when uninstalling the module will cause broken dependencies" do
+      before { preinstall('pmtacceptance-apache', '0.10.0') }
 
-          results = uninstaller.run
-          results[:affected_modules].length.should == 1
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-        end
+      it "should not uninstall the module" do
+        subject.should include :result => :failure
       end
+    end
 
-      context "when uninstalling the module will cause broken dependencies" do
-        it "should not uninstall the module" do
-          Puppet.settings[:modulepath] = modpath1
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-
-          PuppetSpec::Modules.create(
-            'needy',
-            modpath1,
-            :metadata => {
-              :author => 'beggar',
-              :dependencies => [{
-                  "version_requirement" => ">= 1.0.0",
-                  "name" => "puppetlabs/foo"
-              }]
-            }
-          )
-
-          uninstaller.run[:result].should == :failure
-        end
-      end
+    context "when using the --force flag" do
 
-      context "when using the --force flag" do
+      def options
+        super.merge(:force => true)
+      end
 
-        let(:fakemod) do
-          stub(
-            :forge_name => 'puppetlabs/fakemod',
-            :version    => '0.0.1',
-            :has_local_changes? => true
-          )
+      context "with local changes" do
+        before do
+          mark_changed(File.join(primary_dir, 'stdlib'))
         end
 
         it "should ignore local changes" do
-          foo = mkmod("foo", modpath1, foo_metadata)
-          options[:force] = true
-
-          results = uninstaller.run
-          results[:affected_modules].length.should == 1
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+          subject[:affected_modules].length.should == 1
+          subject[:affected_modules].first.forge_name.should == "pmtacceptance/stdlib"
         end
+      end
+
+      context "while depended upon" do
+        before { preinstall('pmtacceptance-apache', '0.10.0') }
 
         it "should ignore broken dependencies" do
-          Puppet.settings[:modulepath] = modpath1
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-
-          PuppetSpec::Modules.create(
-            'needy',
-            modpath1,
-            :metadata => {
-              :author => 'beggar',
-              :dependencies => [{
-                  "version_requirement" => ">= 1.0.0",
-                  "name" => "puppetlabs/foo"
-              }]
-            }
-          )
-          options[:force] = true
-
-          results = uninstaller.run
-          results[:affected_modules].length.should == 1
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+          subject[:affected_modules].length.should == 1
+          subject[:affected_modules].first.forge_name.should == "pmtacceptance/stdlib"
         end
       end
     end

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

@@ -1,4 +1,6 @@
 require 'spec_helper'
+require 'json'
+
 require 'puppet/module_tool/applications'
 require 'puppet_spec/modules'
 
@@ -7,28 +9,26 @@ describe Puppet::ModuleTool::Applications::Unpacker do
 
   let(:target)      { tmpdir("unpacker") }
   let(:module_name) { 'myusername-mytarball' }
-  let(:filename)    { tmpdir("module") + "/#{module_name}-1.0.0.tar.gz" }
+  let(:filename)    { tmpdir("module") + "/module.tar.gz" }
   let(:working_dir) { tmpdir("working_dir") }
-  let(:unpacker) do
-    Puppet::ModuleTool::Applications::Unpacker.new(filename, :target_dir => target)
-  end
 
   before :each do
     Puppet.settings[:module_working_dir] = working_dir
   end
 
-  it "should raise ArgumentError when filename is invalid" do
-    expect { Puppet::ModuleTool::Applications::Unpacker.new("invalid.tar.gz", :target_dir => target) }.to raise_error(ArgumentError)
-  end
-
   it "should attempt to untar file to temporary location" do
-    untarrer = mock('untarrer')
-    Puppet::ModuleTool::Tar.expects(:instance).with(module_name).returns(untarrer)
-    untarrer.expects(:unpack).with(filename, regexp_matches(/^#{Regexp.escape(working_dir)}/)) do |src, dest|
+    untar = mock('Tar')
+    untar.expects(:unpack).with(filename, anything()) do |src, dest, _|
       FileUtils.mkdir(File.join(dest, 'extractedmodule'))
+      File.open(File.join(dest, 'extractedmodule', 'metadata.json'), 'w+') do |file|
+        file.puts JSON.generate('name' => module_name, 'version' => '1.0.0')
+      end
+      true
     end
 
-    unpacker.run
+    Puppet::ModuleTool::Tar.expects(:instance).returns(untar)
+
+    Puppet::ModuleTool::Applications::Unpacker.run(filename, :target_dir => target)
     File.should be_directory(File.join(target, 'mytarball'))
   end
 end

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

@@ -1,34 +1,302 @@
 require 'spec_helper'
 require 'puppet/module_tool/applications'
-require 'puppet_spec/modules'
+require 'puppet_spec/module_tool/shared_functions'
+require 'puppet_spec/module_tool/stub_source'
 require 'semver'
 
 describe Puppet::ModuleTool::Applications::Upgrader do
+  include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
 
-  it "should update the requested module"
-  it "should not update dependencies"
-  it "should fail when updating a dependency to an unsupported version"
-  it "should fail when updating a module that is not installed"
-  it "should warn when the latest version is already installed"
-  it "should warn when the best version is already installed"
+  before do
+    FileUtils.mkdir_p(primary_dir)
+    FileUtils.mkdir_p(secondary_dir)
+  end
+
+  let(:vardir)   { tmpdir('upgrader') }
+  let(:primary_dir) { File.join(vardir, "primary") }
+  let(:secondary_dir) { File.join(vardir, "secondary") }
+  let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
 
-  context "when using the '--version' option" do
-    it "should update an installed module to the requested version"
+  let(:environment) do
+    Puppet.lookup(:current_environment).override_with(
+      :vardir     => vardir,
+      :modulepath => [ primary_dir, secondary_dir ]
+    )
   end
 
-  context "when using the '--force' flag" do
-    it "should ignore missing dependencies"
-    it "should ignore version constraints"
-    it "should not update a module that is not installed"
+  before do
+    Semantic::Dependency.clear_sources
+    installer = Puppet::ModuleTool::Applications::Upgrader.any_instance
+    installer.stubs(:module_repository).returns(remote_source)
   end
 
-  context "when using the '--env' option" do
-    it "should use the correct environment"
+  def upgrader(name, options = {})
+    Puppet::ModuleTool.set_option_defaults(options)
+    Puppet::ModuleTool::Applications::Upgrader.new(name, options)
   end
 
-  context "when there are missing dependencies" do
-    it "should fail to upgrade the original module"
-    it "should raise an error"
+  describe '#run' do
+    let(:module) { 'pmtacceptance-stdlib' }
+
+    def options
+      { :environment => environment }
+    end
+
+    let(:application) { upgrader(self.module, options) }
+    subject { application.run }
+
+    it 'fails if the module is not already installed' do
+      subject.should include :result => :failure
+      subject[:error].should include :oneline => "Could not upgrade '#{self.module}'; module is not installed"
+    end
+
+    context 'for an installed module' do
+      context 'without dependencies' do
+        before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+
+        context 'without options' do
+          it 'properly upgrades the module to the greatest version' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('4.1.0')
+          end
+        end
+
+        context 'with version range' do
+          def options
+            super.merge(:version => '3.x')
+          end
+
+          context 'not matching the installed version' do
+            it 'properly upgrades the module to the greatest version within that range' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('3.2.0')
+            end
+          end
+
+          context 'matching the installed version' do
+            context 'with more recent version' do
+              before { preinstall('pmtacceptance-stdlib', '3.0.0')}
+
+              it 'properly upgrades the module to the greatest version within that range' do
+                subject.should include :result => :success
+                graph_should_include 'pmtacceptance-stdlib', v('3.0.0') => v('3.2.0')
+              end
+            end
+
+            context 'without more recent version' do
+              before { preinstall('pmtacceptance-stdlib', '3.2.0')}
+
+              context 'without options' do
+                it 'declines to upgrade' do
+                  subject.should include :result => :noop
+                end
+              end
+
+              context 'with --force' do
+                def options
+                  super.merge(:force => true)
+                end
+
+                it 'overwrites the installed module with the greatest version matching that range' do
+                  subject.should include :result => :success
+                  graph_should_include 'pmtacceptance-stdlib', v('3.2.0') => v('3.2.0')
+                end
+              end
+            end
+          end
+        end
+      end
+
+      context 'that is depended upon' do
+        # pmtacceptance-keystone depends on pmtacceptance-mysql  >=0.6.1 <1.0.0
+        before { preinstall('pmtacceptance-keystone', '2.1.0') }
+        before { preinstall('pmtacceptance-mysql', '0.9.0') }
+
+        let(:module) { 'pmtacceptance-mysql' }
+
+        context 'and out of date' do
+          before { preinstall('pmtacceptance-mysql', '0.8.0') }
+
+          it 'properly upgrades to the greatest version matching the dependency' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-mysql', v('0.8.0') => v('0.9.0')
+          end
+        end
+
+        context 'and up to date' do
+          it 'declines to upgrade' do
+            subject.should include :result => :failure
+          end
+        end
+
+        context 'when specifying a violating version range' do
+          def options
+            super.merge(:version => '2.1.0')
+          end
+
+          it 'fails to upgrade the module' do
+            # TODO: More helpful error message?
+            subject.should include :result => :failure
+            subject[:error].should include :oneline => "Could not upgrade '#{self.module}' (v0.9.0 -> v2.1.0); no version satisfies all dependencies"
+          end
+
+          context 'using --force' do
+            def options
+              super.merge(:force => true)
+            end
+
+            it 'overwrites the installed module with the specified version' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-mysql', v('0.9.0') => v('2.1.0')
+            end
+          end
+        end
+      end
+
+      context 'with local changes' do
+        before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+        before do
+          release = application.send(:installed_modules)['pmtacceptance-stdlib']
+          mark_changed(release.mod.path)
+        end
+
+        it 'fails to upgrade' do
+          subject.should include :result => :failure
+          subject[:error].should include :oneline => "Could not upgrade '#{self.module}'; module has had changes made locally"
+        end
+      end
+
+      context 'with dependencies' do
+        context 'that are unsatisfied' do
+          def options
+            super.merge(:version => '0.1.1')
+          end
+
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module and installs the missing dependencies' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.1.1')
+            graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0'), :action => :install
+          end
+        end
+
+        context 'with older major versions' do
+          # pmtacceptance-apache 0.0.4 has no dependency on pmtacceptance-stdlib
+          # the next available version (0.1.1) and all subsequent versions depend on pmtacceptance-stdlib >= 2.2.1
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'refuses to upgrade the installed dependency to a new major version, but upgrades the module to the greatest compatible version' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.0.4')
+          end
+
+          context 'using --ignore_dependencies' do
+            def options
+              super.merge(:ignore_dependencies => true)
+            end
+
+            it 'upgrades the module to the greatest available version' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            end
+          end
+        end
+
+        context 'with satisfying major versions' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '2.0.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module and its dependencies to their greatest compatible versions' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', v('2.0.0') => v('2.6.0')
+          end
+        end
+
+        context 'with satisfying versions' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '2.4.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module to the greatest available version' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', nil
+          end
+        end
+
+        context 'with current versions' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '2.6.0') }
+          let(:module) { 'pmtacceptance-apache' }
+
+          it 'upgrades the module to the greatest available version' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', nil
+          end
+        end
+
+        context 'with shared dependencies' do
+          # bacula 0.0.3 depends on stdlib >= 2.2.0 and pmtacceptance/mysql >= 1.0.0
+          # bacula 0.0.2 depends on stdlib >= 2.2.0 and pmtacceptance/mysql >= 0.0.1
+          # bacula 0.0.1 depends on stdlib >= 2.2.0
+
+          # keystone 2.1.0 depends on pmtacceptance/stdlib >= 2.5.0 and pmtacceptance/mysql >=0.6.1 <1.0.0
+
+          before { preinstall('pmtacceptance-bacula', '0.0.1') }
+          before { preinstall('pmtacceptance-mysql', '0.9.0') }
+          before { preinstall('pmtacceptance-keystone', '2.1.0') }
+
+          let(:module) { 'pmtacceptance-bacula' }
+
+          it 'upgrades the module to the greatest version compatible with all other installed modules' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-bacula', v('0.0.1') => v('0.0.2')
+          end
+
+          context 'using --force' do
+            def options
+              super.merge(:force => true)
+            end
+
+            it 'upgrades the module to the greatest version available' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-bacula', v('0.0.1') => v('0.0.3')
+            end
+          end
+        end
+
+        context 'in other modulepath directories' do
+          before { preinstall('pmtacceptance-apache', '0.0.3') }
+          before { preinstall('pmtacceptance-stdlib', '1.0.0', :into => secondary_dir) }
+          let(:module) { 'pmtacceptance-apache' }
+
+          context 'with older major versions' do
+            it 'upgrades the module to the greatest version compatible with the installed modules' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.0.4')
+              graph_should_include 'pmtacceptance-stdlib', nil
+            end
+          end
+
+          context 'with satisfying major versions' do
+            before { preinstall('pmtacceptance-stdlib', '2.0.0', :into => secondary_dir) }
+
+            it 'upgrades the module and its dependencies to their greatest compatible versions, in-place' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-apache', v('0.0.3') => v('0.10.0')
+              graph_should_include 'pmtacceptance-stdlib', v('2.0.0') => v('2.6.0'), :path => secondary_dir
+            end
+          end
+        end
+      end
+    end
   end
 end