osaka 0.4.8 → 0.4.10

data/spec/preview_spec.rb

@@ -6,22 +6,22 @@ describe "Preview application for reading PDFs" do
   include(*Osaka::OsakaExpectations)
 
   subject { Osaka::Preview.new }
-  let(:control) { subject.control = mock("RemoteControl", :mac_version => :mountain_lion)}
+  let(:control) { subject.control = double("RemoteControl", :mac_version => :mountain_lion)}
 
   it "Can get the text context of a PDF document" do
     expect_get!("value", at.static_text(1).scroll_area(1).splitter_group(1)).and_return("Blah")
-    subject.pdf_content.should == "Blah"
+    expect(subject.pdf_content).to eq "Blah"
   end
   
   it "Can open a PDF file via the menu instead of the AppleScript 'open' as that one is buggy" do
     
     expect_click_menu_bar(at.menu_item("Open…"), "File")
     expect_wait_until_exists(at.window("Open"))
-    subject.stub(:do_and_wait_for_new_window).and_yield.and_return("window name")    
-    subject.should_receive(:select_file_from_open_dialog).with("dir/filename", at.window("Open"))
+    expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("window name")    
+    expect(subject).to receive(:select_file_from_open_dialog).with("dir/filename", at.window("Open"))
     expect_set_current_window("window name")
 
     subject.open("dir/filename")
   end
   
-end
+end

data/spec/remotecontrol_spec.rb

@@ -18,14 +18,13 @@ describe "Osaka::RemoteControl" do
     Osaka::ScriptRunner.disable_debug_prints
   end
 
-
   def expect_execute_and_warning_for(action)
     expect_execute_osascript.and_return("An Error")
-    subject.should_receive(:puts).with(/#{action}/)
+    expect(subject).to receive(:puts).with(/#{action}/)
   end
   
   it "Should be able to print warning messages" do
-    subject.should_receive(:puts).with("Osaka WARNING while doing ThisAction: Message")
+    expect(subject).to receive(:puts).with("Osaka WARNING while doing ThisAction: Message")
     subject.print_warning("ThisAction", "Message")
   end
   
@@ -33,28 +32,28 @@ describe "Osaka::RemoteControl" do
 
     it "Should be possible to check whether an application is still running" do
       expect_execute_osascript("tell application \"System Events\"; (name of processes) contains \"#{name}\"; end tell").and_return("false")
-      subject.running?.should be_false
+      expect(subject.running?).to be false
     end
     
     it "Can get the OS version (lion)" do
       expect_execute_osascript("system version of (system info)").and_return("10.7.4\n")
-      subject.mac_version.should == :lion
-      subject.mac_version_string.should == "10.7.4"
+      expect(subject.mac_version).to eq :lion
+      expect(subject.mac_version_string).to eq "10.7.4"
     end
 
     it "Can get the OS version (mountain lion)" do
       expect_execute_osascript("system version of (system info)").and_return("10.8\n")
-      subject.mac_version.should == :mountain_lion
+      expect(subject.mac_version).to eq :mountain_lion
     end
 
     it "Can get the OS version (snow leopard)" do
       expect_execute_osascript("system version of (system info)").and_return("10.6\n")
-      subject.mac_version.should == :snow_leopard
+      expect(subject.mac_version).to eq :snow_leopard
     end
 
     it "Can get the OS version (snow leopard)" do
       expect_execute_osascript("system version of (system info)").and_return("1\n")
-      subject.mac_version.should == :other
+      expect(subject.mac_version).to eq :other
     end
   end  
 
@@ -63,21 +62,21 @@ describe "Osaka::RemoteControl" do
     it "Should be able to clone controls" do
       subject.set_current_window "Window"
       new_control = subject.clone
-      new_control.should == subject
-      new_control.should_not equal(subject)
+      expect(new_control).to eq subject
+      expect(new_control).not_to be subject 
     end
     
     it "Should be having different current window instances when cloning" do
       subject.set_current_window "Window"
       new_control = subject.clone
       new_control.set_current_window "Not the same"
-      subject.current_window_name.should_not == new_control.current_window_name
+      expect(subject.current_window_name).not_to be new_control.current_window_name
       
     end
   
     it "Should be able to compare objects using names" do
-      subject.should == Osaka::RemoteControl.new(name)
-      subject.should_not == Osaka::RemoteControl.new("otherName")
+      expect(subject).to eq Osaka::RemoteControl.new(name)
+      expect(subject).not_to eq Osaka::RemoteControl.new("otherName")
     end
   
     it "Should be able to compare objects using window" do
@@ -87,8 +86,8 @@ describe "Osaka::RemoteControl" do
       subject.set_current_window("Window")
       unequal_object.set_current_window "Another Window"
     
-      subject.should == equal_object
-      subject.should_not == unequal_object
+      expect(subject).to eq equal_object
+      expect(subject).not_to eq unequal_object
     end
   end
   
@@ -122,12 +121,12 @@ describe "Osaka::RemoteControl" do
     
     it "Should be able to check whether a location exists" do
       expect_execute_osascript(/exists button 1/).and_return("true\n")
-      subject.exists?(at.button(1)).should be_true
+      expect(subject.exists?(at.button(1))).to be true
     end
 
     it "Should be able to check whether a location does not exists" do
       expect_execute_osascript(/not exists window 1/).and_return("true\n")
-      subject.not_exists?(at.window(1)).should be_true
+      expect(subject.not_exists?(at.window(1))).to be true
     end
   end
   
@@ -135,41 +134,41 @@ describe "Osaka::RemoteControl" do
   
     it "Should be able to wait for only one location to exist" do
       expect_exists?(at.button(1)).and_return(false, false, true)
-      subject.wait_until_exists!(at.button(1)).should == at.button(1)
+      expect(subject.wait_until_exists!(at.button(1))).to eq at.button(1)
     end
 
     it "Should be able to wait for only one location to exist (with activate)" do
       expect_activate
       expect_exists?(at.button(1)).and_return(false, false, true)
-      subject.wait_until_exists(at.button(1)).should == at.button(1)
+      expect(subject.wait_until_exists(at.button(1))).to eq at.button(1)
     end
       
     it "Should be able to wait until multiple locations exists and return the one that happened" do
       expect_exists?(at.button(1)).and_return(false, false, false)
       expect_exists?(at.sheet(5)).and_return(false, false, true)
-      subject.wait_until_exists!(at.button(1), at.sheet(5)).should == at.sheet(5)
+      expect(subject.wait_until_exists!(at.button(1), at.sheet(5))).to eq at.sheet(5)
     end
 
     it "Should be able to wait until multiple locations exists and return the one that happened (with activate)" do
       expect_activate
       expect_exists?(at.button(1)).and_return(false, false)
       expect_exists?(at.sheet(5)).and_return(false, true)
-      subject.wait_until_exists(at.button(1), at.sheet(5)).should == at.sheet(5)
+      expect(subject.wait_until_exists(at.button(1), at.sheet(5))).to eq at.sheet(5)
     end
     
     it "Should be able to wait for one location to NOT exist" do
       expect_not_exists?(at.button(1)).and_return(false, false, true)
-      subject.wait_until_not_exists!(at.button(1)).should == at.button(1)      
+      expect(subject.wait_until_not_exists!(at.button(1))).to eq at.button(1)      
     end
 
     it "Should be able to wait for one location to NOT exist (with activate)" do
       expect_activate
       expect_not_exists?(at.button(4)).and_return(false, true)
-      subject.wait_until_not_exists(at.button(4)).should == at.button(4)      
+      expect(subject.wait_until_not_exists(at.button(4))).to eq at.button(4)      
     end
     
     it "Should be able to loop over some script until something happens" do
-      Timeout.should_receive(:timeout).with(5).and_yield
+      expect(Timeout).to receive(:timeout).with(10).and_yield
       expect_execute_osascript.and_return("false", "false", "true")
       expect_activate.twice
       
@@ -180,8 +179,13 @@ describe "Osaka::RemoteControl" do
     end
     
     it "Should print a proper error message when it times out while waiting for something" do
-      Timeout.should_receive(:timeout).with(5).and_raise(Timeout::Error.new)
-      expect { subject.until_exists!(at.window(1)) }.to raise_error(Osaka::TimeoutError, "Timed out while waiting for: [window 1]")
+      expect(Timeout).to receive(:timeout).with(10).and_raise(Timeout::Error.new)
+      expect { subject.until_exists!(at.window(1)) }.to raise_error(Osaka::TimeoutError, "Timed out while waiting for: window 1")
+    end
+
+    it "Should print a proper error message when it times out while waiting for more than one thing" do
+      expect(Timeout).to receive(:timeout).with(10).and_raise(Timeout::Error.new)
+      expect { subject.until_exists!(at.window(1), at.button(2)) }.to raise_error(Osaka::TimeoutError, "Timed out while waiting for: window 1, button 2")
     end
   end
 
@@ -290,7 +294,7 @@ describe "Osaka::RemoteControl" do
   end
   
   context "Control should be able to set and get different application values" do
-
+  
     it "Should be able to set a value to an element" do
       expect_system_event!(/set value of window 1 to "newvalue"/).and_return("")
       subject.set!("value", at.window(1), "newvalue")
@@ -308,24 +312,24 @@ describe "Osaka::RemoteControl" do
 
     it "Should be able to get a value from an element" do
       expect_system_event!(/get value of window 1/).and_return("1\n")
-      subject.get!("value", at.window(1)).should == "1"
+      expect(subject.get!("value", at.window(1))).to eq "1"
     end
 
     it "Should use the locally stored window when that one is set." do
       subject.set_current_window("1")
       expect_system_event!(/get value of window \"1\"/).and_return("1\n")
-      subject.get!("value").should == "1"
+      expect(subject.get!("value")).to eq "1"
     end
 
     it "Should combine the location and the window" do
       subject.set_current_window("1")
       expect_system_event!(/get value of dialog 2 of window "1"/).and_return("1\n")
-      subject.get!("value", at.dialog(2)).should == "1"    
+      expect(subject.get!("value", at.dialog(2))).to eq "1"    
     end
 
     it "Should be able to get values from the application itself" do
       expect_system_event!("get value").and_return("1\n")
-      subject.get_app!("value").should == "1"
+      expect(subject.get_app!("value")).to eq "1"
     end
 
     it "Should be able to set a value and activate" do
@@ -336,22 +340,40 @@ describe "Osaka::RemoteControl" do
 
     it "Should be able to get an empty array when requesting for the window list and there are none" do
       expect_get_app!("windows").and_return("\n")
-      subject.window_list.should == []
+      expect(subject.window_list).to eq []
     end
 
     it "Should be able get an array with one window name when there is exactly one window" do
       expect_get_app!("windows").and_return("window one of application process process\n")
-      subject.window_list.should == ["one"]    
+      expect(subject.window_list).to eq ["one"]    
+    end
+    
+    it "Should be able to get a list of standard windows which is empty" do
+      expect(subject).to receive(:window_list).and_return([])
+      subject.standard_window_list
+    end
+    
+    it "Should be able to get a list of all the standard windows when there are only standard windows " do
+      expect(subject).to receive(:window_list).and_return(["window 1"])
+      expect_get!("subrole", at.window("window 1")).and_return("AXStandardWindow")
+      expect(subject.standard_window_list).to eq ["window 1"]
+    end
+    
+    it "Should be able to get a list of all the standard windows excluding the floating ones" do
+      expect(subject).to receive(:window_list).and_return(["window", "float"])
+      expect_get!("subrole", at.window("window")).and_return("AXStandardWindow")
+      expect_get!("subrole", at.window("float")).and_return("AXFloatingWindow")
+      expect(subject.standard_window_list).to eq ["window"]      
     end
     
     it "Should be able to get the attributes of a window and parse the result" do
       expect_get!("attributes", at.window(1)).and_return("attribute AXRole of window 1 of application process ApplicationName, attribute AXRoleDescription of window 1 of application process ApplicationName, attribute AXSubrole of window 1 of application process ApplicationName")
-      subject.attributes(at.window(1)).should == ["AXRole", "AXRoleDescription", "AXSubrole"]
+      expect(subject.attributes(at.window(1))).to eq ["AXRole", "AXRoleDescription", "AXSubrole"]
     end
 
     it "Should be able to get the attributes of the application too" do
     expect_get!("attributes", at.window(1)).and_return("attribute AXRole of application process ApplicationName, attribute AXRoleDescription of application process ApplicationName")
-      subject.attributes(at.window(1)).should == ["AXRole", "AXRoleDescription"]
+      expect(subject.attributes(at.window(1))).to eq ["AXRole", "AXRoleDescription"]
     end
     
   end
@@ -360,12 +382,12 @@ describe "Osaka::RemoteControl" do
 
     it "Should be possible to pass a base location in the creation" do
       subject = Osaka::RemoteControl.new("Application", at.window("Window"))
-      subject.base_location.should == at.window("Window")
+      expect(subject.base_location).to eq at.window("Window")
     end
 
     it "Should be able to get an array of multiple window names" do
       expect_get_app!("windows").and_return("window one of application process process, window two of application process process\n")
-      subject.window_list.should == ["one", "two"]    
+      expect(subject.window_list).to eq ["one", "two"]    
     end
     
     it "Should be able to focus the currently active window" do
@@ -378,12 +400,12 @@ describe "Osaka::RemoteControl" do
       expect_window_list.and_return(["1"])
       expect_focus!
       subject.focus
-      subject.current_window_name.should == "1"
+      expect(subject.current_window_name).to eq "1"
     end
     
     it "Should be able to extract the current window name also when the base location has more than just a window " do
       subject.base_location = at.sheet(1).window("Window")
-      subject.current_window_name.should == "Window"      
+      expect(subject.current_window_name).to eq "Window"      
     end
 
     it "Shouldn't initialize current window when it is already set" do
@@ -392,7 +414,7 @@ describe "Osaka::RemoteControl" do
       expect_focus!
       
       subject.focus
-      subject.base_location.should == at.window("1")
+      expect(subject.base_location).to eq at.window("1")
     end
     
     it "Should re-initialize the current window when it doesn't exist anymore" do
@@ -402,7 +424,7 @@ describe "Osaka::RemoteControl" do
       expect_focus!
             
       subject.focus
-      subject.current_window_name.should == "2"    
+      expect(subject.current_window_name).to eq "2"    
     end
 
     it "Should focus the current window when it doesn't have focus" do
@@ -418,4 +440,4 @@ describe "Osaka::RemoteControl" do
     end
     
   end 
-end
+end

data/spec/scriptrunner_spec.rb

@@ -5,73 +5,73 @@ describe "Osaka::ScriptRunner" do
   subject { Osaka::ScriptRunner }
 
   it "Should be able to run single-line text as osascript" do
-    subject.should_receive(:do_system).with('osascript -e "random number"').and_return("")
-    subject.execute("random number").should == ""
+    expect(Osaka::CommandRunner).to receive(:run).with('osascript -e "random number"').and_return("")
+    expect(subject.execute("random number")).to eq ""
   end
   
   it "Should escape quotes when passing text" do
-    subject.should_receive(:do_system).with('osascript -e "say \\"hello\\""').and_return("")
+    expect(Osaka::CommandRunner).to receive(:run).with('osascript -e "say \\"hello\\""').and_return("")
     subject.execute('say "hello"')
   end
   
   it "Should be able to run on debug printing" do
-    subject.should_receive(:do_system).and_return("Blah blah blah")
-    subject.should_receive(:puts).with('Executing: osascript -e "random number"')
-    subject.should_receive(:puts).with('Output was: Blah blah blah')
+    expect(Osaka::CommandRunner).to receive(:run).and_return("Blah blah blah")
+    expect(subject).to receive(:puts).with('Executing: osascript -e "random number"')
+    expect(subject).to receive(:puts).with('Output was: Blah blah blah')
     Osaka::ScriptRunner::enable_debug_prints
     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>')
+    expect(Osaka::CommandRunner).to receive(:run).and_return("Blah blah blah")
+    expect(subject).to receive(:puts).with('random number<br>')
+    expect(subject).to 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 be able to generate a script of the run for later debugging purposes" do
-    subject.should_receive(:do_system).and_return("Blah blah blah")
-    file = mock("Mocked output file")
-    File.should_receive(:open).with("output_script", File::WRONLY|File::APPEND|File::CREAT, 0755).and_yield(file)
-    file.should_receive(:puts).with("osascript -e \"random number\"")
+    expect(Osaka::CommandRunner).to receive(:run).and_return("Blah blah blah")
+    file = double("Mocked output file")
+    expect(File).to receive(:open).with("output_script", File::WRONLY|File::APPEND|File::CREAT, 0755).and_yield(file)
+    expect(file).to receive(:puts).with("osascript -e \"random number\"")
     Osaka::ScriptRunner.enable_debug_prints(:script, "output_script")
     subject.execute("random number")
     Osaka::ScriptRunner::disable_debug_prints
   end
   
   it "Should explain how to turn on the access for assistive devices when it is disabled... and exit" do
-    subject.should_receive(:do_system).and_raise(Osaka::SystemCommandFailed.new ("execution error: System Events got an error: Access for assistive devices is disabled. (-25211)"))
-    subject.should_receive(:puts).with(/system preferences/)
-    subject.should_receive(:exit)
+    expect(Osaka::CommandRunner).to receive(:run).and_raise(Osaka::SystemCommandFailed.new ("execution error: System Events got an error: Access for assistive devices is disabled. (-25211)"))
+    expect(subject).to receive(:puts).with(/system preferences/)
+    expect(subject).to receive(:exit)
     subject.execute("anything")
   end
     
   it "Should not print any debugging information by default " do
-    subject.should_receive(:do_system).and_return("")
-    subject.should_not_receive(:puts)
+    expect(Osaka::CommandRunner).to receive(:run).and_return("")
+    expect(subject).not_to receive :puts
     subject.execute("random number")
   end
   
   it "Should be able to define multi-line statements using ; as a separator" do
-    subject.should_receive(:do_system).with('osascript -e "tell application \\"Calculator\\"" -e "activate" -e "end tell"').and_return("")
+    expect(Osaka::CommandRunner).to receive(:run).with('osascript -e "tell application \\"Calculator\\"" -e "activate" -e "end tell"').and_return("")
     subject.execute('tell application "Calculator"; activate; end tell')
   end
   
   it "Should raise an exception witha proper error message when the applescript fails" do
-    subject.should_receive(:do_system).and_raise(Osaka::SystemCommandFailed.new("Message"))
+    expect(Osaka::CommandRunner).to receive(:run).and_raise(Osaka::SystemCommandFailed.new("Message"))
     expect {subject.execute("Fuck off!")}.to raise_error(Osaka::ScriptRunnerError, "Error received while executing: \"Fuck off!\" with message \"Message\"")
   end
   
   it "Should be able to execute an file containing applescript" do
-    subject.should_receive(:do_system).with('osascript script.scpt').and_return(true)
+    expect(Osaka::CommandRunner).to receive(:run).with('osascript script.scpt').and_return(true)
     subject.execute_file("script.scpt")
   end
   
   it "Should be able to pass parameters to an applescript" do
-    subject.should_receive(:do_system).with('osascript script.scpt a b c').and_return(true)
+    expect(Osaka::CommandRunner).to receive(:run).with('osascript script.scpt a b c').and_return(true)
     subject.execute_file("script.scpt", "a b c")    
   end
   

data/spec/textedit_spec.rb

@@ -7,7 +7,7 @@ describe "TextEdit" do
 
   subject { Osaka::TextEdit.new }
 
-  let(:control) { subject.control = mock("RemoteControl") }
+  let(:control) { subject.control = double("RemoteControl") }
 
   it "Should be able to type some text" do
     expect_keystroke('Hello World')
@@ -16,7 +16,7 @@ describe "TextEdit" do
   
   it "Should be able to get the text from the document" do
     expect_get!("value", 'text area 1 of scroll area 1').and_return("Hello")
-    subject.text.should == "Hello"
+    expect(subject.text).to eq "Hello"
   end
 
-end
+end

data/spec/typicalapplication_spec.rb

@@ -4,110 +4,110 @@ require 'osaka'
 describe "Osaka::TypicalApplication" do
 
   include(*Osaka::OsakaExpectations)
-  
+
   subject { Osaka::TypicalApplication.new("ApplicationName") }
-  
-  let(:control) { subject.control = mock("RemoteControl", :name => "ApplicationName", :base_location => "base", :mac_version => :mountain_lion) }
+
+  let(:control) { subject.control = double("RemoteControl", :name => "ApplicationName", :base_location => "base", :mac_version => :mountain_lion) }
 
   before (:each) do
     Osaka::ScriptRunner.enable_debug_prints
   end
-  
+
   after (:each) do
     Osaka::ScriptRunner.disable_debug_prints
   end
-  
+
   it "Should be able to do something and wait until a new window pops up" do
     expect_window_list.and_return(["original window"], ["original window"], ["original window"], ["new window", "original window"])
     expect_activate
     code_block_called = false
-    subject.do_and_wait_for_new_window {
+    expect(subject.do_and_wait_for_new_window {
       code_block_called = true
-    }.should == "new window"
-    code_block_called.should == true
+    }).to eq "new window"
+    expect(code_block_called).to eq true
   end
-  
+
   context "Cloning and copying" do
-    
+
     it "Should be able to clone TypicalApplications" do
       expect_clone
-      subject.clone    
+      subject.clone
     end
-  
+
     it "Should be able to clone the typical applications and the remote controls will be different" do
       subject.control.set_current_window "Original"
       new_instance = subject.clone
       new_instance.control.set_current_window "Clone"
-      subject.control.current_window_name.should == "Original"
+      expect(subject.control.current_window_name).to eq "Original"
     end
-  
+
   end
-  
+
   context "Opening and new document" do
-    
+
     it "Should pass the right open string to the application osascript" do
       filename = "filename.key"
       expect_tell("open \"#{File.absolute_path(filename)}\"")
-      subject.stub(:do_and_wait_for_new_window).and_yield.and_return(filename)
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return(filename)
       expect_set_current_window(filename)
-      subject.open(filename)    
+      subject.open(filename)
     end
 
     it "Should only get the basename of the filename when it sets the window title." do
       filename = "/root/dirname/filename.key"
-      subject.should_receive(:do_and_wait_for_new_window).and_return("filename")
+      expect(subject).to receive(:do_and_wait_for_new_window).and_return("filename")
       expect_set_current_window("filename")
-      subject.open(filename)        
+      subject.open(filename)
     end
-    
+
     it "Should be able to create a new document" do
-      subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("new_window")    
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("new_window")
       expect_keystroke("n", :command)
       expect_set_current_window("new_window")
       expect_focus
       subject.new_document
     end
-    
+
     it "Should be able to easily create a document, put something, save it, and close it again" do
 
-      subject.should_receive(:new_document)
-      subject.should_receive(:method_call_from_code_block)
-      subject.should_receive(:save_as).with("filename")
-      subject.should_receive(:close)
+      expect(subject).to receive(:new_document)
+      expect(subject).to receive(:method_call_from_code_block)
+      expect(subject).to receive(:save_as).with("filename")
+      expect(subject).to receive(:close)
 
       subject.create_document("filename") { |doc|
         doc.method_call_from_code_block
       }
     end
-    
+
   end
-  
+
   context "Quiting and closing and checking whether the app is still running" do
-  
+
     it "Should be able to quit" do
       expect_running?.and_return(true)
       expect_quit
       subject.quit
     end
-  
+
     it "Should be able to check if its running" do
       expect_running?.and_return(true)
-      subject.running?.should be_true
+      expect(subject.running?).to be true
     end
-  
+
     it "Won't quit when the application isn't running" do
       expect_running?.and_return(false)
-      subject.quit(:dont_save)  
+      subject.quit(:dont_save)
     end
-  
+
     it "Should be able to quit without saving" do
       expect_running?.and_return(true, true, false)
       expect_quit
       expect_exists?(at.sheet(1)).and_return(true)
       expect_click!(at.button("Don’t Save").sheet(1))
-      subject.quit(:dont_save)  
+      subject.quit(:dont_save)
     end
-    
+
     it "Should be able to close" do
       expect_keystroke("w", :command)
       subject.close
@@ -115,120 +115,120 @@ describe "Osaka::TypicalApplication" do
 
     it "Should be able to close and don't save" do
       expect_keystroke("w", :command)
-      subject.should_receive(:wait_for_window_and_dialogs_to_close).with(:dont_save)
+      expect(subject).to receive(:wait_for_window_and_dialogs_to_close).with(:dont_save)
       subject.close(:dont_save)
     end
-    
+
   end
-  
+
   context "Save and duplicate documents" do
-    
-    let(:save_dialog) { mock("Typical Save Dialog") }
-    let(:new_instance_control) { mock("RemoteControl") }
-    
+
+    let(:save_dialog) { double("Typical Save Dialog") }
+    let(:new_instance_control) { double("RemoteControl") }
+
     it "Should be able to save" do
       expect_keystroke("s", :command)
       subject.save
     end
 
     it "Should be able to save as a file without duplicate being available" do
-      subject.should_receive(:save_pops_up_dialog?).and_return(false)
-      subject.should_receive(:duplicate_available?).and_return(false)
-      
+      expect(subject).to receive(:save_pops_up_dialog?).and_return(false)
+      expect(subject).to receive(:duplicate_available?).and_return(false)
+
       expect_keystroke("s", [:command, :shift])
-      subject.should_receive(:wait_for_save_dialog_and_save_file).with("filename")
-      
+      expect(subject).to receive(:wait_for_save_dialog_and_save_file).with("filename")
+
       subject.save_as("filename")
     end
 
     it "Should be able to save as a file using the duplicate..." do
-      subject.should_receive(:save_pops_up_dialog?).and_return(false)
-      subject.should_receive(:duplicate_available?).and_return(true)
+      expect(subject).to receive(:save_pops_up_dialog?).and_return(false)
+      expect(subject).to receive(:duplicate_available?).and_return(true)
 
-      subject.should_receive(:duplicate_and_close_original)
-      subject.should_receive(:save)
-      subject.should_receive(:wait_for_save_dialog_and_save_file).with("filename")      
+      expect(subject).to receive(:duplicate_and_close_original)
+      expect(subject).to receive(:save)
+      expect(subject).to receive(:wait_for_save_dialog_and_save_file).with("filename")
       subject.save_as("filename")
     end
-    
+
     it "Should be able to use normal Save when that pops up a dialog instead of save_as" do
-      subject.should_receive(:save_pops_up_dialog?).and_return(true)
-      subject.should_receive(:save)
-      subject.should_receive(:wait_for_save_dialog_and_save_file).with("filename")      
+      expect(subject).to receive(:save_pops_up_dialog?).and_return(true)
+      expect(subject).to receive(:save)
+      expect(subject).to receive(:wait_for_save_dialog_and_save_file).with("filename")
       subject.save_as("filename")
     end
-    
+
     it "Should be able to wait for a save dialog and save the file" do
       expect_wait_until_exists(at.sheet(1))
-      subject.should_receive(:create_dialog).with(Osaka::TypicalSaveDialog, at.sheet(1)).and_return(save_dialog)
-      save_dialog.should_receive(:save).with("/tmp/filename")
+      expect(subject).to receive(:create_dialog).with(Osaka::TypicalSaveDialog, at.sheet(1)).and_return(save_dialog)
+      expect(save_dialog).to receive(:save).with("/tmp/filename")
       expect_set_current_window("filename")
       subject.wait_for_save_dialog_and_save_file("/tmp/filename")
     end
-    
+
     it "Should be able to pick a file from an open dialog" do
-      dialog_mock = mock("Open Dialog")
-      subject.should_receive(:create_dialog).with(Osaka::TypicalOpenDialog, at.window("dialog")).and_return(dialog_mock)
-      dialog_mock.should_receive(:set_folder).with("/tmp")
-      dialog_mock.should_receive(:select_file).with("filename")
-      
+      dialog_mock = double("Open Dialog")
+      expect(subject).to receive(:create_dialog).with(Osaka::TypicalOpenDialog, at.window("dialog")).and_return(dialog_mock)
+      expect(dialog_mock).to receive(:set_folder).with("/tmp")
+      expect(dialog_mock).to receive(:select_file).with("filename")
+
       subject.select_file_from_open_dialog("/tmp/filename", at.window("dialog"))
     end
-    
-    
+
+
     it "Should be able to duplicate and close the original document" do
-      subject.stub_chain(:duplicate, :control).and_return(new_instance_control)
-      subject.should_receive(:close)
+      allow(subject).to receive_message_chain(:duplicate, :control).and_return(new_instance_control)
+      expect(subject).to receive(:close)
       subject.duplicate_and_close_original
-      subject.control.should equal(new_instance_control)
+      expect(subject.control).to eq(new_instance_control)
     end
-    
+
     it "Should be able to check whether Duplicate is supported" do
       expect_exists?(at.menu_item("Duplicate").menu(1).menu_bar_item("File").menu_bar(1)).and_return(true)
-      subject.duplicate_available?.should == true
+      expect(subject.duplicate_available?).to eq true
     end
-  
+
     it "Should throw an exception when duplicate is not available"do
-      subject.should_receive(:duplicate_available?).and_return(false)
+      expect(subject).to receive(:duplicate_available?).and_return(false)
       expect {subject.duplicate}.to raise_error(Osaka::VersioningError, "MacOS Versioning Error: Duplicate is not available on this Mac version")
     end
 
     it "Should return a new keynote instance variable after duplication (Lion!)" do
       simulate_mac_version(:lion)
-      subject.should_receive(:duplicate_available?).and_return(true)
-      
+      expect(subject).to receive(:duplicate_available?).and_return(true)
+
       expect_click_menu_bar(at.menu_item("Duplicate"), "File")
-      subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("duplicate window")
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("duplicate window")
 
-      subject.stub_chain(:clone, :control).and_return(new_instance_control)
-      subject.duplicate.control.should equal(new_instance_control)
+      allow(subject).to receive_message_chain(:clone, :control).and_return(new_instance_control)
+      expect(subject.duplicate.control).to eq(new_instance_control)
     end
-  
+
     it "Should return a new keynote instance variable after duplication" do
-      subject.should_receive(:duplicate_available?).and_return(true)
+      expect(subject).to receive(:duplicate_available?).and_return(true)
 
       expect_click_menu_bar(at.menu_item("Duplicate"), "File")
-      subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("duplicate window", "New name duplicate window")
+      expect(subject).to receive(:do_and_wait_for_new_window).and_yield.and_return("duplicate window", "New name duplicate window")
 
-      subject.stub_chain(:clone, :control).and_return(new_instance_control)
-      subject.should_receive(:sleep).with(0.4) # Avoiding Mountain Lion crash
+      allow(subject).to receive_message_chain(:clone, :control).and_return(new_instance_control)
+      expect(subject).to receive(:sleep).with(0.4) # Avoiding Mountain Lion crash
       expect_keystroke!(:return)
-      new_instance_control.should_receive(:set_current_window).with("New name duplicate window")
-      subject.duplicate.control.should equal(new_instance_control)
+      expect(new_instance_control).to receive(:set_current_window).with("New name duplicate window")
+      expect(subject.duplicate.control).to eq(new_instance_control)
     end
-    
+
     it "Should be able to check whether the save will pop up a dialog or not" do
       expect_exists?(at.menu_item("Save…").menu(1).menu_bar_item("File").menu_bar(1)).and_return(true)
-      subject.save_pops_up_dialog?.should == true
+      expect(subject.save_pops_up_dialog?).to eq true
     end
-    
+
   end
-    
+
   it "Should be able to activate" do
     expect_activate
     subject.activate
   end
-  
+
   it "Should be able to activate and launch. This is done because activate alone in Lion lead to strange behavior" do
     simulate_mac_version(:lion)
     expect_running?.and_return(false)
@@ -236,12 +236,12 @@ describe "Osaka::TypicalApplication" do
     expect_activate
     subject.activate
   end
-  
+
   it "Should be able to focus" do
     expect_focus
     subject.focus
   end
-  
+
   context "Copy pasting" do
 
     it "Should be able to copy" do
@@ -251,16 +251,16 @@ describe "Osaka::TypicalApplication" do
 
     it "Should be able to paste" do
       expect_keystroke("v", :command)
-      subject.paste  
+      subject.paste
     end
 
     it "Should be able to cut" do
       expect_keystroke("x", :command)
       subject.cut
     end
-    
+
   end
-    
+
   context "Selecting things" do
     it "Should be able to select all" do
       expect_keystroke("a", :command)
@@ -269,33 +269,44 @@ describe "Osaka::TypicalApplication" do
   end
 
   context "Printing" do
-    
+
     it "Should be able to retrieve a print dialog" do
       expect_keystroke("p", :command)
       expect_wait_until_exists(at.sheet(1))
       subject.print_dialog
     end
   end
-    
+
   context "Application info" do
     it "Should be able to retrieve an application info object and parse it" do
       expect_tell('get info for (path to application "ApplicationName")').and_return('name:ApplicationName.app, creation date:date "Sunday, December 21, 2008 PM 06:14:11"}')
       app_info = subject.get_info
-      app_info.name.should == "ApplicationName.app"
+      expect(app_info.name).to eq "ApplicationName.app"
     end
   end
-  
+
   context "Simple Application helpers to create objects" do
     it "Should be able to create dialogs with a helper" do
-      Osaka::TypicalSaveDialog.should_receive(:new).with(control.name, at.sheet(1) + control.base_location)
+      expect(Osaka::TypicalSaveDialog).to receive(:new).with(control.name, at.sheet(1) + control.base_location)
       subject.create_dialog(Osaka::TypicalSaveDialog, at.sheet(1))
     end
-    
+
     it "Should be able to create top level dialogs also with the helper" do
-      Osaka::TypicalSaveDialog.should_receive(:new).with(control.name, at.window("toplevel"))
+      expect(Osaka::TypicalSaveDialog).to receive(:new).with(control.name, at.window("toplevel"))
       subject.create_dialog(Osaka::TypicalSaveDialog, at.window("toplevel"))
     end
   end
-  
-  
-end
+
+  it "Should be able to check whether any standard windows are open and do nothing if there aren't" do
+    expect_standard_window_list.and_return([])
+    subject.raise_error_on_open_standard_windows("error message")
+  end
+
+  it "Should be able to check whether any standard windows are open and raise an error if so" do
+    expect_standard_window_list.and_return(["Window"])
+    expect {
+      subject.raise_error_on_open_standard_windows("error message")
+    }.to raise_error(Osaka::ApplicationWindowsMustBeClosed, "error message")
+  end
+
+end