puppet 2.7.11 → 2.7.12

data/spec/unit/type/exec_spec.rb

@@ -632,6 +632,13 @@ describe Puppet::Type.type(:exec) do
             @test.check_all_attributes.should == false
           end
         end
+
+        it "should emit output to debug" do
+          Puppet::Util::Log.level = :debug
+          @test[param] = @fail
+          @test.check_all_attributes.should == true
+          @logs.shift.message.should == "test output"
+        end
       end
     end
   end

data/spec/unit/type/file/content_spec.rb

@@ -314,7 +314,7 @@ describe content do
 
       it "should copy content from the source to the file" do
         @resource.write(@source)
-        Puppet::Util.binread(@filename).should == @source_content
+        IO.binread(@filename).should == @source_content
       end
 
       it "should return the checksum computed" do
@@ -343,7 +343,7 @@ describe content do
 
       it "should write the contents to the file" do
         @resource.write(@source)
-        Puppet::Util.binread(@filename).should == @source_content
+        IO.binread(@filename).should == @source_content
       end
 
       it "should not write anything if source is not found" do

data/spec/unit/type/file_spec.rb

@@ -749,11 +749,13 @@ describe Puppet::Type.type(:file) do
   end
 
   describe "#recurse_remote" do
+    let(:my) { File.expand_path('/my') }
+
     before do
       file[:source] = "puppet://foo/bar"
 
-      @first = Puppet::FileServing::Metadata.new("/my", :relative_path => "first")
-      @second = Puppet::FileServing::Metadata.new("/my", :relative_path => "second")
+      @first = Puppet::FileServing::Metadata.new(my, :relative_path => "first")
+      @second = Puppet::FileServing::Metadata.new(my, :relative_path => "second")
       @first.stubs(:ftype).returns "directory"
       @second.stubs(:ftype).returns "directory"
 
@@ -762,14 +764,14 @@ describe Puppet::Type.type(:file) do
     end
 
     it "should pass its source to the :perform_recursion method" do
-      data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
+      data = Puppet::FileServing::Metadata.new(File.expand_path("/whatever"), :relative_path => "foobar")
       file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       file.stubs(:newchild).returns @resource
       file.recurse_remote({})
     end
 
     it "should not recurse when the remote file is not a directory" do
-      data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => ".")
+      data = Puppet::FileServing::Metadata.new(File.expand_path("/whatever"), :relative_path => ".")
       data.stubs(:ftype).returns "file"
       file.expects(:perform_recursion).with("puppet://foo/bar").returns [data]
       file.expects(:newchild).never
@@ -850,7 +852,7 @@ describe Puppet::Type.type(:file) do
 
       describe "and :sourceselect is set to :first" do
         it "should create file instances for the results for the first source to return any values" do
-          data = Puppet::FileServing::Metadata.new("/whatever", :relative_path => "foobar")
+          data = Puppet::FileServing::Metadata.new(File.expand_path("/whatever"), :relative_path => "foobar")
           file[:source] = sources.keys.sort.map { |key| File.expand_path(key) }
           file.expects(:perform_recursion).with(sources['/a']).returns nil
           file.expects(:perform_recursion).with(sources['/b']).returns []
@@ -868,18 +870,19 @@ describe Puppet::Type.type(:file) do
 
         it "should return every found file that is not in a previous source" do
           klass = Puppet::FileServing::Metadata
-          file[:source] = %w{/a /b /c /d}.map {|f| File.expand_path(f) }
+
+          file[:source] = abs_path = %w{/a /b /c /d}.map {|f| File.expand_path(f) }
           file.stubs(:newchild).returns @resource
 
-          one = [klass.new("/a", :relative_path => "a")]
+          one = [klass.new(abs_path[0], :relative_path => "a")]
           file.expects(:perform_recursion).with(sources['/a']).returns one
           file.expects(:newchild).with("a").returns @resource
 
-          two = [klass.new("/b", :relative_path => "a"), klass.new("/b", :relative_path => "b")]
+          two = [klass.new(abs_path[1], :relative_path => "a"), klass.new(abs_path[1], :relative_path => "b")]
           file.expects(:perform_recursion).with(sources['/b']).returns two
           file.expects(:newchild).with("b").returns @resource
 
-          three = [klass.new("/c", :relative_path => "a"), klass.new("/c", :relative_path => "c")]
+          three = [klass.new(abs_path[2], :relative_path => "a"), klass.new(abs_path[2], :relative_path => "c")]
           file.expects(:perform_recursion).with(sources['/c']).returns three
           file.expects(:newchild).with("c").returns @resource
 

data/spec/unit/type/package_spec.rb

@@ -230,6 +230,7 @@ describe Puppet::Type.type(:package) do
       [:purged, :absent].each do |state|
         it "should install if it is #{state.to_s}" do
           @provider.stubs(:properties).returns(:ensure => state)
+          @package.property(:ensure).insync?(state).should be_false
           @provider.expects(:install)
           @catalog.apply
         end
@@ -237,15 +238,39 @@ describe Puppet::Type.type(:package) do
 
       it "should do nothing if the current version is equal to the desired version" do
         @provider.stubs(:properties).returns(:ensure => "1.0")
+        @package.property(:ensure).insync?('1.0').should be_true
         @provider.expects(:install).never
         @catalog.apply
       end
 
       it "should install if the current version is not equal to the specified version" do
         @provider.stubs(:properties).returns(:ensure => "2.0")
+        @package.property(:ensure).insync?('2.0').should be_false
         @provider.expects(:install)
         @catalog.apply
       end
+
+      describe "when current value is an array" do
+        let(:installed_versions) { ["1.0", "2.0", "3.0"] }
+
+        before (:each) do
+          @provider.stubs(:properties).returns(:ensure => installed_versions)
+        end
+
+        it "should install if value not in the array" do
+          @package[:ensure] = "1.5"
+          @package.property(:ensure).insync?(installed_versions).should be_false
+          @provider.expects(:install)
+          @catalog.apply
+        end
+
+        it "should not install if value is in the array" do
+          @package[:ensure] = "2.0"
+          @package.property(:ensure).insync?(installed_versions).should be_true
+          @provider.expects(:install).never
+          @catalog.apply
+        end
+      end
     end
   end
 end

data/spec/unit/type/schedule_spec.rb

@@ -33,24 +33,24 @@ describe Puppet::Type.type(:schedule) do
     include ScheduleTesting
 
     it "should apply to device" do
-      @schedule.should be_appliable_to_device
+      @schedule.must be_appliable_to_device
     end
 
     it "should apply to host" do
-      @schedule.should be_appliable_to_host
+      @schedule.must be_appliable_to_host
     end
 
     it "should default to :distance for period-matching" do
-      @schedule[:periodmatch].should == :distance
+      @schedule[:periodmatch].must == :distance
     end
 
     it "should default to a :repeat of 1" do
-      @schedule[:repeat].should == 1
+      @schedule[:repeat].must == 1
     end
 
     it "should never match when the period is :never" do
       @schedule[:period] = :never
-      @schedule.should_not be_match
+      @schedule.must_not be_match
     end
   end
 
@@ -61,7 +61,7 @@ describe Puppet::Type.type(:schedule) do
       period = period.to_sym
       it "should produce a #{period} schedule with the period set appropriately" do
         schedules = Puppet::Type.type(:schedule).mkdefaultschedules
-        schedules.find { |s| s[:name] == period.to_s and s[:period] == period }.should be_instance_of(Puppet::Type.type(:schedule))
+        schedules.find { |s| s[:name] == period.to_s and s[:period] == period }.must be_instance_of(Puppet::Type.type(:schedule))
       end
     end
 
@@ -69,7 +69,7 @@ describe Puppet::Type.type(:schedule) do
       schedules = Puppet::Type.type(:schedule).mkdefaultschedules
       schedules.find { |s|
         s[:name] == "puppet" and s[:period] == :hourly and s[:repeat] == 2
-      }.should be_instance_of(Puppet::Type.type(:schedule))
+      }.must be_instance_of(Puppet::Type.type(:schedule))
     end
   end
 
@@ -98,7 +98,7 @@ describe Puppet::Type.type(:schedule) do
     it "should throw an error if the upper limit is less than the lower limit" do
       pending "bug #7639"
       @schedule[:range] = "01:02:03 - 01:00:00"
-      @schedule.should_throw Puppet::Error
+      @schedule.must_throw Puppet::Error
     end
 
     it "should not match the current time fails between an array of ranges" do
@@ -128,15 +128,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was an hour ago" do
-      @schedule.should be_match(hour("-", 1))
+      @schedule.must be_match(hour("-", 1))
     end
 
     it "should not match when the previous time was now" do
-      @schedule.should_not be_match(Time.now)
+      @schedule.must_not be_match(Time.now)
     end
 
     it "should not match when the previous time was 59 minutes ago" do
-      @schedule.should_not be_match(min("-", 59))
+      @schedule.must_not be_match(min("-", 59))
     end
   end
 
@@ -151,15 +151,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was one day ago" do
-      @schedule.should be_match(day("-", 1))
+      @schedule.must be_match(day("-", 1))
     end
 
     it "should not match when the previous time is now" do
-      @schedule.should_not be_match(Time.now)
+      @schedule.must_not be_match(Time.now)
     end
 
     it "should not match when the previous time was 23 hours ago" do
-      @schedule.should_not be_match(hour("-", 23))
+      @schedule.must_not be_match(hour("-", 23))
     end
   end
 
@@ -174,15 +174,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was seven days ago" do
-      @schedule.should be_match(day("-", 7))
+      @schedule.must be_match(day("-", 7))
     end
 
     it "should not match when the previous time was now" do
-      @schedule.should be_match(Time.now)
+      @schedule.must_not be_match(Time.now)
     end
 
     it "should not match when the previous time was six days ago" do
-      @schedule.should_not be_match(day("-", 6))
+      @schedule.must_not be_match(day("-", 6))
     end
   end
 
@@ -197,15 +197,15 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time was 32 days ago" do
-      @schedule.should be_match(day("-", 32))
+      @schedule.must be_match(day("-", 32))
     end
 
     it "should not match when the previous time was now" do
-      @schedule.should_not be_match(Time.now)
+      @schedule.must_not be_match(Time.now)
     end
 
     it "should not match when the previous time was 27 days ago" do
-      @schedule.should_not be_match(day("-", 27))
+      @schedule.must_not be_match(day("-", 27))
     end
   end
 
@@ -222,7 +222,7 @@ describe Puppet::Type.type(:schedule) do
       previous = Time.utc(2007, 12, 31, 23, 59, 0)
 
       Time.stubs(:now).returns(current)
-      @schedule.should be_match(previous)
+      @schedule.must be_match(previous)
     end
 
     it "should not match if the times are 59 minutes apart and the current minute is 59" do
@@ -230,7 +230,7 @@ describe Puppet::Type.type(:schedule) do
       previous = Time.utc(2009, 2, 1, 12, 0, 0)
 
       Time.stubs(:now).returns(current)
-      @schedule.should_not be_match(previous)
+      @schedule.must_not be_match(previous)
     end
   end
 
@@ -249,7 +249,7 @@ describe Puppet::Type.type(:schedule) do
       previous = current - 60
 
       Time.stubs(:now).returns(current)
-      @schedule.should be_match(previous)
+      @schedule.must be_match(previous)
     end
 
     it "should not match if the times are 23 hours and 58 minutes apart and the current hour is 23 and the current minute is 59" do
@@ -261,7 +261,7 @@ describe Puppet::Type.type(:schedule) do
       now = previous + (23 * 3600) + (59 * 60)
 
       Time.stubs(:now).returns(now)
-      @schedule.should_not be_match(previous)
+      @schedule.must_not be_match(previous)
     end
   end
 
@@ -278,7 +278,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 6, 23, 59, 59) # Sat
 
-      @schedule.should be_match(previous)
+      @schedule.must be_match(previous)
     end
 
     it "should not match if the previous time is after the most recent Saturday" do
@@ -286,7 +286,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 7, 0, 0, 0) # Sunday
 
-      @schedule.should_not be_match(previous)
+      @schedule.must_not be_match(previous)
     end
   end
 
@@ -303,7 +303,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "oct", 31, 23, 59, 59)
 
-      @schedule.should be_match(previous)
+      @schedule.must be_match(previous)
     end
 
     it "should not match when the previous time is after the last day of last month" do
@@ -311,7 +311,7 @@ describe Puppet::Type.type(:schedule) do
       Time.stubs(:now).returns(now)
       previous = Time.utc(2010, "nov", 1, 0, 0, 0)
 
-      @schedule.should_not be_match(previous)
+      @schedule.must_not be_match(previous)
     end
   end
 
@@ -327,17 +327,17 @@ describe Puppet::Type.type(:schedule) do
 
     it "should fail if the periodmatch is 'number'" do
       @schedule[:periodmatch] = :number
-      proc { @schedule[:repeat] = 2 }.should raise_error(Puppet::Error)
+      proc { @schedule[:repeat] = 2 }.must raise_error(Puppet::Error)
     end
 
     it "should match if the previous run was further away than the distance divided by the repeat" do
       previous = Time.now - (3600 * 13)
-      @schedule.should be_match(previous)
+      @schedule.must be_match(previous)
     end
 
     it "should not match if the previous run was closer than the distance divided by the repeat" do
       previous = Time.now - (3600 * 11)
-      @schedule.should_not be_match(previous)
+      @schedule.must_not be_match(previous)
     end
   end
 end

data/spec/unit/util/diff_spec.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/util/diff'
+
+describe Puppet::Util::Diff do
+  describe ".diff" do
+    it "should execute the diff command with arguments" do
+      Puppet[:diff] = 'foo'
+      Puppet[:diff_args] = 'bar'
+
+      subject.expects(:execute).with(['foo', 'bar', 'a', 'b'], {:failonfail => false}).returns('baz')
+      subject.diff('a', 'b').should == 'baz'
+    end
+
+    it "should omit diff arguments if none are specified" do
+      Puppet[:diff] = 'foo'
+      Puppet[:diff_args] = ''
+
+      subject.expects(:execute).with(['foo', 'a', 'b'], {:failonfail => false}).returns('baz')
+      subject.diff('a', 'b').should == 'baz'
+    end
+
+    it "should return empty string if the diff command is empty" do
+      Puppet[:diff] = ''
+
+      subject.expects(:execute).never
+      subject.diff('a', 'b').should == ''
+    end
+  end
+end

data/spec/unit/util/execution_stub_spec.rb

@@ -16,8 +16,7 @@ describe Puppet::Util::ExecutionStub do
     Puppet::Util::ExecutionStub.current_value.should == nil
   end
 
-  # fails on windows, see #11740
-  it "should restore normal execution after 'reset' is called", :fails_on_windows => true do
+  it "should restore normal execution after 'reset' is called" do
     # Note: "true" exists at different paths in different OSes
     if Puppet.features.microsoft_windows?
       true_command = [Puppet::Util.which('cmd.exe').tr('/', '\\'), '/c', 'exit 0']

data/spec/unit/util/log/destinations_spec.rb

@@ -109,3 +109,54 @@ describe Puppet::Util::Log.desttypes[:syslog] do
   end
 end
 
+describe Puppet::Util::Log.desttypes[:console] do
+  describe "when color is available" do
+    it "should support color output" do
+      Puppet.stubs(:[]).with(:color).returns(true)
+      subject.colorize(:red, 'version').should == "\e[0;31mversion\e[0m"
+    end
+
+    it "should withhold color output when not appropriate" do
+      Puppet.stubs(:[]).with(:color).returns(false)
+      subject.colorize(:red, 'version').should == "version"
+    end
+
+    it "should handle multiple overlapping colors in a stack-like way" do
+      Puppet.stubs(:[]).with(:color).returns(true)
+      vstring = subject.colorize(:red, 'version')
+      subject.colorize(:green, "(#{vstring})").should == "\e[0;32m(\e[0;31mversion\e[0;32m)\e[0m"
+    end
+
+    it "should handle resets in a stack-like way" do
+      Puppet.stubs(:[]).with(:color).returns(true)
+      vstring = subject.colorize(:reset, 'version')
+      subject.colorize(:green, "(#{vstring})").should == "\e[0;32m(\e[mversion\e[0;32m)\e[0m"
+    end
+  end
+end
+
+describe Puppet::Util::Log.desttypes[:telly_prototype_console] do
+  describe "when color is available" do
+    it "should support color output" do
+      Puppet.stubs(:[]).with(:color).returns(true)
+      subject.colorize(:red, 'version').should == "\e[0;31mversion\e[0m"
+    end
+
+    it "should withhold color output when not appropriate" do
+      Puppet.stubs(:[]).with(:color).returns(false)
+      subject.colorize(:red, 'version').should == "version"
+    end
+
+    it "should handle multiple overlapping colors in a stack-like way" do
+      Puppet.stubs(:[]).with(:color).returns(true)
+      vstring = subject.colorize(:red, 'version')
+      subject.colorize(:green, "(#{vstring})").should == "\e[0;32m(\e[0;31mversion\e[0;32m)\e[0m"
+    end
+
+    it "should handle resets in a stack-like way" do
+      Puppet.stubs(:[]).with(:color).returns(true)
+      vstring = subject.colorize(:reset, 'version')
+      subject.colorize(:green, "(#{vstring})").should == "\e[0;32m(\e[mversion\e[0;32m)\e[0m"
+    end
+  end
+end