osaka 0.2.2 → 0.2.3

data/lib/osaka/applicationwrapper.rb

@@ -1,6 +1,9 @@
 
 module Osaka
 
+  class InvalidLocation < RuntimeError
+  end
+  
   class ConditionProxy
     
     def initialize(wrapper, action)
@@ -28,37 +31,45 @@ module Osaka
   end
   
   class CheckAction
-      def execute(wrapper, condition, *args, &block)
-        wrapper.system_event!("#{condition.as_script(*args)};").strip == "true"
-      end
+    def execute(wrapper, condition, *args, &block)
+      wrapper.system_event!("#{condition.as_script(*args)};").strip == "true"
     end
+  end
   
   class ExistsCondition
-    def as_script(element_to_wait_for)
-      "exists #{element_to_wait_for}"
+    def as_script(element_to_check)
+      "exists #{element_to_check}"
     end
   end
   
   class Not_existsCondition
-    def as_script(element_to_wait_for)
-      "not exists #{element_to_wait_for}"
+    def as_script(element_to_check)
+      "not exists #{element_to_check}"
     end
   end
     
   class ApplicationWrapper
   
+    attr_accessor :window
+    
     def initialize(name)
       @name = name
     end
     
+    def tell(command)
+      ScriptRunner::execute("tell application \"#{@name}\"; #{command}; end tell")
+    end
+  
+    def system_event!(event)
+      ScriptRunner::execute("tell application \"System Events\"; tell process \"#{@name}\"; #{event}; end tell; end tell")
+    end
+
     def print_warning(action, message)
       puts "Osaka WARNING while doing #{action}: #{message}"
     end
     
     def check_output(output, action)
-      if (!output.empty?)
-        print_warning(action, output)
-      end
+      print_warning(action, output) unless output.empty?
       output
     end
     
@@ -67,16 +78,8 @@ module Osaka
     end
   
     def quit
-      check_output( tell("quit"), "quit" )
-    end
-  
-    def tell(command)
-      ScriptRunner::execute("tell application \"#{@name}\"; #{command}; end tell")
-    end
-  
-    def system_event!(event)
-      ScriptRunner::execute("tell application \"System Events\"; tell process \"#{@name}\"; #{event}; end tell; end tell")
-    end
+      keystroke("q", :command)
+    end  
 
     def system_event(event)
       activate
@@ -92,13 +95,13 @@ module Osaka
       ConditionProxy.new(self, CheckAction.new)
     end
     
-    def wait_until!
-      ConditionProxy.new(self, RepeatAction.new)
-    end
+    alias check! check
     
     def until!
       ConditionProxy.new(self, RepeatAction.new)
     end
+    
+    alias wait_until! until!
         
     def construct_modifier_statement(modifier_keys)
       modified_key_string = [ modifier_keys ].flatten.collect! { |mod_key| mod_key.to_s + " down"}.join(", ")
@@ -113,6 +116,7 @@ module Osaka
     
     def keystroke(key, modifier_keys = [])
       activate
+      focus
       keystroke!(key, modifier_keys)
     end
         
@@ -128,16 +132,44 @@ module Osaka
     end
         
     def set!(element, location, value)
-      check_output( system_event!("set #{element} of #{location} to \"#{value}\""), "set")
+      encoded_value = (value.class == String) ? "\"#{value}\"" : value.to_s
+      check_output( system_event!("set #{element} of #{location} to #{encoded_value}"), "set")
+    end
+    
+    def focus
+      current_windows = window_list
+      @window = current_windows[0] if @window.nil? || current_windows.index(@window).nil?
+      set!("value", "attribute \"AXMain\" of window \"#{window}\"", true) if current_windows[0] != @window
+    end
+    
+    def construct_window_info(location)
+      location_string = ""
+      location_string += " of #{location}" unless location.empty?
+      location_string += " of window \"#{window}\"" unless window.nil?
+      
+      raise(Osaka::InvalidLocation, "Invalid location for command:#{location_string}") if location_string.scan("of window").length > 1
+      
+      location_string
     end
     
-    def get!(element, location)
-      system_event!("get #{element} of #{location}")
+    def get!(element, location = "")
+      system_event!("get #{element}#{construct_window_info(location)}").strip
+    end
+
+    def get_app!(element)
+      system_event!("get #{element}").strip
     end
 
     def set(element, location, value)
       activate
       set!(element, location, value)
     end
+    
+    def window_list
+      windows = get_app!("windows").strip.split(',')
+      windows.collect { |window|
+        window[7...window =~ / of application process/].strip
+      }
+    end 
   end
 end

data/lib/osaka/applicationwrapperexpectations.rb

@@ -2,33 +2,37 @@
 module Osaka
   module ApplicationWrapperExpectations
 
-    def should_wait(wait_command, wait_condition, wait_element)
-      condition = double(:ConditionAndActionProxy)
-      @wrapper.should_receive(wait_command).and_return(condition)
-      condition.should_receive(wait_condition).with(wait_element)
-    end
-
     def should_wait_until(wait_condition, wait_element)
-      should_wait(:wait_until, wait_condition, wait_element)
+      should_do_with_condition(:wait_until, wait_condition, wait_element)
     end
-
+    
     def should_wait_until!(wait_condition, wait_element)
-      should_wait(:wait_until!, wait_condition, wait_element)
+      should_do_with_condition(:wait_until!, wait_condition, wait_element)
     end
-
-    def should_do_until!(wait_condition, wait_element)
-      should_wait(:until!, wait_condition, wait_element).and_yield
+    
+    def should_check!(condition, element, return_value)
+      should_do_with_condition(:check!, condition, element).and_return(return_value)
+    end
+    
+    def should_do_until!(condition, element)
+      should_do_with_condition(:until!, condition, element).and_yield
       yield
     end
-
-    def expect_keystroke(key, modifier)
-      @wrapper.should_receive(:keystroke).with(key, modifier).and_return(@wrapper)
+    
+    def expect_keystroke(key, modifier = [])
+      @wrapper.should_receive(:keystroke).with(key, modifier).and_return(@wrapper) unless modifier.empty?
+      @wrapper.should_receive(:keystroke).with(key).and_return(@wrapper) if modifier.empty?
     end
-
+    
+    def expect_keystroke!(key, modifier = [])
+      @wrapper.should_receive(:keystroke!).with(key, modifier).and_return(@wrapper) unless modifier.empty?
+      @wrapper.should_receive(:keystroke!).with(key).and_return(@wrapper) if modifier.empty?
+    end
+    
     def expect_click!(location)
       @wrapper.should_receive(:click!).with(location).and_return(@wrapper)
     end
-
+    
     def expect_click(location)
       @wrapper.should_receive(:click).with(location).and_return(@wrapper)
     end
@@ -41,6 +45,13 @@ module Osaka
       @wrapper.should_receive(:system_event).with(event)
     end
     
+private
+    def should_do_with_condition(command, condition, element)
+      condition_proxy = double(:ConditionAndActionProxy)
+      @wrapper.should_receive(command).and_return(condition_proxy)
+      condition_proxy.should_receive(condition).with(element)
+    end
+  
     
   end
 end

data/lib/osaka/calculator.rb

@@ -0,0 +1,32 @@
+
+module Osaka
+  class Calculator < TypicalApplication
+    attr_accessor :wrapper
+    
+    def initialize
+      @name = "Calculator"
+      @wrapper = ApplicationWrapper.new("Calculator")
+    end
+    
+    def activate
+      super
+      if (@wrapper.window.nil?)
+        wait_for_new_window([])
+        @wrapper.window = @wrapper.window_list[0]
+      end
+    end
+    
+    def click(key)
+      @wrapper.click!("button \"#{key}\" of group 2 of window \"#{@name}\"")
+    end
+    
+    def key(k)
+      @wrapper.keystroke(k)
+    end
+    
+    def result
+      @wrapper.get!('value', "static text 1 of group 1")
+    end
+    
+  end
+end

data/lib/osaka/textedit.rb

@@ -0,0 +1,28 @@
+
+module Osaka
+  class TextEdit < TypicalApplication
+    attr_accessor :wrapper
+    
+    def initialize
+      @name = "TextEdit"
+      @wrapper = ApplicationWrapper.new("TextEdit")
+    end
+    
+    def activate
+      super
+      if (@wrapper.window.nil?)
+        wait_for_new_window([])
+        @wrapper.window = @wrapper.window_list[0]
+      end
+    end
+    
+    def type(text)
+      @wrapper.keystroke(text)
+    end
+    
+    def text
+      @wrapper.get!("value", 'text area 1 of scroll area 1')
+    end
+    
+  end
+end

data/lib/osaka/typicalapplication.rb

@@ -56,27 +56,75 @@ module Osaka
       }
     end
   end
+  
+  class ApplicationInfo
+
+    attr_reader :name
+
+    def initialize(script_info)
+      @name = script_info.match(/name:(.+?), creation date/)[1]
+    end
+    
+  end
 
   class TypicalApplication
   
     attr_accessor :wrapper
   
     def initialize(name)
+      @name = name
       @wrapper = ApplicationWrapper.new(name)
     end
+    
+    def get_info
+      script_info = @wrapper.tell("get info for (path to application \"#{@name}\")")
+      ApplicationInfo.new(script_info)
+    end
   
     def open (filename)
       abolutePathFileName = File.absolute_path(filename)
       @wrapper.tell("open \"#{abolutePathFileName}\"")
+      @wrapper.window = filename
     end
-  
-    def quit
+
+    def wait_for_window_and_dialogs_to_close(option)
+      if (option != :user_chose)
+        @wrapper.until!.not_exists("window \"#{wrapper.window}\"") {
+          if (@wrapper.check!.exists("sheet 1 of window \"#{wrapper.window}\""))
+            @wrapper.click!("button 2 of sheet 1 of window \"#{wrapper.window}\"")
+          end
+        }
+      end
+    end
+      
+    def quit(option = :user_chose)
       @wrapper.quit
+      wait_for_window_and_dialogs_to_close(option)
     end
 
+    def wait_for_new_window(original_window_list)
+      latest_window_list = original_window_list
+      while (original_window_list == latest_window_list)
+        latest_window_list = @wrapper.window_list
+      end
+      (latest_window_list - original_window_list)[0]
+    end
+    
+    def new_document
+      window_list = @wrapper.window_list
+      @wrapper.keystroke("n", :command)
+      @wrapper.window = wait_for_new_window(window_list)
+      @wrapper.focus
+    end
+    
     def save
       @wrapper.keystroke("s", :command)
     end
+    
+    def close(option = :user_chose)
+      @wrapper.keystroke("w", :command)
+      wait_for_window_and_dialogs_to_close(option)
+    end
   
     def activate
       @wrapper.activate
@@ -87,7 +135,7 @@ module Osaka
     end
   
     def print_dialog
-      location = "sheet 1 of window 1"
+      location = "sheet 1#{@wrapper.construct_window_info}"
       @wrapper.keystroke("p", :command).wait_until.exists(location)
       create_print_dialog(location)
     end

data/lib/osaka/version.rb

@@ -1,4 +1,4 @@
 
 module Osaka
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/lib/osaka.rb

@@ -6,3 +6,6 @@ require 'osaka/typicalapplication'
 require 'osaka/pages'
 require 'osaka/numbers'
 require 'osaka/keynote'
+require 'osaka/calculator'
+require 'osaka/textedit'
+

data/spec/applicationwrapper_spec.rb

@@ -27,26 +27,16 @@ describe "Osaka::ApplicationWrapper" do
     subject.print_warning("action", "Message")
   end
 
-  it "Has a short-cut method for activation" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/activate/).and_return("")
-    subject.activate
-  end
-  
   it "Should print an Warning message with the ScriptRunner returns text when doing activate" do
     check_for_warning("activate")
     subject.activate
   end
   
   it "Has a short-cut method for quitting" do
-    Osaka::ScriptRunner.should_receive(:execute).with(/quit/).and_return("")
+    subject.should_receive(:keystroke).with("q", :command)
     subject.quit
   end
   
-  it "Prints a warning message when quit results in some output" do
-    check_for_warning("quit")
-    subject.quit    
-  end
-    
   it "Should be able to generate events via the Systems Events" do
     Osaka::ScriptRunner.should_receive(:execute).with(/tell application "System Events"; tell process #{quoted_name}; quit; end tell; end tell/)
     subject.system_event!("quit")
@@ -95,6 +85,7 @@ describe "Osaka::ApplicationWrapper" do
   
   it "Should be able to keystroke and activate" do
     subject.should_receive(:activate)
+    subject.should_receive(:focus)
     subject.should_receive(:keystroke!).with("a", [])
     subject.keystroke("a", [])        
   end
@@ -117,6 +108,7 @@ describe "Osaka::ApplicationWrapper" do
   
   it "Should be able to keystroke_and_wait_until_exists and activate" do
     subject.should_receive(:activate)
+    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")    
@@ -147,26 +139,53 @@ describe "Osaka::ApplicationWrapper" do
   end
     
   it "Should be able to set a value to an element" do
-    check_for_warning("set")
+    subject.should_receive(:system_event!).with(/set value of window to "newvalue"/).and_return("")
     subject.set!("value", "window", "newvalue")
   end
 
   it "Prints a warning when setting and element and output is received" do
-    subject.should_receive(:system_event!).with(/set value of window to "newvalue"/).and_return("")
+    check_for_warning("set")
     subject.set!("value", "window", "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)    
+  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")
+    subject.should_receive(:system_event!).with(/get value of window/).and_return("1\n")
     subject.get!("value", "window").should == "1"
   end
   
+  it "Should use the locally stored window when that one is set." do
+    subject.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.should_receive(:system_event!).with(/get value of dialog 2 of window "1"/).and_return("1\n")
+    subject.get!("value", "dialog 2").should == "1"    
+  end
+  
+  it "Should be able to get values from the application itself" do
+    subject.should_receive(:system_event!).with("get value").and_return("1\n")
+    subject.get_app!("value").should == "1"
+  end
+    
   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")
   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 {
@@ -183,4 +202,53 @@ describe "Osaka::ApplicationWrapper" do
     }
   end
   
+  it "Should be able to get an empty array when requesting for the window list and there are none" do
+    subject.should_receive(:get_app!).with("windows").and_return("\n")
+    subject.window_list.should == []
+  end
+  
+  it "Should be able get an array with one window name when there is exactly one window" do
+    subject.should_receive(:get_app!).with("windows").and_return("window one of application process process\n")
+    subject.window_list.should == ["one"]    
+  end
+  
+  it "Should be able to get an array of multiple window names" do
+    subject.should_receive(:get_app!).with("windows").and_return("window one of application process process, window two of application process process\n")
+    subject.window_list.should == ["one", "two"]    
+  end
+  
+  it "Should initialize the current window when it is not focused yet" do
+    subject.should_receive(:window_list).and_return(["1"])
+    subject.focus
+    subject.window.should == "1"
+  end
+  
+  it "Shouldn't initialize current window when it is already set" do
+    subject.should_receive(:window_list).and_return(["1"])
+    subject.focus
+
+    subject.should_receive(:window_list).and_return(["2", "1"])
+    subject.should_receive(:set!)
+    subject.focus
+    subject.window.should == "1"
+  end
+  
+  it "Should re-initialize the current window when it doesn't exist anymore" do
+    subject.should_receive(:window_list).and_return(["1"])
+    subject.focus
+
+    subject.should_receive(:window_list).and_return(["2"])
+    subject.focus
+    subject.window.should == "2"    
+  end
+  
+  it "Should focus the current window when it doesn't have focus" do
+    subject.should_receive(:window_list).and_return(["1"])
+    subject.focus
+
+    subject.should_receive(:window_list).and_return(["2", "1"])
+    subject.should_receive(:set!).with("value", "attribute \"AXMain\" of window \"1\"", true )
+    subject.focus
+  end  
+  
 end

data/spec/calculator_spec.rb

@@ -0,0 +1,47 @@
+
+require 'osaka'
+
+describe "Mac GUI Calculator" do
+
+  include(*Osaka::ApplicationWrapperExpectations)
+
+  subject { Osaka::Calculator.new }
+
+  before (:each) do
+    @wrapper = subject.wrapper = double("Osaka::ApplicationWrapper")
+  end
+  
+  it "Should be setting the window when starting the Calculator" do
+    
+    # TODO: Fix this duplication between this and TextEdit.
+    
+    @wrapper.should_receive(:activate)
+    @wrapper.should_receive(:window).and_return(nil)
+    subject.should_receive(:wait_for_new_window).with([])
+    @wrapper.should_receive(:window_list).and_return(["Calculator"])
+    @wrapper.should_receive(: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"')
+    subject.click("1")
+  end
+  
+  it "Should be able to use keystroke on the calculator" do
+    expect_keystroke("1")
+    subject.key("1")
+  end
+  
+  it "Should be able to quit the calculator" do
+    @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")
+    subject.result.should == "0"
+  end
+  
+end

data/spec/integration_calculator_spec.rb

@@ -0,0 +1,43 @@
+
+require 'osaka'
+
+describe "Integration test using the Calculator" do
+
+  subject { Osaka::Calculator.new }
+
+  before (:each) do
+    subject.activate
+  end
+  
+  after (:each) do
+    subject.quit
+  end
+  
+  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
+    subject.click("1")
+    subject.click("+")
+    subject.click("1")
+    subject.click("=")
+    subject.result.should == "2"
+  end
+  
+  it "Should be able to do calculations using keyboard" do
+    subject.key("10")
+    subject.key("*")
+    subject.key("10")
+    subject.key("=")
+    subject.result.should == "100"    
+  end
+  
+  it "Should do whole formulas using key" do
+    subject.key("100+10*3+99=")
+    sleep 0.5
+    subject.result.should == "229"        
+  end
+  
+end

data/spec/integration_textedit_spec.rb

@@ -0,0 +1,38 @@
+
+require 'osaka'
+
+describe "Integration test using TextEdit" do
+
+  subject { Osaka::TextEdit.new }
+
+  before (:each) do
+  end
+  
+  after (:each) do
+    subject.quit(:dont_save)
+  end
+  
+  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"
+    
+    editor1.close(:dont_save)
+    editor2.close(:dont_save)
+  end
+
+end

data/spec/textedit_spec.rb

@@ -0,0 +1,39 @@
+
+require 'osaka'
+
+describe "TextEdit" do
+
+  include(*Osaka::ApplicationWrapperExpectations)
+
+  subject { Osaka::TextEdit.new }
+
+  before (:each) do
+    @wrapper = subject.wrapper = double("Osaka::ApplicationWrapper")
+  end
+  
+  it "should set the window on activation" do
+    @wrapper.should_receive(:activate)
+    @wrapper.should_receive(:window).and_return(nil)
+    subject.should_receive(:wait_for_new_window).with([])
+    @wrapper.should_receive(:window_list).and_return(["Untitled"])
+    @wrapper.should_receive(:window=).with("Untitled")
+    subject.activate
+  end
+  
+  it "shouldn't set the window on activation when it is already set" do
+    @wrapper.should_receive(:activate)
+    @wrapper.should_receive(:window).and_return("Untitled")
+    subject.activate    
+  end
+  
+  it "Should be able to type some text" do
+    expect_keystroke('Hello World')
+    subject.type("Hello World")
+  end
+  
+  it "Should be able to get the text from the document" do
+    subject.wrapper.should_receive(:get!).with("value", 'text area 1 of scroll area 1').and_return("Hello")
+    subject.text.should == "Hello"
+  end
+
+end

data/spec/typicalapplication_spec.rb

@@ -14,6 +14,7 @@ describe "Osaka::TypicalApplication" do
   it "Should pass the right open string to the Keynote application osascript" do
     filename = "filename.key"
     expect_tell("open \"#{File.absolute_path(filename)}\"")
+    @wrapper.should_receive(:window=).with(filename)
     subject.open(filename)    
   end
   
@@ -22,11 +23,56 @@ describe "Osaka::TypicalApplication" do
     subject.quit
   end
   
+  it "Should be able to quit without saving" do
+    @wrapper.should_receive(:window).any_number_of_times.and_return("Untitled")
+    @wrapper.should_receive(:quit)
+    should_do_until!(:not_exists, "window \"Untitled\"") {
+      should_check!(:exists, "sheet 1 of window \"Untitled\"", true)
+      expect_click!('button 2 of sheet 1 of window "Untitled"')
+    }
+    subject.quit(:dont_save)  
+  end
+  
+  it "Should be able to wait until a new window exists" do
+    subject.wrapper.should_receive(:window_list).and_return(["new window"])
+    subject.wait_for_new_window([])    
+  end
+  
+  it "Should be able to wait until a new window exists and it takes 4 calls" do
+    counter = 0
+    subject.wrapper.should_receive(:window_list).exactly(4).times.and_return(["new window"]) {
+        counter = counter + 1
+        counter.should <= 5 # Added here so that the test won't end up in an endless loop.
+        counter >= 4 ? [ "new window" ] : []
+      }
+      subject.wait_for_new_window([])    
+  end
+  
+  it "Should be able to create a new document" do    
+    subject.wrapper.should_receive(:window_list)
+    expect_keystroke("n", :command)
+    subject.should_receive(:wait_for_new_window).and_return("new_window")
+    subject.wrapper.should_receive(:window=).with("new_window")
+    subject.wrapper.should_receive(:focus)
+    subject.new_document
+  end
+  
   it "Should be able to save" do
     expect_keystroke("s", :command)
     subject.save
   end
   
+  it "Should be able to close" do
+    expect_keystroke("w", :command)
+    subject.close
+  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
+    
   it "Should be able to activate keynote" do
     @wrapper.should_receive(:activate)
     subject.activate
@@ -34,9 +80,18 @@ describe "Osaka::TypicalApplication" do
   
   it "Should be able to retrieve a print dialog" do
     expect_keystroke("p", :command)
+    @wrapper.should_receive(:construct_window_info).and_return(" of window 1")
     should_wait_until(:exists, "sheet 1 of window 1")
     subject.print_dialog
-  end  
+  end
+  
+  describe "Application info" do
+    it "Should be able to retrieve an application info object and parse it" do
+      @wrapper.should_receive(:tell).with('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
   
   describe "Generic Print Dialog" do
     

metadata

@@ -2,7 +2,7 @@
 name: osaka
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors: 
 - Bas Vodde
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-26 00:00:00 +08:00
+date: 2012-04-14 00:00:00 +08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,18 +49,24 @@ files:
 - lib/osaka.rb
 - lib/osaka/applicationwrapper.rb
 - lib/osaka/applicationwrapperexpectations.rb
+- lib/osaka/calculator.rb
 - lib/osaka/keynote.rb
 - lib/osaka/numbers.rb
 - lib/osaka/pages.rb
 - lib/osaka/scriptrunner.rb
+- lib/osaka/textedit.rb
 - lib/osaka/typicalapplication.rb
 - lib/osaka/version.rb
 - osaka.gemfile
 - spec/applicationwrapper_spec.rb
+- spec/calculator_spec.rb
+- spec/integration_calculator_spec.rb
+- spec/integration_textedit_spec.rb
 - spec/keynote_spec.rb
 - spec/numbers_spec.rb
 - spec/pages_spec.rb
 - spec/scriptrunner_spec.rb
+- spec/textedit_spec.rb
 - spec/typicalapplication_spec.rb
 has_rdoc: true
 homepage: https://github.com/basvodde/osaka