diff --git a/spec/unit/util/command_line_utils/puppet_option_parser_spec.rb b/spec/unit/util/command_line_utils/puppet_option_parser_spec.rb
index 9f530fe00..1b5251ba9 100644
--- a/spec/unit/util/command_line_utils/puppet_option_parser_spec.rb
+++ b/spec/unit/util/command_line_utils/puppet_option_parser_spec.rb
@@ -1,99 +1,103 @@
 require 'spec_helper'
 require 'puppet/util/command_line/puppet_option_parser'
 
-class Puppet::Util::CommandLine
-  describe PuppetOptionParser do
-    let(:option_parser) { PuppetOptionParser.new }
-
-
-    it "should trigger callback for a 'long' option with a value" do
-      self.expects(:handle_option).with("--angry", "foo")
-      option_parser.on(*["--angry", "Angry", :REQUIRED]) do |val|
-        handle_option("--angry", val)
-      end
-      expect { option_parser.parse(["--angry", "foo"]) }.not_to raise_error
-    end
+describe Puppet::Util::CommandLine::PuppetOptionParser do
+  let(:option_parser) { described_class.new }
+
+  it "parses a 'long' option with a value" do
+    parses(
+      :option => ["--angry", "Angry", :REQUIRED],
+      :from_arguments => ["--angry", "foo"],
+      :expects => "foo"
+    )
+  end
 
-    it "should trigger callback for a 'short' option with a value" do
-      self.expects(:handle_option).with("--angry", "foo")
-      option_parser.on(*["--angry", "-a", "Angry", :REQUIRED]) do |val|
-        handle_option("--angry", val)
-      end
-      expect { option_parser.parse(["-a", "foo"]) }.not_to raise_error
-    end
+  it "parses a 'short' option with a value" do
+    parses(
+      :option => ["--angry", "-a", "Angry", :REQUIRED],
+      :from_arguments => ["-a", "foo"],
+      :expects => "foo"
+    )
+  end
 
-    it "should trigger callback for a 'long' option without a value" do
-      self.expects(:handle_option).with("--angry", true)
-      option_parser.on(*["--angry", "Angry", :NONE]) do |val|
-        handle_option("--angry", val)
-      end
-      expect { option_parser.parse(["--angry"]) }.not_to raise_error
-    end
+  it "parses a 'long' option without a value" do
+    parses(
+      :option => ["--angry", "Angry", :NONE],
+      :from_arguments => ["--angry"],
+      :expects => true
+    )
+  end
 
-    it "should trigger callback for a 'short' option without a value" do
-      self.expects(:handle_option).with("--angry", true)
-      option_parser.on(*["--angry", "-a", "Angry", :NONE]) do |val|
-        handle_option("--angry", val)
-      end
-      expect { option_parser.parse(["-a"]) }.not_to raise_error
-    end
+  it "parses a 'short' option without a value" do
+    parses(
+      :option => ["--angry", "-a", "Angry", :NONE],
+      :from_arguments => ["-a"],
+      :expects => true
+    )
+  end
 
-    it "should support the '--no-blah' syntax" do
-      self.expects(:handle_option).with("--rage", false)
-      option_parser.on(*["--[no-]rage", "Rage", :NONE]) do |val|
-        handle_option("--rage", val)
-      end
-      expect { option_parser.parse(["--no-rage"]) }.not_to raise_error
-    end
+  it "supports the '--no-blah' syntax" do
+    parses(
+      :option => ["--[no-]rage", "Rage", :NONE],
+      :from_arguments => ["--no-rage"],
+      :expects => false
+    )
+  end
 
-    describe "#parse" do
-      it "should not modify the original argument array" do
-        self.expects(:handle_option).with("--foo", true)
-        option_parser.on(*["--foo", "Foo", :NONE]) do |val|
-           handle_option("--foo", val)
-        end
-        args = ["--foo"]
-        expect { option_parser.parse(args) }.not_to raise_error
-        args.length.should == 1
-      end
-    end
+  it "does not modify the original argument array" do
+    option_parser.on("--foo", "Foo", :NONE) { |val| }
+    args = ["--foo"]
 
+    option_parser.parse(args)
 
+    args.length.should == 1
+  end
 
+  # The ruby stdlib OptionParser has an awesome "feature" that you cannot disable, whereby if
+  #  it sees a short option that you haven't specifically registered with it (e.g., "-r"), it
+  #  will automatically attempt to expand it out to whatever long options that you might have
+  #  registered.  Since we need to do our option parsing in two passes (one pass against only
+  #  the global/puppet-wide settings definitions, and then a second pass that includes the
+  #  application or face settings--because we can't load the app/face until we've determined
+  #  the libdir), it is entirely possible that we intend to define our "short" option as part
+  #  of the second pass.  Therefore, if the option parser attempts to expand it out into a
+  #  long option during the first pass, terrible things will happen.
+  #
+  # A long story short: we need to have the ability to control this kind of behavior in our
+  #  option parser, and this test simply affirms that we do.
+  it "does not try to expand short options that weren't explicitly registered" do
+
+    [
+     ["--ridiculous", "This is ridiculous", :REQUIRED],
+     ["--rage-inducing", "This is rage-inducing", :REQUIRED]
+    ].each do |option|
+      option_parser.on(*option) {}
+    end
 
-    # The ruby stdlib OptionParser has an awesome "feature" that you cannot disable, whereby if
-    #  it sees a short option that you haven't specifically registered with it (e.g., "-r"), it
-    #  will automatically attempt to expand it out to whatever long options that you might have
-    #  registered.  Since we need to do our option parsing in two passes (one pass against only
-    #  the global/puppet-wide settings definitions, and then a second pass that includes the
-    #  application or face settings--because we can't load the app/face until we've determined
-    #  the libdir), it is entirely possible that we intend to define our "short" option as part
-    #  of the second pass.  Therefore, if the option parser attempts to expand it out into a
-    #  long option during the first pass, terrible things will happen.
-    #
-    # A long story short: we need to have the ability to control this kind of behavior in our
-    #  option parser, and this test simply affirms that we do.
-    it "should not try to expand short options that weren't explicitly registered" do
+    expect { option_parser.parse(["-r"]) }.to raise_error(Puppet::Util::CommandLine::PuppetUnrecognizedOptionError)
+  end
 
-      [
-       ["--ridiculous", "This is ridiculous", :REQUIRED],
-       ["--rage-inducing", "This is rage-inducing", :REQUIRED]
-      ].each do |option|
-        option_parser.on(*option) {}
-      end
+  it "respects :ignore_invalid_options" do
+    option_parser.ignore_invalid_options = true
+    expect { option_parser.parse(["--unknown-option"]) }.not_to raise_error
+  end
 
-      expect { option_parser.parse(["-r"]) }.to raise_error(PuppetUnrecognizedOptionError)
-    end
+  it "raises if there is an invalid option and :ignore_invalid_options is not set" do
+    expect { option_parser.parse(["--unknown-option"]) }.to raise_error(Puppet::Util::CommandLine::PuppetOptionError)
+  end
 
-    it "should respect :ignore_invalid_options" do
-      option_parser.ignore_invalid_options = true
-      expect { option_parser.parse(["--foo"]) }.not_to raise_error
-    end
+  def parses(option_case)
+    option = option_case[:option]
+    expected_value = option_case[:expects]
+    arguments = option_case[:from_arguments]
 
-    it "should raise if there is an invalid option and :ignore_invalid_options is not set" do
-      expect { option_parser.parse(["--foo"]) }.to raise_error(PuppetOptionError)
+    seen_value = nil
+    option_parser.on(*option) do |val|
+      seen_value = val
     end
 
+    option_parser.parse(arguments)
 
+    seen_value.should == expected_value
   end
 end