puppet 0.25.5 → 2.6.0

data/spec/unit/application/queue_spec.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/application/queue'
+
+describe Puppet::Application::Queue do
+  before :each do
+    @queue = Puppet::Application[:queue]
+    @queue.stubs(:puts)
+    @daemon = stub_everything 'daemon', :daemonize => nil
+    Puppet::Util::Log.stubs(:newdestination)
+    Puppet::Util::Log.stubs(:level=)
+
+    Puppet::Resource::Catalog.stubs(:terminus_class=)
+  end
+
+  it "should ask Puppet::Application to parse Puppet configuration file" do
+    @queue.should_parse_config?.should be_true
+  end
+
+  it "should declare a main command" do
+    @queue.should respond_to(:main)
+  end
+
+  it "should declare a preinit block" do
+    @queue.should respond_to(:preinit)
+  end
+
+  describe "in preinit" do
+    before :each do
+      @queue.stubs(:trap)
+    end
+
+    it "should catch INT" do
+      @queue.expects(:trap).with { |arg,block| arg == :INT }
+
+      @queue.preinit
+    end
+
+    it "should init :verbose to false" do
+      @queue.preinit
+
+      @queue.options[:verbose].should be_false
+    end
+
+    it "should init :debug to false" do
+      @queue.preinit
+
+      @queue.options[:debug].should be_false
+    end
+
+    it "should create a Daemon instance and copy ARGV to it" do
+      ARGV.expects(:dup).returns "eh"
+      daemon = mock("daemon")
+      daemon.expects(:argv=).with("eh")
+      Puppet::Daemon.expects(:new).returns daemon
+      @queue.preinit
+    end
+  end
+
+  describe "when handling options" do
+
+    [:debug, :verbose].each do |option|
+      it "should declare handle_#{option} method" do
+        @queue.should respond_to("handle_#{option}".to_sym)
+      end
+
+      it "should store argument value when calling handle_#{option}" do
+        @queue.options.expects(:[]=).with(option, 'arg')
+        @queue.send("handle_#{option}".to_sym, 'arg')
+      end
+    end
+  end
+
+  describe "during setup" do
+    before :each do
+      @queue.options.stubs(:[])
+      @queue.daemon.stubs(:daemonize)
+      Puppet.stubs(:info)
+      Puppet.features.stubs(:stomp?).returns true
+      Puppet::Resource::Catalog.stubs(:terminus_class=)
+      Puppet.stubs(:settraps)
+      Puppet.settings.stubs(:print_config?)
+      Puppet.settings.stubs(:print_config)
+    end
+
+    it "should fail if the stomp feature is missing" do
+      Puppet.features.expects(:stomp?).returns false
+      lambda { @queue.setup }.should raise_error(ArgumentError)
+    end
+
+    it "should print puppet config if asked to in Puppet config" do
+      @queue.stubs(:exit)
+      Puppet.settings.stubs(:print_configs?).returns(true)
+
+      Puppet.settings.expects(:print_configs)
+
+      @queue.setup
+    end
+
+    it "should exit after printing puppet config if asked to in Puppet config" do
+      Puppet.settings.stubs(:print_configs?).returns(true)
+
+      lambda { @queue.setup }.should raise_error(SystemExit)
+    end
+
+    it "should call setup_logs" do
+      @queue.expects(:setup_logs)
+      @queue.setup
+    end
+
+    describe "when setting up logs" do
+      before :each do
+        Puppet::Util::Log.stubs(:newdestination)
+      end
+
+      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
+      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
+      end
+
+      [:verbose, :debug].each do |level|
+        it "should set console as the log destination with level #{level}" do
+          @queue.options.stubs(:[]).with(level).returns(true)
+
+          Puppet::Util::Log.expects(:newdestination).with(:console)
+
+          @queue.setup_logs
+        end
+      end
+    end
+
+    it "should configure the Catalog class to use ActiveRecord" do
+      Puppet::Resource::Catalog.expects(:terminus_class=).with(:active_record)
+
+      @queue.setup
+    end
+
+    it "should daemonize if needed" do
+      Puppet.expects(:[]).with(:daemonize).returns(true)
+
+      @queue.daemon.expects(:daemonize)
+
+      @queue.setup
+    end
+  end
+
+  describe "when running" do
+    before :each do
+      @queue.stubs(:sleep_forever)
+      Puppet::Resource::Catalog::Queue.stubs(:subscribe)
+      Thread.list.each { |t| t.stubs(:join) }
+    end
+
+    it "should subscribe to the queue" do
+      Puppet::Resource::Catalog::Queue.expects(:subscribe)
+      @queue.main
+    end
+
+    it "should log and save each catalog passed by the queue" do
+      catalog = mock 'catalog', :name => 'eh'
+      catalog.expects(:save)
+
+      Puppet::Resource::Catalog::Queue.expects(:subscribe).yields(catalog)
+      Puppet.expects(:notice).times(2)
+      @queue.main
+    end
+
+    it "should join all of the running threads" do
+      Thread.list.each { |t| t.expects(:join) }
+      @queue.main
+    end
+  end
+end

data/spec/unit/application/resource_spec.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/application/resource'
+
+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
+
+  it "should ask Puppet::Application to not parse Puppet configuration file" do
+    @resource.should_parse_config?.should be_false
+  end
+
+  it "should declare a main command" do
+    @resource.should respond_to(:main)
+  end
+
+  it "should declare a host option" do
+    @resource.should respond_to(:handle_host)
+  end
+
+  it "should declare a types option" do
+    @resource.should respond_to(:handle_types)
+  end
+
+  it "should declare a param option" do
+    @resource.should respond_to(:handle_param)
+  end
+
+  it "should declare a preinit block" do
+    @resource.should respond_to(:preinit)
+  end
+
+  describe "in preinit" do
+    it "should set hosts to nil" do
+      @resource.preinit
+
+      @resource.host.should be_nil
+    end
+
+    it "should init extra_params to empty array" do
+      @resource.preinit
+
+      @resource.extra_params.should == []
+    end
+
+    it "should load Facter facts" do
+      Facter.expects(:loadfacts).once
+      @resource.preinit
+    end
+  end
+
+  describe "when handling options" do
+
+    [:debug, :verbose, :edit].each do |option|
+      it "should declare handle_#{option} method" do
+        @resource.should respond_to("handle_#{option}".to_sym)
+      end
+
+      it "should store argument value when calling handle_#{option}" do
+        @resource.options.expects(:[]=).with(option, 'arg')
+        @resource.send("handle_#{option}".to_sym, 'arg')
+      end
+    end
+
+    it "should set options[:host] to given host" do
+      @resource.handle_host(:whatever)
+
+      @resource.host.should == :whatever
+    end
+
+    it "should load an display all types with types option" do
+      type1 = stub_everything 'type1', :name => :type1
+      type2 = stub_everything 'type2', :name => :type2
+      Puppet::Type.stubs(:loadall)
+      Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
+      @resource.stubs(:exit)
+
+      @resource.expects(:puts).with(['type1','type2'])
+      @resource.handle_types(nil)
+    end
+
+    it "should add param to extra_params list" do
+      @resource.extra_params = [ :param1 ]
+      @resource.handle_param("whatever")
+
+      @resource.extra_params.should == [ :param1, :whatever ]
+    end
+  end
+
+  describe "during setup" do
+    before :each do
+      Puppet::Log.stubs(:newdestination)
+      Puppet::Log.stubs(:level=)
+      Puppet.stubs(:parse_config)
+    end
+
+
+    it "should set console as the log destination" do
+      Puppet::Log.expects(:newdestination).with(:console)
+
+      @resource.setup
+    end
+
+    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
+    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
+    end
+
+    it "should Parse puppet config" do
+      Puppet.expects(:parse_config)
+
+      @resource.setup
+    end
+  end
+
+  describe "when running" do
+
+    before :each do
+      @type = stub_everything 'type', :properties => []
+      @resource.command_line.stubs(:args).returns(['type'])
+      Puppet::Type.stubs(:type).returns(@type)
+    end
+
+    it "should raise an error if no type is given" do
+      @resource.command_line.stubs(:args).returns([])
+      lambda { @resource.main }.should raise_error
+    end
+
+    it "should raise an error when editing a remote host" do
+      @resource.options.stubs(:[]).with(:edit).returns(true)
+      @resource.host = 'host'
+
+      lambda { @resource.main }.should raise_error
+    end
+
+    it "should raise an error if the type is not found" do
+      Puppet::Type.stubs(:type).returns(nil)
+
+      lambda { @resource.main }.should raise_error
+    end
+
+    describe "with a host" do
+      before :each do
+        @resource.stubs(:puts)
+        @resource.host = 'host'
+
+        Puppet::Resource.stubs(:find  ).never
+        Puppet::Resource.stubs(:search).never
+        Puppet::Resource.stubs(:save  ).never
+      end
+
+      it "should search for resources" do
+        @resource.command_line.stubs(:args).returns(['type'])
+        Puppet::Resource.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
+        @resource.main
+      end
+
+      it "should describe the given resource" do
+        @resource.command_line.stubs(:args).returns(['type', 'name'])
+        x = stub_everything 'resource'
+        Puppet::Resource.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
+        @resource.main
+      end
+
+      it "should add given parameters to the object" do
+        @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
+
+        res = stub "resource"
+        res.expects(:save).with('https://host:8139/production/resources/type/name').returns(res)
+        res.expects(:collect)
+        res.expects(:to_manifest)
+        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
+
+        @resource.main
+      end
+
+    end
+
+    describe "without a host" do
+      before :each do
+        @resource.stubs(:puts)
+        @resource.host = nil
+
+        Puppet::Resource.stubs(:find  ).never
+        Puppet::Resource.stubs(:search).never
+        Puppet::Resource.stubs(:save  ).never
+      end
+
+      it "should search for resources" do
+        Puppet::Resource.expects(:search).with('type/', {}).returns([])
+        @resource.main
+      end
+
+      it "should describe the given resource" do
+        @resource.command_line.stubs(:args).returns(['type','name'])
+        x = stub_everything 'resource'
+        Puppet::Resource.expects(:find).with('type/name').returns(x)
+        @resource.main
+      end
+
+      it "should add given parameters to the object" do
+        @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
+
+        res = stub "resource"
+        res.expects(:save).with('type/name').returns(res)
+        res.expects(:collect)
+        res.expects(:to_manifest)
+        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
+
+        @resource.main
+      end
+
+    end
+  end
+end

data/spec/unit/application_spec.rb

@@ -0,0 +1,531 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'puppet/application'
+require 'puppet'
+require 'getoptlong'
+
+describe Puppet::Application do
+
+  before do
+    @app = Class.new(Puppet::Application).new
+    @appclass = @app.class
+
+    # avoid actually trying to parse any settings
+    Puppet.settings.stubs(:parse)
+  end
+
+  describe ".run_mode" do
+    it "should default to user" do
+      @appclass.run_mode.name.should == :user
+    end
+
+    it "should set and get a value" do
+      @appclass.run_mode :agent
+      @appclass.run_mode.name.should == :agent
+    end
+  end
+
+  it "should have a run entry-point" do
+    @app.should respond_to(:run)
+  end
+
+  it "should have a read accessor to options" do
+    @app.should respond_to(:options)
+  end
+
+  it "should include a default setup method" do
+    @app.should respond_to(:setup)
+  end
+
+  it "should include a default preinit method" do
+    @app.should respond_to(:preinit)
+  end
+
+  it "should include a default run_command method" do
+    @app.should respond_to(:run_command)
+  end
+
+  it "should invoke main as the default" do
+    @app.expects( :main )
+    @app.run_command
+  end
+
+  describe 'when invoking clear!' do
+    before :each do
+      Puppet::Application.run_status = :stop_requested
+      Puppet::Application.clear!
+    end
+
+    it 'should have nil run_status' do
+      Puppet::Application.run_status.should be_nil
+    end
+
+    it 'should return false for restart_requested?' do
+      Puppet::Application.restart_requested?.should be_false
+    end
+
+    it 'should return false for stop_requested?' do
+      Puppet::Application.stop_requested?.should be_false
+    end
+
+    it 'should return false for interrupted?' do
+      Puppet::Application.interrupted?.should be_false
+    end
+
+    it 'should return true for clear?' do
+      Puppet::Application.clear?.should be_true
+    end
+  end
+
+  describe 'after invoking stop!' do
+    before :each do
+      Puppet::Application.run_status = nil
+      Puppet::Application.stop!
+    end
+
+    after :each do
+      Puppet::Application.run_status = nil
+    end
+
+    it 'should have run_status of :stop_requested' do
+      Puppet::Application.run_status.should == :stop_requested
+    end
+
+    it 'should return true for stop_requested?' do
+      Puppet::Application.stop_requested?.should be_true
+    end
+
+    it 'should return false for restart_requested?' do
+      Puppet::Application.restart_requested?.should be_false
+    end
+
+    it 'should return true for interrupted?' do
+      Puppet::Application.interrupted?.should be_true
+    end
+
+    it 'should return false for clear?' do
+      Puppet::Application.clear?.should be_false
+    end
+  end
+
+  describe 'when invoking restart!' do
+    before :each do
+      Puppet::Application.run_status = nil
+      Puppet::Application.restart!
+    end
+
+    after :each do
+      Puppet::Application.run_status = nil
+    end
+
+    it 'should have run_status of :restart_requested' do
+      Puppet::Application.run_status.should == :restart_requested
+    end
+
+    it 'should return true for restart_requested?' do
+      Puppet::Application.restart_requested?.should be_true
+    end
+
+    it 'should return false for stop_requested?' do
+      Puppet::Application.stop_requested?.should be_false
+    end
+
+    it 'should return true for interrupted?' do
+      Puppet::Application.interrupted?.should be_true
+    end
+
+    it 'should return false for clear?' do
+      Puppet::Application.clear?.should be_false
+    end
+  end
+
+  describe 'when performing a controlled_run' do
+    it 'should not execute block if not :clear?' do
+      Puppet::Application.run_status = :stop_requested
+      target = mock 'target'
+      target.expects(:some_method).never
+      Puppet::Application.controlled_run do
+        target.some_method
+      end
+    end
+
+    it 'should execute block if :clear?' do
+      Puppet::Application.run_status = nil
+      target = mock 'target'
+      target.expects(:some_method).once
+      Puppet::Application.controlled_run do
+        target.some_method
+      end
+    end
+
+    describe 'on POSIX systems' do
+      confine "HUP works only on POSIX systems" => Puppet.features.posix?
+
+      it 'should signal process with HUP after block if restart requested during block execution' do
+        Puppet::Application.run_status = nil
+        target = mock 'target'
+        target.expects(:some_method).once
+        old_handler = trap('HUP') { target.some_method }
+        begin
+          Puppet::Application.controlled_run do
+            Puppet::Application.run_status = :restart_requested
+          end
+        ensure
+          trap('HUP', old_handler)
+        end
+      end
+    end
+
+    after :each do
+      Puppet::Application.run_status = nil
+    end
+  end
+
+  describe "when parsing command-line options" do
+
+    before :each do
+      @app.command_line.stubs(:args).returns([])
+
+      Puppet.settings.stubs(:optparse_addargs).returns([])
+    end
+
+    it "should create a new option parser when needed" do
+      option_parser = stub "option parser"
+      option_parser.stubs(:on)
+      option_parser.stubs(:default_argv=)
+      OptionParser.expects(:new).returns(option_parser).once
+      @app.option_parser.should == option_parser
+      @app.option_parser.should == option_parser
+    end
+
+    it "should pass the banner to the option parser" do
+      option_parser = stub "option parser"
+      option_parser.stubs(:on)
+      option_parser.stubs(:default_argv=)
+      @app.class.instance_eval do
+        banner "banner"
+      end
+
+      OptionParser.expects(:new).with("banner").returns(option_parser)
+
+      @app.option_parser
+    end
+
+    it "should set the optionparser's args to the command line args" do
+      option_parser = stub "option parser"
+      option_parser.stubs(:on)
+      option_parser.expects(:default_argv=).with(%w{ fake args })
+      @app.command_line.stubs(:args).returns(%w{ fake args })
+      OptionParser.expects(:new).returns(option_parser)
+      @app.option_parser
+    end
+
+    it "should get options from Puppet.settings.optparse_addargs" do
+      Puppet.settings.expects(:optparse_addargs).returns([])
+
+      @app.parse_options
+    end
+
+    it "should add Puppet.settings options to OptionParser" do
+      Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
+
+      @app.option_parser.expects(:on).with { |*arg| arg == ["--option","-o", "Funny Option"] }
+
+      @app.parse_options
+    end
+
+    it "should ask OptionParser to parse the command-line argument" do
+      @app.option_parser.expects(:parse!)
+
+      @app.parse_options
+    end
+
+    describe "when using --help" do
+      confine "rdoc" => Puppet.features.usage?
+
+      it "should call RDoc::usage and exit" do
+        @app.expects(:exit)
+        RDoc.expects(:usage).returns(true)
+
+        @app.handle_help(nil)
+      end
+
+    end
+
+    describe "when using --version" do
+      it "should declare a version option" do
+        @app.should respond_to(:handle_version)
+      end
+
+      it "should exit after printing the version" do
+        @app.stubs(:puts)
+
+        lambda { @app.handle_version(nil) }.should raise_error(SystemExit)
+      end
+    end
+
+    describe "when dealing with an argument not declared directly by the application" do
+      it "should pass it to handle_unknown if this method exists" do
+        Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled"]])
+        @app.option_parser.stubs(:on).yields("value")
+
+        @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
+
+        @app.parse_options
+      end
+
+      it "should pass it to Puppet.settings if handle_unknown says so" do
+        Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet"]])
+        @app.option_parser.stubs(:on).yields("value")
+
+        @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
+
+        Puppet.settings.expects(:handlearg).with("--topuppet", "value")
+        @app.parse_options
+      end
+
+      it "should pass it to Puppet.settings if there is no handle_unknown method" do
+        Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet"]])
+        @app.option_parser.stubs(:on).yields("value")
+
+        @app.stubs(:respond_to?).returns(false)
+
+        Puppet.settings.expects(:handlearg).with("--topuppet", "value")
+        @app.parse_options
+      end
+
+      it "should transform boolean false value to string for Puppet.settings" do
+        Puppet.settings.expects(:handlearg).with("--option", "false")
+        @app.handlearg("--option", false)
+      end
+
+      it "should transform boolean true value to string for Puppet.settings" do
+        Puppet.settings.expects(:handlearg).with("--option", "true")
+        @app.handlearg("--option", true)
+      end
+
+      it "should transform boolean option to normal form for Puppet.settings" do
+        Puppet.settings.expects(:handlearg).with("--option", "true")
+        @app.handlearg("--[no-]option", true)
+      end
+
+      it "should transform boolean option to no- form for Puppet.settings" do
+        Puppet.settings.expects(:handlearg).with("--no-option", "false")
+        @app.handlearg("--[no-]option", false)
+      end
+
+    end
+
+    it "should exit if OptionParser raises an error" do
+      $stderr.stubs(:puts)
+      @app.option_parser.stubs(:parse!).raises(OptionParser::ParseError.new("blah blah"))
+
+      @app.expects(:exit)
+
+      lambda { @app.parse_options }.should_not raise_error
+    end
+
+  end
+
+  describe "when calling default setup" do
+
+    before :each do
+      @app.stubs(:should_parse_config?).returns(false)
+      @app.options.stubs(:[])
+    end
+
+    [ :debug, :verbose ].each do |level|
+      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
+      end
+    end
+
+    it "should honor setdest option" do
+      @app.options.stubs(:[]).with(:setdest).returns(false)
+
+      Puppet::Util::Log.expects(:newdestination).with(:syslog)
+
+      @app.setup
+    end
+
+  end
+
+  describe "when running" do
+
+    before :each do
+      @app.stubs(:preinit)
+      @app.stubs(:setup)
+      @app.stubs(:parse_options)
+    end
+
+    it "should call preinit" do
+      @app.stubs(:run_command)
+
+      @app.expects(:preinit)
+
+      @app.run
+    end
+
+    it "should call parse_options" do
+      @app.stubs(:run_command)
+
+      @app.expects(:parse_options)
+
+      @app.run
+    end
+
+    it "should call run_command" do
+
+      @app.expects(:run_command)
+
+      @app.run
+    end
+
+    it "should parse Puppet configuration if should_parse_config is called" do
+      @app.stubs(:run_command)
+      @app.class.should_parse_config
+
+      Puppet.settings.expects(:parse)
+
+      @app.run
+    end
+
+    it "should not parse_option if should_not_parse_config is called" do
+      @app.stubs(:run_command)
+      @app.class.should_not_parse_config
+
+      Puppet.settings.expects(:parse).never
+
+      @app.run
+    end
+
+    it "should parse Puppet configuration if needed" do
+      @app.stubs(:run_command)
+      @app.stubs(:should_parse_config?).returns(true)
+
+      Puppet.settings.expects(:parse)
+
+      @app.run
+    end
+
+    it "should call run_command" do
+      @app.expects(:run_command)
+
+      @app.run
+    end
+
+    it "should call main as the default command" do
+      @app.expects(:main)
+
+      @app.run
+    end
+
+    it "should warn and exit if no command can be called" do
+      $stderr.expects(:puts)
+      @app.expects(:exit).with(1)
+      @app.run
+    end
+
+    it "should raise an error if dispatch returns no command" do
+      @app.stubs(:get_command).returns(nil)
+      $stderr.expects(:puts)
+      @app.expects(:exit).with(1)
+      @app.run
+    end
+
+    it "should raise an error if dispatch returns an invalid command" do
+      @app.stubs(:get_command).returns(:this_function_doesnt_exist)
+      $stderr.expects(:puts)
+      @app.expects(:exit).with(1)
+      @app.run
+    end
+  end
+
+  describe "when metaprogramming" do
+
+    describe "when calling option" do
+      it "should create a new method named after the option" do
+        @app.class.option("--test1","-t") do
+        end
+
+        @app.should respond_to(:handle_test1)
+      end
+
+      it "should transpose in option name any '-' into '_'" do
+        @app.class.option("--test-dashes-again","-t") do
+        end
+
+        @app.should respond_to(:handle_test_dashes_again)
+      end
+
+      it "should create a new method called handle_test2 with option(\"--[no-]test2\")" do
+        @app.class.option("--[no-]test2","-t") do
+        end
+
+        @app.should respond_to(:handle_test2)
+      end
+
+      describe "when a block is passed" do
+        it "should create a new method with it" do
+          @app.class.option("--[no-]test2","-t") do
+            raise "I can't believe it, it works!"
+          end
+
+          lambda { @app.handle_test2 }.should raise_error
+        end
+
+        it "should declare the option to OptionParser" do
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
+
+          @app.class.option("--[no-]test3","-t") do
+          end
+
+          @app.option_parser
+        end
+
+        it "should pass a block that calls our defined method" do
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
+
+          @app.expects(:send).with(:handle_test4, nil)
+
+          @app.class.option("--test4","-t") do
+          end
+
+          @app.option_parser
+        end
+      end
+
+      describe "when no block is given" do
+        it "should declare the option to OptionParser" do
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.expects(:on).with("--test4","-t")
+
+          @app.class.option("--test4","-t")
+
+          @app.option_parser
+        end
+
+        it "should give to OptionParser a block that adds the the value to the options array" do
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
+
+          @app.options.expects(:[]=).with(:test4,nil)
+
+          @app.class.option("--test4","-t")
+
+          @app.option_parser
+        end
+      end
+    end
+
+  end
+end