hirb 0.3.1 → 0.3.2

data/test/hirb_test.rb

@@ -1,10 +1,10 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class HirbTest < Test::Unit::TestCase
-  before(:all) { Hirb.config_files = nil }
-  before(:each) { Hirb.config = nil }
+describe "Hirb" do
+  before_all { Hirb.config_files = nil }
+  before { Hirb.config = nil }
 
-  test "config converts yaml when config file exists" do
+  it "config converts yaml when config file exists" do
     yaml_data = {:blah=>'blah'}
     File.stubs('exists?').returns(true)
     Hirb.config_files = ['ok']
@@ -12,25 +12,25 @@ class HirbTest < Test::Unit::TestCase
     Hirb.config.should == yaml_data
   end
   
-  test "config defaults to hash when no config file" do
+  it "config defaults to hash when no config file" do
     File.stubs('exists?').returns(false)
     Hirb.config.should == {}
   end
   
-  test "config reloads if given explicit reload" do
+  it "config reloads if given explicit reload" do
     Hirb.config
     Hirb.expects(:read_config_file).returns({})
     Hirb.config(true)
   end
 
-  test "config reads multiple config files and merges them" do
+  it "config reads multiple config files and merges them" do
     Hirb.config_files = %w{one two}
     Hirb.expects(:read_config_file).times(2).returns({:output=>{"String"=>:auto_table}}, {:output=>{"Array"=>:auto_table}})
     Hirb.config.should == {:output=>{"Array"=>:auto_table, "String"=>:auto_table}}
     Hirb.config_files = nil
   end
 
-  test "config_file sets correctly when no ENV['HOME']" do
+  it "config_file sets correctly when no ENV['HOME']" do
     Hirb.config_files = nil
     home = ENV.delete('HOME')
     Hirb.config_files[0].class.should == String

data/test/import_test.rb

@@ -1,9 +1,9 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Hirb::ImportTest < Test::Unit::TestCase
-  test "require import_object extends Object" do
-    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should be(false)
+describe "import" do
+  it "require import_object extends Object" do
+    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should == false
     require 'hirb/import_object'
-    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should be(true)
+    Object.ancestors.map {|e| e.to_s}.include?("Hirb::ObjectMethods").should == true
   end
 end

data/test/menu_test.rb

@@ -1,10 +1,10 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Hirb::MenuTest < Test::Unit::TestCase
-  before(:all) { Hirb::View.instance_variable_set("@config", :width=>Hirb::View::DEFAULT_WIDTH) }
+describe "Menu" do
+  before_all { View.instance_variable_set("@config", :width=>Hirb::View::DEFAULT_WIDTH) }
 
   def menu(*args, &block)
-    # testing via menu's main use case (through console) instead of Hirb::Menu.render
+    # testing via menu's main use case (through console) instead of Menu.render
     @console ||= Object.new.extend(Hirb::Console)
     @console.menu(*args, &block)
   end
@@ -18,8 +18,8 @@ class Hirb::MenuTest < Test::Unit::TestCase
     $stdin.expects(:gets).returns(input)
   end
 
-  context "menu" do
-    test "by default renders table menu" do
+  describe "menu" do
+    it "by default renders table menu" do
       expected_menu = <<-MENU.unindent
       +--------+-------+
       | number | value |
@@ -33,7 +33,7 @@ class Hirb::MenuTest < Test::Unit::TestCase
       basic_menu([1,2,3]).include?(expected_menu).should == true
     end
 
-    test "with block renders" do
+    it "with block renders" do
       menu_input "1,2"
       expected_result = [1,2]
       capture_stdout { 
@@ -41,7 +41,7 @@ class Hirb::MenuTest < Test::Unit::TestCase
       }
     end
 
-    test "with block and no chosen doesn't call block" do
+    it "with block and no chosen doesn't call block" do
       menu_input ""
       block = lambda {|e| @called = true }
       capture_stdout {
@@ -50,12 +50,12 @@ class Hirb::MenuTest < Test::Unit::TestCase
       assert !@called
     end
 
-    test "with valid helper_class option renders" do
-      Hirb::Helpers::Table.expects(:render)
+    it "with valid helper_class option renders" do
+      Helpers::Table.expects(:render)
       basic_menu [1,2,3], :helper_class=>"Hirb::Helpers::Table"
     end
 
-    test "with invalid helper_class option renders default menu" do
+    it "with invalid helper_class option renders default menu" do
       expected_menu = <<-MENU.unindent
       1: 1
       2: 2
@@ -64,7 +64,7 @@ class Hirb::MenuTest < Test::Unit::TestCase
       basic_menu([1,2,3], :helper_class=>"SomeHelper").include?(expected_menu).should == true
     end
 
-    test "with false helper_class option renders default menu" do
+    it "with false helper_class option renders default menu" do
       expected_menu = <<-MENU.unindent
       1: 1
       2: 2
@@ -73,30 +73,30 @@ class Hirb::MenuTest < Test::Unit::TestCase
       basic_menu([1,2,3], :helper_class=>false).include?(expected_menu).should == true
     end
 
-    test "prints prompt option" do
+    it "prints prompt option" do
       prompt = "Input or else ..."
       basic_menu([1,2,3], :prompt=>prompt).include?(prompt).should == true
     end
 
-    test "converts non-array inputs to array" do
-      Hirb::Helpers::AutoTable.expects(:render).with([1], anything)
+    it "converts non-array inputs to array" do
+      Helpers::AutoTable.expects(:render).with([1], anything)
       basic_menu 1
     end
 
-    test "with false ask option returns one choice without asking" do
+    it "with false ask option returns one choice without asking" do
       $stdin.expects(:gets).never
       menu([1], :ask=>false).should == [1]
     end
 
-    test "with no items to choose from always return without asking" do
+    it "with no items to choose from always return without asking" do
       $stdin.expects(:gets).never
       menu([], :ask=>false).should == []
       menu([], :ask=>true).should == []
     end
 
-    test "with directions option turns off directions" do
+    it "with directions option turns off directions" do
       menu_input('blah')
-      capture_stdout { menu([1], :directions=>false) }.should_not =~ /range.*all/
+      capture_stdout { menu([1], :directions=>false) }.should.not =~ /range.*all/
     end
   end
 
@@ -104,7 +104,7 @@ class Hirb::MenuTest < Test::Unit::TestCase
     if options[:invokes] || options[:invoke]
       cmd = options[:command] || 'p'
       (options[:invokes] || [options[:invoke]]).each {|e|
-        Hirb::Menu.any_instance.expects(:invoke).with(cmd, e)
+        Menu.any_instance.expects(:invoke).with(cmd, e)
       }
     end
 
@@ -114,107 +114,107 @@ class Hirb::MenuTest < Test::Unit::TestCase
     }
   end
 
-  context "2d menu" do
-    test "with default field from last_table renders" do
+  describe "2d menu" do
+    it "with default field from last_table renders" do
       menu_input "1"
       two_d_menu.should == [1]
     end
 
-    test "with default field from fields option renders" do
+    it "with default field from fields option renders" do
       menu_input "1"
       two_d_menu(:fields=>[:bro, :a]).should == [2]
     end
 
-    test "with default field option renders" do
+    it "with default field option renders" do
       menu_input "1"
       two_d_menu(:default_field=>:bro).should == [2]
     end
 
-    test "with non-table helper class renders" do
+    it "with non-table helper class renders" do
       menu_input "1"
       two_d_menu(:helper_class=>false, :fields=>[:a,:bro]).should == [1]
     end
 
-    test "with no default field prints error" do
+    it "with no default field prints error" do
       menu_input "1"
       capture_stderr { two_d_menu(:fields=>[]) }.should =~ /No default.*found/
     end
 
-    test "with invalid field prints error" do
+    it "with invalid field prints error" do
       menu_input "1:z"
       capture_stderr { two_d_menu }.should =~ /Invalid.*'z'/
     end
 
-    test "with choice from abbreviated field" do
+    it "with choice from abbreviated field" do
       menu_input "2:b"
       two_d_menu.should == [4]
     end
 
-    test "with choices from multiple fields renders" do
+    it "with choices from multiple fields renders" do
       menu_input "1 2:bro"
       two_d_menu.should == [1,4]
     end
   end
 
-  context "action menu" do
-    test "invokes" do
+  describe "action menu" do
+    it "invokes" do
       menu_input "p 1 2:bro"
       two_d_menu(:action=>true, :invoke=>[[1,4]])
     end
 
-    test "with 1d invokes" do
+    it "with 1d invokes" do
       menu_input "p 1"
       two_d_menu(:action=>true, :two_d=>nil, :invoke=>[[{:a=>1, :bro=>2}]])
     end
 
-    test "with non-choice arguments invokes" do
+    it "with non-choice arguments invokes" do
       menu_input "p arg1 1"
       two_d_menu :action=>true, :invoke=>['arg1', [1]]
     end
 
-    test "with multiple choice arguments flattens them into arg" do
+    it "with multiple choice arguments flattens them into arg" do
       menu_input "p arg1 1 2:bro arg2"
       two_d_menu :action=>true, :invoke=>['arg1', [1,4], 'arg2']
     end
 
-    test "with nothing chosen prints error" do
+    it "with nothing chosen prints error" do
       menu_input "cmd"
       capture_stderr { two_d_menu(:action=>true) }.should =~ /No rows chosen/
     end
 
-    test "with no command given prints error" do
+    it "with no command given prints error" do
       menu_input "1"
       capture_stderr { two_d_menu(:action=>true) }.should =~ /No command given/
     end
 
-    test "with multi_action option invokes" do
+    it "with multi_action option invokes" do
       menu_input "p 1 2:bro"
       two_d_menu(:action=>true, :multi_action=>true, :invokes=>[[1], [4]])
     end
 
-    test "with command option invokes" do
+    it "with command option invokes" do
       menu_input "1"
       two_d_menu(:action=>true, :command=>'p', :invoke=>[[1]])
     end
 
-    test "with command option and empty input doesn't invoke action and exists silently" do
-      Hirb::Menu.any_instance.expects(:invoke).never
+    it "with command option and empty input doesn't invoke action and exists silently" do
+      Menu.any_instance.expects(:invoke).never
       menu_input ""
       two_d_menu(:action=>true, :command=>'p').should == nil
     end
 
-    test "with action_object option invokes" do
+    it "with action_object option invokes" do
       obj = mock(:blah=>true)
       menu_input "blah 1"
       two_d_menu(:action=>true, :action_object=>obj)
     end
 
-    test "with ask false and defaults invokes" do
+    it "with ask false and defaults invokes" do
       two_d_menu(:output=>[{:a=>1, :bro=>2}], :action=>true, :ask=>false, :default_field=>:a,
         :command=>'p', :invoke=>[[1]])
     end
 
-    test "with ask false and no defaults prints error" do
+    it "with ask false and no defaults prints error" do
       capture_stderr {
         two_d_menu(:output=>[{:a=>1, :bro=>2}], :action=>true, :ask=>false, :command=>'p')
       }.should =~ /Default.*required/

data/test/object_table_test.rb

@@ -1,75 +1,73 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Hirb::Helpers::ObjectTableTest < Test::Unit::TestCase
-  context "object table" do
-    def table(*args)
-      Hirb::Helpers::ObjectTable.render(*args)
-    end
+describe "object table" do
+  def table(*args)
+    Helpers::ObjectTable.render(*args)
+  end
 
-    before(:all) {
-      @pets = [stub(:name=>'rufus', :age=>7, :to_s=>'rufus'), stub(:name=>'alf', :age=>101, :to_s=>'alf')]
-    }
-    test "renders" do
-      expected_table = <<-TABLE.unindent
-      +-------+-----+
-      | name  | age |
-      +-------+-----+
-      | rufus | 7   |
-      | alf   | 101 |
-      +-------+-----+
-      2 rows in set
-      TABLE
-      table(@pets, :fields=>[:name, :age]).should == expected_table
-    end
-    
-    test "with no options defaults to to_s field" do
-      expected_table = <<-TABLE.unindent
-      +-------+
-      | value |
-      +-------+
-      | rufus |
-      | alf   |
-      +-------+
-      2 rows in set
-      TABLE
-      table(@pets).should == expected_table
-    end
+  before_all {
+    @pets = [stub(:name=>'rufus', :age=>7, :to_s=>'rufus'), stub(:name=>'alf', :age=>101, :to_s=>'alf')]
+  }
+  it "renders" do
+    expected_table = <<-TABLE.unindent
+    +-------+-----+
+    | name  | age |
+    +-------+-----+
+    | rufus | 7   |
+    | alf   | 101 |
+    +-------+-----+
+    2 rows in set
+    TABLE
+    table(@pets, :fields=>[:name, :age]).should == expected_table
+  end
+  
+  it "with no options defaults to to_s field" do
+    expected_table = <<-TABLE.unindent
+    +-------+
+    | value |
+    +-------+
+    | rufus |
+    | alf   |
+    +-------+
+    2 rows in set
+    TABLE
+    table(@pets).should == expected_table
+  end
 
-    test "renders simple arrays" do
-      expected_table = <<-TABLE.unindent
-      +-------+
-      | value |
-      +-------+
-      | 1     |
-      | 2     |
-      | 3     |
-      | 4     |
-      +-------+
-      4 rows in set
-      TABLE
-      table([1,2,3,4]).should == expected_table
-    end
+  it "renders simple arrays" do
+    expected_table = <<-TABLE.unindent
+    +-------+
+    | value |
+    +-------+
+    | 1     |
+    | 2     |
+    | 3     |
+    | 4     |
+    +-------+
+    4 rows in set
+    TABLE
+    table([1,2,3,4]).should == expected_table
+  end
 
-    test "renders simple arrays with custom header" do
-      expected_table = <<-TABLE.unindent
-      +-----+
-      | num |
-      +-----+
-      | 1   |
-      | 2   |
-      | 3   |
-      | 4   |
-      +-----+
-      4 rows in set
-      TABLE
-      table([1,2,3,4], :headers=>{:to_s=>'num'}).should == expected_table
-    end
+  it "renders simple arrays with custom header" do
+    expected_table = <<-TABLE.unindent
+    +-----+
+    | num |
+    +-----+
+    | 1   |
+    | 2   |
+    | 3   |
+    | 4   |
+    +-----+
+    4 rows in set
+    TABLE
+    table([1,2,3,4], :headers=>{:to_s=>'num'}).should == expected_table
+  end
 
-    test "with empty fields" do
-      expected_table = <<-TABLE.unindent
-      0 rows in set
-      TABLE
-      table(@pets, :fields => []).should == expected_table
-    end
+  it "with empty fields" do
+    expected_table = <<-TABLE.unindent
+    0 rows in set
+    TABLE
+    table(@pets, :fields => []).should == expected_table
   end
 end

data/test/pager_test.rb

@@ -1,164 +1,162 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Hirb
-  class PagerTest < Test::Unit::TestCase
-    def pager; View.pager; end
-
-    def create_pageable_string(inspect_mode=false, size={})
-      size = {:width=>pager.width, :height=>pager.height}.merge(size)
-      seed = inspect_mode ? "a" : "a\n"
-      if inspect_mode
-        seed * (size[:width] * size[:height] + 1)
-      else
-        seed * (size[:height] + 1)
-      end
+describe "Pager" do
+  def pager; View.pager; end
+
+  def create_pageable_string(inspect_mode=false, size={})
+    size = {:width=>pager.width, :height=>pager.height}.merge(size)
+    seed = inspect_mode ? "a" : "a\n"
+    if inspect_mode
+      seed * (size[:width] * size[:height] + 1)
+    else
+      seed * (size[:height] + 1)
     end
+  end
 
-    test "command_pager sets pager_command when command exists" do
-      Util.expects(:command_exists?).returns(true)
-      Pager.expects(:basic_pager)
-      Pager.command_pager 'blah', :pager_command=>'less'
+  it "command_pager sets pager_command when command exists" do
+    Util.expects(:command_exists?).returns(true)
+    Pager.expects(:basic_pager)
+    Pager.command_pager 'blah', :pager_command=>'less'
+  end
+
+  it "command_pager doesn't set pager_command when command doesn't exist" do
+    Util.expects(:command_exists?).returns(false)
+    Pager.expects(:basic_pager).never
+    Pager.command_pager 'blah', :pager_command=>'moreless'
+  end
+
+  describe "default_pager" do
+    before_all { reset_config; Hirb.enable :pager=>true }
+    before { View.pager = nil; Pager.stubs(:pager_command).returns(nil) }
+
+    it "pages once in normal mode" do
+      $stdin.expects(:gets).returns("\n")
+      output = capture_stdout { pager.page(create_pageable_string, false) }
+      output.include?('quit').should == true
+      output.include?('finished').should == true
     end
 
-    test "command_pager doesn't set pager_command when command doesn't exist" do
-      Util.expects(:command_exists?).returns(false)
-      Pager.expects(:basic_pager).never
-      Pager.command_pager 'blah', :pager_command=>'moreless'
+    it "doesn't page in normal mode" do
+      $stdin.expects(:gets).never
+      output = capture_stdout { pager.page("a\n", false) }
+      output.include?("a\n=== Pager finished. ===\n").should == true
+    end
+
+    it "pages once in inspect mode" do
+      $stdin.expects(:gets).returns("\n")
+      output = capture_stdout { pager.page(create_pageable_string(true), true) }
+      output.include?('quit').should == true
+      output.include?('finished').should == true
+    end
+
+    it "doesn't page in inspect mode" do
+      $stdin.expects(:gets).never
+      output = capture_stdout { pager.page("a", true) }
+      output.include?("a\n=== Pager finished. ===\n").should == true
     end
+    after_all { Hirb.disable }
+  end
 
-    context "default_pager" do
-      before(:all) { reset_config; Hirb.enable :pager=>true }
-      before(:each) { View.pager = nil; Pager.stubs(:pager_command).returns(nil) }
-      after(:all) { Hirb.disable }
+  describe "pager" do
+    before_all { reset_config; Hirb.enable }
+    before { View.pager = nil; View.formatter = nil }
+
+    def irb_eval(string)
+      context_stub = stub(:last_value=>string)
+      ::IRB::Irb.new(context_stub).output_value
+    end
 
-      test "pages once in normal mode" do
-        $stdin.expects(:gets).returns("\n")
-        output = capture_stdout { pager.page(create_pageable_string, false) }
-        output.include?('quit').should be(true)
-        output.include?('finished').should be(true)
+    # this mode is called within @irb.output_value
+    describe "in inspect_mode" do
+      it "activates when output is wide enough" do
+        output = create_pageable_string(true)
+        pager.expects(:page).with(output.inspect, true)
+        View.expects(:render_output).returns(false)
+        irb_eval output
       end
 
-      test "doesn't page in normal mode" do
-        $stdin.expects(:gets).never
-        output = capture_stdout { pager.page("a\n", false) }
-        output.include?("a\n=== Pager finished. ===\n").should be(true)
+      it "doesn't activate when output isn't wide enough" do
+        pager.expects(:page).never
+        View.expects(:render_output).returns(false)
+        irb_eval("a")
       end
 
-      test "pages once in inspect mode" do
-        $stdin.expects(:gets).returns("\n")
-        output = capture_stdout { pager.page(create_pageable_string(true), true) }
-        output.include?('quit').should be(true)
-        output.include?('finished').should be(true)
+      it "activates with an explicit width" do
+        View.config[:width] = 10
+        output = create_pageable_string true, :width=>10
+        pager.expects(:page).with(output.inspect, true)
+        View.expects(:render_output).returns(false)
+        irb_eval output
       end
 
-      test "doesn't page in inspect mode" do
-        $stdin.expects(:gets).never
-        output = capture_stdout { pager.page("a", true) }
-        output.include?("a\n=== Pager finished. ===\n").should be(true)
+      it "activates default_pager when pager command is invalid" do
+        Pager.expects(:pager_command).returns(nil)
+        output = create_pageable_string(true)
+        Pager.expects(:default_pager).with(output.inspect, anything)
+        View.expects(:render_output).returns(false)
+        capture_stdout { irb_eval output }
       end
     end
 
-    context "pager" do
-      before(:all) { reset_config; Hirb.enable }
-      before(:each) { View.pager = nil; View.formatter = nil }
-      after(:all) { Hirb.disable }
-
-      def irb_eval(string)
-        context_stub = stub(:last_value=>string)
-        ::IRB::Irb.new(context_stub).output_value
+    # this mode is called within View.render_output
+    describe "in normal mode" do
+      it "activates when output is long enough" do
+        output = create_pageable_string
+        View.formatter.expects(:format_output).returns(output)
+        pager.expects(:page).with(output, false)
+        irb_eval(output)
       end
 
-      # this mode is called within @irb.output_value
-      context "in inspect_mode" do
-        test "activates when output is wide enough" do
-          output = create_pageable_string(true)
-          pager.expects(:page).with(output.inspect, true)
-          View.expects(:render_output).returns(false)
-          irb_eval output
-        end
-
-        test "doesn't activate when output isn't wide enough" do
-          pager.expects(:page).never
-          View.expects(:render_output).returns(false)
-          irb_eval("a")
-        end
-
-        test "activates with an explicit width" do
-          View.config[:width] = 10
-          output = create_pageable_string true, :width=>10
-          pager.expects(:page).with(output.inspect, true)
-          View.expects(:render_output).returns(false)
-          irb_eval output
-        end
-
-        test "activates default_pager when pager command is invalid" do
-          Pager.expects(:pager_command).returns(nil)
-          output = create_pageable_string(true)
-          Pager.expects(:default_pager).with(output.inspect, anything)
-          View.expects(:render_output).returns(false)
-          capture_stdout { irb_eval output }
-        end
+      it "doesn't activate when output isn't long enough" do
+        output = "a\n"
+        View.formatter.expects(:format_output).returns(output)
+        pager.expects(:page).never
+        capture_stdout { irb_eval(output) }
       end
 
-      # this mode is called within Hirb::View.render_output
-      context "in normal mode" do
-        test "activates when output is long enough" do
-          output = create_pageable_string
-          View.formatter.expects(:format_output).returns(output)
-          pager.expects(:page).with(output, false)
-          irb_eval(output)
-        end
-
-        test "doesn't activate when output isn't long enough" do
-          output = "a\n"
-          View.formatter.expects(:format_output).returns(output)
-          pager.expects(:page).never
-          capture_stdout { irb_eval(output) }
-        end
-
-        test "activates with an explicit height" do
-          View.config[:height] = 100
-          output = create_pageable_string false, :height=>100
-          View.formatter.expects(:format_output).returns(output)
-          pager.expects(:page).with(output, false)
-          irb_eval(output)
-        end
-
-        test "activates default_pager when pager_command is invalid" do
-          Pager.expects(:pager_command).returns(nil)
-          output = create_pageable_string
-          Pager.expects(:default_pager).with(output, anything)
-          View.formatter.expects(:format_output).returns(output)
-          capture_stdout { irb_eval output }
-        end
+      it "activates with an explicit height" do
+        View.config[:height] = 100
+        output = create_pageable_string false, :height=>100
+        View.formatter.expects(:format_output).returns(output)
+        pager.expects(:page).with(output, false)
+        irb_eval(output)
       end
 
-      test "activates pager_command with valid pager_command option" do
-        View.config[:pager_command] = "less"
-        View.expects(:render_output).returns(false)
-        Util.expects(:command_exists?).returns(true)
-        Pager.expects(:command_pager)
-        irb_eval create_pageable_string(true)
-        View.config[:pager_command] = nil
+      it "activates default_pager when pager_command is invalid" do
+        Pager.expects(:pager_command).returns(nil)
+        output = create_pageable_string
+        Pager.expects(:default_pager).with(output, anything)
+        View.formatter.expects(:format_output).returns(output)
+        capture_stdout { irb_eval output }
       end
+    end
 
-      test "activates pager_command with pager_command option that has command options" do
-        View.config[:pager_command] = "less -r"
-        View.expects(:render_output).returns(false)
-        Util.expects(:command_exists?).with('less').returns(true)
-        Pager.expects(:command_pager)
-        irb_eval create_pageable_string(true)
-        View.config[:pager_command] = nil
-      end
+    it "activates pager_command with valid pager_command option" do
+      View.config[:pager_command] = "less"
+      View.expects(:render_output).returns(false)
+      Util.expects(:command_exists?).returns(true)
+      Pager.expects(:command_pager)
+      irb_eval create_pageable_string(true)
+      View.config[:pager_command] = nil
+    end
 
-      test "doesn't activate pager_command with invalid pager_command option" do
-        View.config[:pager_command] = "moreless"
-        View.expects(:render_output).returns(false)
-        Util.expects(:command_exists?).returns(false)
-        Pager.expects(:default_pager)
-        irb_eval create_pageable_string(true)
-        View.config[:pager_command] = nil
-      end
+    it "activates pager_command with pager_command option that has command options" do
+      View.config[:pager_command] = "less -r"
+      View.expects(:render_output).returns(false)
+      Util.expects(:command_exists?).with('less').returns(true)
+      Pager.expects(:command_pager)
+      irb_eval create_pageable_string(true)
+      View.config[:pager_command] = nil
+    end
+
+    it "doesn't activate pager_command with invalid pager_command option" do
+      View.config[:pager_command] = "moreless"
+      View.expects(:render_output).returns(false)
+      Util.expects(:command_exists?).returns(false)
+      Pager.expects(:default_pager)
+      irb_eval create_pageable_string(true)
+      View.config[:pager_command] = nil
     end
   end
-end
+  after_all { Hirb.disable }
+end