rautomation 0.5.1 → 0.6.0

data/lib/rautomation/adapter/win_ffi/table.rb

@@ -5,14 +5,53 @@ module RAutomation
         include WaitHelper
         include Locators
 
-        private
+        def strings
+          rows = []
+          header_columns = []
+
+          raise "Not a list control" unless UiaDll::current_control_type(uia_control(@locators[:id])) == Constants::UIA_LIST_CONTROL_TYPE
+
+          children_count = count_children(uia_control(@locators[:id]))
+          children = FFI::MemoryPointer.new :pointer, children_count
+          UiaDll::find_children(uia_control(@locators[:id]), children)
+          children.read_array_of_pointer(children_count).each do |child|
+            grandchildren_count = count_children(child)
+            grandchildren = FFI::MemoryPointer.new :pointer, grandchildren_count
+            UiaDll::find_children(child, grandchildren)
+            grandchildren.read_array_of_pointer(grandchildren_count).each do |grandchild|
+              grandchild_name = FFI::MemoryPointer.new :char, UiaDll::get_name(grandchild, nil) + 1
+              UiaDll::get_name(grandchild, grandchild_name)
+              header_columns.push grandchild_name.read_string
+            end
+
+            rows.push header_columns
+            header_columns = []
+          end
+
+          rows
+        end
+
+        def select(row)
+          Functions.select_table_row(@window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
+        end
+
+        def selected?(row)
+          state = Functions.get_table_row_state(@window.oleacc_module_handle, Functions.control_hwnd(@window.hwnd, @locators), row)
+          state & Constants::STATE_SYSTEM_SELECTED != 0
+        end
 
         def row_count
-          Functions.send_message(Functions.control_hwnd(@window.hwnd, @locators), Constants::LVM_GETITEMCOUNT, 0, nil)
+          UiaDll::find_children(uia_control(@locators[:id]), nil)
+        end
+
+        private
+
+        def count_children(element)
+          UiaDll::find_children(element, nil)
         end
 
+
       end
     end
   end
 end
-

data/lib/rautomation/adapter/win_ffi/text_field.rb

@@ -10,6 +10,8 @@ module RAutomation
 
         # @see RAutomation::TextField#set
         def set(text)
+          raise "Cannot set value on a disabled text field" if disabled?
+
           wait_until do
             hwnd = Functions.control_hwnd(@window.hwnd, @locators)
             @window.activate
@@ -22,14 +24,28 @@ module RAutomation
 
         # @see RAutomation::TextField#clear
         def clear
+          raise "Cannot set value on a disabled text field" if disabled?
           set ""
         end
 
         # @see RAutomation::TextField#value
         def value
-          Functions.control_value(Functions.control_hwnd(@window.hwnd, @locators))
+          Functions.control_value(hwnd)
+        end
+
+        # @see RAutomation::TextField#hwnd
+        def hwnd
+          Functions.control_hwnd(@window.hwnd, @locators)
+        end
+
+        def exist?
+          @locators[:id].nil? ? super : super && matches_type(Constants::UIA_EDIT_CONTROL_TYPE)
         end
 
+        alias_method :exists?, :exist?
+
+
+
       end
     end
   end

data/lib/rautomation/adapter/win_ffi/window.rb

@@ -4,6 +4,9 @@ module RAutomation
       class Window
         include WaitHelper
         include Locators
+        extend ElementCollections
+
+        has_many :controls
 
         class << self
           def initialize_com
@@ -109,19 +112,28 @@ module RAutomation
 
         # Activates the window and sends keys to it.
         #
-        # Refer to MSDN documentation at http://msdn.microsoft.com/en-us/library/dd375731(v=VS.85).aspx
-        # for the keycodes.
+        # Refer to KeystrokeConverter#convert_special_characters for the special keycodes.
         # @see RAutomation::Window#send_keys
-        def send_keys(*keys)
-          keys.each do |key|
+        def send_keys(keys)
+          shift_pressed = false
+          KeystrokeConverter.convert(keys).each do |key|
             wait_until do
               activate
               active?
             end
-            Functions.send_key(0x12, 0, 0, nil)
-            Functions.send_key(key, 0, 0, nil)
-            Functions.send_key(0x12, 0, Constants::KEYEVENTF_KEYUP, nil)
-            Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
+            press_key key
+
+            if key == Constants::VK_LSHIFT
+              shift_pressed = true
+              next
+            end
+
+            release_key key
+
+            if shift_pressed
+              shift_pressed = false
+              release_key Constants::VK_LSHIFT
+            end
           end
         end
 
@@ -142,6 +154,22 @@ module RAutomation
           TextField.new(self, locator)
         end
 
+        def label(locator)
+          Label.new(self, locator)
+        end
+
+        def control(locator)
+          Control.new(self, locator)
+        end
+
+        def controls(locator)
+          Controls.new(self, locator)
+        end
+
+        def list_box(locator)
+          ListBox.new(self, locator)
+        end
+
         # Redirects all method calls not part of the public API to the {Functions} directly.
         # @see RAutomation::Window#method_missing
         def method_missing(name, *args)
@@ -182,6 +210,17 @@ module RAutomation
           end
         end
 
+        private
+
+        def press_key key
+          Functions.send_key(key, 0, 0, nil)
+          sleep 0.01
+        end
+
+        def release_key key
+          Functions.send_key(key, 0, Constants::KEYEVENTF_KEYUP, nil)
+          sleep 0.1
+        end
       end
     end
   end

data/lib/rautomation/button.rb

@@ -39,6 +39,11 @@ module RAutomation
 
     alias_method :exist?, :exists?
 
+    # Allows to execute specific {Adapter} methods not part of the public API.
+    def method_missing(name, *args)
+      @button.send(name, *args)
+    end
+
     private
 
     def wait_until_exists

data/lib/rautomation/element_collections.rb

@@ -6,9 +6,12 @@ module RAutomation
     #   and methods.
     def has_many(*elements)
       elements.each do |element|
-        class_name = element.to_s.split("_").map {|e| e.capitalize}.join
-        RAutomation.class_eval %Q{
-            class #{class_name}
+        class_name_plural = element.to_s.split("_").map {|e| e.capitalize}.join
+        class_name = class_name_plural.chop
+        adapter_class = self.to_s.scan(/(.*)::/).to_s
+        clazz = RAutomation.constants.include?(class_name) ? RAutomation : class_eval(adapter_class)
+        clazz.class_eval %Q{
+            class #{class_name_plural}
               include Enumerable
 
               def initialize(window, locators)
@@ -20,7 +23,7 @@ module RAutomation
                 i = -1 
                 while true
                   args = [@window, @locators.merge(:index => i += 1)].compact
-                  object = RAutomation::#{class_name.chop}.new(*args)
+                  object = #{clazz}::#{class_name}.new(*args)
                   break unless object.exists?
                   yield object
                 end
@@ -35,7 +38,7 @@ module RAutomation
 
         class_eval %Q{
             def #{element}(locators = {})
-              #{class_name}.new(@window, locators)
+              #{class_name_plural}.new(@window, locators)
             end
         }
       end

data/lib/rautomation/text_field.rb

@@ -37,8 +37,18 @@ module RAutomation
       @text_field.exists?
     end
 
+    def hwnd
+      wait_until_exists
+      @text_field.hwnd
+    end
+
     alias_method :exist?, :exists?
 
+    # Allows to execute specific {Adapter} methods not part of the public API.
+    def method_missing(name, *args)
+      @text_field.send(name, *args)
+    end
+
     private
 
     def wait_until_exists

data/lib/rautomation/window.rb

@@ -87,21 +87,21 @@ module RAutomation
     # @return [Fixnum] handle of the window which is used internally for other methods.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def hwnd
-      wait_until_exists
+      wait_until_present
       @window.hwnd
     end
 
     # @return [Fixnum] process identifier (PID) of the window.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def pid
-      wait_until_exists
+      wait_until_present
       @window.pid
     end
 
     # @return [String] title of the window.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def title
-      wait_until_exists
+      wait_until_present
       @window.title
     end
 
@@ -120,7 +120,7 @@ module RAutomation
     # @return [String] visible text of the window.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def text
-      wait_until_exists
+      wait_until_present
       @window.text
     end
 
@@ -150,14 +150,14 @@ module RAutomation
     # Maximizes the window.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def maximize
-      wait_until_exists
+      wait_until_present
       @window.maximize
     end
 
     # Minimizes the window.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def minimize
-      wait_until_exists
+      wait_until_present
       @window.minimize
     end
 
@@ -165,7 +165,7 @@ module RAutomation
     # @return [Boolean] true if window is minimized, false otherwise.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def minimized?
-      wait_until_exists
+      wait_until_present
       @window.minimized?
     end
 
@@ -173,15 +173,15 @@ module RAutomation
     # @note If the window is minimized, makes it visible again.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def restore
-      wait_until_exists
+      wait_until_present
       @window.restore
     end
 
     # Sends keyboard keys to the window. Refer to specific {Adapter} documentation for all possible values.
     # @raise [UnknownWindowException] if the window doesn't exist.
-    def send_keys(*keys)
-      wait_until_exists
-      @window.send_keys(*keys)
+    def send_keys(keys)
+      wait_until_present
+      @window.send_keys(keys)
     end
 
     # Closes the window if it exists.
@@ -195,7 +195,7 @@ module RAutomation
     # @param [Hash] locators for the {Button}.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def button(locators)
-      wait_until_exists
+      wait_until_present
       Button.new(@window, locators)
     end
 
@@ -203,7 +203,7 @@ module RAutomation
     # @note Refer to specific {Adapter} documentation for possible _locators_ parameters.
     # @raise [UnknownWindowException] if the window doesn't exist.
     def text_field(locators)
-      wait_until_exists
+      wait_until_present
       TextField.new(@window, locators)
     end
 
@@ -214,10 +214,16 @@ module RAutomation
 
     private
 
+    def wait_until_present
+      WaitHelper.wait_until {present?}
+    rescue WaitHelper::TimeoutError
+      raise UnknownWindowException, "Window with locator #{@window.locators.inspect} doesn't exist or is not visible!"
+    end
+
     def wait_until_exists
       WaitHelper.wait_until {exists?}
     rescue WaitHelper::TimeoutError
-      raise UnknownWindowException, "Window with locator #{@window.locators.inspect} doesn't exist!" unless exists?
+      raise UnknownWindowException, "Window with locator #{@window.locators.inspect} doesn't exist!"
     end
 
     def normalize adapter

data/spec/adapter/win_ffi/button_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "WinFfi::Button", :if => SpecHelper.adapter == :win_ffi do
+  it "find by id" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    window.button(:id => "aboutButton").should exist
+  end
+
+  it "check for button class" do
+    RAutomation::Window.new(:title => "MainFormWindow").button(:id => "textField").should_not exist
+  end
+
+
+  it "enabled/disabled" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    window.button(:id => "enabledButton").should be_enabled
+    window.button(:id => "enabledButton").should_not be_disabled
+
+    window.button(:id => "disabledButton").should be_disabled
+    window.button(:id => "disabledButton").should_not be_enabled
+  end
+
+  it "#set_focus" do
+    button = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title]).button(:id => "enabledButton")
+    button.should_not have_focus
+
+    button.set_focus
+    button.should have_focus
+  end
+
+  it "cannot click disabled button" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    lambda { window.button(:id => "disabledButton").click }.should raise_error
+  end
+
+  it "cannot set focus to disabled button" do
+    window = RAutomation::Window.new(:title => SpecHelper::DATA[:window1_title])
+    lambda { window.button(:id => "disabledButton").set_focus }.should raise_error
+  end
+
+end

data/spec/adapter/win_ffi/checkbox_spec.rb

@@ -9,6 +9,11 @@ describe "WinFfi::Checkbox", :if => SpecHelper.adapter == :win_ffi do
       to raise_exception(RAutomation::UnknownWindowException)
   end
 
+  it "check for checkbox class" do
+    RAutomation::Window.new(:title => "MainFormWindow").checkbox(:id => "textField").should_not exist
+  end
+
+
   it "#set? & #set" do
     checkbox = RAutomation::Window.new(:title => "MainFormWindow").checkbox(:value => "checkBox")
     checkbox.should_not be_set
@@ -26,4 +31,18 @@ describe "WinFfi::Checkbox", :if => SpecHelper.adapter == :win_ffi do
     checkbox.should_not be_set
   end
 
+  it "enabled/disabled" do
+    RAutomation::Window.new(:title => "MainFormWindow").checkbox(:id => "checkBox").should be_enabled
+    RAutomation::Window.new(:title => "MainFormWindow").checkbox(:id => "checkBox").should_not be_disabled
+
+    RAutomation::Window.new(:title => "MainFormWindow").checkbox(:id => "checkBoxDisabled").should_not be_enabled
+    RAutomation::Window.new(:title => "MainFormWindow").checkbox(:id => "checkBoxDisabled").should be_disabled
+  end
+
+  it "cannot check a disabled checkbox" do
+    lambda {
+      RAutomation::Window.new(:title => "MainFormWindow").checkbox(:id => "checkBoxDisabled").set
+    }.should raise_error
+  end
+
 end

data/spec/adapter/win_ffi/keystroke_converter_spec.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rautomation'
+require 'rspec'
+
+describe "KeystrokeConverter" do
+
+  it "converts plain ASCII" do
+    codes = RAutomation::Adapter::WinFfi::KeystrokeConverter.convert("abc")
+    converted_keys = convert_keys "abc"
+    codes.should == converted_keys
+  end
+
+  it "uses caps lock for entering downcase keys" do
+    codes = RAutomation::Adapter::WinFfi::KeystrokeConverter.convert("aBc")
+    converted_keys = convert_keys "abc"
+    converted_keys = converted_keys.insert(1, RAutomation::Adapter::WinFfi::Constants::VK_LSHIFT)
+    codes.should == converted_keys
+  end
+
+  it "converts special keys" do
+    codes = RAutomation::Adapter::WinFfi::KeystrokeConverter.convert("{tab}a{backspace}b{enter}c {left}d{right}ee{down}f{up}g{unsupported}")
+    expected_codes = [
+      RAutomation::Adapter::WinFfi::Constants::VK_TAB,
+      convert_keys("a"),
+      RAutomation::Adapter::WinFfi::Constants::VK_BACK,
+      convert_keys("b"),
+      RAutomation::Adapter::WinFfi::Constants::VK_RETURN,
+      convert_keys("c"),
+      RAutomation::Adapter::WinFfi::Constants::VK_SPACE,
+      RAutomation::Adapter::WinFfi::Constants::VK_LEFT,
+      convert_keys("d"),
+      RAutomation::Adapter::WinFfi::Constants::VK_RIGHT,
+      convert_keys("ee"),
+      RAutomation::Adapter::WinFfi::Constants::VK_DOWN,
+      convert_keys("f"),
+      RAutomation::Adapter::WinFfi::Constants::VK_UP,
+      convert_keys("g"),
+      convert_keys("unsupported")
+    ].flatten
+    codes.should == expected_codes
+  end
+
+  def convert_keys keys
+    keys.split("").map {|k| k.upcase.unpack("c")[0]}
+  end
+
+end