puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/provider/package/pacman_spec.rb

@@ -2,7 +2,6 @@
 require 'spec_helper'
 require 'stringio'
 
-
 describe Puppet::Type.type(:package).provider(:pacman) do
   let(:no_extra_options) { { :failonfail => true, :combine => true, :custom_environment => {} } }
   let(:executor) { Puppet::Util::Execution }
@@ -16,6 +15,8 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     described_class.stubs(:which).with('/usr/bin/pacman').returns('/usr/bin/pacman')
     resolver.stubs(:which).with('/usr/bin/yaourt').returns('/usr/bin/yaourt')
     described_class.stubs(:which).with('/usr/bin/yaourt').returns('/usr/bin/yaourt')
+    described_class.stubs(:group?).returns(false)
+    described_class.stubs(:yaourt?).returns(false)
   end
 
   describe "when installing" do
@@ -26,24 +27,40 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call pacman to install the right package quietly when yaourt is not installed" do
-      provider.stubs(:yaourt?).returns(false)
-      args = ['--noconfirm', '--noprogressbar', '-Sy', resource[:name]]
+      args = ['--noconfirm', '--needed', '--noprogressbar', '-Sy', resource[:name]]
       provider.expects(:pacman).at_least_once.with(*args).returns ''
       provider.install
     end
 
     it "should call yaourt to install the right package quietly when yaourt is installed" do
-      provider.stubs(:yaourt?).returns(true)
-      args = ['--noconfirm', '-S', resource[:name]]
+      described_class.stubs(:yaourt?).returns(true)
+      args = ['--noconfirm', '--needed', '--noprogressbar', '-Sy', resource[:name]]
       provider.expects(:yaourt).at_least_once.with(*args).returns ''
       provider.install
     end
 
-    it "should raise an ExecutionFailure if the installation failed" do
+    it "should raise an Puppet::Error if the installation failed" do
       executor.stubs(:execute).returns("")
       provider.expects(:query).returns(nil)
 
-      lambda { provider.install }.should raise_exception(Puppet::ExecutionFailure)
+      expect {
+        provider.install
+      }.to raise_exception(Puppet::Error, /Could not find package/)
+    end
+
+    it "should raise an Puppet::Error when trying to install a group and allow_virtual is false" do
+      described_class.stubs(:group?).returns(true)
+      resource[:allow_virtual] = false
+      expect {
+        provider.install
+      }.to raise_error(Puppet::Error, /Refusing to install package group/)
+    end
+
+    it "should not raise an Puppet::Error when trying to install a group and allow_virtual is true" do
+      described_class.stubs(:group?).returns(true)
+      resource[:allow_virtual] = true
+      executor.stubs(:execute).returns("")
+      provider.install
     end
 
     describe "and install_options are given" do
@@ -52,15 +69,14 @@ describe Puppet::Type.type(:package).provider(:pacman) do
       end
 
       it "should call pacman to install the right package quietly when yaourt is not installed" do
-        provider.stubs(:yaourt?).returns(false)
-        args = ['--noconfirm', '--noprogressbar', '-x', '--arg=value', '-Sy', resource[:name]]
+        args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-Sy', resource[:name]]
         provider.expects(:pacman).at_least_once.with(*args).returns ''
         provider.install
       end
 
       it "should call yaourt to install the right package quietly when yaourt is installed" do
-        provider.stubs(:yaourt?).returns(true)
-        args = ['--noconfirm', '-x', '--arg=value', '-S', resource[:name]]
+        described_class.stubs(:yaourt?).returns(true)
+        args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-Sy', resource[:name]]
         provider.expects(:yaourt).at_least_once.with(*args).returns ''
         provider.install
       end
@@ -124,17 +140,21 @@ describe Puppet::Type.type(:package).provider(:pacman) do
         end
 
         it "should fail" do
-          lambda { provider.install }.should raise_error(Puppet::Error)
+          expect {
+            provider.install
+          }.to raise_error(Puppet::Error, /puppet:\/\/ URL is not supported/)
         end
       end
 
-      context "as a malformed URL" do
+      context "as an unsupported URL scheme" do
         before do
-          resource[:source] = "blah://"
+          resource[:source] = "blah://foo.com"
         end
 
         it "should fail" do
-          lambda { provider.install }.should raise_error(Puppet::Error)
+          expect {
+            provider.install
+          }.to raise_error(Puppet::Error, /Source blah:\/\/foo\.com is not supported/)
         end
       end
     end
@@ -143,7 +163,7 @@ describe Puppet::Type.type(:package).provider(:pacman) do
   describe "when updating" do
     it "should call install" do
       provider.expects(:install).returns("install return value")
-      provider.update.should == "install return value"
+      expect(provider.update).to eq("install return value")
     end
   end
 
@@ -154,120 +174,180 @@ describe Puppet::Type.type(:package).provider(:pacman) do
       provider.uninstall
     end
 
+    it "should call yaourt to remove the right package quietly" do
+      described_class.stubs(:yaourt?).returns(true)
+      args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
+      provider.expects(:yaourt).with(*args)
+      provider.uninstall
+    end
+
     it "adds any uninstall_options" do
       resource[:uninstall_options] = ['-x', {'--arg' => 'value'}]
       args = ["/usr/bin/pacman", "--noconfirm", "--noprogressbar", "-x", "--arg=value", "-R", resource[:name]]
       executor.expects(:execute).with(args, no_extra_options).returns ""
       provider.uninstall
     end
+
+    it "should recursively remove packages when given a package group" do
+      described_class.stubs(:group?).returns(true)
+      args = ["/usr/bin/pacman", "--noconfirm", "--noprogressbar", "-R", "-s", resource[:name]]
+      executor.expects(:execute).with(args, no_extra_options).returns ""
+      provider.uninstall
+    end
   end
 
   describe "when querying" do
     it "should query pacman" do
-      executor.
-        expects(:execute).
-        with(["/usr/bin/pacman", "-Qi", resource[:name]], no_extra_options)
+      executor.expects(:execpipe).with(["/usr/bin/pacman", '-Q'])
+      executor.expects(:execpipe).with(["/usr/bin/pacman", '-Sgg', 'package'])
       provider.query
     end
 
     it "should return the version" do
-      query_output = <<EOF
-Name           : package
-Version        : 1.01.3-2
-URL            : http://www.archlinux.org/pacman/
-Licenses       : GPL
-Groups         : base
-Provides       : None
-Depends On     : bash  libarchive>=2.7.1  libfetch>=2.25  pacman-mirrorlist
-Optional Deps  : fakeroot: for makepkg usage as normal user
-                 curl: for rankmirrors usage
-Required By    : None
-Conflicts With : None
-Replaces       : None
-Installed Size : 2352.00 K
-Packager       : Dan McGee <dan@archlinux.org>
-Architecture   : i686
-Build Date     : Sat 22 Jan 2011 03:56:41 PM EST
-Install Date   : Thu 27 Jan 2011 06:45:49 AM EST
-Install Reason : Explicitly installed
-Install Script : Yes
-Description    : A library-based package manager with dependency support
+      executor.
+          expects(:execpipe).
+          with(["/usr/bin/pacman", "-Q"]).yields(<<EOF)
+otherpackage 1.2.3.4
+package 1.01.3-2
+yetanotherpackage 1.2.3.4
 EOF
+      executor.expects(:execpipe).with(['/usr/bin/pacman', '-Sgg', 'package']).yields('')
 
-      executor.expects(:execute).returns(query_output)
-      provider.query.should == {:ensure => "1.01.3-2"}
+      expect(provider.query).to eq({ :name => 'package', :ensure => '1.01.3-2', :provider => :pacman,  })
     end
 
-    it "should return a nil if the package isn't found" do
-      executor.expects(:execute).returns("")
-      provider.query.should be_nil
+    it "should return a hash indicating that the package is missing" do
+      executor.expects(:execpipe).twice.yields("")
+      expect(provider.query).to be_nil
     end
 
-    it "should return a hash indicating that the package is missing on error" do
-      executor.expects(:execute).raises(Puppet::ExecutionFailure.new("ERROR!"))
-      provider.query.should == {
-        :ensure => :purged,
-        :status => 'missing',
-        :name => resource[:name],
-        :error => 'ok',
-      }
+    it "should raise an error if execpipe fails" do
+      executor.expects(:execpipe).raises(Puppet::ExecutionFailure.new("ERROR!"))
+
+      expect { provider.query }.to raise_error(RuntimeError)
     end
-  end
 
+    describe 'when querying a group' do
+      before :each do
+        executor.expects(:execpipe).with(['/usr/bin/pacman', '-Q']).yields('foo 1.2.3')
+        executor.expects(:execpipe).with(['/usr/bin/pacman', '-Sgg', 'package']).yields('package foo')
+      end
+
+      it 'should warn when allow_virtual is false' do
+        resource[:allow_virtual] = false
+        provider.expects(:warning)
+        provider.query
+      end
 
+      it 'should not warn allow_virtual is true' do
+        resource[:allow_virtual] = true
+        described_class.expects(:warning).never
+        provider.query
+      end
+    end
+  end
 
-  describe "when fetching a package list" do
-    it "should retrieve installed packages" do
+  describe "when determining instances" do
+    it "should retrieve installed packages and groups" do
       described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Q'])
-      described_class.installedpkgs
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Sgg'])
+      described_class.instances
     end
 
-    it "should retrieve installed package groups" do
-      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Qg'])
-      described_class.installedgroups
+    it "should return installed packages" do
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Q']).yields(StringIO.new("package1 1.23-4\npackage2 2.00\n"))
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Sgg']).yields("")
+      instances = described_class.instances
+
+      expect(instances.length).to eq(2)
+
+      expect(instances[0].properties).to eq({
+          :provider => :pacman,
+          :ensure => '1.23-4',
+          :name => 'package1'
+      })
+
+      expect(instances[1].properties).to eq({
+          :provider => :pacman,
+          :ensure => '2.00',
+          :name => 'package2'
+      })
     end
 
-    it "should return installed packages with their versions" do
-      described_class.expects(:execpipe).yields(StringIO.new("package1 1.23-4\npackage2 2.00\n"))
-      packages = described_class.installedpkgs
+    it "should return completely installed groups with a virtual version together with packages" do
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Q']).yields(<<EOF)
+package1 1.00
+package2 1.00
+EOF
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Sgg']).yields(<<EOF)
+group1 package1
+group1 package2
+EOF
+      instances = described_class.instances
 
-      packages.length.should == 2
+      expect(instances.length).to eq(3)
 
-      packages[0].properties.should == {
+      expect(instances[0].properties).to eq({
         :provider => :pacman,
-        :ensure => '1.23-4',
-        :name => 'package1'
-      }
-
-      packages[1].properties.should == {
+        :ensure   => '1.00',
+        :name     => 'package1'
+      })
+      expect(instances[1].properties).to eq({
         :provider => :pacman,
-        :ensure => '2.00',
-        :name => 'package2'
-      }
+        :ensure   => '1.00',
+        :name     => 'package2'
+      })
+      expect(instances[2].properties).to eq({
+        :provider => :pacman,
+        :ensure   => 'package1 1.00, package2 1.00',
+        :name     => 'group1'
+      })
     end
 
-    it "should return installed groups with a dummy version" do
-      described_class.expects(:execpipe).yields(StringIO.new("group1 pkg1\ngroup1 pkg2"))
-      groups = described_class.installedgroups
+    it "should not return partially installed packages" do
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Q']).yields(<<EOF)
+package1 1.00
+EOF
+      described_class.expects(:execpipe).with(["/usr/bin/pacman", '-Sgg']).yields(<<EOF)
+group1 package1
+group1 package2
+EOF
+      instances = described_class.instances
 
-      groups.length.should == 1
+      expect(instances.length).to eq(1)
 
-      groups[0].properties.should == {
+      expect(instances[0].properties).to eq({
         :provider => :pacman,
-        :ensure   => '1',
-        :name     => 'group1'
+        :ensure   => '1.00',
+        :name     => 'package1'
+      })
+    end
+
+    it 'should sort package names for installed groups' do
+      described_class.expects(:execpipe).with(['/usr/bin/pacman', '-Sgg', 'group1']).yields(<<EOF)
+group1 aa
+group1 b
+group1 a
+EOF
+      package_versions= {
+        'a' => '1',
+        'aa' => '1',
+        'b' => '1',
       }
+
+      virtual_group_version = described_class.get_installed_groups(package_versions, 'group1')
+      expect(virtual_group_version).to eq({ 'group1' => 'a 1, aa 1, b 1' })
     end
 
     it "should return nil on error" do
-      described_class.expects(:execpipe).twice.raises(Puppet::ExecutionFailure.new("ERROR!"))
-      described_class.instances.should be_nil
+      described_class.expects(:execpipe).raises(Puppet::ExecutionFailure.new("ERROR!"))
+      expect { described_class.instances }.to raise_error(RuntimeError)
     end
 
     it "should warn on invalid input" do
-      described_class.expects(:execpipe).yields(StringIO.new("blah"))
-      described_class.expects(:warning).with("Failed to match line blah")
-      described_class.installedpkgs == []
+      described_class.expects(:execpipe).twice.yields(StringIO.new("blah"))
+      described_class.expects(:warning).with("Failed to match line 'blah'")
+      expect(described_class.instances).to eq([])
     end
   end
 
@@ -308,7 +388,26 @@ EOF
         at_least_once().
         returns("1.00.2-3\n")
 
-      provider.latest.should == "1.00.2-3"
+      expect(provider.latest).to eq("1.00.2-3")
+    end
+
+    it "should return a virtual group version when resource is a package group" do
+      described_class.stubs(:group?).returns(true)
+      get_latest_version = sequence("get_latest_version")
+      executor.
+        stubs(:execute).
+        with(['/usr/bin/pacman', '-Sy'], no_extra_options).
+        in_sequence(get_latest_version)
+
+      executor.
+        expects(:execute).
+        in_sequence(get_latest_version).
+        with(['/usr/bin/pacman', '-Sp', '--print-format', '%n %v', resource[:name]], no_extra_options).
+        returns(<<EOF)
+package2 1.0.1
+package1 1.0.0
+EOF
+      expect(provider.latest).to eq('package1 1.0.0, package2 1.0.1')
     end
   end
 end

data/spec/unit/provider/package/pip_spec.rb

@@ -12,20 +12,21 @@ describe provider_class do
     @client = stub_everything('client')
     @client.stubs(:call).with('package_releases', 'real_package').returns(["1.3", "1.2.5", "1.2.4"])
     @client.stubs(:call).with('package_releases', 'fake_package').returns([])
+    XMLRPC::Client.stubs(:new2).returns(@client)
   end
 
   describe "parse" do
 
     it "should return a hash on valid input" do
-      provider_class.parse("real_package==1.2.5").should == {
+      expect(provider_class.parse("real_package==1.2.5")).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-      }
+      })
     end
 
     it "should return nil on invalid input" do
-      provider_class.parse("foo").should == nil
+      expect(provider_class.parse("foo")).to eq(nil)
     end
 
   end
@@ -34,18 +35,18 @@ describe provider_class do
     it "should return pip-python on RedHat < 7 systems" do
       Facter.stubs(:value).with(:osfamily).returns("RedHat")
       Facter.stubs(:value).with(:operatingsystemmajrelease).returns("6")
-      provider_class.cmd.should == 'pip-python'
+      expect(provider_class.cmd).to eq('pip-python')
     end
 
     it "should return pip on RedHat >= 7 systems" do
       Facter.stubs(:value).with(:osfamily).returns("RedHat")
       Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
-      provider_class.cmd.should == 'pip'
+      expect(provider_class.cmd).to eq('pip')
     end
 
     it "should return pip by default" do
       Facter.stubs(:value).with(:osfamily).returns("Not RedHat")
-      provider_class.cmd.should == 'pip'
+      expect(provider_class.cmd).to eq('pip')
     end
 
   end
@@ -67,7 +68,7 @@ describe provider_class do
         Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
         Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
         provider_class.expects(:which).with(pip_cmd).returns nil
-        provider_class.instances.should == []
+        expect(provider_class.instances).to eq([])
       end
     end
 
@@ -86,16 +87,16 @@ describe provider_class do
         :provider => :pip,
       })]
 
-      @provider.query.should == {
+      expect(@provider.query).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-      }
+      })
     end
 
     it "should return nil when the package is missing" do
       provider_class.expects(:instances).returns []
-      @provider.query.should == nil
+      expect(@provider.query).to eq(nil)
     end
 
     it "should be case insensitive" do
@@ -107,63 +108,33 @@ describe provider_class do
         :provider => :pip,
       })]
 
-      @provider.query.should == {
+      expect(@provider.query).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
-      }
+      })
     end
 
   end
 
   describe "latest" do
-    context "connecting directly" do
-
-      before :each do
-        XMLRPC::Client.expects(:new2).with("http://pypi.python.org/pypi", nil).returns(@client)
-      end
-
-      it "should find a version number for real_package" do
-        @resource[:name] = "real_package"
-        @provider.latest.should_not == nil
-      end
-
-      it "should not find a version number for fake_package" do
-        @resource[:name] = "fake_package"
-        @provider.latest.should == nil
-      end
-
-      it "should handle a timeout gracefully" do
-        @resource[:name] = "fake_package"
-        @client.stubs(:call).raises(Timeout::Error)
-        lambda { @provider.latest }.should raise_error(Puppet::Error)
-      end
 
+    it "should find a version number for real_package" do
+      @resource[:name] = "real_package"
+      expect(@provider.latest).not_to eq(nil)
     end
 
-    context "connecting via a proxy" do
-      before :each do
-        Puppet::Util::HttpProxy.expects(:http_proxy_host).returns 'some_host'
-        Puppet::Util::HttpProxy.expects(:http_proxy_port).returns 'some_port'
-        XMLRPC::Client.expects(:new2).with("http://pypi.python.org/pypi", "some_host:some_port").returns(@client)
-      end
-
-      it "should find a version number for real_package" do
-        @resource[:name] = "real_package"
-        @provider.latest.should_not == nil
-      end
-
-      it "should not find a version number for fake_package" do
-        @resource[:name] = "fake_package"
-        @provider.latest.should == nil
-      end
+    it "should not find a version number for fake_package" do
+      @resource[:name] = "fake_package"
+      expect(@provider.latest).to eq(nil)
+    end
 
-      it "should handle a timeout gracefully" do
-        @resource[:name] = "fake_package"
-        @client.stubs(:call).raises(Timeout::Error)
-        lambda { @provider.latest }.should raise_error(Puppet::Error)
-      end
+    it "should handle a timeout gracefully" do
+      @resource[:name] = "fake_package"
+      @client.stubs(:call).raises(Timeout::Error)
+      expect { @provider.latest }.to raise_error(Puppet::Error)
     end
+
   end
 
   describe "install" do