puppet 4.2.3-x64-mingw32 → 4.3.0-x64-mingw32

data/spec/unit/pops/types/type_factory_spec.rb

@@ -60,7 +60,7 @@ describe 'The type factory' do
     end
 
     it 'tuple() returns PTupleType' do
-      expect(Puppet::Pops::Types::TypeFactory.tuple().class()).to eq(Puppet::Pops::Types::PTupleType)
+      expect(Puppet::Pops::Types::TypeFactory.tuple.class()).to eq(Puppet::Pops::Types::PTupleType)
     end
 
     it 'undef() returns PUndefType' do
@@ -136,7 +136,7 @@ describe 'The type factory' do
     end
 
     it 'array_of(PIntegerType) returns PArrayType[PIntegerType]' do
-      at = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PIntegerType.new())
+      at = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::PIntegerType::DEFAULT)
       expect(at.class()).to eq(Puppet::Pops::Types::PArrayType)
       expect(at.element_type.class).to eq(Puppet::Pops::Types::PIntegerType)
     end
@@ -162,16 +162,14 @@ describe 'The type factory' do
     end
 
     it 'a size constrained collection can be created from array' do
-      t = Puppet::Pops::Types::TypeFactory.array_of_data()
-      expect(Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2)).to eq(t)
+      t = Puppet::Pops::Types::TypeFactory.array_of(Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(1,2))
       expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
       expect(t.size_type.from).to eq(1)
       expect(t.size_type.to).to eq(2)
     end
 
     it 'a size constrained collection can be created from hash' do
-      t = Puppet::Pops::Types::TypeFactory.hash_of_data()
-      expect(Puppet::Pops::Types::TypeFactory.constrain_size(t, 1,2)).to eq(t)
+      t = Puppet::Pops::Types::TypeFactory.hash_of(Puppet::Pops::Types::TypeFactory.scalar, Puppet::Pops::Types::TypeFactory.data, Puppet::Pops::Types::TypeFactory.range(1,2))
       expect(t.size_type.class).to eq(Puppet::Pops::Types::PIntegerType)
       expect(t.size_type.from).to eq(1)
       expect(t.size_type.to).to eq(2)
@@ -252,11 +250,11 @@ describe 'The type factory' do
       end
 
       it 'the with_block methods decorates a Callable with a block_type' do
-        t = Puppet::Pops::Types::TypeFactory.callable()
-        t2 = Puppet::Pops::Types::TypeFactory.with_block(t)
+        t = Puppet::Pops::Types::TypeFactory.callable
+        t2 = Puppet::Pops::Types::TypeFactory.callable(t)
         block_t = t2.block_type
         # given t is returned after mutation
-        expect(t2).to be(t)
+        expect(block_t).to be(t)
         expect(block_t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(block_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(block_t.param_types.types).to be_empty
@@ -264,13 +262,15 @@ describe 'The type factory' do
       end
 
       it 'the with_optional_block methods decorates a Callable with an optional block_type' do
-        t = Puppet::Pops::Types::TypeFactory.callable()
-        t2 = Puppet::Pops::Types::TypeFactory.with_optional_block(t)
+        b = Puppet::Pops::Types::TypeFactory.callable
+        t = Puppet::Pops::Types::TypeFactory.optional(b)
+        t2 = Puppet::Pops::Types::TypeFactory.callable(t)
         opt_t = t2.block_type
         expect(opt_t.class).to be(Puppet::Pops::Types::POptionalType)
         block_t = opt_t.optional_type
         # given t is returned after mutation
-        expect(t2).to be(t)
+        expect(opt_t).to be(t)
+        expect(block_t).to be(b)
         expect(block_t.class).to be(Puppet::Pops::Types::PCallableType)
         expect(block_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
         expect(block_t.param_types.types).to be_empty

data/spec/unit/pops/types/type_parser_spec.rb

@@ -83,20 +83,16 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it "parses a size constrained collection using capped range" do
-    parameterized_array = types.array_of(types.integer)
-    types.constrain_size(parameterized_array, 1,2)
-    parameterized_hash = types.hash_of(types.integer, types.boolean)
-    types.constrain_size(parameterized_hash, 1,2)
+    parameterized_array = types.array_of(types.integer, types.range(1,2))
+    parameterized_hash = types.hash_of(types.integer, types.boolean, types.range(1,2))
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
   end
 
   it "parses a size constrained collection with open range" do
-    parameterized_array = types.array_of(types.integer)
-    types.constrain_size(parameterized_array, 1,:default)
-    parameterized_hash = types.hash_of(types.integer, types.boolean)
-    types.constrain_size(parameterized_hash, 1,:default)
+    parameterized_array = types.array_of(types.integer, types.range(1, :default))
+    parameterized_hash = types.hash_of(types.integer, types.boolean, types.range(1, :default))
 
     expect(the_type_parsed_from(parameterized_array)).to be_the_type(parameterized_array)
     expect(the_type_parsed_from(parameterized_hash)).to be_the_type(parameterized_hash)
@@ -108,13 +104,12 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it "parses tuple type" do
-    tuple_t = types.tuple(Integer, String)
+    tuple_t = types.tuple([Integer, String])
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
   it "parses tuple type with occurrence constraint" do
-    tuple_t = types.tuple(Integer, String)
-    types.constrain_size(tuple_t, 2, 5)
+    tuple_t = types.tuple([Integer, String], types.range(2, 5))
     expect(the_type_parsed_from(tuple_t)).to be_the_type(tuple_t)
   end
 
@@ -173,7 +168,7 @@ describe Puppet::Pops::Types::TypeParser do
   end
 
   it 'parses a collection size range' do
-   expect(parser.parse("Collection[1,2]")).to be_the_type(types.constrain_size(types.collection,1,2))
+   expect(parser.parse("Collection[1,2]")).to be_the_type(types.collection(types.range(1,2)))
   end
 
   it 'parses a type type' do

data/spec/unit/pops/validator/validator_spec.rb

@@ -243,6 +243,31 @@ describe "validating 4x" do
     end
   end
 
+  context "capability annotations" do
+    before(:each) do
+      with_app_management(true)
+    end
+
+    after(:each) do
+      with_app_management(false)
+    end
+
+    ['produces', 'consumes'].each do |word|
+      it "rejects illegal resource types in #{word} clauses" do
+        expect(validate(parse("foo produces Bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+      end
+
+      it "accepts legal resource and capability types in #{word} clauses" do
+        expect(validate(parse("Foo produces Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+        expect(validate(parse("Mod::Foo produces ::Mod2::Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+      end
+
+      it "rejects illegal capability types in #{word} clauses" do
+        expect(validate(parse("Foo produces bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+      end
+    end
+  end
+
   def parse(source)
     Puppet::Pops::Parser::Parser.new().parse_string(source)
   end

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -195,6 +195,56 @@ describe provider_class do
     end
   end
 
+  describe "values filters" do
+    before do
+      augeas = stub("augeas", :match => ["set", "of", "values"])
+      augeas.stubs(:get).returns('set').then.returns('of').then.returns('values')
+      augeas.stubs("close")
+      @provider = provider_class.new(@resource)
+      @provider.aug = augeas
+    end
+
+    it "should return true for includes match" do
+      command = ["values", "fake value", "include values"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return false for includes non match" do
+      command = ["values", "fake value", "include JarJar"]
+      expect(@provider.process_values(command)).to eq(false)
+    end
+
+    it "should return true for includes match" do
+      command = ["values", "fake value", "not_include JarJar"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return false for includes non match" do
+      command = ["values", "fake value", "not_include values"]
+      expect(@provider.process_values(command)).to eq(false)
+    end
+
+    it "should return true for an array match" do
+      command = ["values", "fake value", "== ['set', 'of', 'values']"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+
+    it "should return false for an array non match" do
+      command = ["values", "fake value", "== ['this', 'should', 'not', 'match']"]
+      expect(@provider.process_values(command)).to eq(false)
+    end
+
+    it "should return false for an array match with noteq" do
+      command = ["values", "fake value", "!= ['set', 'of', 'values']"]
+      expect(@provider.process_values(command)).to eq(false)
+    end
+
+    it "should return true for an array non match with noteq" do
+      command = ["values", "fake value", "!= ['this', 'should', 'not', 'match']"]
+      expect(@provider.process_values(command)).to eq(true)
+    end
+  end
+
   describe "match filters" do
     before do
       augeas = stub("augeas", :match => ["set", "of", "values"])

data/spec/unit/provider/group/directoryservice_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Puppet::Type.type(:group).provider(:directoryservice) do
+  let :resource do
+    Puppet::Type.type(:group).new(
+      :title => 'testgroup',
+      :provider => :directoryservice,
+    )
+  end
+
+  let(:provider) { resource.provider }
+
+  it 'should return true for same lists of unordered members' do
+    expect(provider.members_insync?(['user1', 'user2'], ['user2', 'user1'])).to be_truthy
+  end
+
+  it 'should return false when the group currently has no members' do
+    expect(provider.members_insync?([], ['user2', 'user1'])).to be_falsey
+  end
+
+  it 'should return true for the same lists of members irrespective of duplicates' do
+    expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user1', 'user2'])).to be_truthy
+  end
+
+  it "should return true when current and should members are empty lists" do
+    expect(provider.members_insync?([], [])).to be_truthy
+  end
+
+  it "should return true when current is :absent and should members is empty list" do
+    expect(provider.members_insync?(:absent, [])).to be_truthy
+  end
+
+end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -162,6 +162,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
         expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
       end
+      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
+        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+      end
     end
   end
 

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

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+# Note that much of the functionality of the dnf provider is already tested with yum provider tests,
+# as yum is the parent provider.
+
+provider_class = Puppet::Type.type(:package).provider(:dnf)
+
+describe provider_class do
+  let(:name) { 'mypackage' }
+  let(:resource) do
+    Puppet::Type.type(:package).new(
+      :name => name,
+      :ensure => :installed,
+      :provider => 'dnf'
+    )
+  end
+
+  let(:provider) do
+    provider = provider_class.new
+    provider.resource = resource
+    provider
+  end
+
+  before do
+    provider_class.stubs(:command).with(:cmd).returns('/usr/bin/dnf')
+    provider.stubs(:rpm).returns 'rpm'
+    provider.stubs(:get).with(:version).returns '1'
+    provider.stubs(:get).with(:release).returns '1'
+    provider.stubs(:get).with(:arch).returns 'i386'
+  end
+
+  describe 'provider features' do
+    it { is_expected.to be_versionable }
+    it { is_expected.to be_install_options }
+    it { is_expected.to be_virtual_packages }
+  end
+
+  # provider should repond to the following methods
+   [:install, :latest, :update, :purge, :install_options].each do |method|
+     it "should have a(n) #{method}" do
+       expect(provider).to respond_to(method)
+    end
+  end
+
+  describe 'when installing' do
+    before(:each) do
+      Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
+      provider.stubs(:which).with("rpm").returns("/bin/rpm")
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns('22')
+    end
+
+    it 'should call dnf install for :installed' do
+      resource.stubs(:should).with(:ensure).returns :installed
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-d', '0', '-e', '1', '-y', :install, 'mypackage'])
+      provider.install
+    end
+
+    it 'should be able to downgrade' do
+      current_version = '1.2'
+      version = '1.0'
+      resource[:ensure] = '1.0'
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-d', '0', '-e', '1', '-y', :downgrade, "#{name}-#{version}"])
+      provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
+      provider.install
+    end
+
+    it 'should accept install options' do
+      resource[:ensure] = :installed
+      resource[:install_options] = ['-t', {'-x' => 'expackage'}]
+
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-d', '0', '-e', '1', '-y', ['-t', '-x=expackage'], :install, name])
+      provider.install
+    end
+  end
+
+  describe 'when uninstalling' do
+    it 'should use erase to purge' do
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-y', :erase, name])
+      provider.purge
+    end
+  end
+
+  describe "executing yum check-update" do
+    it "passes repos to enable to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/dnf check-update --enablerepo=updates --enablerepo=fedoraplus]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates(%w[updates fedoraplus], [], [])
+    end
+  end
+end

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

@@ -88,6 +88,13 @@ context 'installing myresource' do
             provider.install
           end
         end
+        describe "as a windows path on windows", :if => Puppet.features.microsoft_windows? do
+          it "should treat the source as a local path" do
+            resource[:source] = "c:/this/is/a/path/to/a/gem.gem"
+            provider.expects(:execute).with { |args| args[2] == "c:/this/is/a/path/to/a/gem.gem" }.returns ""
+            provider.install
+          end
+        end
         describe "with an invalid uri" do
           it "should fail" do
             URI.expects(:parse).raises(ArgumentError)

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

@@ -12,6 +12,7 @@ describe provider_class do
     chkconfig 0 1.3.30.2 2.el5 x86_64
     myresource 0 1.2.3.4 5.el4 noarch
     mysummaryless 0 1.2.3.4 5.el4 noarch
+    tomcat 1 1.2.3.4 5.fc22 noarch
     RPM_OUTPUT
   end
 
@@ -116,7 +117,18 @@ describe provider_class do
           :ensure => "1.3.30.2-2.el5",
         }
       )
-      expect(installed_packages.last.properties).to eq(
+      expect(installed_packages[3].properties).to eq(
+        {
+          :provider    => :rpm,
+          :name        => "myresource",
+          :epoch       => "0",
+          :version     => "1.2.3.4",
+          :release     => "5.el4",
+          :arch        => "noarch",
+          :ensure      => "1.2.3.4-5.el4",
+        }
+      )
+      expect(installed_packages[4].properties).to eq(
         {
           :provider    => :rpm,
           :name        => "mysummaryless",
@@ -127,6 +139,17 @@ describe provider_class do
           :ensure      => "1.2.3.4-5.el4",
         }
       )
+      expect(installed_packages[5].properties).to eq(
+        {
+          :provider    => :rpm,
+          :name        => "tomcat",
+          :epoch       => "1",
+          :version     => "1.2.3.4",
+          :release     => "5.fc22",
+          :arch        => "noarch",
+          :ensure      => "1:1.2.3.4-5.fc22",
+        }
+      )
     end
   end
 
@@ -269,7 +292,7 @@ describe provider_class do
           line.gsub(field, delimiter),
           package_hash.merge(
             field.to_sym => delimiter,
-            :ensure => 'version-release'.gsub(field, delimiter)
+            :ensure => 'epoch:version-release'.gsub(field, delimiter)
           )
         )
       end

data/spec/unit/provider/package/windows/package_spec.rb

@@ -132,6 +132,47 @@ describe Puppet::Provider::Package::Windows::Package do
     end
   end
 
+  context '::get_display_name' do
+    it 'should return nil if values is nil' do
+      expect(subject.get_display_name(nil)).to be_nil
+    end
+
+    it 'should return empty if values is empty' do
+      reg_values =  {}
+      expect(subject.get_display_name(reg_values)).to eq('')
+    end
+
+    it 'should return DisplayName when available' do
+      reg_values =  { 'DisplayName' => 'Google' }
+      expect(subject.get_display_name(reg_values)).to eq('Google')
+    end
+
+    it 'should return DisplayName when available, even when QuietDisplayName is also available' do
+      reg_values =  { 'DisplayName' => 'Google', 'QuietDisplayName' => 'Google Quiet' }
+      expect(subject.get_display_name(reg_values)).to eq('Google')
+    end
+
+    it 'should return QuietDisplayName when available if DisplayName is empty' do
+      reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'Google Quiet' }
+      expect(subject.get_display_name(reg_values)).to eq('Google Quiet')
+    end
+
+    it 'should return QuietDisplayName when DisplayName is not available' do
+      reg_values =  { 'QuietDisplayName' =>'Google Quiet' }
+      expect(subject.get_display_name(reg_values)).to eq('Google Quiet')
+    end
+
+    it 'should return empty when DisplayName is empty and QuietDisplay name is not available' do
+      reg_values =  { 'DisplayName' => '' }
+      expect(subject.get_display_name(reg_values)).to eq('')
+    end
+
+    it 'should return empty when DisplayName is empty and QuietDisplay name is empty' do
+      reg_values =  { 'DisplayName' => '', 'QuietDisplayName' =>'' }
+      expect(subject.get_display_name(reg_values)).to eq('')
+    end
+  end
+
   it 'should implement instance methods' do
     pkg = subject.new('orca', '5.0')