puppet 2.7.9 → 2.7.11

data/spec/unit/type/k5login_spec.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+require 'spec_helper'
+require 'fileutils'
+require 'puppet/type'
+
+describe Puppet::Type.type(:k5login), :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+
+  context "the type class" do
+    subject { described_class }
+    it { should be_validattr :ensure }
+    it { should be_validattr :path }
+    it { should be_validattr :principals }
+    it { should be_validattr :mode }
+    # We have one, inline provider implemented.
+    it { should be_validattr :provider }
+  end
+
+  let(:path) { tmpfile('k5login') }
+
+  def resource(attrs = {})
+    attrs = {
+      :ensure     => 'present',
+      :path       => path,
+      :principals => 'fred@EXAMPLE.COM'
+    }.merge(attrs)
+
+    if content = attrs.delete(:content)
+      File.open(path, 'w') { |f| f.print(content) }
+    end
+
+    resource = described_class.new(attrs)
+    resource
+  end
+
+  before :each do
+    FileUtils.touch(path)
+  end
+
+  context "the provider" do
+    context "when the file is missing" do
+      it "should initially be absent" do
+        File.delete(path)
+        resource.retrieve[:ensure].must == :absent
+      end
+
+      it "should create the file when synced" do
+        resource(:ensure => 'present').parameter(:ensure).sync
+        File.should be_exist path
+      end
+    end
+
+    context "when the file is present" do
+      context "retrieved initial state" do
+        subject { resource.retrieve }
+
+        it "should retrieve its properties correctly with zero principals" do
+          subject[:ensure].should == :present
+          subject[:principals].should == []
+          # We don't really care what the mode is, just that it got it
+          subject[:mode].should_not be_nil
+        end
+
+        context "with one principal" do
+          subject { resource(:content => "daniel@EXAMPLE.COM\n").retrieve }
+
+          it "should retrieve its principals correctly" do
+            subject[:principals].should == ["daniel@EXAMPLE.COM"]
+          end
+        end
+
+        context "with two principals" do
+          subject do
+            content = ["daniel@EXAMPLE.COM", "george@EXAMPLE.COM"].join("\n")
+            resource(:content => content).retrieve
+          end
+
+          it "should retrieve its principals correctly" do
+            subject[:principals].should == ["daniel@EXAMPLE.COM", "george@EXAMPLE.COM"]
+          end
+        end
+      end
+
+      it "should remove the file ensure is absent" do
+        resource(:ensure => 'absent').property(:ensure).sync
+        File.should_not be_exist path
+      end
+
+      it "should write one principal to the file" do
+        File.read(path).should == ""
+        resource(:principals => ["daniel@EXAMPLE.COM"]).property(:principals).sync
+        File.read(path).should == "daniel@EXAMPLE.COM\n"
+      end
+
+      it "should write multiple principals to the file" do
+        content = ["daniel@EXAMPLE.COM", "george@EXAMPLE.COM"]
+
+        File.read(path).should == ""
+        resource(:principals => content).property(:principals).sync
+        File.read(path).should == content.join("\n") + "\n"
+      end
+
+      describe "when setting the mode" do
+        # The defined input type is "mode, as an octal string"
+        ["400", "600", "700", "644", "664"].each do |mode|
+          it "should update the mode to #{mode}" do
+            resource(:mode => mode).property(:mode).sync
+
+            (File.stat(path).mode & 07777).to_s(8).should == mode
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/type/schedule_spec.rb

@@ -82,17 +82,17 @@ describe Puppet::Type.type(:schedule) do
 
     it "should match when the start time is before the current time and the end time is after the current time" do
       @schedule[:range] = "10:59:50 - 11:00:10"
-      @schedule.should be_match
+      @schedule.must be_match
     end
 
     it "should not match when the start time is after the current time" do
       @schedule[:range] = "11:00:05 - 11:00:10"
-      @schedule.should_not be_match
+      @schedule.must_not be_match
     end
 
     it "should not match when the end time is previous to the current time" do
       @schedule[:range] = "10:59:50 - 10:59:55"
-      @schedule.should be_match
+      @schedule.must_not be_match
     end
 
     it "should throw an error if the upper limit is less than the lower limit" do
@@ -103,17 +103,17 @@ describe Puppet::Type.type(:schedule) do
 
     it "should not match the current time fails between an array of ranges" do
       @schedule[:range] = ["4-6", "20-23"]
-      @schedule.should_not be_match
+      @schedule.must_not be_match
     end
 
     it "should match the lower array of ranges" do
       @schedule[:range] = ["9-11", "14-16"]
-      @schedule.should be_match
+      @schedule.must be_match
     end
 
     it "should match the upper array of ranges" do
       @schedule[:range] = ["4-6", "11-12"]
-      @schedule.should be_match
+      @schedule.must be_match
     end
   end
 

data/spec/unit/type_spec.rb

@@ -4,6 +4,28 @@ require 'spec_helper'
 describe Puppet::Type, :fails_on_windows => true do
   include PuppetSpec::Files
 
+  it "should be Comparable" do
+    a = Puppet::Type.type(:notify).new(:name => "a")
+    b = Puppet::Type.type(:notify).new(:name => "b")
+    c = Puppet::Type.type(:notify).new(:name => "c")
+
+    [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
+      this.sort.should == [a, b, c]
+    end
+
+    a.should be < b
+    a.should be < c
+    b.should be > a
+    b.should be < c
+    c.should be > a
+    c.should be > b
+
+    [a, b, c].each {|x| a.should be <= x }
+    [a, b, c].each {|x| c.should be >= x }
+
+    b.should be_between(a, c)
+  end
+
   it "should consider a parameter to be valid if it is a valid parameter" do
     Puppet::Type.type(:mount).should be_valid_parameter(:path)
   end
@@ -588,6 +610,35 @@ describe Puppet::Type, :fails_on_windows => true do
       resource.should_not be_suitable
     end
   end
+
+  describe "::ensurable?" do
+    before :each do
+      class TestEnsurableType < Puppet::Type
+        def exists?; end
+        def create; end
+        def destroy; end
+      end
+    end
+
+    it "is true if the class has exists?, create, and destroy methods defined" do
+      TestEnsurableType.should be_ensurable
+    end
+
+    it "is false if exists? is not defined" do
+      TestEnsurableType.class_eval { remove_method(:exists?) }
+      TestEnsurableType.should_not be_ensurable
+    end
+
+    it "is false if create is not defined" do
+      TestEnsurableType.class_eval { remove_method(:create) }
+      TestEnsurableType.should_not be_ensurable
+    end
+
+    it "is false if destroy is not defined" do
+      TestEnsurableType.class_eval { remove_method(:destroy) }
+      TestEnsurableType.should_not be_ensurable
+    end
+  end
 end
 
 describe Puppet::Type::RelationshipMetaparam do

data/spec/unit/util/anonymous_filelock_spec.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/anonymous_filelock'
+
+describe Puppet::Util::AnonymousFilelock do
+  require 'puppet_spec/files'
+  include PuppetSpec::Files
+
+  before(:each) do
+    @lockfile = tmpfile("lock")
+    @lock = Puppet::Util::AnonymousFilelock.new(@lockfile)
+  end
+
+  it "should be anonymous" do
+    @lock.should be_anonymous
+  end
+
+  describe "#lock" do
+    it "should return false if already locked" do
+      @lock.stubs(:locked?).returns(true)
+      @lock.lock.should be_false
+    end
+
+    it "should return true if it successfully locked" do
+      @lock.lock.should be_true
+    end
+
+    it "should create a lock file" do
+      @lock.lock
+
+      File.should be_exists(@lockfile)
+    end
+
+    it "should create a lock file containing a message" do
+      @lock.lock("message")
+
+      File.read(@lockfile).should == "message"
+    end
+  end
+
+  describe "#unlock" do
+    it "should return true when unlocking" do
+      @lock.lock
+      @lock.unlock.should be_true
+    end
+
+    it "should return false when not locked" do
+      @lock.unlock.should be_false
+    end
+
+    it "should clear the lock file" do
+      File.open(@lockfile, 'w') { |fd| fd.print("locked") }
+      @lock.unlock
+      File.should_not be_exists(@lockfile)
+    end
+  end
+
+  it "should be locked when locked" do
+    @lock.lock
+    @lock.should be_locked
+  end
+
+  it "should not be locked when not locked" do
+    @lock.should_not be_locked
+  end
+
+  it "should not be locked when unlocked" do
+    @lock.lock
+    @lock.unlock
+    @lock.should_not be_locked
+  end
+
+  it "should return the lock message" do
+    @lock.lock("lock message")
+    @lock.message.should == "lock message"
+  end
+end

data/spec/unit/util/execution_stub_spec.rb

@@ -16,7 +16,8 @@ describe Puppet::Util::ExecutionStub do
     Puppet::Util::ExecutionStub.current_value.should == nil
   end
 
-  it "should restore normal execution after 'reset' is called" do
+  # fails on windows, see #11740
+  it "should restore normal execution after 'reset' is called", :fails_on_windows => true 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/instrumentation/data_spec.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require 'matchers/json'
+require 'puppet/util/instrumentation'
+require 'puppet/util/instrumentation/data'
+
+describe Puppet::Util::Instrumentation::Data do
+  Puppet::Util::Instrumentation::Data
+
+  before(:each) do
+    @listener = stub 'listener', :name => "name"
+    Puppet::Util::Instrumentation.stubs(:[]).with("name").returns(@listener)
+  end
+
+  it "should indirect instrumentation_data" do
+    Puppet::Util::Instrumentation::Data.indirection.name.should == :instrumentation_data
+  end
+
+  it "should lookup the corresponding listener" do
+    Puppet::Util::Instrumentation.expects(:[]).with("name").returns(@listener)
+    Puppet::Util::Instrumentation::Data.new("name")
+  end
+
+  it "should error if the listener can not be found" do
+    Puppet::Util::Instrumentation.expects(:[]).with("name").returns(nil)
+    expect { Puppet::Util::Instrumentation::Data.new("name") }.to raise_error
+  end
+
+  it "should return pson data" do
+    data = Puppet::Util::Instrumentation::Data.new("name")
+    @listener.stubs(:data).returns({ :this_is_data  => "here also" })
+    data.should set_json_attribute('name').to("name")
+    data.should set_json_attribute('this_is_data').to("here also")
+  end
+
+  it "should not error if the underlying listener doesn't have data" do
+    lambda { Puppet::Util::Instrumentation::Data.new("name").to_pson }.should_not raise_error
+  end
+
+  it "should return a hash containing data when unserializing from pson" do
+    Puppet::Util::Instrumentation::Data.from_pson({:name => "name"}).should == {:name => "name"}
+  end
+end

data/spec/unit/util/instrumentation/indirection_probe_spec.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+require 'matchers/json'
+require 'puppet/util/instrumentation'
+require 'puppet/util/instrumentation/indirection_probe'
+
+describe Puppet::Util::Instrumentation::IndirectionProbe do
+  Puppet::Util::Instrumentation::IndirectionProbe
+
+  it "should indirect instrumentation_probe" do
+    Puppet::Util::Instrumentation::IndirectionProbe.indirection.name.should == :instrumentation_probe
+  end
+
+  it "should return pson data" do
+    probe = Puppet::Util::Instrumentation::IndirectionProbe.new("probe")
+    probe.should set_json_attribute('name').to("probe")
+  end
+end

data/spec/unit/util/instrumentation/instrumentable_spec.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+require 'puppet/util/instrumentation'
+require 'puppet/util/instrumentation/instrumentable'
+
+describe Puppet::Util::Instrumentation::Instrumentable::Probe do
+
+  before(:each) do
+    Puppet::Util::Instrumentation.stubs(:start)
+    Puppet::Util::Instrumentation.stubs(:stop)
+
+    class ProbeTest
+      def mymethod(arg1, arg2, arg3)
+        :it_worked
+      end
+    end
+  end
+
+  after(:each) do
+    if ProbeTest.method_defined?(:instrumented_mymethod)
+      ProbeTest.class_eval {
+        remove_method(:mymethod)
+        alias_method(:mymethod, :instrumented_mymethod)
+      }
+    end
+    Puppet::Util::Instrumentation::Instrumentable.clear_probes
+  end
+
+  describe "when enabling a probe" do
+    it "should raise an error if the probe is already enabled" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      lambda { probe.enable }.should raise_error
+    end
+
+    it "should rename the original method name" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      ProbeTest.new.should respond_to(:instrumented_mymethod)
+    end
+
+    it "should create a new method of the original name" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      ProbeTest.new.should respond_to(:mymethod)
+    end
+  end
+
+  describe "when disabling a probe" do
+    it "should raise an error if the probe is already enabled" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      lambda { probe.disable }.should raise_error
+    end
+
+    it "should rename the original method name" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      probe.disable
+
+      Puppet::Util::Instrumentation.expects(:start).never
+      Puppet::Util::Instrumentation.expects(:stop).never
+      ProbeTest.new.mymethod(1,2,3).should == :it_worked
+    end
+
+    it "should remove the created method" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      probe.disable
+      ProbeTest.new.should_not respond_to(:instrumented_mymethod)
+    end
+  end
+
+  describe "when a probe is called" do
+    it "should call the original method" do
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      test = ProbeTest.new
+      test.expects(:instrumented_mymethod).with(1,2,3)
+      test.mymethod(1,2,3)
+    end
+
+    it "should start the instrumentation" do
+      Puppet::Util::Instrumentation.expects(:start)
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      test = ProbeTest.new
+      test.mymethod(1,2,3)
+    end
+
+    it "should stop the instrumentation" do
+      Puppet::Util::Instrumentation.expects(:stop)
+      probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+      probe.enable
+      test = ProbeTest.new
+      test.mymethod(1,2,3)
+    end
+
+    describe "and the original method raises an exception" do
+      it "should propagate the exception" do
+        probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+        probe.enable
+        test = ProbeTest.new
+        test.expects(:instrumented_mymethod).with(1,2,3).raises
+        lambda { test.mymethod(1,2,3) }.should raise_error
+      end
+
+      it "should stop the instrumentation" do
+        Puppet::Util::Instrumentation.expects(:stop)
+        probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest)
+        probe.enable
+        test = ProbeTest.new
+        test.expects(:instrumented_mymethod).with(1,2,3).raises
+        lambda { test.mymethod(1,2,3) }.should raise_error
+      end
+    end
+
+    describe "with a static label" do
+      it "should send the label to the instrumentation layer" do
+        probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest, :label => :mylabel)
+        probe.enable
+        test = ProbeTest.new
+        Puppet::Util::Instrumentation.expects(:start).with { |label,data| label == :mylabel }.returns(42)
+        Puppet::Util::Instrumentation.expects(:stop).with(:mylabel, 42, {})
+        test.mymethod(1,2,3)
+      end
+    end
+
+    describe "with a dynamic label" do
+      it "should send the evaluated label to the instrumentation layer" do
+        probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest, :label => Proc.new { |parent,args| "dynamic#{args[0]}" } )
+        probe.enable
+        test = ProbeTest.new
+        Puppet::Util::Instrumentation.expects(:start).with { |label,data| label == "dynamic1" }.returns(42)
+        Puppet::Util::Instrumentation.expects(:stop).with("dynamic1",42,{})
+        test.mymethod(1,2,3)
+      end
+    end
+
+    describe "with static data" do
+      it "should send the data to the instrumentation layer" do
+        probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest, :data => { :static_data => "nothing" })
+        probe.enable
+        test = ProbeTest.new
+        Puppet::Util::Instrumentation.expects(:start).with { |label,data| data == { :static_data => "nothing" }}
+        test.mymethod(1,2,3)
+      end
+    end
+
+    describe "with dynamic data" do
+      it "should send the evaluated label to the instrumentation layer" do
+        probe = Puppet::Util::Instrumentation::Instrumentable::Probe.new(:mymethod, ProbeTest, :data => Proc.new { |parent, args| { :key => args[0] }  } )
+        probe.enable
+        test = ProbeTest.new
+        Puppet::Util::Instrumentation.expects(:start).with { |label,data| data == { :key => 1 } }
+        Puppet::Util::Instrumentation.expects(:stop)
+        test.mymethod(1,2,3)
+      end
+    end
+  end
+end
+
+describe Puppet::Util::Instrumentation::Instrumentable do
+  before(:each) do
+    class ProbeTest2
+      extend Puppet::Util::Instrumentation::Instrumentable
+      probe :mymethod
+      def mymethod(arg1,arg2,arg3)
+      end
+    end
+  end
+
+  after do
+    Puppet::Util::Instrumentation::Instrumentable.clear_probes
+  end
+
+  it "should allow probe definition" do
+    Puppet::Util::Instrumentation::Instrumentable.probe_names.should be_include("ProbeTest2.mymethod")
+  end
+
+  it "should be able to enable all probes" do
+    Puppet::Util::Instrumentation::Instrumentable.enable_probes
+    ProbeTest2.new.should respond_to(:instrumented_mymethod)
+  end
+end