osaka 0.3.2 → 0.4.0

data/spec/typicalapplication_spec.rb

@@ -3,12 +3,12 @@ require 'osaka'
 
 describe "Osaka::TypicalApplication" do
 
-  include(*Osaka::ApplicationWrapperExpectations)
+  include(*Osaka::OsakaExpectations)
   
   subject { Osaka::TypicalApplication.new("ApplicationName") }
   
-  let(:wrapper) { subject.wrapper = double("Osaka::ApplicationWrapper") }
-  
+  let(:control) { subject.control = mock("RemoteControl", :name => "ApplicationName", :base_location => "", :mac_version => :mountain_lion) }
+
   before (:each) do
     Osaka::ScriptRunner.enable_debug_prints
   end
@@ -17,57 +17,6 @@ describe "Osaka::TypicalApplication" do
     Osaka::ScriptRunner.disable_debug_prints
   end
   
-  it "Should be able to clone TypicalApplications" do
-    expect_clone
-    subject.clone    
-  end
-  
-  it "Should pass the right open string to the application osascript" do
-    filename = "filename.key"
-    expect_tell("open \"#{File.absolute_path(filename)}\"")
-    expect_set_current_window(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"
-    expect_tell("open \"#{File.absolute_path(filename)}\"")
-    expect_set_current_window("filename.key")
-    subject.open(filename)        
-  end
-  
-  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 == true
-  end
-  
-  it "Won't quit when the application isn't running" do
-    expect_running?.and_return(false)
-    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)  
-  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_keystroke("n", :command)
-    expect_set_current_window("new_window")
-    expect_focus
-    subject.new_document
-  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
@@ -77,208 +26,233 @@ describe "Osaka::TypicalApplication" do
     }.should == "new window"
     code_block_called.should == true
   end
-    
-  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(:duplicate_available?).and_return(false)
-    save_dialog = double("Osaka::TypicalSaveDialog")
-    subject.should_receive(:save_dialog).and_return(save_dialog)
-    save_dialog.should_receive(:save).with("filename")
-    expect_set_current_window("filename")
-    subject.save_as("filename")
-  end
-
-  it "Should be able to save as a file using the duplicate..." do
-    new_instance = mock(:TypicalApplication)
-    new_instance_wrapper = mock(:ApplicationWrapper)
-    save_dialog = double("Osaka::TypicalSaveDialog").as_null_object
-
-    subject.should_receive(:duplicate_available?).and_return(true)
-    subject.should_receive(:duplicate).and_return(new_instance)
-    new_instance.should_receive(:wrapper).and_return(new_instance_wrapper)
-    new_instance_wrapper.should_receive(:clone).and_return(wrapper)
+  context "Cloning and copying" do
     
-    subject.should_receive(:close)
-    subject.should_receive(:save_dialog).and_return(save_dialog)
-    expect_set_current_window("filename")
-    subject.save_as("filename")    
-  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
-  end
+    it "Should be able to clone TypicalApplications" do
+      expect_clone
+      subject.clone    
+    end
   
-  it "Should throw an exception when duplicate is not available"do
-    subject.should_receive(:duplicate_available?).and_return(false)
-    lambda {subject.duplicate}.should raise_error(Osaka::VersioningError, "MacOS Versioning Error: Duplicate is not available on this Mac version")
-  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"
+    end
   
-  it "Should return a new keynote instance variable after duplication" do
-    new_instance = mock(:TypicalApplication)
-    subject.should_receive(:duplicate_available?).and_return(true)
-    subject.should_receive(:do_and_wait_for_new_window).and_yield.and_return("duplicate window", "New name duplicate window")
-    expect_keystroke("s", [:command, :shift])  
-    subject.should_receive(:clone).and_return(new_instance)
-    new_instance.should_receive(:wrapper).and_return(wrapper)
-    subject.should_receive(:sleep).with(0.4) # Avoiding Mountain Lion crash
-    expect_keystroke!(:return)
-    expect_set_current_window("New name duplicate window")
-    subject.duplicate.should == new_instance
+    it "Should pass the right open string to the application osascript" do
+      filename = "filename.key"
+      expect_tell("open \"#{File.absolute_path(filename)}\"")
+      expect_set_current_window(filename)
+      subject.open(filename)    
+    end
   end
   
-  it "Should be able to close" do
-    expect_keystroke("w", :command)
-    subject.close
+  context "Opening and new document" do
+    
+    it "Should only get the basename of the filename when it sets the window title." do
+      filename = "/root/dirname/filename.key"
+      expect_tell("open \"#{File.absolute_path(filename)}\"")
+      expect_set_current_window("filename.key")
+      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_keystroke("n", :command)
+      expect_set_current_window("new_window")
+      expect_focus
+      subject.new_document
+    end
+    
   end
   
-  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)
-    subject.close(:dont_save)
-  end
+  context "Quiting and closing and checking whether the app is still running" do
   
-  it "Should be able to activate" do
-    expect_activate
-    subject.activate
-  end
+    it "Should be able to quit" do
+      expect_running?.and_return(true)
+      expect_quit
+      subject.quit
+    end
   
-  it "Should be able to focus" do
-    expect_focus
-    subject.focus
-  end
+    it "Should be able to check if its running" do
+      expect_running?.and_return(true)
+      subject.running?.should be_true
+    end
   
-  it "Should be able to copy" do
-    expect_keystroke("c", :command)
-    subject.copy
-  end
+    it "Won't quit when the application isn't running" do
+      expect_running?.and_return(false)
+      subject.quit(:dont_save)  
+    end
   
-  it "Should be able to paste" do
-    expect_keystroke("v", :command)
-    subject.paste  
-  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)  
+    end
+    
+    it "Should be able to close" do
+      expect_keystroke("w", :command)
+      subject.close
+    end
 
-  it "Should be able to cut" do
-    expect_keystroke("x", :command)
-    subject.cut
-  end
-  
-  it "Should be able to select all" do
-    expect_keystroke("a", :command)
-    subject.select_all
-  end
-  
-  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
-  
-  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
-  end
-  
-  it "Should be able to retrieve a save dialog by using save as" do
-    subject.should_receive(:save_pops_up_dialog?).and_return(false)
-    expect_keystroke("s", [:command, :shift])
-    expect_wait_until_exists(at.sheet(1))
-    subject.save_dialog    
-  end
-  
-  it "Should be able to retrieve a save dialog using duplicate and save" do
-    subject.should_receive(:save_pops_up_dialog?).and_return(true)
-    subject.should_receive(:save)
-    expect_wait_until_exists(at.sheet(1))
-    subject.save_dialog
-  end
-  
-  describe "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"
+    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)
+      subject.close(:dont_save)
     end
+    
   end
   
-  describe "Generic Print Dialog" do
+  context "Save and duplicate documents" do
     
-    subject { Osaka::TypicalPrintDialog.new(at.sheet(1), double(:OSAApp).as_null_object) }
-
-    it "Should be able to save the PDF in a print dialog" do
-      save_dialog_mock = double(:GenericSaveDialog)
+    let(:save_dialog) { mock("Typical Save Dialog") }
+    let(:new_instance_control) { mock("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(:duplicate_available?).and_return(false)
       
-      expect_click!(at.menu_button("PDF").sheet(1)) 
-      expect_wait_until_exists!(at.menu(1).menu_button("PDF").sheet(1))
+      subject.should_receive(:save_dialog).and_return(save_dialog)
+      save_dialog.should_receive(:save).with("filename")
+      expect_set_current_window("filename")
       
-      expect_click!(at.menu_item(2).menu(1).menu_button("PDF").sheet(1))
-      expect_wait_until_exists!(at.window("Save"), at.sheet(1).window("Print")).and_return(at.window("Save"))
+      subject.save_as("filename")
+    end
+
+    it "Should be able to save as a file using the duplicate..." do
+      subject.should_receive(:duplicate_available?).and_return(true)
 
-      subject.should_receive(:create_save_dialog).with(at.window("Save"), subject.wrapper).and_return(save_dialog_mock)
-      save_dialog_mock.should_receive(:save).with("filename")
+      subject.stub_chain(:duplicate, :control, :clone).and_return(new_instance_control)
+      subject.should_receive(:close)
+      subject.stub_chain(:save_dialog, :save)
+      new_instance_control.should_receive(:set_current_window).with("filename")
       
-      expect_until_not_exists!(at.sheet(1))
-      expect_exists(at.checkbox(1).sheet(1)).and_return(true)
-      expect_click!(at.checkbox(1).sheet(1))
+      subject.save_as("filename")
+      subject.control.should equal(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
+    end
+  
+    it "Should throw an exception when duplicate is not available"do
+      subject.should_receive(:duplicate_available?).and_return(false)
+      lambda {subject.duplicate}.should 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)
       
-      subject.save_as_pdf("filename")
+      expect_click_menu_bar(at.menu_item("Duplicate"), "File")
+      subject.should_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)
     end
-  end
   
-  describe "Generic Save Dialog" do
-    
-    subject { Osaka::TypicalSaveDialog.new(at.sheet(1), double("Osaka::ApplicationWrapper").as_null_object)}
-    
-    it "Should clone the wrapper and change the window name to Save" do
-      app_wrapper = double("Osaka::ApplicationWrapper")
-      app_cloned_wrapper = double("Osaka::ApplicationWrapper")
-      app_wrapper.should_receive(:clone).and_return(app_cloned_wrapper)
-      Osaka::TypicalSaveDialog.new(at.sheet(1), app_wrapper)
+    it "Should return a new keynote instance variable after duplication" do
+      subject.should_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")
+
+      subject.stub_chain(:clone, :control).and_return(new_instance_control)
+      subject.should_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)
     end
     
-    it "Should set the filename in the test field" do
-      subject.should_receive(:set_filename).with("filename")
-      subject.should_receive(:click_save)
-      subject.should_not_receive(:set_folder)
-      subject.save("filename")
+    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
     end
-    
-    it "Should pick only the base filename when a path is given" do
-      subject.should_receive(:set_filename).with("filename")
-      subject.should_receive(:set_folder)
-      subject.should_receive(:click_save)
-      subject.save("/path/filename")
+
+    it "Should be able to retrieve a save dialog by using save as" do
+      subject.should_receive(:save_pops_up_dialog?).and_return(false)
+      expect_keystroke("s", [:command, :shift])
+      expect_wait_until_exists(at.sheet(1))
+      subject.save_dialog    
     end
+
+    it "Should be able to retrieve a save dialog using duplicate and save" do
+      subject.should_receive(:save_pops_up_dialog?).and_return(true)
+      subject.should_receive(:save)
+      expect_wait_until_exists(at.sheet(1))
+      subject.save_dialog
+    end
+    
+  end
     
-    it "Should set the path when a full path is given" do
-      wrapper.as_null_object
-      subject.should_receive(:set_filename)
-      subject.should_receive(:set_folder).with("/path/second")
-      subject.save("/path/second/name")
+  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)
+    expect_launch
+    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
+      expect_keystroke("c", :command)
+      subject.copy
+    end
+
+    it "Should be able to paste" do
+      expect_keystroke("v", :command)
+      subject.paste  
+    end
+
+    it "Should be able to cut" do
+      expect_keystroke("x", :command)
+      subject.cut
     end
     
-    it "Should be able to click save" do
-      expect_click(at.button("Save").sheet(1))
-      expect_wait_until_not_exists(at.sheet(1))
-      subject.click_save
+  end
+    
+  context "Selecting things" do
+    it "Should be able to select all" do
+      expect_keystroke("a", :command)
+      subject.select_all
     end
+  end
+
+  context "Printing" do
     
-    it "Should be able to set the filename" do
-      wrapper.should_receive(:set).with('value', at.text_field(1).sheet(1), "filename")
-      subject.set_filename("filename")
+    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
     
-    it "Should be able to set the path" do
-      expect_keystroke("g", [ :command, :shift ])
-      expect_wait_until_exists(at.sheet(1).sheet(1))
-      expect_set("value", at.text_field(1).sheet(1).sheet(1), "path")
-      expect_click(at.button("Go").sheet(1).sheet(1))
-      expect_wait_until_not_exists(at.sheet(1).sheet(1))
-      subject.set_folder("path")
+  describe "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"
     end
   end
+  
 end

data/spec/typicalprintdialog_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'osaka'
+
+describe "Osaka::TypicalPrintDialog" do
+
+  include(*Osaka::OsakaExpectations)
+  subject { Osaka::TypicalPrintDialog.new("App", at.window("Print")) }
+    
+  let(:control) { subject.control = mock("RemoteControl", :name => "App") }
+
+  it "Should be able to save the PDF in a print dialog" do
+    
+    control.stub(:base_location).and_return(at.window("Print"))
+    
+    save_dialog_mock = mock("Generic Save Dialog")
+    
+    expect_click!(at.menu_button("PDF")) 
+    expect_wait_until_exists!(at.menu(1).menu_button("PDF"))
+    
+    expect_click!(at.menu_item(2).menu(1).menu_button("PDF"))
+    expect_wait_until_exists!(at.window("Save"), at.sheet(1).window("Print")).and_return(at.window("Save"))
+
+    subject.should_receive(:create_save_dialog).with("App", at.window("Save")).and_return(save_dialog_mock)
+    save_dialog_mock.should_receive(:save).with("filename")
+    
+    expect_until_not_exists!(at.window("Print"))
+    expect_exists?(at.checkbox(1)).and_return(true)
+    expect_click!(at.checkbox(1))
+    
+    subject.save_as_pdf("filename")
+  end
+
+end

data/spec/typicalsavedialog_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+require 'osaka'
+
+describe "Osaka::TypicalSaveDialog" do
+
+  include(*Osaka::OsakaExpectations)
+  subject { Osaka::TypicalSaveDialog.new("Application", at.sheet(1))}
+  let(:control) { subject.control = mock("RemoteControl", :base_location => at.sheet(1)) }
+  
+  it "Should set the filename in the test field" do
+    subject.should_receive(:set_filename).with("filename")
+    subject.should_receive(:click_save)
+    subject.should_not_receive(:set_folder)
+    subject.save("filename")
+  end
+  
+  it "Should pick only the base filename when a path is given" do
+    subject.should_receive(:set_filename).with("filename")
+    subject.should_receive(:set_folder)
+    subject.should_receive(:click_save)
+    subject.save("/path/filename")
+  end
+  
+  it "Should set the path when a full path is given" do
+    control.as_null_object
+    subject.should_receive(:set_filename)
+    subject.should_receive(:set_folder).with("/path/second")
+    subject.save("/path/second/name")
+  end
+  
+  it "Should be able to click save" do
+    expect_click(at.button("Save"))
+    expect_wait_until_not_exists(at.sheet(1))
+    subject.click_save
+  end
+  
+  it "Should be able to set the filename" do
+    control.should_receive(:set).with('value', at.text_field(1), "filename")
+    subject.set_filename("filename")
+  end
+  
+  it "Should be able to set the path" do
+    expect_keystroke("g", [ :command, :shift ])
+    expect_wait_until_exists(at.sheet(1))
+    expect_set("value", at.text_field(1).sheet(1), "path")
+    expect_click(at.button("Go").sheet(1))
+    expect_wait_until_not_exists(at.sheet(1))
+    subject.set_folder("path")
+  end
+
+end

metadata

@@ -2,7 +2,7 @@
 name: osaka
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - Bas Vodde
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-08-13 00:00:00 -05:00
+date: 2012-08-21 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -47,21 +47,22 @@ files:
 - README.rdoc
 - Rakefile
 - lib/osaka.rb
-- lib/osaka/applicationwrapper.rb
-- lib/osaka/applicationwrapperexpectations.rb
 - lib/osaka/calculator.rb
 - lib/osaka/keynote.rb
 - lib/osaka/keynoteflow.rb
 - lib/osaka/location.rb
 - lib/osaka/mailmergeflow.rb
 - lib/osaka/numbers.rb
+- lib/osaka/osakaexpectations.rb
 - lib/osaka/pages.rb
+- lib/osaka/remotecontrol.rb
 - lib/osaka/scriptrunner.rb
 - lib/osaka/textedit.rb
 - lib/osaka/typicalapplication.rb
+- lib/osaka/typicalprintdialog.rb
+- lib/osaka/typicalsavedialog.rb
 - lib/osaka/version.rb
 - osaka.gemfile
-- spec/applicationwrapper_spec.rb
 - spec/assets/01_first_slides.key
 - spec/assets/02_second_slides.key
 - spec/assets/03_third_slides.key
@@ -77,10 +78,14 @@ files:
 - spec/location_spec.rb
 - spec/mailmergeflow_spec.rb
 - spec/numbers_spec.rb
+- spec/osakaexpectations_spec.rb
 - spec/pages_spec.rb
+- spec/remotecontrol_spec.rb
 - spec/scriptrunner_spec.rb
 - spec/textedit_spec.rb
 - spec/typicalapplication_spec.rb
+- spec/typicalprintdialog_spec.rb
+- spec/typicalsavedialog_spec.rb
 has_rdoc: true
 homepage: https://github.com/basvodde/osaka
 licenses: []