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

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

@@ -171,5 +171,106 @@ describe 'The type factory' do
       t.size_type.from.should == 1
       t.size_type.to.should == 2
     end
+
+    context 'callable types' do
+      it 'the callable methods produces a Callable' do
+        t = Puppet::Pops::Types::TypeFactory.callable()
+        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.param_types.types).to be_empty
+        expect(t.block_type).to be_nil
+      end
+
+      it 'callable method with types produces the corresponding Tuple for parameters and generated names' do
+        tf = Puppet::Pops::Types::TypeFactory
+        t = tf.callable(tf.integer, tf.string)
+        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.param_types.types).to eql([tf.integer, tf.string])
+        expect(t.block_type).to be_nil
+      end
+
+      it 'callable accepts min range to be given' do
+        tf = Puppet::Pops::Types::TypeFactory
+        t = tf.callable(tf.integer, tf.string, 1)
+        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.param_types.size_type.from).to eql(1)
+        expect(t.param_types.size_type.to).to be_nil
+      end
+
+      it 'callable accepts max range to be given' do
+        tf = Puppet::Pops::Types::TypeFactory
+        t = tf.callable(tf.integer, tf.string, 1, 3)
+        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.param_types.size_type.from).to eql(1)
+        expect(t.param_types.size_type.to).to eql(3)
+      end
+
+      it 'callable accepts max range to be given as :default' do
+        tf = Puppet::Pops::Types::TypeFactory
+        t = tf.callable(tf.integer, tf.string, 1, :default)
+        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(t.param_types.size_type.from).to eql(1)
+        expect(t.param_types.size_type.to).to be_nil
+      end
+
+      it 'the all_callables method produces a Callable matching any Callable' do
+        t = Puppet::Pops::Types::TypeFactory.all_callables()
+        expect(t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(t.param_types).to be_nil
+        expect(t.block_type).to be_nil
+      end
+
+      it 'with block are created by placing a Callable last' do
+        block_t = Puppet::Pops::Types::TypeFactory.callable(String)
+        t = Puppet::Pops::Types::TypeFactory.callable(String, block_t)
+        expect(t.block_type).to be(block_t)
+      end
+
+      it 'min size constraint can be used with a block last' do
+        block_t = Puppet::Pops::Types::TypeFactory.callable(String)
+        t = Puppet::Pops::Types::TypeFactory.callable(String, 1, block_t)
+        expect(t.block_type).to be(block_t)
+        expect(t.param_types.size_type.from).to eql(1)
+        expect(t.param_types.size_type.to).to be_nil
+      end
+
+      it 'min, max size constraint can be used with a block last' do
+        block_t = Puppet::Pops::Types::TypeFactory.callable(String)
+        t = Puppet::Pops::Types::TypeFactory.callable(String, 1, 3, block_t)
+        expect(t.block_type).to be(block_t)
+        expect(t.param_types.size_type.from).to eql(1)
+        expect(t.param_types.size_type.to).to eql(3)
+      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)
+        block_t = t2.block_type
+        # given t is returned after mutation
+        expect(t2).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
+        expect(block_t.block_type).to be_nil
+      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)
+        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(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
+        expect(block_t.block_type).to be_nil
+      end
+    end
   end
 end

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

@@ -162,6 +162,28 @@ describe Puppet::Pops::Types::TypeParser do
     expect(parser.parse("Ruby['Integer']")).to be_the_type(types.ruby_type('Integer'))
   end
 
+  it 'parses a callable type' do
+    expect(parser.parse("Callable")).to be_the_type(types.all_callables())
+  end
+
+  it 'parses a parameterized callable type' do
+    expect(parser.parse("Callable[String, Integer]")).to be_the_type(types.callable(String, Integer))
+  end
+
+  it 'parses a parameterized callable type with min/max' do
+    expect(parser.parse("Callable[String, Integer, 1, default]")).to be_the_type(types.callable(String, Integer, 1, :default))
+  end
+
+  it 'parses a parameterized callable type with block' do
+    expect(parser.parse("Callable[String, Callable[Boolean]]")).to be_the_type(types.callable(String, types.callable(true)))
+  end
+
+  it 'parses a parameterized callable type with only min/max' do
+    t = parser.parse("Callable[0,0]")
+    expect(t).to be_the_type(types.callable())
+    expect(t.param_types.types).to be_empty
+  end
+
   matcher :be_the_type do |type|
     calc = Puppet::Pops::Types::TypeCalculator.new
 

data/spec/unit/property/list_spec.rb

@@ -93,9 +93,10 @@ describe list_class do
     end
 
     describe "when calling retrieve" do
+      let(:provider) { @provider }
       before do
         @provider = mock("provider")
-        @property.stubs(:provider).returns(@provider)
+        @property.stubs(:provider).returns(provider)
       end
 
       it "should send 'name' to the provider" do
@@ -115,6 +116,13 @@ describe list_class do
         @property.stubs(:name).returns(:group)
         @property.retrieve == :absent
       end
+
+      context "and provider is nil" do
+        let(:provider) { nil }
+        it "should return :absent" do
+          @property.retrieve == :absent
+        end
+      end
     end
 
     describe "when calling safe_insync?" do

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

@@ -365,16 +365,56 @@ describe provider_class do
     end
 
     #Ticket 5211 testing
-    it "should return false when a size doeas equal the provided value" do
+    it "should return false when a size does equal the provided value" do
       @resource[:onlyif] = "match path size != 3"
       @augeas.stubs("match").returns(["set", "of", "values"])
       @provider.need_to_run?.should == false
     end
 
+    [true, false].product([true, false]) do |cfg, param|
+      describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
+        let(:file) { "/some/random/file" }
+
+        before(:each) do
+          Puppet[:show_diff] = cfg
+          @resource[:show_diff] = param
+
+          @resource[:root] = ""
+          @resource[:context] = "/files"
+          @resource[:changes] = ["set #{file}/foo bar"]
+
+          File.stubs(:delete)
+          @provider.stubs(:get_augeas_version).returns("0.10.0")
+          @provider.stubs("diff").with("#{file}", "#{file}.augnew").returns("diff")
+
+          @augeas.stubs(:set).returns(true)
+          @augeas.stubs(:save).returns(true)
+          @augeas.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved"])
+          @augeas.stubs(:get).with("/augeas/events/saved").returns("/files#{file}")
+          @augeas.stubs(:set).with("/augeas/save", "newfile")
+        end
+
+        if cfg && param
+          it "should display a diff" do
+            @provider.should be_need_to_run
+
+            expect(@logs[0].message).to eq("\ndiff")
+          end
+        else
+          it "should not display a diff" do
+            @provider.should be_need_to_run
+
+            @logs.should be_empty
+          end
+        end
+      end
+    end
+
     # Ticket 2728 (diff files)
-    describe "and Puppet[:show_diff] is set" do
+    describe "and configured to show diffs" do
       before(:each) do
         Puppet[:show_diff] = true
+        @resource[:show_diff] = true
 
         @resource[:root] = ""
         @provider.stubs(:get_augeas_version).returns("0.10.0")
@@ -382,23 +422,26 @@ describe provider_class do
         @augeas.stubs(:save).returns(true)
       end
 
-      it "should call diff when a file is shown to have been changed" do
+      it "should display a diff when a single file is shown to have been changed" do
         file = "/etc/hosts"
         File.stubs(:delete)
 
+        @resource[:loglevel] = "crit"
         @resource[:context] = "/files"
         @resource[:changes] = ["set #{file}/foo bar"]
 
         @augeas.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved"])
         @augeas.stubs(:get).with("/augeas/events/saved").returns("/files#{file}")
         @augeas.expects(:set).with("/augeas/save", "newfile")
-        @augeas.expects(:close).never()
+        @provider.expects("diff").with("#{file}", "#{file}.augnew").returns("diff")
 
-        @provider.expects("diff").with("#{file}", "#{file}.augnew").returns("")
         @provider.should be_need_to_run
+
+        expect(@logs[0].message).to eq("\ndiff")
+        expect(@logs[0].level).to eq(:crit)
       end
 
-      it "should call diff for each file thats changed" do
+      it "should display a diff for each file that is changed when changing many files" do
         file1 = "/etc/hosts"
         file2 = "/etc/resolv.conf"
         File.stubs(:delete)
@@ -410,11 +453,13 @@ describe provider_class do
         @augeas.stubs(:get).with("/augeas/events/saved[1]").returns("/files#{file1}")
         @augeas.stubs(:get).with("/augeas/events/saved[2]").returns("/files#{file2}")
         @augeas.expects(:set).with("/augeas/save", "newfile")
-        @augeas.expects(:close).never()
+        @provider.expects(:diff).with("#{file1}", "#{file1}.augnew").returns("diff #{file1}")
+        @provider.expects(:diff).with("#{file2}", "#{file2}.augnew").returns("diff #{file2}")
 
-        @provider.expects(:diff).with("#{file1}", "#{file1}.augnew").returns("")
-        @provider.expects(:diff).with("#{file2}", "#{file2}.augnew").returns("")
         @provider.should be_need_to_run
+
+        expect(@logs.collect(&:message)).to include("\ndiff #{file1}", "\ndiff #{file2}")
+        expect(@logs.collect(&:level)).to eq([:notice, :notice])
       end
 
       describe "and resource[:root] is set" do
@@ -430,10 +475,12 @@ describe provider_class do
           @augeas.stubs(:match).with("/augeas/events/saved").returns(["/augeas/events/saved"])
           @augeas.stubs(:get).with("/augeas/events/saved").returns("/files#{file}")
           @augeas.expects(:set).with("/augeas/save", "newfile")
-          @augeas.expects(:close).never()
+          @provider.expects(:diff).with("#{root}#{file}", "#{root}#{file}.augnew").returns("diff")
 
-          @provider.expects(:diff).with("#{root}#{file}", "#{root}#{file}.augnew").returns("")
           @provider.should be_need_to_run
+
+          expect(@logs[0].message).to eq("\ndiff")
+          expect(@logs[0].level).to eq(:notice)
         end
       end
 

data/spec/unit/provider/cron/crontab_spec.rb

@@ -153,6 +153,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
     let(:resource) do
      s = stub(:resource)
      s.stubs(:[]).with(:user).returns 'root'
+     s.stubs(:[]).with(:target).returns 'root'
      s
     end
 

data/spec/unit/provider/cron/parsed_spec.rb

@@ -31,6 +31,14 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
     )
   end
 
+  let :resource_sparse do
+    Puppet::Type.type(:cron).new(
+      :minute => %w{42},
+      :target => 'root',
+      :name   => 'sparse'
+    )
+  end
+
   let :record_special do
     {
       :record_type => :crontab,
@@ -317,5 +325,12 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
         end
       end
     end
+
+    describe "with a resource without a command" do
+      it "should not raise an error" do
+        expect { described_class.match(record,{resource_sparse[:name] => resource_sparse}) }.to_not raise_error
+      end
+    end
+
   end
 end

data/spec/unit/provider/naginator_spec.rb

@@ -63,3 +63,17 @@ describe Nagios::Base do
     obj.host_name.should == "my_hostname"
   end
 end
+
+describe Nagios::Parser do
+  include PuppetSpec::Files
+
+  subject do
+    described_class.new
+  end
+
+  let(:config) { File.new( my_fixture('define_empty_param') ).read }
+
+  it "should handle empty parameter values" do
+    expect { subject.parse(config) }.to_not raise_error
+  end
+end

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

@@ -1,44 +1,46 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-provider = Puppet::Type.type(:package).provider(:apt)
-
-describe provider do
-  before do
-    @resource = stub 'resource', :[] => "asdf"
-    @provider = provider.new(@resource)
-
-    @fakeresult = <<-EOF
-install ok installed asdf 1.0 "asdf summary
- asdf multiline description
- with multiple lines
-EOF
+provider_class = Puppet::Type.type(:package).provider(:apt)
+
+describe provider_class do
+  let(:name) { 'asdf' }
+
+  let(:resource) do
+    Puppet::Type.type(:package).new(
+      :name     => name,
+      :provider => 'apt'
+    )
+  end
+
+  let(:provider) do
+    provider = provider_class.new
+    provider.resource = resource
+    provider
   end
 
   it "should be versionable" do
-    provider.should be_versionable
+    provider_class.should be_versionable
   end
 
   it "should use :install to update" do
-    @provider.expects(:install)
-    @provider.update
+    provider.expects(:install)
+    provider.update
   end
 
   it "should use 'apt-get remove' to uninstall" do
-    @provider.expects(:aptget).with("-y", "-q", :remove, "asdf")
-
-    @provider.uninstall
+    provider.expects(:aptget).with("-y", "-q", :remove, name)
+    provider.uninstall
   end
 
   it "should use 'apt-get purge' and 'dpkg purge' to purge" do
-    @provider.expects(:aptget).with("-y", "-q", :remove, "--purge", "asdf")
-    @provider.expects(:dpkg).with("--purge", "asdf")
-
-    @provider.purge
+    provider.expects(:aptget).with("-y", "-q", :remove, "--purge", name)
+    provider.expects(:dpkg).with("--purge", name)
+    provider.purge
   end
 
   it "should use 'apt-cache policy' to determine the latest version of a package" do
-    @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:
+    provider.expects(:aptcache).with(:policy, name).returns "#{name}:
 Installed: 1:1.0
 Candidate: 1:1.1
 Version table:
@@ -47,100 +49,112 @@ Version table:
 *** 1:1.1
   100 /var/lib/dpkg/status"
 
-    @provider.latest.should == "1:1.1"
+    provider.latest.should == "1:1.1"
   end
 
   it "should print and error and return nil if no policy is found" do
-    @provider.expects(:aptcache).with(:policy, "asdf").returns "asdf:"
+    provider.expects(:aptcache).with(:policy, name).returns "#{name}:"
 
-    @provider.expects(:err)
-    @provider.latest.should be_nil
+    provider.expects(:err)
+    provider.latest.should be_nil
   end
 
   it "should be able to preseed" do
-    @provider.should respond_to(:run_preseed)
+    provider.should respond_to(:run_preseed)
   end
 
   it "should preseed with the provided responsefile when preseeding is called for" do
-    @resource.expects(:[]).with(:responsefile).returns "/my/file"
-    Puppet::FileSystem.expects(:exist?).with("/my/file").returns true
+    resource[:responsefile] = '/my/file'
+    Puppet::FileSystem.expects(:exist?).with('/my/file').returns true
 
-    @provider.expects(:info)
-    @provider.expects(:preseed).with("/my/file")
+    provider.expects(:info)
+    provider.expects(:preseed).with('/my/file')
 
-    @provider.run_preseed
+    provider.run_preseed
   end
 
   it "should not preseed if no responsefile is provided" do
-    @resource.expects(:[]).with(:responsefile).returns nil
-
-    @provider.expects(:info)
-    @provider.expects(:preseed).never
+    provider.expects(:info)
+    provider.expects(:preseed).never
 
-    @provider.run_preseed
+    provider.run_preseed
   end
 
   describe "when installing" do
     it "should preseed if a responsefile is provided" do
-      @resource.expects(:[]).with(:responsefile).returns "/my/file"
-      @provider.expects(:run_preseed)
+      resource[:responsefile] = "/my/file"
+      provider.expects(:run_preseed)
 
-      @provider.stubs(:aptget)
-      @provider.install
+      provider.stubs(:aptget)
+      provider.install
     end
 
     it "should check for a cdrom" do
-      @provider.expects(:checkforcdrom)
+      provider.expects(:checkforcdrom)
 
-      @provider.stubs(:aptget)
-      @provider.install
+      provider.stubs(:aptget)
+      provider.install
     end
 
     it "should use 'apt-get install' with the package name if no version is asked for" do
-      @resource.expects(:[]).with(:ensure).returns :installed
-      @provider.expects(:aptget).with { |*command| command[-1] == "asdf" and command[-2] == :install }
+      resource[:ensure] = :installed
+      provider.expects(:aptget).with { |*command| command[-1] == name and command[-2] == :install }
 
-      @provider.install
+      provider.install
     end
 
     it "should specify the package version if one is asked for" do
-      @resource.expects(:[]).with(:ensure).returns "1.0"
-      @provider.expects(:aptget).with { |*command| command[-1] == "asdf=1.0" }
+      resource[:ensure] = '1.0'
+      provider.expects(:aptget).with { |*command| command[-1] == "#{name}=1.0" }
 
-      @provider.install
+      provider.install
     end
 
     it "should use --force-yes if a package version is specified" do
-      @resource.expects(:[]).with(:ensure).returns "1.0"
-      @provider.expects(:aptget).with { |*command| command.include?("--force-yes") }
+      resource[:ensure] = '1.0'
+      provider.expects(:aptget).with { |*command| command.include?("--force-yes") }
 
-      @provider.install
+      provider.install
     end
 
     it "should do a quiet install" do
-      @provider.expects(:aptget).with { |*command| command.include?("-q") }
+      provider.expects(:aptget).with { |*command| command.include?("-q") }
 
-      @provider.install
+      provider.install
     end
 
     it "should default to 'yes' for all questions" do
-      @provider.expects(:aptget).with { |*command| command.include?("-y") }
+      provider.expects(:aptget).with { |*command| command.include?("-y") }
 
-      @provider.install
+      provider.install
     end
 
     it "should keep config files if asked" do
-      @resource.expects(:[]).with(:configfiles).returns :keep
-      @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
+      resource[:configfiles] = :keep
+      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confold") }
 
-      @provider.install
+      provider.install
     end
 
     it "should replace config files if asked" do
-      @resource.expects(:[]).with(:configfiles).returns :replace
-      @provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
+      resource[:configfiles] = :replace
+      provider.expects(:aptget).with { |*command| command.include?("DPkg::Options::=--force-confnew") }
+
+      provider.install
+    end
+
+    it 'should support string install options' do
+      resource[:install_options] = ['--foo', '--bar']
+      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar', :install, name)
+
+      provider.install
+    end
+
+    it 'should support hash install options' do
+      resource[:install_options] = ['--foo', { '--bar' => 'baz', '--baz' => 'foo' }]
+      provider.expects(:aptget).with('-q', '-y', '-o', 'DPkg::Options::=--force-confold', '--foo', '--bar=baz', '--baz=foo', :install, name)
 
-      @provider.install
+      provider.install
     end
   end
 end