puppet 6.0.4-x86-mingw32 → 6.0.5-x86-mingw32

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

@@ -1,9 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:package).provider(:pip3)
-
-describe provider_class do
+describe Puppet::Type.type(:package).provider(:pip3) do
 
   it { is_expected.to be_installable }
   it { is_expected.to be_uninstallable }
@@ -12,11 +9,11 @@ describe provider_class do
   it { is_expected.to be_install_options }
 
   it "should inherit most things from pip provider" do
-    expect(provider_class < Puppet::Type.type(:package).provider(:pip))
+    expect(described_class < Puppet::Type.type(:package).provider(:pip))
   end
 
   it "should use pip3 command" do
-    expect(provider_class.cmd).to eq(["pip3"])
+    expect(described_class.cmd).to eq(["pip3"])
   end
 
 end

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

@@ -1,21 +1,19 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:package).provider(:pip)
 osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python'] }
 
-describe provider_class do
-  before do
+describe Puppet::Type.type(:package).provider(:pip) do
+  before do  
     @resource = Puppet::Resource.new(:package, "fake_package")
-    @provider = provider_class.new(@resource)
+    @provider = described_class.new(@resource)
     @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([])
   end
 
-  describe "parse" do
+  context "parse" do
     it "should return a hash on valid input" do
-      expect(provider_class.parse("real_package==1.2.5")).to eq({
+      expect(described_class.parse("real_package==1.2.5")).to eq({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
@@ -23,43 +21,43 @@ describe provider_class do
     end
 
     it "should return nil on invalid input" do
-      expect(provider_class.parse("foo")).to eq(nil)
+      expect(described_class.parse("foo")).to eq(nil)
     end
   end
 
-  describe "cmd" do
+  context "cmd" do
     it "should return 'pip.exe' by default on Windows systems" do
       Puppet::Util::Platform.stubs(:windows?).returns true
-      expect(provider_class.cmd[0]).to eq('pip.exe')
+      expect(described_class.cmd[0]).to eq('pip.exe')
     end
 
     it "could return pip-python on legacy redhat systems which rename pip" do
       Puppet::Util::Platform.stubs(:windows?).returns false
-      expect(provider_class.cmd[1]).to eq('pip-python')
+      expect(described_class.cmd[1]).to eq('pip-python')
     end
 
     it "should return pip by default on other systems" do
       Puppet::Util::Platform.stubs(:windows?).returns false
-      expect(provider_class.cmd[0]).to eq('pip')
+      expect(described_class.cmd[0]).to eq('pip')
     end
   end
 
-  describe "instances" do
+  context "instances" do
     osfamilies.each do |osfamily, pip_cmds|
       it "should return an array on #{osfamily} systems when #{pip_cmds.join(' or ')} is present" do
         Puppet::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
         pip_cmds.each do |pip_cmd|
           pip_cmds.each do |cmd|
             unless cmd == pip_cmd
-              provider_class.expects(:which).with(cmd).returns(nil)
+              described_class.expects(:which).with(cmd).returns(nil)
             end
           end
-          provider_class.stubs(:pip_version).returns('8.0.1')
-          provider_class.expects(:which).with(pip_cmd).returns("/fake/bin/#{pip_cmd}")
+          described_class.stubs(:pip_version).returns('8.0.1')
+          described_class.expects(:which).with(pip_cmd).returns("/fake/bin/#{pip_cmd}")
           p = stub("process")
           p.expects(:collect).yields("real_package==1.2.5")
-          provider_class.expects(:execpipe).with(["/fake/bin/#{pip_cmd}", "freeze"]).yields(p)
-          provider_class.instances
+          described_class.expects(:execpipe).with(["/fake/bin/#{pip_cmd}", "freeze"]).yields(p)
+          described_class.instances
         end
       end
 
@@ -68,12 +66,12 @@ describe provider_class do
         versions.each do |version|
           it "should use the --all option when version is '#{version}'" do
             Puppet::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
-            provider_class.stubs(:pip_cmd).returns('/fake/bin/pip')
-            provider_class.stubs(:pip_version).returns(version)
+            described_class.stubs(:pip_cmd).returns('/fake/bin/pip')
+            described_class.stubs(:pip_version).returns(version)
             p = stub("process")
             p.expects(:collect).yields("real_package==1.2.5")
-            provider_class.expects(:execpipe).with(["/fake/bin/pip", "freeze", "--all"]).yields(p)
-            provider_class.instances
+            described_class.expects(:execpipe).with(["/fake/bin/pip", "freeze", "--all"]).yields(p)
+            described_class.instances
           end
         end
       end
@@ -81,20 +79,20 @@ describe provider_class do
       it "should return an empty array on #{osfamily} systems when #{pip_cmds.join(' and ')} are missing" do
         Puppet::Util::Platform.stubs(:windows?).returns (osfamily == 'windows')
         pip_cmds.each do |cmd|
-          provider_class.expects(:which).with(cmd).returns nil
+          described_class.expects(:which).with(cmd).returns nil
         end
-        expect(provider_class.instances).to eq([])
+        expect(described_class.instances).to eq([])
       end
     end
   end
 
-  describe "query" do
+  context "query" do
     before do
       @resource[:name] = "real_package"
     end
 
     it "should return a hash when pip and the package are present" do
-      provider_class.expects(:instances).returns [provider_class.new({
+      described_class.expects(:instances).returns [described_class.new({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
@@ -108,14 +106,14 @@ describe provider_class do
     end
 
     it "should return nil when the package is missing" do
-      provider_class.expects(:instances).returns []
+      described_class.expects(:instances).returns []
       expect(@provider.query).to eq(nil)
     end
 
     it "should be case insensitive" do
       @resource[:name] = "Real_Package"
 
-      provider_class.expects(:instances).returns [provider_class.new({
+      described_class.expects(:instances).returns [described_class.new({
         :ensure   => "1.2.5",
         :name     => "real_package",
         :provider => :pip,
@@ -127,16 +125,15 @@ describe provider_class do
         :provider => :pip,
       })
     end
-
   end
 
-  describe "latest" do
+  context "latest" do
     context "with pip version < 1.5.4" do
       before :each do
-        provider_class.stubs(:pip_version).returns('1.0.1')
-        provider_class.stubs(:which).with('pip').returns("/fake/bin/pip")
-        provider_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
-        provider_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
+        described_class.stubs(:pip_version).returns('1.0.1')
+        described_class.stubs(:which).with('pip').returns("/fake/bin/pip")
+        described_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
+        described_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
       end
 
       it "should find a version number for new_pip_package" do
@@ -188,12 +185,11 @@ describe provider_class do
     context "with pip version >= 1.5.4" do
       # For Pip 1.5.4 and above, you can get a version list from CLI - which allows for native pip behavior
       # with regards to custom repositories, proxies and the like
-
       before :each do
-        provider_class.stubs(:pip_version).returns('1.5.4')
-        provider_class.stubs(:which).with('pip').returns("/fake/bin/pip")
-        provider_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
-        provider_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
+        described_class.stubs(:pip_version).returns('1.5.4')
+        described_class.stubs(:which).with('pip').returns("/fake/bin/pip")
+        described_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
+        described_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
       end
 
       it "should find a version number for real_package" do
@@ -239,7 +235,7 @@ describe provider_class do
     end
   end
 
-  describe "install" do
+  context "install" do
     before do
       @resource[:name] = "fake_package"
       @url = "git+https://example.com/fake_package.git"
@@ -304,7 +300,7 @@ describe provider_class do
     end
   end
 
-  describe "uninstall" do
+  context "uninstall" do
     it "should uninstall" do
       @resource[:name] = "fake_package"
       @provider.expects(:lazy_pip).
@@ -313,29 +309,29 @@ describe provider_class do
     end
   end
 
-  describe "update" do
+  context "update" do
     it "should just call install" do
       @provider.expects(:install).returns(nil)
       @provider.update
     end
   end
 
-  describe "pip_version" do
+  context "pip_version" do
     it "should return nil on missing pip" do
-      provider_class.stubs(:pip_cmd).returns(nil)
-      expect(provider_class.pip_version).to eq(nil)
+      described_class.stubs(:pip_cmd).returns(nil)
+      expect(described_class.pip_version).to eq(nil)
     end
 
     it "should look up version if pip is present" do
-      provider_class.stubs(:pip_cmd).returns('/fake/bin/pip')
+      described_class.stubs(:pip_cmd).returns('/fake/bin/pip')
       p = stub("process")
       p.expects(:collect).yields('pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)')
-      provider_class.expects(:execpipe).with(['/fake/bin/pip', '--version']).yields(p)
-      expect(provider_class.pip_version).to eq('8.0.2')
+      described_class.expects(:execpipe).with(['/fake/bin/pip', '--version']).yields(p)
+      expect(described_class.pip_version).to eq('8.0.2')
     end
   end
 
-  describe "lazy_pip" do
+  context "lazy_pip" do
     after(:each) do
       Puppet::Type::Package::ProviderPip.instance_variable_set(:@confine_collection, nil)
     end

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

@@ -1,19 +1,16 @@
 require "spec_helper"
 
-provider_class = Puppet::Type.type(:package).provider(:pkgin)
-
-describe provider_class do
+describe Puppet::Type.type(:package).provider(:pkgin) do
   let(:resource) { Puppet::Type.type(:package).new(:name => "vim", :provider => :pkgin) }
   subject        { resource.provider }
 
   describe "Puppet provider interface" do
     it "can return the list of all packages" do
-      expect(provider_class).to respond_to(:instances)
+      expect(described_class).to respond_to(:instances)
     end
   end
 
   describe "#install" do
-
    describe "a package not installed" do
     before { resource[:ensure] = :absent }
     it "uses pkgin install to install" do
@@ -29,7 +26,6 @@ describe provider_class do
       subject.install
     end
    end
-
   end
 
   describe "#uninstall" do
@@ -45,19 +41,19 @@ describe provider_class do
     end
 
     before do
-      provider_class.stubs(:pkgin).with(:list).returns(pkgin_ls_output)
+      described_class.stubs(:pkgin).with(:list).returns(pkgin_ls_output)
     end
 
     it "returns an array of providers for each package" do
-      instances = provider_class.instances
+      instances = described_class.instances
       expect(instances).to have(2).items
       instances.each do |instance|
-        expect(instance).to be_a(provider_class)
+        expect(instance).to be_a(described_class)
       end
     end
 
     it "populates each provider with an installed package" do
-      zlib_provider, zziplib_provider = provider_class.instances
+      zlib_provider, zziplib_provider = described_class.instances
       expect(zlib_provider.get(:name)).to eq("zlib")
       expect(zlib_provider.get(:ensure)).to eq("1.2.3")
       expect(zziplib_provider.get(:name)).to eq("zziplib")
@@ -67,7 +63,7 @@ describe provider_class do
 
   describe "#latest" do
     before do
-      provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
+      described_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
     end
 
     context "when the package is installed" do
@@ -119,7 +115,7 @@ SEARCH
       end
 
       it "returns the newest available version" do
-        provider_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
+        described_class.stubs(:pkgin).with(:search, "vim").returns(pkgin_search_output)
         expect(subject.latest).to eq("7.3")
       end
     end
@@ -140,7 +136,7 @@ SEARCH
       let(:package) { "vim-7.2.446;=;Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => "=" ,
                                                              :ensure => "7.2.446" })
       end
@@ -150,7 +146,7 @@ SEARCH
       let(:package) { "ruby18-puppet-0.25.5nb1;>;Configuration management framework written in Ruby" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby18-puppet",
                                                              :status => ">" ,
                                                              :ensure => "0.25.5nb1" })
       end
@@ -160,7 +156,7 @@ SEARCH
       let(:package) { "ruby200-facter-2.4.3nb1;=;Cross-platform Ruby library for retrieving facts from OS" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name =>  "ruby200-facter",
                                                              :status => "=" ,
                                                              :ensure => "2.4.3nb1" })
       end
@@ -170,18 +166,17 @@ SEARCH
       let(:package) { "vim-7.2.446;Vim editor (vi clone) without GUI" }
 
       it "extracts the name and status" do
-        expect(provider_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
+        expect(described_class.parse_pkgin_line(package)).to eq({ :name => "vim" ,
                                                              :status => nil ,
                                                              :ensure => "7.2.446" })
       end
-
     end
 
     context "with an invalid package" do
       let(:package) { "" }
 
       it "returns nil" do
-        expect(provider_class.parse_pkgin_line(package)).to be_nil
+        expect(described_class.parse_pkgin_line(package)).to be_nil
       end
     end
   end

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

@@ -1,10 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/provider/package/pkgng'
 
-provider_class = Puppet::Type.type(:package).provider(:pkgng)
-
-describe provider_class do
+describe Puppet::Type.type(:package).provider(:pkgng) do
   let(:name) { 'bash' }
   let(:installed_name) { 'zsh' }
   let(:pkgng) { 'pkgng' }
@@ -38,41 +35,41 @@ describe provider_class do
   end
 
   before do
-    provider_class.stubs(:command).with(:pkg) { '/usr/local/sbin/pkg' }
+    described_class.stubs(:command).with(:pkg) { '/usr/local/sbin/pkg' }
 
     info = File.read(my_fixture('pkg.info'))
-    provider_class.stubs(:get_query).returns(info)
+    described_class.stubs(:get_query).returns(info)
 
     version_list = File.read(my_fixture('pkg.version'))
-    provider_class.stubs(:get_version_list).returns(version_list)
+    described_class.stubs(:get_version_list).returns(version_list)
   end
 
   context "#instances" do
     it "should return the empty set if no packages are listed" do
-      provider_class.stubs(:get_query).returns('')
-      provider_class.stubs(:get_version_list).returns('')
-      expect(provider_class.instances).to be_empty
+      described_class.stubs(:get_query).returns('')
+      described_class.stubs(:get_version_list).returns('')
+      expect(described_class.instances).to be_empty
     end
 
     it "should return all packages when invoked" do
-      expect(provider_class.instances.map(&:name).sort).to eq(
+      expect(described_class.instances.map(&:name).sort).to eq(
         %w{ca_root_nss curl nmap pkg gnupg zsh tac_plus}.sort)
     end
 
     it "should set latest to current version when no upgrade available" do
-      nmap = provider_class.instances.find {|i| i.properties[:origin] == 'security/nmap' }
+      nmap = described_class.instances.find {|i| i.properties[:origin] == 'security/nmap' }
 
       expect(nmap.properties[:version]).to eq(nmap.properties[:latest])
     end
 
     it "should return an empty array when pkg calls raise an exception" do
-      provider_class.stubs(:get_query).raises(Puppet::ExecutionFailure, 'An error occurred.')
-      expect(provider_class.instances).to eq([])
+      described_class.stubs(:get_query).raises(Puppet::ExecutionFailure, 'An error occurred.')
+      expect(described_class.instances).to eq([])
     end
 
     describe "version" do
       it "should retrieve the correct version of the current package" do
-        zsh = provider_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
+        zsh = described_class.instances.find {|i| i.properties[:origin] == 'shells/zsh' }
         expect( zsh.properties[:version]).to eq('5.0.2_1')
       end
     end
@@ -118,32 +115,32 @@ describe provider_class do
 
   context "#prefetch" do
     it "should fail gracefully when " do
-      provider_class.stubs(:instances).returns([])
-      expect{ provider_class.prefetch({}) }.to_not raise_error
+      described_class.stubs(:instances).returns([])
+      expect{ described_class.prefetch({}) }.to_not raise_error
     end
   end
 
   context "#query" do
     it "should return the installed version if present" do
-      provider_class.prefetch({installed_name => installed_resource})
+      described_class.prefetch({installed_name => installed_resource})
       expect(installed_provider.query).to eq({:version=>'5.0.2_1'})
     end
 
     it "should return nil if not present" do
       fixture = File.read(my_fixture('pkg.query_absent'))
-      provider_class.stubs(:get_resource_info).with('bash').returns(fixture)
+      described_class.stubs(:get_resource_info).with('bash').returns(fixture)
       expect(provider.query).to equal(nil)
     end
   end
 
   describe "latest" do
     it "should retrieve the correct version of the latest package" do
-      provider_class.prefetch( { installed_name => installed_resource })
+      described_class.prefetch( { installed_name => installed_resource })
       expect(installed_provider.latest).not_to be_nil
     end
 
     it "should set latest to newer package version when available" do
-      instances = provider_class.instances
+      instances = described_class.instances
       curl = instances.find {|i| i.properties[:origin] == 'ftp/curl' }
       expect(curl.properties[:latest]).to eq('7.33.0_2')
     end
@@ -164,13 +161,13 @@ describe provider_class do
   describe "get_latest_version" do
     it "should rereturn nil when the current package is the latest" do
       version_list = File.read(my_fixture('pkg.version'))
-      nmap_latest_version = provider_class.get_latest_version('security/nmap', version_list)
+      nmap_latest_version = described_class.get_latest_version('security/nmap', version_list)
       expect(nmap_latest_version).to be_nil
     end
 
     it "should match the package name exactly" do
       version_list = File.read(my_fixture('pkg.version'))
-      bash_comp_latest_version = provider_class.get_latest_version('shells/bash-completion', version_list)
+      bash_comp_latest_version = described_class.get_latest_version('shells/bash-completion', version_list)
       expect(bash_comp_latest_version).to eq('2.1_3')
     end
   end
@@ -179,7 +176,7 @@ describe provider_class do
     context "on FreeBSD" do
       it "should be the default provider" do
         Facter.expects(:value).with(:operatingsystem).at_least_once.returns :freebsd
-        expect(provider_class).to be_default
+        expect(described_class).to be_default
       end
     end
   end