From c87d6c98ec1a315d435be38e7eb2258984c7d88c Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Wed, 20 Apr 2011 02:35:40 +1000
Subject: Fixed #7166 - Replaced deprecated stomp "send" method with "publish"

The "send" method in the stomp gem has been deprecated since:

http://gitorious.org/stomp/mainline/commit/d542a976028cb4c5badcbb69e3383e746721e44c

It's been replaced with the "publish" method.

Also renamed the send_message method to publish_message more in
keeping with language used in queuing.
---
 spec/integration/indirector/catalog/queue_spec.rb |  4 ++--
 spec/unit/indirector/queue_spec.rb                |  8 ++++----
 spec/unit/util/queue/stomp_spec.rb                | 20 ++++++++++----------
 3 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/indirector/catalog/queue_spec.rb b/spec/integration/indirector/catalog/queue_spec.rb
index 569f096bf..940c8bab8 100755
--- a/spec/integration/indirector/catalog/queue_spec.rb
+++ b/spec/integration/indirector/catalog/queue_spec.rb
@@ -19,13 +19,13 @@ describe "Puppet::Resource::Catalog::Queue", :if => Puppet.features.pson? do
 
   after { Puppet.settings.clear }
 
-  it "should render catalogs to pson and send them via the queue client when catalogs are saved" do
+  it "should render catalogs to pson and publish them via the queue client when catalogs are saved" do
     terminus = Puppet::Resource::Catalog.indirection.terminus(:queue)
 
     client = mock 'client'
     terminus.stubs(:client).returns client
 
-    client.expects(:send_message).with(:catalog, @catalog.to_pson)
+    client.expects(:publish_message).with(:catalog, @catalog.to_pson)
 
     request = Puppet::Indirector::Request.new(:catalog, :save, "foo", :instance => @catalog)
 
diff --git a/spec/unit/indirector/queue_spec.rb b/spec/unit/indirector/queue_spec.rb
index b84ed2aea..eba136bbc 100755
--- a/spec/unit/indirector/queue_spec.rb
+++ b/spec/unit/indirector/queue_spec.rb
@@ -60,20 +60,20 @@ describe Puppet::Indirector::Queue, :if => Puppet.features.pson? do
   describe "when saving" do
     it 'should render the instance using pson' do
       @subject.expects(:render).with(:pson)
-      @store.client.stubs(:send_message)
+      @store.client.stubs(:publish_message)
       @store.save(@request)
     end
 
-    it "should send the rendered message to the appropriate queue on the client" do
+    it "should publish the rendered message to the appropriate queue on the client" do
       @subject.expects(:render).returns "mypson"
 
-      @store.client.expects(:send_message).with(:my_queue, "mypson")
+      @store.client.expects(:publish_message).with(:my_queue, "mypson")
 
       @store.save(@request)
     end
 
     it "should catch any exceptions raised" do
-      @store.client.expects(:send_message).raises ArgumentError
+      @store.client.expects(:publish_message).raises ArgumentError
 
       lambda { @store.save(@request) }.should raise_error(Puppet::Error)
     end
diff --git a/spec/unit/util/queue/stomp_spec.rb b/spec/unit/util/queue/stomp_spec.rb
index f67189cf5..99c77d0b4 100755
--- a/spec/unit/util/queue/stomp_spec.rb
+++ b/spec/unit/util/queue/stomp_spec.rb
@@ -63,26 +63,26 @@ describe 'Puppet::Util::Queue::Stomp', :if => Puppet.features.stomp? do
     end
   end
 
-  describe "when sending a message" do
+  describe "when publishing a message" do
     before do
       @client = stub 'client'
       Stomp::Client.stubs(:new).returns @client
       @queue = Puppet::Util::Queue::Stomp.new
     end
 
-    it "should send it to the queue client instance" do
-      @client.expects(:send).with { |queue, msg, options| msg == "Smite!" }
-      @queue.send_message('fooqueue', 'Smite!')
+    it "should publish it to the queue client instance" do
+      @client.expects(:publish).with { |queue, msg, options| msg == "Smite!" }
+      @queue.publish_message('fooqueue', 'Smite!')
     end
 
-    it "should send it to the transformed queue name" do
-      @client.expects(:send).with { |queue, msg, options| queue == "/queue/fooqueue" }
-      @queue.send_message('fooqueue', 'Smite!')
+    it "should publish it to the transformed queue name" do
+      @client.expects(:publish).with { |queue, msg, options| queue == "/queue/fooqueue" }
+      @queue.publish_message('fooqueue', 'Smite!')
     end
 
-    it "should send it as a persistent message" do
-      @client.expects(:send).with { |queue, msg, options| options[:persistent] == true }
-      @queue.send_message('fooqueue', 'Smite!')
+    it "should publish it as a persistent message" do
+      @client.expects(:publish).with { |queue, msg, options| options[:persistent] == true }
+      @queue.publish_message('fooqueue', 'Smite!')
     end
   end
 
-- 
cgit 


From 5d7ef5caf30a0c5b3253340c5f2722e51c56c75e Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Tue, 19 Apr 2011 20:23:27 -0700
Subject: (#7062) better argument handling in the action wrapper methods
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We previously used *args to collect all arguments to the action when_invoked
block, then tried vaguely to massage some little bits of them into the right
shape.

Methods defined with blocks, in Ruby 1.8, also have some fun behaviours.  The
most special is that if you pass more than one argument to a block defined
with only one Ruby will automatically coerce the arguments into an array – and
this is preserved when it is bound to a method.

This led to routine situations where we would pass the wrong number of
arguments to the block because, say, the user gave an extra argument on the
command line.

Instead of failing this would transmogrify the arguments in counterintuitive
ways, and end up with horrible stack traces when that interacted badly with
the code as written.

Now, instead, we work out the right argument format based on the arguments
that the when_invoked block takes.  This gives much better (albeit perhaps not
so user friendly) behaviour at the interface level.  Which is, at least,
consistent with other Ruby API.

Reviewed-By: Max Martin <max@puppetlabs.com>
---
 spec/unit/interface/action_spec.rb | 56 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/interface/action_spec.rb b/spec/unit/interface/action_spec.rb
index 0eb450ee2..24826a6ef 100755
--- a/spec/unit/interface/action_spec.rb
+++ b/spec/unit/interface/action_spec.rb
@@ -12,6 +12,62 @@ describe Puppet::Interface::Action do
     end
   end
 
+  describe "#when_invoked=" do
+    it "should fail if the block has arity 0" do
+      pending "Ruby 1.8 (painfully) treats argument-free blocks as arity -1" if
+        RUBY_VERSION =~ /^1\.8/
+
+      expect {
+        Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+          action :foo do
+            when_invoked do
+            end
+          end
+        end
+      }.to raise_error ArgumentError, /foobra/
+    end
+
+    it "should work with arity 1 blocks" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|one| }
+        end
+      end
+      # -1, because we use option defaulting. :(
+      face.method(:foo).arity.should == -1
+    end
+
+    it "should work with arity 2 blocks" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|one, two| }
+        end
+      end
+      # -2, because we use option defaulting. :(
+      face.method(:foo).arity.should == -2
+    end
+
+    it "should work with arity 1 blocks that collect arguments" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|*one| }
+        end
+      end
+      # -1, because we use only varargs
+      face.method(:foo).arity.should == -1
+    end
+
+    it "should work with arity 2 blocks that collect arguments" do
+      face = Puppet::Interface.new(:action_when_invoked, '1.0.0') do
+        action :foo do
+          when_invoked {|one, *two| }
+        end
+      end
+      # -2, because we take one mandatory argument, and one varargs
+      face.method(:foo).arity.should == -2
+    end
+  end
+
   describe "when invoking" do
     it "should be able to call other actions on the same object" do
       face = Puppet::Interface.new(:my_face, '0.0.1') do
-- 
cgit 


From 601baf1f25e5f62b5f501635cf49721187045f29 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Tue, 19 Apr 2011 20:43:47 -0700
Subject: maint: remove redundant context from the test.

We had a block of tests in a describe block inside a describe block; they were
literally one hundred percent overlap.  Eliminate that and just keep the
outer.

Reviewed-By: Max Martin <max@puppetlabs.com>
---
 spec/unit/application/face_base_spec.rb | 204 ++++++++++++++++----------------
 1 file changed, 101 insertions(+), 103 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index 5403608cf..7dbe59fd7 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -40,126 +40,124 @@ describe Puppet::Application::FaceBase do
       app.command_line.stubs(:args).returns %w{}
     end
 
-    describe "parsing the command line" do
-      context "with just an action" do
-        before :all do
-          # We have to stub Signal.trap to avoid a crazy mess where we take
-          # over signal handling and make it impossible to cancel the test
-          # suite run.
-          #
-          # It would be nice to fix this elsewhere, but it is actually hard to
-          # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
-          Signal.stubs(:trap)
-          app.command_line.stubs(:args).returns %w{foo}
-          app.preinit
-          app.parse_options
-        end
-
-        it "should set the face based on the type" do
-          app.face.name.should == :basetest
-        end
-
-        it "should find the action" do
-          app.action.should be
-          app.action.name.should == :foo
-        end
+    context "with just an action" do
+      before :all do
+        # We have to stub Signal.trap to avoid a crazy mess where we take
+        # over signal handling and make it impossible to cancel the test
+        # suite run.
+        #
+        # It would be nice to fix this elsewhere, but it is actually hard to
+        # capture this in rspec 2.5 and all. :(  --daniel 2011-04-08
+        Signal.stubs(:trap)
+        app.command_line.stubs(:args).returns %w{foo}
+        app.preinit
+        app.parse_options
       end
 
-      it "should use the default action if not given any arguments" do
-        app.command_line.stubs(:args).returns []
-        action = stub(:options => [])
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
-        app.stubs(:main)
-        app.run
-        app.action.should == action
-        app.arguments.should == [ { } ]
+      it "should set the face based on the type" do
+        app.face.name.should == :basetest
       end
 
-      it "should use the default action if not given a valid one" do
-        app.command_line.stubs(:args).returns %w{bar}
-        action = stub(:options => [])
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
-        app.stubs(:main)
-        app.run
-        app.action.should == action
-        app.arguments.should == [ 'bar', { } ]
+      it "should find the action" do
+        app.action.should be
+        app.action.name.should == :foo
       end
+    end
 
-      it "should have no action if not given a valid one and there is no default action" do
-        app.command_line.stubs(:args).returns %w{bar}
-        Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
-        app.stubs(:main)
-        app.run
-        app.action.should be_nil
-        app.arguments.should == [ 'bar', { } ]
-      end
+    it "should use the default action if not given any arguments" do
+      app.command_line.stubs(:args).returns []
+      action = stub(:options => [])
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
+      app.stubs(:main)
+      app.run
+      app.action.should == action
+      app.arguments.should == [ { } ]
+    end
 
-      it "should report a sensible error when options with = fail" do
-        app.command_line.stubs(:args).returns %w{--action=bar foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --action/
-      end
+    it "should use the default action if not given a valid one" do
+      app.command_line.stubs(:args).returns %w{bar}
+      action = stub(:options => [])
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
+      app.stubs(:main)
+      app.run
+      app.action.should == action
+      app.arguments.should == [ 'bar', { } ]
+    end
 
-      it "should fail if an action option is before the action" do
-        app.command_line.stubs(:args).returns %w{--action foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --action/
-      end
+    it "should have no action if not given a valid one and there is no default action" do
+      app.command_line.stubs(:args).returns %w{bar}
+      Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
+      app.stubs(:main)
+      app.run
+      app.action.should be_nil
+      app.arguments.should == [ 'bar', { } ]
+    end
 
-      it "should fail if an unknown option is before the action" do
-        app.command_line.stubs(:args).returns %w{--bar foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --bar/
-      end
+    it "should report a sensible error when options with = fail" do
+      app.command_line.stubs(:args).returns %w{--action=bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+    end
 
-      it "should fail if an unknown option is after the action" do
-        app.command_line.stubs(:args).returns %w{foo --bar}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --bar/
-      end
+    it "should fail if an action option is before the action" do
+      app.command_line.stubs(:args).returns %w{--action foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+    end
+
+    it "should fail if an unknown option is before the action" do
+      app.command_line.stubs(:args).returns %w{--bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+    end
+
+    it "should fail if an unknown option is after the action" do
+      app.command_line.stubs(:args).returns %w{foo --bar}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+    end
+
+    it "should accept --bar as an argument to a mandatory option after action" do
+      app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
+      app.preinit
+      app.parse_options
+      app.action.name.should == :foo
+      app.options.should == { :mandatory => "--bar" }
+    end
+
+    it "should accept --bar as an argument to a mandatory option before action" do
+      app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+      app.preinit
+      app.parse_options
+      app.action.name.should == :foo
+      app.options.should == { :mandatory => "--bar" }
+    end
+
+    it "should not skip when --foo=bar is given" do
+      app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
+      expect { app.preinit; app.parse_options }.
+        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+    end
 
-      it "should accept --bar as an argument to a mandatory option after action" do
-        app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
+    { "boolean options before" => %w{--trace foo},
+      "boolean options after"  => %w{foo --trace}
+    }.each do |name, args|
+      it "should accept global boolean settings #{name} the action" do
+        app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
-        app.action.name.should == :foo
-        app.options.should == { :mandatory => "--bar" }
+        Puppet[:trace].should be_true
       end
+    end
 
-      it "should accept --bar as an argument to a mandatory option before action" do
-        app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
+    { "before" => %w{--syslogfacility user1 foo},
+      " after" => %w{foo --syslogfacility user1}
+    }.each do |name, args|
+      it "should accept global settings with arguments #{name} the action" do
+        app.command_line.stubs(:args).returns args
         app.preinit
         app.parse_options
-        app.action.name.should == :foo
-        app.options.should == { :mandatory => "--bar" }
-      end
-
-      it "should not skip when --foo=bar is given" do
-        app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
-        expect { app.preinit; app.parse_options }.
-          to raise_error OptionParser::InvalidOption, /invalid option: --bar/
-      end
-
-      { "boolean options before" => %w{--trace foo},
-        "boolean options after"  => %w{foo --trace}
-      }.each do |name, args|
-        it "should accept global boolean settings #{name} the action" do
-          app.command_line.stubs(:args).returns args
-          app.preinit
-          app.parse_options
-          Puppet[:trace].should be_true
-        end
-      end
-
-      { "before" => %w{--syslogfacility user1 foo},
-        " after" => %w{foo --syslogfacility user1}
-      }.each do |name, args|
-        it "should accept global settings with arguments #{name} the action" do
-          app.command_line.stubs(:args).returns args
-          app.preinit
-          app.parse_options
-          Puppet[:syslogfacility].should == "user1"
-        end
+        Puppet[:syslogfacility].should == "user1"
       end
     end
   end
-- 
cgit 


From 379b46d4b9e2a57f954ff178956ca6850c3c56f7 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Tue, 19 Apr 2011 21:08:05 -0700
Subject: (#7116) Handle application-level options in parse_options

We hid another layer of per-application option in the class backing the
application, which wasn't correctly handled in the parse_options method.

They are now found and handled, so that global flags like --debug work as
expected on the left of the action, not just the right.

Reviewed-By: Max Martin <max@puppetlabs.com>
---
 spec/unit/application/face_base_spec.rb | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/application/face_base_spec.rb b/spec/unit/application/face_base_spec.rb
index 7dbe59fd7..f7c55c556 100755
--- a/spec/unit/application/face_base_spec.rb
+++ b/spec/unit/application/face_base_spec.rb
@@ -40,7 +40,7 @@ describe Puppet::Application::FaceBase do
       app.command_line.stubs(:args).returns %w{}
     end
 
-    context "with just an action" do
+    describe "with just an action" do
       before :all do
         # We have to stub Signal.trap to avoid a crazy mess where we take
         # over signal handling and make it impossible to cancel the test
@@ -160,6 +160,13 @@ describe Puppet::Application::FaceBase do
         Puppet[:syslogfacility].should == "user1"
       end
     end
+
+    it "should handle application-level options" do
+      app.command_line.stubs(:args).returns %w{help --verbose help}
+      app.preinit
+      app.parse_options
+      app.face.name.should == :basetest
+    end
   end
 
   describe "#setup" do
-- 
cgit 


From 7b3744cd363c817c515f865ccdf45bdfbdb5796b Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Wed, 20 Apr 2011 15:22:57 -0700
Subject: maint: stop stubbing log level setting.

The underlying problem turned up when another test (as a side effect) changed
the logging level to be more verbose, and a very distant test broke.  This
revealed that we didn't preserve that global state around tests.

Fixing that further revealed that we stubbed setting that log level all over
the place, as a point fix for the same problem, and to assert the operation of
various tools.

So, additionally, we strip out all that stubbing, and assert on the desired
effect rather than the mechanism for achieving it.

Reviewed-By: Max Martin <max@puppetlabs.com>
---
 spec/spec_helper.rb                      |  3 +++
 spec/unit/application/agent_spec.rb      |  9 ++-------
 spec/unit/application/apply_spec.rb      | 10 ++--------
 spec/unit/application/cert_spec.rb       | 10 ++--------
 spec/unit/application/device_spec.rb     | 10 ++--------
 spec/unit/application/doc_spec.rb        |  8 ++------
 spec/unit/application/filebucket_spec.rb | 10 ++--------
 spec/unit/application/kick_spec.rb       | 10 ++--------
 spec/unit/application/master_spec.rb     | 10 ++--------
 spec/unit/application/queue_spec.rb      |  9 ++-------
 spec/unit/application/resource_spec.rb   | 10 ++--------
 spec/unit/application_spec.rb            |  4 +---
 12 files changed, 24 insertions(+), 79 deletions(-)
 mode change 100644 => 100755 spec/unit/application/device_spec.rb

(limited to 'spec')

diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 1187c1caf..b04ec6ffd 100755
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -50,6 +50,8 @@ RSpec.configure do |config|
 
     @logs = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(@logs))
+
+    @log_level = Puppet::Util::Log.level
   end
 
   config.after :each do
@@ -62,6 +64,7 @@ RSpec.configure do |config|
 
     @logs.clear
     Puppet::Util::Log.close_all
+    Puppet::Util::Log.level = @log_level
 
     GC.enable
   end
diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index 03cf14429..b30a8cc6c 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -18,7 +18,6 @@ describe Puppet::Application::Agent do
     Puppet::Agent.stubs(:new).returns(@agent)
     @puppetd.preinit
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
@@ -223,18 +222,14 @@ describe Puppet::Application::Agent do
 
       it "should set log level to debug if --debug was passed" do
         @puppetd.options.stubs(:[]).with(:debug).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @puppetd.setup_logs
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose was passed" do
         @puppetd.options.stubs(:[]).with(:verbose).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @puppetd.setup_logs
+        Puppet::Util::Log.level.should == :info
       end
 
       [:verbose, :debug].each do |level|
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index dca2a4156..ec3f083db 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -9,7 +9,6 @@ describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
@@ -51,7 +50,6 @@ describe Puppet::Application::Apply do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
@@ -84,18 +82,14 @@ describe Puppet::Application::Apply do
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @apply.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @apply.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should print puppet config if asked to in Puppet config" do
diff --git a/spec/unit/application/cert_spec.rb b/spec/unit/application/cert_spec.rb
index a1b5eb19a..4a91c1e6c 100755
--- a/spec/unit/application/cert_spec.rb
+++ b/spec/unit/application/cert_spec.rb
@@ -6,7 +6,6 @@ describe Puppet::Application::Cert do
   before :each do
     @cert_app = Puppet::Application[:cert]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   it "should operate in master run_mode" do
@@ -28,22 +27,17 @@ describe Puppet::Application::Cert do
   end
 
   it "should set log level to info with the --verbose option" do
-
-    Puppet::Log.expects(:level=).with(:info)
-
     @cert_app.handle_verbose(0)
+    Puppet::Log.level.should == :info
   end
 
   it "should set log level to debug with the --debug option" do
-
-    Puppet::Log.expects(:level=).with(:debug)
-
     @cert_app.handle_debug(0)
+    Puppet::Log.level.should == :debug
   end
 
   it "should set the fingerprint digest with the --digest option" do
     @cert_app.handle_digest(:digest)
-
     @cert_app.digest.should == :digest
   end
 
diff --git a/spec/unit/application/device_spec.rb b/spec/unit/application/device_spec.rb
old mode 100644
new mode 100755
index 086e321e9..832b7e55b
--- a/spec/unit/application/device_spec.rb
+++ b/spec/unit/application/device_spec.rb
@@ -10,10 +10,8 @@ require 'puppet/configurer'
 describe Puppet::Application::Device do
   before :each do
     @device = Puppet::Application[:device]
-#    @device.stubs(:puts)
     @device.preinit
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
@@ -144,18 +142,14 @@ describe Puppet::Application::Device do
 
       it "should set log level to debug if --debug was passed" do
         @device.options.stubs(:[]).with(:debug).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @device.setup_logs
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose was passed" do
         @device.options.stubs(:[]).with(:verbose).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @device.setup_logs
+        Puppet::Util::Log.level.should == :info
       end
 
       [:verbose, :debug].each do |level|
diff --git a/spec/unit/application/doc_spec.rb b/spec/unit/application/doc_spec.rb
index 66a833b9d..43a4b9849 100755
--- a/spec/unit/application/doc_spec.rb
+++ b/spec/unit/application/doc_spec.rb
@@ -11,7 +11,6 @@ describe Puppet::Application::Doc do
     @doc.stubs(:puts)
     @doc.preinit
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
@@ -186,7 +185,6 @@ describe Puppet::Application::Doc do
       before :each do
         @doc.options.stubs(:[]).returns(false)
         Puppet.stubs(:parse_config)
-        Puppet::Util::Log.stubs(:level=)
         Puppet::Util::Log.stubs(:newdestination)
       end
 
@@ -232,16 +230,14 @@ describe Puppet::Application::Doc do
 
       it "should set log level to debug if --debug" do
         @doc.options.stubs(:[]).with(:debug).returns(true)
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @doc.setup_rdoc
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose" do
         @doc.options.stubs(:[]).with(:verbose).returns(true)
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @doc.setup_rdoc
+        Puppet::Util::Log.level.should == :info
       end
 
       it "should set log destination to console if --verbose" do
diff --git a/spec/unit/application/filebucket_spec.rb b/spec/unit/application/filebucket_spec.rb
index 8ba86be9e..92bc0410a 100755
--- a/spec/unit/application/filebucket_spec.rb
+++ b/spec/unit/application/filebucket_spec.rb
@@ -41,7 +41,6 @@ describe Puppet::Application::Filebucket do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
@@ -62,18 +61,14 @@ describe Puppet::Application::Filebucket do
 
     it "should set log level to debug if --debug was passed" do
       @filebucket.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @filebucket.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @filebucket.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @filebucket.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
@@ -140,7 +135,6 @@ describe Puppet::Application::Filebucket do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       @filebucket.options.stubs(:[]).with(any_parameters)
diff --git a/spec/unit/application/kick_spec.rb b/spec/unit/application/kick_spec.rb
index 29e4caea4..742c0fff6 100755
--- a/spec/unit/application/kick_spec.rb
+++ b/spec/unit/application/kick_spec.rb
@@ -10,7 +10,6 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
     Puppet::Util::Ldap::Connection.stubs(:new).returns(stub_everything)
     @kick = Puppet::Application[:kick]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   describe ".new" do
@@ -120,7 +119,6 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
       @kick.classes = []
       @kick.tags = []
       @kick.hosts = []
-      Puppet::Log.stubs(:level=)
       @kick.stubs(:trap)
       @kick.stubs(:puts)
       Puppet.stubs(:parse_config)
@@ -130,18 +128,14 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
     it "should set log level to debug if --debug was passed" do
       @kick.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @kick.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @kick.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @kick.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
diff --git a/spec/unit/application/master_spec.rb b/spec/unit/application/master_spec.rb
index ea5d3f518..2a24086f3 100755
--- a/spec/unit/application/master_spec.rb
+++ b/spec/unit/application/master_spec.rb
@@ -11,7 +11,6 @@ describe Puppet::Application::Master do
     @daemon = stub_everything 'daemon'
     Puppet::Daemon.stubs(:new).returns(@daemon)
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Node.indirection.stubs(:terminus_class=)
     Puppet::Node.indirection.stubs(:cache_class=)
@@ -111,7 +110,6 @@ describe Puppet::Application::Master do
     before :each do
       Puppet::Log.stubs(:newdestination)
       Puppet.stubs(:settraps)
-      Puppet::Log.stubs(:level=)
       Puppet::SSL::CertificateAuthority.stubs(:instance)
       Puppet::SSL::CertificateAuthority.stubs(:ca?)
       Puppet.settings.stubs(:use)
@@ -121,18 +119,14 @@ describe Puppet::Application::Master do
 
     it "should set log level to debug if --debug was passed" do
       @master.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @master.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @master.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @master.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should set console as the log destination if no --logdest and --daemonize" do
diff --git a/spec/unit/application/queue_spec.rb b/spec/unit/application/queue_spec.rb
index 87713ca97..d71c879a9 100755
--- a/spec/unit/application/queue_spec.rb
+++ b/spec/unit/application/queue_spec.rb
@@ -10,7 +10,6 @@ describe Puppet::Application::Queue do
     @queue.stubs(:puts)
     @daemon = stub_everything 'daemon', :daemonize => nil
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
 
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
   end
@@ -113,18 +112,14 @@ describe Puppet::Application::Queue do
 
       it "should set log level to debug if --debug was passed" do
         @queue.options.stubs(:[]).with(:debug).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:debug)
-
         @queue.setup_logs
+        Puppet::Util::Log.level.should == :debug
       end
 
       it "should set log level to info if --verbose was passed" do
         @queue.options.stubs(:[]).with(:verbose).returns(true)
-
-        Puppet::Util::Log.expects(:level=).with(:info)
-
         @queue.setup_logs
+        Puppet::Util::Log.level.should == :info
       end
 
       [:verbose, :debug].each do |level|
diff --git a/spec/unit/application/resource_spec.rb b/spec/unit/application/resource_spec.rb
index 673bd65d7..af60f12c1 100755
--- a/spec/unit/application/resource_spec.rb
+++ b/spec/unit/application/resource_spec.rb
@@ -7,7 +7,6 @@ describe Puppet::Application::Resource do
   before :each do
     @resource = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
@@ -95,7 +94,6 @@ describe Puppet::Application::Resource do
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
     end
 
@@ -108,19 +106,15 @@ describe Puppet::Application::Resource do
 
     it "should set log level to debug if --debug was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @resource.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @resource.options.stubs(:[]).with(:debug).returns(false)
       @resource.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @resource.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
diff --git a/spec/unit/application_spec.rb b/spec/unit/application_spec.rb
index f46959092..de1ca1257 100755
--- a/spec/unit/application_spec.rb
+++ b/spec/unit/application_spec.rb
@@ -369,10 +369,8 @@ describe Puppet::Application do
       it "should honor option #{level}" do
         @app.options.stubs(:[]).with(level).returns(true)
         Puppet::Util::Log.stubs(:newdestination)
-
-        Puppet::Util::Log.expects(:level=).with(level == :verbose ? :info : :debug)
-
         @app.setup
+        Puppet::Util::Log.level.should == (level == :verbose ? :info : :debug)
       end
     end
 
-- 
cgit 


From 677752d44e180d7293fbae6594f51fe7d41fb3fc Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Wed, 20 Apr 2011 16:26:02 -0700
Subject: maint: handle face clear/reset sanely in the interface spec.

We used to flush the loaded face cache, but not the list of 'require' things,
which meant that these tests couldn't work with anything outside their own
setup, which is actually pretty undesirable.

Instead, port the code from the face_collection spec that handles this in a
way that makes me less inclined to weep, and which lets the surrounding code
work as designed.
---
 spec/unit/interface_spec.rb | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/interface_spec.rb b/spec/unit/interface_spec.rb
index b4fef0307..5eb7922a2 100755
--- a/spec/unit/interface_spec.rb
+++ b/spec/unit/interface_spec.rb
@@ -5,16 +5,17 @@ require 'puppet/interface'
 describe Puppet::Interface do
   subject { Puppet::Interface }
 
-  before :all do
-    @faces = Puppet::Interface::FaceCollection.instance_variable_get("@faces").dup
-  end
-
   before :each do
+    @faces = Puppet::Interface::FaceCollection.
+      instance_variable_get("@faces").dup
+    @dq = $".dup
+    $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
     Puppet::Interface::FaceCollection.instance_variable_get("@faces").clear
   end
 
-  after :all do
+  after :each do
     Puppet::Interface::FaceCollection.instance_variable_set("@faces", @faces)
+    $".clear ; @dq.each do |item| $" << item end
   end
 
   describe "#[]" do
-- 
cgit 


From 7db4793eac52cbbf9c5919597e8e3a6b0a7bbd38 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Wed, 20 Apr 2011 19:04:50 -0700
Subject: maint: clean up testing code a fraction...

This rewrites a block of identical tests down to a little table, then applies
the test over that.
---
 spec/unit/interface/face_collection_spec.rb | 32 +++++++++--------------------
 1 file changed, 10 insertions(+), 22 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/interface/face_collection_spec.rb b/spec/unit/interface/face_collection_spec.rb
index f9498cbb8..c3e43435c 100755
--- a/spec/unit/interface/face_collection_spec.rb
+++ b/spec/unit/interface/face_collection_spec.rb
@@ -25,28 +25,16 @@ describe Puppet::Interface::FaceCollection do
   end
 
   describe "::validate_version" do
-    it 'should permit three number versions' do
-      subject.validate_version('10.10.10').should == true
-    end
-
-    it 'should permit versions with appended descriptions' do
-      subject.validate_version('10.10.10beta').should == true
-    end
-
-    it 'should not permit versions with more than three numbers' do
-      subject.validate_version('1.2.3.4').should == false
-    end
-
-    it 'should not permit versions with only two numbers' do
-      subject.validate_version('10.10').should == false
-    end
-
-    it 'should not permit versions with only one number' do
-      subject.validate_version('123').should == false
-    end
-
-    it 'should not permit versions with text in any position but at the end' do
-      subject.validate_version('v1.1.1').should == false
+    { '10.10.10'     => true,
+      '1.2.3.4'      => false,
+      '10.10.10beta' => true,
+      '10.10'        => false,
+      '123'          => false,
+      'v1.1.1'       => false,
+    }.each do |input, result|
+      it "should#{result ? '' : ' not'} permit #{input.inspect}" do
+        subject.validate_version(input).should(result ? be_true : be_false)
+      end
     end
   end
 
-- 
cgit 


From 7414ee7ebda1052f4c52f3e5565726f20de5a20b Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Thu, 21 Apr 2011 12:03:13 -0700
Subject: maint: better disabling of Signal#trap in our tests.

We tried to stub out the trap method on signal to stop our application level
signal handlers getting in the way, but it kept not sticking.

Now, instead, we just stub it out globally at the module level in our spec
helper.  Less fun, but more effective.  Until rspec starts installing a signal
handler, at least. :)
---
 spec/monkey_patches/disable_signal_trap.rb | 5 +++++
 spec/spec_helper.rb                        | 5 +++++
 2 files changed, 10 insertions(+)
 create mode 100644 spec/monkey_patches/disable_signal_trap.rb

(limited to 'spec')

diff --git a/spec/monkey_patches/disable_signal_trap.rb b/spec/monkey_patches/disable_signal_trap.rb
new file mode 100644
index 000000000..5159626e3
--- /dev/null
+++ b/spec/monkey_patches/disable_signal_trap.rb
@@ -0,0 +1,5 @@
+module Signal
+  def trap(*args)
+    # The goggles, they do nothing!
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index b04ec6ffd..01ffabc48 100755
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -22,6 +22,7 @@ require 'lib/puppet_spec/files'
 require 'lib/puppet_spec/fixtures'
 require 'monkey_patches/alias_should_to_must'
 require 'monkey_patches/publicize_methods'
+require 'monkey_patches/disable_signal_trap'
 
 Pathname.glob("#{dir}/shared_behaviours/**/*.rb") do |behaviour|
   require behaviour.relative_path_from(Pathname.new(dir))
@@ -38,6 +39,10 @@ RSpec.configure do |config|
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
+
+    # REVISIT: I think this conceals other bad tests, but I don't have time to
+    # fully diagnose those right now.  When you read this, please come tell me
+    # I suck for letting this float. --daniel 2011-04-21
     Signal.stubs(:trap)
 
     # Set the confdir and vardir to gibberish so that tests
-- 
cgit 


From f17f6bba87519db888854acf7017ddff61f635be Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@puppetlabs.com>
Date: Wed, 20 Apr 2011 15:51:39 -0700
Subject: (#7183) Implement "invisible glob" version matching for faces

"Invisible glob", or "prefix", version matching means that when you specify a
version string to use you can specify as little as one version number out of
the semantic versioning spec.

Matching is done on the prefix; an omitted number is treated as "anything" in
that slot, and we return the highest matching versioned face by that spec.

For example, given the set of versions: 1.0.0, 1.0.1, 1.1.0, 1.1.1, 2.0.0
The following would be matched:

  input    matched
  1        1.1.1
  1.0      1.0.1
  1.0.1    1.0.1
  1.0.2    fail - no match
  1.1      1.1.1
  1.1.1    1.1.1
  1.2      fail - no match
---
 spec/lib/puppet/face/version_matching.rb    | 10 +++++++
 spec/unit/interface/face_collection_spec.rb | 42 +++++++++++++++++------------
 spec/unit/interface_spec.rb                 | 22 +++++++++++++++
 3 files changed, 57 insertions(+), 17 deletions(-)
 create mode 100644 spec/lib/puppet/face/version_matching.rb

(limited to 'spec')

diff --git a/spec/lib/puppet/face/version_matching.rb b/spec/lib/puppet/face/version_matching.rb
new file mode 100644
index 000000000..bfd0013f7
--- /dev/null
+++ b/spec/lib/puppet/face/version_matching.rb
@@ -0,0 +1,10 @@
+require 'puppet/face'
+
+# The set of versions here are used explicitly in the interface_spec; if you
+# change this you need to ensure that is still correct. --daniel 2011-04-21
+['1.0.0', '1.0.1', '1.1.0', '1.1.1', '2.0.0'].each do |version|
+  Puppet::Face.define(:version_matching, version) do
+    summary "version matching face #{version}"
+    script :version do version end
+  end
+end
diff --git a/spec/unit/interface/face_collection_spec.rb b/spec/unit/interface/face_collection_spec.rb
index c3e43435c..890e06a9e 100755
--- a/spec/unit/interface/face_collection_spec.rb
+++ b/spec/unit/interface/face_collection_spec.rb
@@ -24,6 +24,22 @@ describe Puppet::Interface::FaceCollection do
     $".clear ; @original_required.each do |item| $" << item end
   end
 
+  describe "::prefix_match?" do
+    #   want     have
+    { ['1.0.0', '1.0.0'] => true,
+      ['1.0',   '1.0.0'] => true,
+      ['1',     '1.0.0'] => true,
+      ['1.0.0', '1.1.0'] => false,
+      ['1.0',   '1.1.0'] => false,
+      ['1',     '1.1.0'] => true,
+      ['1.0.1', '1.0.0'] => false,
+    }.each do |data, result|
+      it "should return #{result.inspect} for prefix_match?(#{data.join(', ')})" do
+        subject.prefix_match?(*data).should == result
+      end
+    end
+  end
+
   describe "::validate_version" do
     { '10.10.10'     => true,
       '1.2.3.4'      => false,
@@ -56,12 +72,10 @@ describe Puppet::Interface::FaceCollection do
       subject.expects(:require).with('puppet/face/fozzie')
       subject['fozzie', :current]
     end
-  end
 
-  describe "::face?" do
     it "should return true if the face specified is registered" do
       subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
-      subject.face?("foo", '0.0.1').should == true
+      subject["foo", '0.0.1'].should == 10
     end
 
     it "should attempt to require the face if it is not registered" do
@@ -69,24 +83,18 @@ describe Puppet::Interface::FaceCollection do
         subject.instance_variable_get("@faces")[:bar]['0.0.1'] = true
         file == 'puppet/face/bar'
       end
-      subject.face?("bar", '0.0.1').should == true
-    end
-
-    it "should return true if requiring the face registered it" do
-      subject.stubs(:require).with do
-        subject.instance_variable_get("@faces")[:bar]['0.0.1'] = 20
-      end
+      subject["bar", '0.0.1'].should be_true
     end
 
     it "should return false if the face is not registered" do
       subject.stubs(:require).returns(true)
-      subject.face?("bar", '0.0.1').should be_false
+      subject["bar", '0.0.1'].should be_false
     end
 
     it "should return false if the face file itself is missing" do
       subject.stubs(:require).
         raises(LoadError, 'no such file to load -- puppet/face/bar')
-      subject.face?("bar", '0.0.1').should be_false
+      subject["bar", '0.0.1'].should be_false
     end
 
     it "should register the version loaded by `:current` as `:current`" do
@@ -94,26 +102,26 @@ describe Puppet::Interface::FaceCollection do
         subject.instance_variable_get("@faces")[:huzzah]['2.0.1'] = :huzzah_face
         file == 'puppet/face/huzzah'
       end
-      subject.face?("huzzah", :current)
+      subject["huzzah", :current]
       subject.instance_variable_get("@faces")[:huzzah][:current].should == :huzzah_face
     end
 
     context "with something on disk" do
       it "should register the version loaded from `puppet/face/{name}` as `:current`" do
-        subject.should be_face "huzzah", '2.0.1'
-        subject.should be_face "huzzah", :current
+        subject["huzzah", '2.0.1'].should be
+        subject["huzzah", :current].should be
         Puppet::Face[:huzzah, '2.0.1'].should == Puppet::Face[:huzzah, :current]
       end
 
       it "should index :current when the code was pre-required" do
         subject.instance_variable_get("@faces")[:huzzah].should_not be_key :current
         require 'puppet/face/huzzah'
-        subject.face?(:huzzah, :current).should be_true
+        subject[:huzzah, :current].should be_true
       end
     end
 
     it "should not cause an invalid face to be enumerated later" do
-      subject.face?(:there_is_no_face, :current).should be_false
+      subject[:there_is_no_face, :current].should be_false
       subject.faces.should_not include :there_is_no_face
     end
   end
diff --git a/spec/unit/interface_spec.rb b/spec/unit/interface_spec.rb
index 5eb7922a2..a1d70cf64 100755
--- a/spec/unit/interface_spec.rb
+++ b/spec/unit/interface_spec.rb
@@ -30,6 +30,28 @@ describe Puppet::Interface do
     it "should raise an exception when the requested face doesn't exist" do
       expect { subject[:burrble_toot, :current] }.should raise_error, Puppet::Error
     end
+
+    describe "version matching" do
+      { '1'     => '1.1.1',
+        '1.0'   => '1.0.1',
+        '1.0.1' => '1.0.1',
+        '1.1'   => '1.1.1',
+        '1.1.1' => '1.1.1'
+      }.each do |input, expect|
+        it "should match #{input.inspect} to #{expect.inspect}" do
+          face = subject[:version_matching, input]
+          face.should be
+          face.version.should == expect
+        end
+      end
+
+      %w{1.0.2 1.2}.each do |input|
+        it "should not match #{input.inspect} to any version" do
+          expect { subject[:version_matching, input] }.
+            to raise_error Puppet::Error, /Could not find version/
+        end
+      end
+    end
   end
 
   describe "#define" do
-- 
cgit