osaka 0.2.3 → 0.3.0

data/spec/applicationwrapper_spec.rb

@@ -7,6 +7,37 @@ describe "Osaka::ApplicationWrapper" do
   quoted_name = "\"#{name}\""
   subject { Osaka::ApplicationWrapper.new(name) }
 
+  before (:each) do
+    Osaka::ScriptRunner.enable_debug_prints
+  end
+  
+  after (:each) do
+    Osaka::ScriptRunner.disable_debug_prints
+  end
+
+  it "Should be able to clone wrappers" do
+    subject.set_current_window "Window"
+    new_wrapper = subject.clone
+    new_wrapper.should == subject
+    new_wrapper.should_not.equal?(subject)
+  end
+  
+  it "Should be able to compare objects using names" do
+    subject.should == Osaka::ApplicationWrapper.new(name)
+    subject.should_not == Osaka::ApplicationWrapper.new("otherName")
+  end
+  
+  it "Should be able to compare objects using window" do
+    equal_object = Osaka::ApplicationWrapper.new(name)
+    unequal_object = Osaka::ApplicationWrapper.new(name)
+    equal_object.set_current_window("Window")
+    subject.set_current_window("Window")
+    unequal_object.set_current_window "Another Window"
+    
+    subject.should == equal_object
+    subject.should_not == unequal_object
+  end
+  
   def check_for_warning(action)
     Osaka::ScriptRunner.should_receive(:execute).and_return("Blah")
     subject.should_receive(:print_warning).with(action, "Blah")
@@ -42,6 +73,11 @@ describe "Osaka::ApplicationWrapper" do
     subject.system_event!("quit")
   end
 
+  it "Should be possible to check whether an application is still running" do
+    Osaka::ScriptRunner.should_receive(:execute).with("tell application \"System Events\"; (name of processes) contains \"#{name}\"; end tell").and_return("false")
+    subject.running?.should == false
+  end
+
   it "Should be able to generate events via the Systems Events and activate the application first" do
     subject.should_receive(:activate)
     subject.should_receive(:system_event!).with("quit")
@@ -50,7 +86,7 @@ describe "Osaka::ApplicationWrapper" do
   
   it "Should be able to check whether a specific element exists" do
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true\n")
-    subject.check.exists("window 1").should == true
+    subject.check.exists(at.window(1)).should == true
   end
   
   it "Should be able to wait for for a specific element existing" do
@@ -59,18 +95,18 @@ describe "Osaka::ApplicationWrapper" do
       counter = counter + 1
       (counter == 5).to_s
     }
-    subject.wait_until!.exists("window 1")
+    subject.wait_until!.exists(at.window(1))
   end
   
   it "Should be able to wait until exists and activate the application first" do
     subject.should_receive(:activate)
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
-    subject.wait_until.exists("window 1")
+    subject.wait_until.exists(at.window(1))
   end
 
   it "Should be able to wait for a specific element to not exist anymore" do
     Osaka::ScriptRunner.should_receive(:execute).with(/not exists window 1/).and_return("true")
-    subject.wait_until!.not_exists("window 1")    
+    subject.wait_until!.not_exists(at.window(1))    
   end
   
   it "Should be able to generate keystroke events" do
@@ -103,7 +139,7 @@ describe "Osaka::ApplicationWrapper" do
   it "Should be able to do a keystroke and wait until something happen in one easy line" do
     Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/).and_return("")
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
-    subject.keystroke!("p", []).wait_until!.exists("window 1")
+    subject.keystroke!("p", []).wait_until!.exists(at.window(1))
   end
   
   it "Should be able to keystroke_and_wait_until_exists and activate" do
@@ -111,12 +147,12 @@ describe "Osaka::ApplicationWrapper" do
     subject.should_receive(:focus)
     Osaka::ScriptRunner.should_receive(:execute).with(/keystroke "p"/).and_return("")
     Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
-    subject.keystroke("p", []).wait_until!.exists("window 1")    
+    subject.keystroke("p", []).wait_until!.exists(at.window(1))    
   end
   
   it "Should be able to do clicks" do
     Osaka::ScriptRunner.should_receive(:execute).with(/click menu button "PDF"/).and_return("")
-    subject.click!('menu button "PDF"')
+    subject.click!(at.menu_button("PDF"))
   end
 
   it "Should be able to do click and activate" do
@@ -124,55 +160,56 @@ describe "Osaka::ApplicationWrapper" do
     subject.should_receive(:click!).with("button")
     subject.click("button")    
   end
-  
+    
   it "Should be able to do clicks and wait until something happened in one easy line" do
     Osaka::ScriptRunner.should_receive(:execute).with(/click/).and_return("")
-    Osaka::ScriptRunner.should_receive(:execute).with(/exists window/).and_return("true")
-    subject.click!("button").wait_until!.exists("window")
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
+    subject.click!("button").wait_until!.exists(at.window(1))
   end
   
   it "Should be able to click_and_wait_until_exists and activate" do
     subject.should_receive(:activate)
     Osaka::ScriptRunner.should_receive(:execute).with(/click/).and_return("")
-    Osaka::ScriptRunner.should_receive(:execute).with(/exists window/).and_return("true")
-    subject.click("button").wait_until!.exists("window")
+    Osaka::ScriptRunner.should_receive(:execute).with(/exists window 1/).and_return("true")
+    subject.click("button").wait_until!.exists(at.window(1))
+  end
+
+  it "Should be able to click on menu bar items" do
+    subject.should_receive("activate")
+    subject.should_receive("click!").with(at.menu_item("Hey").menu(1).menu_bar_item("File").menu_bar(1))
+    subject.click_menu_bar(at.menu_item("Hey"), "File")    
   end
     
   it "Should be able to set a value to an element" do
-    subject.should_receive(:system_event!).with(/set value of window to "newvalue"/).and_return("")
-    subject.set!("value", "window", "newvalue")
+    subject.should_receive(:system_event!).with(/set value of window 1 to "newvalue"/).and_return("")
+    subject.set!("value", at.window(1), "newvalue")
   end
 
   it "Prints a warning when setting and element and output is received" do
     check_for_warning("set")
-    subject.set!("value", "window", "newvalue")
+    subject.set!("value", at.window(1), "newvalue")
   end
   
   it "Should be able to set to boolean values" do
-    subject.should_receive(:system_event!).with(/set value of window to true/).and_return("")
-    subject.set!("value", "window", true)    
+    subject.should_receive(:system_event!).with(/set value of window 1 to true/).and_return("")
+    subject.set!("value", at.window(1), true)    
   end
     
   it "Should be able to get a value from an element" do
-    subject.should_receive(:system_event!).with(/get value of window/).and_return("1\n")
-    subject.get!("value", "window").should == "1"
+    subject.should_receive(:system_event!).with(/get value of window 1/).and_return("1\n")
+    subject.get!("value", at.window(1)).should == "1"
   end
   
   it "Should use the locally stored window when that one is set." do
-    subject.window = "1"
+    subject.set_current_window("1")
     subject.should_receive(:system_event!).with(/get value of window \"1\"/).and_return("1\n")
     subject.get!("value").should == "1"
   end
-  
-  it "Should throw an exception when window is set multiple times." do
-    subject.window = "Untitled"
-    lambda {subject.get!("value", "window 1")}.should raise_error(Osaka::InvalidLocation, "Invalid location for command: of window 1 of window \"Untitled\"")
-  end
-  
+    
   it "Should combine the location and the window" do
-    subject.window = "1"
+    subject.set_current_window("1")
     subject.should_receive(:system_event!).with(/get value of dialog 2 of window "1"/).and_return("1\n")
-    subject.get!("value", "dialog 2").should == "1"    
+    subject.get!("value", at.dialog(2)).should == "1"    
   end
   
   it "Should be able to get values from the application itself" do
@@ -182,13 +219,13 @@ describe "Osaka::ApplicationWrapper" do
     
   it "Should be able to set a value and activate" do
     subject.should_receive(:activate)
-    subject.should_receive(:set!).with("value", "window", "newvalue")
-    subject.set("value", "window", "newvalue")
+    subject.should_receive(:set!).with("value", at.window(1), "newvalue")
+    subject.set("value", at.window(1), "newvalue")
   end
     
   it "Should be able to loop over some script until something happens" do
     counter = 0
-    Osaka::ScriptRunner.should_receive(:execute).exactly(3).times.with(/exists window/).and_return {
+    Osaka::ScriptRunner.should_receive(:execute).exactly(3).times.with(/exists window 1/).and_return {
       counter = counter + 1
       if counter > 2
         "true"
@@ -197,7 +234,7 @@ describe "Osaka::ApplicationWrapper" do
       end
     }
     subject.should_receive(:activate).twice
-    subject.until!.exists("window") {
+    subject.until!.exists(at.window(1)) {
       subject.activate
     }
   end
@@ -218,9 +255,9 @@ describe "Osaka::ApplicationWrapper" do
   end
   
   it "Should initialize the current window when it is not focused yet" do
-    subject.should_receive(:window_list).and_return(["1"])
+    subject.should_receive(:window_list).and_return(["1"])    
     subject.focus
-    subject.window.should == "1"
+    subject.current_window_name.should == "1"
   end
   
   it "Shouldn't initialize current window when it is already set" do
@@ -230,7 +267,7 @@ describe "Osaka::ApplicationWrapper" do
     subject.should_receive(:window_list).and_return(["2", "1"])
     subject.should_receive(:set!)
     subject.focus
-    subject.window.should == "1"
+    subject.current_window_name.should == "1"
   end
   
   it "Should re-initialize the current window when it doesn't exist anymore" do
@@ -239,7 +276,7 @@ describe "Osaka::ApplicationWrapper" do
 
     subject.should_receive(:window_list).and_return(["2"])
     subject.focus
-    subject.window.should == "2"    
+    subject.current_window_name.should == "2"    
   end
   
   it "Should focus the current window when it doesn't have focus" do
@@ -247,8 +284,8 @@ describe "Osaka::ApplicationWrapper" do
     subject.focus
 
     subject.should_receive(:window_list).and_return(["2", "1"])
-    subject.should_receive(:set!).with("value", "attribute \"AXMain\" of window \"1\"", true )
+    subject.should_receive(:set!).with("value", "attribute \"AXMain\"", true )
     subject.focus
-  end  
-  
+  end
+    
 end

data/spec/calculator_spec.rb

@@ -16,16 +16,15 @@ describe "Mac GUI Calculator" do
     # TODO: Fix this duplication between this and TextEdit.
     
     @wrapper.should_receive(:activate)
-    @wrapper.should_receive(:window).and_return(nil)
+    @wrapper.should_receive(:current_window_name).and_return("")
     subject.should_receive(:wait_for_new_window).with([])
     @wrapper.should_receive(:window_list).and_return(["Calculator"])
-    @wrapper.should_receive(:window=).with("Calculator")
+    @wrapper.should_receive(:set_current_window).with("Calculator")
     subject.activate
   end
-  
-  
+    
   it "Should be able to click a button on the calculator" do
-    expect_click!('button "1" of group 2 of window "Calculator"')
+    expect_click!(at.button("1").group(2))
     subject.click("1")
   end
   
@@ -35,12 +34,13 @@ describe "Mac GUI Calculator" do
   end
   
   it "Should be able to quit the calculator" do
+    @wrapper.should_receive(:running?).and_return(true)
     @wrapper.should_receive(:quit)
     subject.quit
   end
   
   it "Should be able to get the value from the screen" do
-    @wrapper.should_receive(:get!).with("value", 'static text 1 of group 1').and_return("0")
+    @wrapper.should_receive(:get!).with("value", at.static_text(1).group(1)).and_return("0")
     subject.result.should == "0"
   end
   

data/spec/integration_calculator_spec.rb

@@ -15,7 +15,6 @@ describe "Integration test using the Calculator" do
   
   it "Should be able to get info from the calculator" do
     app_info = subject.get_info
-    
   end
   
   it "Should be able to do calculations with mouse" do

data/spec/integration_keynote_spec.rb

@@ -0,0 +1,29 @@
+require 'tmpdir'
+require 'osaka'
+
+describe "Integration tests for Keynote and Common Flows" do
+  
+  it "Should be able to do a combine with just one file" do
+   
+    assets_directory =  File.join(File.dirname(__FILE__), "assets")
+    
+    keynote_file = File.join(assets_directory, "01_first_slides.key")
+    Dir.mktmpdir { |dir|
+      results_file = File.join(dir, "results.key")
+      CommonFlows.keynote_combine_files(results_file, keynote_file)
+      File.exists?(results_file).should == true
+    }
+  end
+  
+  it "Should be able to combine multiple files" do
+    assets_directory =  File.join(File.dirname(__FILE__), "assets")
+    
+    Dir.mktmpdir { |dir|
+      results_file = File.join(dir, "results.key")
+      CommonFlows.keynote_combine_files_from_directory_sorted(results_file, assets_directory)
+      File.exists?(results_file).should == true
+    }
+    
+  end
+  
+end

data/spec/integration_pages_numbers_mail_merge_spec.rb

@@ -0,0 +1,17 @@
+require 'tmpdir'
+require 'osaka'
+
+describe "Integration of mail merge flow with Pages and Numbers" do
+  
+  it "Should mail merge the assets and generate a PDF" do
+  
+    assets_directory =  File.join(File.dirname(__FILE__), "assets")
+    numbers_data = File.join(assets_directory, "mail_merge_data.numbers")
+    pages_template = File.join(assets_directory, "mail_merge_template.pages")
+    Dir.mktmpdir { |dir|
+      pdf_output_file = File.join(dir, "output.pdf")
+      CommonFlows::number_and_pages_mail_merge(numbers_data, pages_template, pdf_output_file)
+      File.exists?(pdf_output_file).should == true
+    }
+  end
+end

data/spec/integration_textedit_spec.rb

@@ -6,28 +6,32 @@ describe "Integration test using TextEdit" do
   subject { Osaka::TextEdit.new }
 
   before (:each) do
+    if subject.running?
+        subject.quit(:dont_save)
+      end
   end
   
   after (:each) do
     subject.quit(:dont_save)
   end
   
-  it "can type in the window" do    
+  it "can type in the window" do
     subject.activate
     subject.type("Hello World")
     subject.text.should == "Hello World"
   end
   
   it "can type in two windows using two instances" do
+    
     editor1 = subject
     editor2 = Osaka::TextEdit.new
-    
+        
     editor1.activate
     editor2.new_document
     
     editor1.type("Typing in window 1")
     editor2.type("Typing in window 2")
-    
+        
     editor1.text.should == "Typing in window 1"
     editor2.text.should == "Typing in window 2"
     

data/spec/keynote_flows_spec.rb

@@ -0,0 +1,62 @@
+
+require "osaka"
+
+describe "Common flows in keynote" do
+
+  before(:each) do
+    @mock_keynote = double(:Keynote)
+  end
+
+  it "Should be able to combine just one single file" do
+    Osaka::Keynote.should_receive(:new).and_return(@mock_keynote)
+    @mock_keynote.should_receive(:open).with("one_file.key")
+    @mock_keynote.should_receive(:save_as).with("result.key")
+    @mock_keynote.should_receive(:save)
+    @mock_keynote.should_receive(:quit)
+    CommonFlows.keynote_combine_files("result.key", "one_file.key")
+  end
+  
+  it "Should be able to combine multiple files in one result" do
+    mock2_keynote = double(:Keynote)
+    mock3_keynote = double(:Keynote)
+    Osaka::Keynote.should_receive(:new).and_return(@mock_keynote, mock2_keynote, mock3_keynote)  
+    @mock_keynote.should_receive(:open).with("one_file.key")
+    @mock_keynote.should_receive(:save_as).with("result.key")
+    @mock_keynote.should_receive(:select_all_slides).exactly(2).times
+    @mock_keynote.should_receive(:paste).exactly(2).times
+    @mock_keynote.should_receive(:save)
+    
+
+    mock2_keynote.should_receive(:open).with("two_file.key")
+    mock2_keynote.should_receive(:select_all_slides)
+    mock2_keynote.should_receive(:copy)
+    mock2_keynote.should_receive(:close)
+    
+    mock3_keynote.should_receive(:open).with("three_file.key")
+    mock3_keynote.should_receive(:select_all_slides)
+    mock3_keynote.should_receive(:copy)
+    mock3_keynote.should_receive(:close)
+    
+    @mock_keynote.should_receive(:quit)
+    CommonFlows.keynote_combine_files("result.key", ["one_file.key", "two_file.key", "three_file.key"])    
+  end
+  
+  it "Should be able to combine multiple files from one directory sorted" do
+    files_in_dir = [".", "..", "one.key", "05_file.key", "02key.wrong", "another", "01hey.key", "last"]
+    files_matching = ["./05_file.key", "./01hey.key", "./one.key"]
+    Dir.should_receive(:new).with(".").and_return(files_in_dir)
+    CommonFlows.should_receive(:keynote_combine_files).with("results.key", files_matching.sort)
+    CommonFlows.keynote_combine_files_from_directory_sorted("results.key")    
+  end
+
+  it "Should be able to combine multiple files from one directory sorted with pattern" do
+    files_in_dir = [".", "..", "05_file.key", "02key.wrong", "another", "01hey.key", "last"]
+    files_in_dir_to_be_used = ["dirname/01hey.key", "dirname/05_file.key"]
+    mocked_dir = double(:Dir)
+    Dir.should_receive(:new).with("dirname").and_return(mocked_dir)
+    mocked_dir.should_receive(:entries).and_return(files_in_dir)
+    CommonFlows.should_receive(:keynote_combine_files).with("results.key", files_in_dir_to_be_used)
+    CommonFlows.keynote_combine_files_from_directory_sorted("results.key", "dirname", /^\d+.*\.key$/)    
+  end
+  
+end

data/spec/keynote_spec.rb

@@ -3,14 +3,34 @@ require 'osaka'
 
 describe "Osaka::Keynote" do
 
+  include(*Osaka::ApplicationWrapperExpectations)
+
   subject { Osaka::Keynote.new }
   
   before (:each) do
-    subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
+    @wrapper = subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
   end
   
   it "Should create the correct keynote print dialog" do
     subject.create_print_dialog("window").class.should == Osaka::KeynotePrintDialog
   end
   
+  it "Should be possible to select all the slides in the default location" do
+    slides_button_location = at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1)    
+    should_check!(:exists, slides_button_location, true)
+    expect_click(slides_button_location)
+    subject.should_receive(:select_all)
+    subject.select_all_slides
+  end
+
+  it "Should be possible to select all the slides in the alternative location" do
+    slides_button_location = at.button("Slides").group(1).outline(1).scroll_area(2).splitter_group(1).splitter_group(1)    
+    alternative_slides_button_location = at.button("Slides").group(1).outline(1).scroll_area(1).splitter_group(1).splitter_group(1)
+    should_check!(:exists, slides_button_location, false)
+    expect_click(alternative_slides_button_location)
+    subject.should_receive(:select_all)
+    subject.select_all_slides
+  end
+  
+  
 end

data/spec/location_spec.rb

@@ -0,0 +1,53 @@
+
+require 'osaka'
+
+describe "Location path for an applescript command" do
+  
+  it "Should be able to create a valid location when appending two locations" do
+    location = Osaka::Location.new("scrollbar") + Osaka::Location.new("window 1")
+    location.to_s.should == "scrollbar of window 1"
+  end
+  
+  it "Should be able to add empty locations" do
+    location = Osaka::Location.new("location") + ""
+    location.to_s.should == "location"
+  end
+  
+  it "Should be able to create locations using at" do
+    at.button(1).to_s.should == "button 1"
+  end
+  
+  it "Should be able to create empty prefixed locations" do
+    Osaka::Location.new("").as_prefixed_location.should == ""
+  end
+  
+  it "Should be able to check whether the location already has a window" do
+    Osaka::Location.new("").has_window?.should == false
+    at.window("one").has_window?.should == true
+  end
+  
+  it "Should be able to create groups" do
+    at.group(1).to_s.should == "group 1"
+  end
+  
+  it "Should be able to combine buttons with groups" do
+    at.button("1").group(2).to_s.should == 'button "1" of group 2'
+  end
+  
+  it "Should be able to combine groups with windows" do
+    at.button(1).group(2).window("Name").to_s.should == 'button 1 of group 2 of window "Name"'
+  end
+  
+  it "Can compare different locations" do
+    at.button(1).should == at.button(1)
+  end
+  
+  it "Should be able to convert to a prefixed location" do
+    at.button(1).as_prefixed_location == " of button 1"
+  end
+  
+  it "Cannot create a location with two times window" do
+    lambda {at.window(1).window(1)}.should raise_error(Osaka::InvalidLocation, "Invalid location: window 1 of window 1")
+  end
+
+end

data/spec/mailmergeflow_spec.rb

@@ -0,0 +1,40 @@
+
+require "osaka"
+
+describe "Mail Merge to PDF common flow" do
+
+  before(:each) do
+    @mock_numbers = double(:Numbers)
+    @mock_pages = double(:Pages)
+  end
+  
+  it "Should do a good mail merge with Pages and Keynote flow" do
+    Osaka::Numbers.should_receive(:new).and_return(@mock_numbers)
+    Osaka::Pages.should_receive(:new).and_return(@mock_pages)
+    
+    @mock_numbers.should_receive(:open).with("/template/numbers")    
+    @mock_numbers.should_receive(:save)
+
+    @mock_pages.should_receive(:open).with("/template/pages")
+    @mock_pages.should_receive(:mail_merge_to_pdf).with("/output/file.pdf")
+    
+    @mock_numbers.should_receive(:quit).with(:dont_save)
+    @mock_pages.should_receive(:quit).with(:dont_save)
+    
+    CommonFlows.number_and_pages_mail_merge("/template/numbers", "/template/pages", "/output/file.pdf") {}
+  end
+  
+  it "Should yield for filling in the numbers fields" do
+    @mock_numbers.as_null_object
+    @mock_pages.as_null_object
+    Osaka::Numbers.should_receive(:new).and_return(@mock_numbers)
+    Osaka::Pages.should_receive(:new).and_return(@mock_pages)
+
+    retrieved_numbers = nil
+    CommonFlows.number_and_pages_mail_merge("1", "2", "3") { |numbers|
+      retrieved_numbers = numbers
+    }    
+    retrieved_numbers.should == @mock_numbers
+  end
+  
+end

data/spec/pages_spec.rb

@@ -25,18 +25,18 @@ describe "Osaka::Pages" do
   end
     
   it "Should be able to select the Mail Merge" do
-    expect_system_event('tell menu bar 1; tell menu "Edit"; click menu item 20; end tell; end tell')
-    should_wait_until(:exists, 'button "Merge" of sheet 1 of window 1')
+    @wrapper.should_receive(:current_window_name).any_number_of_times.and_return("Pages.pages")
+    expect_click_menu_bar(at.menu_item(20), "Edit")
+    should_wait_until(:exists, at.button("Merge").sheet(1))
     subject.mail_merge
   end
 
   it "Should click the merge button of the mail merge dialog" do
-    expect_click!('button "Merge" of sheet 1 of window 1')
-    should_wait_until!(:exists, 'menu button "PDF" of window "Print"')
+    @wrapper.should_receive(:current_window_name).any_number_of_times.and_return("Pages.pages")
+    expect_click!(at.button("Merge").sheet(1))
+    should_wait_until!(:exists, at.menu_button("PDF").window("Print"))
     subject.mail_merge.merge
   end
-  
-  
 end
 
 describe "Osaka::Pages Mail Merge dialog" do
@@ -47,20 +47,20 @@ describe "Osaka::Pages Mail Merge dialog" do
   
   before (:each) do
     @wrapper = subject.wrapper = double("Osaka::ApplicationWrapper").as_null_object
-    @location = subject.location = "window 1"
+    @location = subject.location = "window \"Pages.pages\""
   end
   
   it "Should be able to set the mail merge dialog to merge to new document" do
-    expect_click("pop up button 2 of #{@location}")
-    should_wait_until!(:exists, "menu item 1 of menu 1 of pop up button 2 of #{@location}")
-    expect_click!("menu item 1 of menu 1 of pop up button 2 of #{@location}")
+    expect_click(at.pop_up_button(2).sheet(1))
+    should_wait_until!(:exists, at.menu_item(1).menu(1).pop_up_button(2).sheet(1))
+    expect_click!(at.menu_item(1).menu(1).pop_up_button(2).sheet(1))
     subject.set_merge_to_new_document
   end
   
   it "Should be able to set the mail merge dialog to merge to printer" do
-    expect_click("pop up button 2 of #{@location}")
-    should_wait_until!(:exists, "menu item 2 of menu 1 of pop up button 2 of #{@location}")
-    expect_click!("menu item 2 of menu 1 of pop up button 2 of #{@location}")
+    expect_click(at.pop_up_button(2).sheet(1))
+    should_wait_until!(:exists, at.menu_item(2).menu(1).pop_up_button(2).sheet(1))
+    expect_click!(at.menu_item(2).menu(1).pop_up_button(2).sheet(1))
     subject.set_merge_to_printer    
   end
 end

data/spec/scriptrunner_spec.rb

@@ -22,6 +22,15 @@ describe "Osaka::ScriptRunner" do
     subject.execute("random number")
     Osaka::ScriptRunner::disable_debug_prints
   end
+
+  it "Should be able to run on debug printing with HTML tags" do
+    subject.should_receive(:do_system).and_return("Blah blah blah")
+    subject.should_receive(:puts).with('random number<br>')
+    subject.should_receive(:puts).with('Output: <b>Blah blah blah</b><br>')
+    Osaka::ScriptRunner::enable_debug_prints(:short_html)
+    subject.execute("random number")
+    Osaka::ScriptRunner::disable_debug_prints
+  end
   
   it "Should not print any debugging information by default " do
     subject.should_receive(:do_system).and_return("")