puppet 2.6.4 → 2.6.5

data/lib/puppet/transaction/change.rb

@@ -1,87 +0,0 @@
-require 'puppet/transaction'
-require 'puppet/transaction/event'
-
-# Handle all of the work around performing an actual change,
-# including calling 'sync' on the properties and producing events.
-class Puppet::Transaction::Change
-  attr_accessor :is, :should, :property, :proxy, :auditing
-
-  def auditing?
-    auditing
-  end
-
-  # Create our event object.
-  def event
-    result = property.event
-    result.previous_value = is
-    result.desired_value = should
-    result
-  end
-
-  def initialize(property, currentvalue)
-    @property = property
-    @is = currentvalue
-
-    @should = property.should
-
-    @changed = false
-  end
-
-  def apply
-    return audit_event if auditing?
-    return noop_event if noop?
-
-    property.sync
-
-    result = event
-    result.message = property.change_to_s(is, should)
-    result.status = "success"
-    result.send_log
-    result
-  rescue => detail
-    puts detail.backtrace if Puppet[:trace]
-    result = event
-    result.status = "failure"
-
-    result.message = "change from #{property.is_to_s(is)} to #{property.should_to_s(should)} failed: #{detail}"
-    result.send_log
-    result
-  end
-
-  # Is our property noop?  This is used for generating special events.
-  def noop?
-    @property.noop
-  end
-
-  # The resource that generated this change.  This is used for handling events,
-  # and the proxy resource is used for generated resources, since we can't
-  # send an event to a resource we don't have a direct relationship with.  If we
-  # have a proxy resource, then the events will be considered to be from
-  # that resource, rather than us, so the graph resolution will still work.
-  def resource
-    self.proxy || @property.resource
-  end
-
-  def to_s
-    "change #{@property.change_to_s(@is, @should)}"
-  end
-
-  private
-
-  def audit_event
-    # This needs to store the appropriate value, and then produce a new event
-    result = event
-    result.message = "audit change: previously recorded value #{property.should_to_s(should)} has been changed to #{property.is_to_s(is)}"
-    result.status = "audit"
-    result.send_log
-    result
-  end
-
-  def noop_event
-    result = event
-    result.message = "is #{property.is_to_s(is)}, should be #{property.should_to_s(should)} (noop)"
-    result.status = "noop"
-    result.send_log
-    result
-  end
-end

data/spec/Rakefile

@@ -1,91 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper.rb")
-require 'rake'
-require 'spec/rake/spectask'
-
-basedir = File.dirname(__FILE__)
-puppetlibdir = File.join(basedir, "../lib")
-puppettestlibdir = File.join(basedir, "../test/lib")
-speclibdir = File.join(basedir, "lib")
-
-require 'find'
-
-include Find
-include FileTest
-
-$exclusions = %W(lib)
-
-filemap = Hash.new { |hash, key| hash[key] = [] }
-
-allfiles = []
-
-# First collect the entire file list.
-find(".") do |f|
-    # Get rid of the leading ./
-    f = f.sub(/^\.\//, '')
-
-    file = File.basename(f)
-    dir = File.dirname(f)
-
-    # Prune . directories and excluded dirs
-    if (file =~ /^\./ and f != ".") or $exclusions.include?(File.basename(file))
-        prune
-        next
-    end
-    next if f == "."
-    next if dir == "."
-
-    # If we're a ruby script, then add it to the list of files for that dir
-    if file =~ /\.rb$/
-        allfiles << f
-        # Add it to all of the parent dirs, not just our own
-        parts = File.split(dir)
-        if parts[0] == "."
-            parts.shift
-        end
-        parts.each_with_index { |part, i|
-            path = File.join(parts[0..i])
-            filemap[path] << f
-        }
-    end
-end
-
-
-libs = [puppetlibdir, puppettestlibdir, speclibdir]
-desc "Run all specs"
-Spec::Rake::SpecTask.new('all') do |t|
-    t.spec_files = FileList['integration/**/*.rb', 'unit/**/*.rb']
-    t.libs = libs
-    t.spec_opts = ['--options', 'spec.opts']
-end
-
-task :default => [:all]
-
-# Now create a task for every directory
-filemap.each do |dir, files|
-    ns = dir.gsub "/", ":"
-
-    # First create a separate task for each file in the namespace.
-    namespace ns do
-        files.each do |file|
-            Spec::Rake::SpecTask.new(File.basename(file, '.rb').to_sym) do |t|
-                t.spec_files = [ file ]
-                t.libs = libs
-                t.spec_opts = ['--options', 'spec.opts']
-            end
-        end
-    end
-
-    # Then create a task that matches the directory itself.
-    Spec::Rake::SpecTask.new(dir) do |t|
-       if ENV["TESTFILES"]
-           t.spec_files = ENV["TESTFILES"].split(/\s+/)
-       else
-           t.spec_files = files.sort
-       end
-       t.libs = libs
-       t.spec_opts = ['--options', 'spec.opts']
-    end
-
-    # And alias it with a slash on the end
-    task(dir + "/" => dir)
-end

data/spec/monkey_patches/add_confine_and_runnable_to_rspec_dsl.rb

@@ -1,46 +0,0 @@
-dir = File.expand_path(File.dirname(__FILE__))
-[ "#{dir}/../../lib", "#{dir}/../../test/lib"].each do |dir|
-    fulldir = File.expand_path(dir)
-    $LOAD_PATH.unshift(fulldir) unless $LOAD_PATH.include?(fulldir)
-end
-
-require 'spec'
-require 'puppettest/runnable_test'
-
-module Spec
-  module Runner
-    class ExampleGroupRunner
-      def run
-        prepare
-        success = true
-        example_groups.each do |example_group|
-          unless example_group.runnable?
-            warn "Skipping unsuitable example group #{example_group.description}: #{example_group.messages.join(", ")}"
-            next
-          end
-          success = success & example_group.run(@options)
-          Puppet.settings.clear
-        end
-        return success
-      ensure
-        finish
-      end
-    end
-  end
-end
-
-module Spec
-  module Example
-    class ExampleGroup
-      extend PuppetTest::RunnableTest
-    end
-  end
-end
-
-module Test
-  module Unit
-    class TestCase
-      extend PuppetTest::RunnableTest
-    end
-  end
-end

data/spec/spec_specs/runnable_spec.rb

@@ -1,95 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe PuppetTest::RunnableTest do
-  before do
-    @runnable_test = Class.new.extend(PuppetTest::RunnableTest)
-  end
-
-  describe "#confine" do
-    subject { @runnable_test }
-
-    it "should accept a hash" do
-      subject.confine({}).should_not raise_error(ArgumentError)
-    end
-
-    it "should accept a message and a block" do
-      subject.confine(""){}.should_not raise_error(ArgumentError)
-    end
-
-  end
-
-  describe "#runnable?" do
-    describe "when the superclass is not runnable" do
-      before { @runnable_test.stubs(:superclass).returns(stub("unrunnable superclass", :runnable? => false)) }
-      subject { @runnable_test.runnable? }
-
-      it { should be_false }
-    end
-
-    describe "when a confine is false" do
-      before { @runnable_test.confine(:message => false) }
-      subject { @runnable_test.runnable? }
-
-      it { should be_false }
-    end
-
-    describe "when a confine has a block that returns false" do
-      before { @runnable_test.confine(:message){ false } }
-      subject { @runnable_test.runnable? }
-
-      it { should be_false }
-    end
-
-    describe "when a confine is true and no false confines" do
-      before { @runnable_test.confine(:message => true) }
-      subject { @runnable_test.runnable? }
-
-      it { should be_true }
-    end
-
-    describe "when a confine has block that returns true and no false confines" do
-      before { @runnable_test.confine(:message){ true } }
-      subject { @runnable_test.runnable? }
-
-      it { should be_true }
-    end
-
-  end
-
-  describe "#messages" do
-    describe "before runnable? is called" do
-      subject { @runnable_test.messages }
-
-      it { should == [] }
-    end
-
-    describe "when runnable? is called and returns false" do
-      before do
-        @runnable_test.confine(:message => false)
-        @runnable_test.runnable?
-      end
-
-      subject { @runnable_test.messages }
-
-      it "should include the failed confine's message" do
-        should include(:message)
-      end
-
-    end
-
-    describe "when runnable? is called whose block returns false" do
-      before do
-        @runnable_test.confine(:message){ false }
-        @runnable_test.runnable?
-      end
-
-      subject { @runnable_test.messages }
-
-      it "should include the failed confine's message" do
-        should include(:message)
-      end
-
-    end
-
-  end
-end

data/spec/unit/transaction/change_spec.rb

@@ -1,193 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-require 'puppet/transaction/change'
-
-describe Puppet::Transaction::Change do
-  Change = Puppet::Transaction::Change
-
-  describe "when initializing" do
-    before do
-      @property = stub 'property', :path => "/property/path", :should => "shouldval"
-    end
-
-    it "should require the property and current value" do
-      lambda { Change.new }.should raise_error
-    end
-
-    it "should set its property to the provided property" do
-      Change.new(@property, "value").property.should == :property
-    end
-
-    it "should set its 'is' value to the provided value" do
-      Change.new(@property, "value").is.should == "value"
-    end
-
-    it "should retrieve the 'should' value from the property" do
-      # Yay rspec :)
-      Change.new(@property, "value").should.should == @property.should
-    end
-  end
-
-  describe "when an instance" do
-    before do
-      @property = stub 'property', :path => "/property/path", :should => "shouldval"
-      @change = Change.new(@property, "value")
-    end
-
-    it "should be noop if the property is noop" do
-      @property.expects(:noop).returns true
-      @change.noop?.should be_true
-    end
-
-    it "should be auditing if set so" do
-      @change.auditing = true
-      @change.must be_auditing
-    end
-
-    it "should set its resource to the proxy if it has one" do
-      @change.proxy = :myresource
-      @change.resource.should == :myresource
-    end
-
-    it "should set its resource to the property's resource if no proxy is set" do
-      @property.expects(:resource).returns :myresource
-      @change.resource.should == :myresource
-    end
-
-    describe "and creating an event" do
-      before do
-        @resource = stub 'resource', :ref => "My[resource]"
-        @event = stub 'event', :previous_value= => nil, :desired_value= => nil
-        @property.stubs(:event).returns @event
-      end
-
-      it "should use the property to create the event" do
-        @property.expects(:event).returns @event
-        @change.event.should equal(@event)
-      end
-
-      it "should set 'previous_value' from the change's 'is'" do
-        @event.expects(:previous_value=).with(@change.is)
-        @change.event
-      end
-
-      it "should set 'desired_value' from the change's 'should'" do
-        @event.expects(:desired_value=).with(@change.should)
-        @change.event
-      end
-    end
-
-    describe "and executing" do
-      before do
-        @event = Puppet::Transaction::Event.new(:myevent)
-        @event.stubs(:send_log)
-        @change.stubs(:noop?).returns false
-        @property.stubs(:event).returns @event
-
-        @property.stub_everything
-        @property.stubs(:resource).returns "myresource"
-        @property.stubs(:name).returns :myprop
-      end
-
-      describe "in noop mode" do
-        before { @change.stubs(:noop?).returns true }
-
-        it "should log that it is in noop" do
-          @property.expects(:is_to_s)
-          @property.expects(:should_to_s)
-
-          @event.expects(:message=).with { |msg| msg.include?("should be") }
-
-          @change.apply
-        end
-
-        it "should produce a :noop event and return" do
-          @property.stub_everything
-
-          @event.expects(:status=).with("noop")
-
-          @change.apply.should == @event
-        end
-      end
-
-      describe "in audit mode" do
-        before { @change.auditing = true }
-
-        it "should log that it is in audit mode" do
-          @property.expects(:is_to_s)
-          @property.expects(:should_to_s)
-
-          @event.expects(:message=).with { |msg| msg.include?("audit") }
-
-          @change.apply
-        end
-
-        it "should produce a :audit event and return" do
-          @property.stub_everything
-
-          @event.expects(:status=).with("audit")
-
-          @change.apply.should == @event
-        end
-      end
-
-      it "should sync the property" do
-        @property.expects(:sync)
-
-        @change.apply
-      end
-
-      it "should return the default event if syncing the property returns nil" do
-        @property.stubs(:sync).returns nil
-
-        @change.expects(:event).with(nil).returns @event
-
-        @change.apply.should == @event
-      end
-
-      it "should return the default event if syncing the property returns an empty array" do
-        @property.stubs(:sync).returns []
-
-        @change.expects(:event).with(nil).returns @event
-
-        @change.apply.should == @event
-      end
-
-      it "should log the change" do
-        @property.expects(:sync).returns [:one]
-
-        @event.expects(:send_log)
-
-        @change.apply
-      end
-
-      it "should set the event's message to the change log" do
-        @property.expects(:change_to_s).returns "my change"
-        @change.apply.message.should == "my change"
-      end
-
-      it "should set the event's status to 'success'" do
-        @change.apply.status.should == "success"
-      end
-
-      describe "and the change fails" do
-        before { @property.expects(:sync).raises "an exception" }
-
-        it "should catch the exception and log the err" do
-          @event.expects(:send_log)
-          lambda { @change.apply }.should_not raise_error
-        end
-
-        it "should mark the event status as 'failure'" do
-          @change.apply.status.should == "failure"
-        end
-
-        it "should set the event log to a failure log" do
-          @change.apply.message.should be_include("failed")
-        end
-      end
-    end
-  end
-end