watir_robot 0.1.0

data/lib/watir_robot/keywords/button.rb

@@ -0,0 +1,21 @@
+module WatirRobot
+  
+  #
+  # Functionality related to HTML buttons (whether +<input>+ type submit or actual +<button>+ tags)
+  # 
+  module Button
+    
+    ### Actions ###
+    
+    #
+    # Click a button
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    #
+    def click_button(loc)
+      @browser.button(parse_location(loc)).click
+    end
+    
+  end
+  
+end

data/lib/watir_robot/keywords/checkbox.rb

@@ -0,0 +1,53 @@
+module WatirRobot
+  
+  #
+  # Functionality related to checkbox form elements
+  # 
+  module CheckBox
+    
+    ### Actions ###
+    
+    #
+    # Check a checkbox
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    #
+    def select_checkbox(loc)
+      @browser.checkbox(parse_location(loc)).set
+    end
+    
+    #
+    # Uncheck a checkbox
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    #
+    def unselect_checkbox(loc)
+      @browser.checkbox(parse_location(loc)).set(false)
+    end
+    
+    
+    ### Conditions ###
+    
+    #
+    # Verify that checkbox is checked
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def checkbox_should_be_selected(loc)
+      raise(Exception::CheckboxSelectionError, "The checkbox located at #{loc} is not checked off.") unless
+        @browser.checkbox(parse_location(loc)).set?
+    end
+
+    #
+    # Verify that checkbox is not checked
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def checkbox_should_not_be_selected(loc)
+      raise(Exception::CheckboxSelectionError, "The checkbox located at #{loc} is checked off.") if
+        @browser.checkbox(parse_location(loc)).set?
+    end
+    
+  end
+  
+end

data/lib/watir_robot/keywords/element.rb

@@ -0,0 +1,95 @@
+module WatirRobot
+  
+  #
+  # Functionality related to HTML elements in a generic, global context
+  # 
+  module Element
+    
+    ### Actions ###
+    
+    #
+    # Get the value of an attribute for an element
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @param [String] attr the attribute for which to return a value
+    # @return [String] the value of the attribute for the given HTML element
+    # 
+    def get_element_attribute(loc, attr)
+      @browser.element(parse_location(loc)).attribute_value(attr)
+    end
+    
+    #
+    # Get an element's text
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @return [String] the text of a given HTML *without* any HTML markup
+    #
+    def get_element_text(loc)
+      @browser.element(parse_location(loc)).text
+    end
+    
+    #
+    # Click any HTML element
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def click_element(loc)
+      @browser.element(parse_location(loc)).click
+    end
+    
+    #
+    # Set focus to element
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def focus(loc)
+      @browser.element(parse_location(loc)).focus
+    end
+    
+    ### Conditions ###
+
+    #
+    # Verify that an element is visible
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def element_should_be_visible(loc)
+      raise(Exception::ElementVisibilityError, "The element described by #{parse_location(loc)} is not visible") unless
+        @browser.element(parse_location(loc)).visible?
+    end
+    
+    #
+    # Verify that an element is not visible
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def element_should_not_be_visible(loc)
+      raise(Exception::ElementVisibilityError, "The element described by #{parse_location(loc)} is not visible") if
+        @browser.element(parse_location(loc)).visible?
+    end
+    
+    #
+    # Verify that an element's text contains a specific value
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @param [String] text the text to compare against
+    # 
+    def element_text_should_contain(loc, text)
+      raise(Exception::ElementMatchError, "The element's text #{@browser.element(parse_location(loc)).text} does not contain the text #{text}") unless
+        @browser.element(parse_location(loc)).text.include? text
+    end
+    
+    #
+    # Verify that an element's text matches a specific value
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @param [String] text the text to compare against
+    # 
+    def element_text_should_be(loc, text)
+      raise(Exception::ElementMatchError, "The element's text #{@browser.element(parse_location(loc)).text} does not equal #{text}") unless
+        @browser.element(parse_location(loc)).text == text      
+    end
+    
+  end  
+  
+end
+

data/lib/watir_robot/keywords/file_field.rb

@@ -0,0 +1,30 @@
+module WatirRobot
+  
+  #
+  # Functionality for HTML file-upload fields
+  #
+  module FileField
+    
+    ### Actions ###
+    
+    #
+    # Insert path of a file into a file-upload field
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @param [String] path the path to the file you wish to upload from your computer
+    #
+    def choose_file(loc, path)
+      @browser.file_field(parse_location(loc)).set path
+    end
+    
+    #
+    # Get the file path present in a file-upload field
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @param [String] the path of the file in a file-upload field
+    # 
+    def get_filefield_path(loc)
+      @browser.file_field(parse_location(loc)).value
+    end
+  end
+end

data/lib/watir_robot/keywords/form.rb

@@ -0,0 +1,143 @@
+module WatirRobot
+  
+  #
+  # Functionality related to HTML forms as a whole
+  #
+  # @todo Add keywords here
+  module Form
+
+    #
+    # Verify that a form contains a specific button
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_contain_button(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The button described by #{field_loc} was not located in the form described by #{form_loc}") unless
+        @browser.form(parse_location(form_loc)).button(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form does not contain a specific button
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_not_contain_button(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The button described by #{field_loc} was not located in the form described by #{form_loc}") if
+        @browser.form(parse_location(form_loc)).button(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form contains a specific checkbox
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_contain_checkbox(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The checkbox described by #{field_loc} was not located in the form described by #{form_loc}") unless
+        @browser.form(parse_location(form_loc)).checkbox(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form does not contain a specific checkbox
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_not_contain_checkbox(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The checkbox described by #{field_loc} was not located in the form described by #{form_loc}") if
+        @browser.form(parse_location(form_loc)).checkbox(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form contains a specific file-field
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_contain_filefield(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The file-field described by #{field_loc} was not located in the form described by #{form_loc}") unless
+        @browser.form(parse_location(form_loc)).file_field(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form does not contain a specific file-field
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_not_contain_filefield(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The file-field described by #{field_loc} was not located in the form described by #{form_loc}") if
+        @browser.form(parse_location(form_loc)).file_field(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form contains a specific radio button
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_contain_radio_button(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The radio button described by #{field_loc} was not located in the form described by #{form_loc}") unless
+        @browser.form(parse_location(form_loc)).radio(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form does not contain a specific radio button
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_not_contain_radio_button(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The radio button described by #{field_loc} was not located in the form described by #{form_loc}") if
+        @browser.form(parse_location(form_loc)).radio(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form contains a specific select list
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_contain_select_list(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The select list described by #{field_loc} was not located in the form described by #{form_loc}") unless
+        @browser.form(parse_location(form_loc)).select(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form does not contain a specific select list
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_not_contain_select_list(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The select list described by #{field_loc} was not located in the form described by #{form_loc}") if
+        @browser.form(parse_location(form_loc)).select(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form contains a specific text field
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_contain_textfield(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The textfield described by #{field_loc} was not located in the form described by #{form_loc}") unless
+        @browser.form(parse_location(form_loc)).text_field(parse_location(field_loc)).exists?
+    end
+
+    #
+    # Verify that a form does not contain a specific text field
+    #
+    # @param [String] form_loc attribute/value pairs that match an HTML element
+    # @param [String] field_loc attribute/value pairs that match an HTML element
+    #
+    def form_should_not_contain_textfield(form_loc, field_loc)
+      raise(Exception::ElementMatchError, "The textfield described by #{field_loc} was not located in the form described by #{form_loc}") if
+        @browser.form(parse_location(form_loc)).text_field(parse_location(field_loc)).exists?
+    end
+    
+  end
+  
+end

data/lib/watir_robot/keywords/image.rb

@@ -0,0 +1,18 @@
+module WatirRobot
+  
+  #
+  # Functionality related to images in an HTML document
+  module Image
+    
+    #
+    # Click an image
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def click_image(loc)
+      @browser.image(parse_location(loc)).click
+    end
+    
+  end
+  
+end

data/lib/watir_robot/keywords/link.rb

@@ -0,0 +1,21 @@
+module WatirRobot
+  
+  #
+  # Functionality related to links in an HTML document
+  # 
+  module Link
+    
+    ### Actions ###
+    
+    #
+    # Click a link
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # 
+    def click_link(loc)
+      @browser.link(parse_location(loc)).click
+    end
+
+  end
+  
+end

data/lib/watir_robot/keywords/list.rb

@@ -0,0 +1,42 @@
+module WatirRobot
+  
+  #
+  # Functionality related to ordered and unordered HTML lists
+  # 
+  module List
+    
+    ### Actions ###
+    
+    #
+    # Get text from the items of a list
+    #
+    # The second argument can be "true" or "false"; true for ordered list, false (default) for unordered.
+    #
+    # @param [String] loc attribute/value pairs that match an HTML element
+    # @param [String] ordered true is ol, false is ul; strings for the booleans because the arguments come from Robot Framework
+    # @param [String] sep the separator that should be used to separate the list items
+    # 
+    def get_list_items(loc, ordered = "false", sep = ";;")
+      ordered = ordered.downcase unless ordered.nil?
+      if ordered.nil?
+        # TODO: Warn user about this ambiguity
+        list = @browser.ul(parse_location(loc))
+      elsif ordered == 'true'
+        list = @browser.ol(parse_location(loc))
+      elsif ordered == 'false'
+        list = @browser.ul(parse_location(loc))
+      else
+        raise(ArgumentError, "If you specify ordered vs. unordered lists, the only valid values are 'true' or 'false' (case-insensitive)")
+      end
+      
+      items = []
+      list.lis.each do |item|
+        items << item.text
+      end
+      
+      items.join(sep)
+    end
+    
+  end
+  
+end

data/lib/watir_robot/keywords/native.rb

@@ -0,0 +1,148 @@
+module WatirRobot
+  
+  #
+  # Native functionality for manipulating the mouse and keyboard via Java's java.awt.Robot class
+  # 
+  module Native
+    require 'java'
+    java_import 'java.awt.Robot'
+    java_import 'java.awt.event.InputEvent'
+    java_import 'java.awt.event.KeyEvent'
+    java_import 'java.awt.Toolkit'
+    java_import 'java.awt.Dimension'
+    java_import 'java.awt.Rectangle'
+    java_import 'java.awt.image.BufferedImage'
+    java_import 'javax.imageio.ImageIO'
+  
+    #
+    # Move mouse to specific coordinates
+    #
+    # @param [String] x x-axis coordinate (as string because arg comes from Robot Framework)
+    # @param [String] y y-axis coordinate (as string because arg comes from Robot Framework)
+    # 
+    def move_mouse_to_position(x, y)
+      @robot ||= Robot.new
+      @robot.mouseMove(x.to_i, y.to_i)
+    end
+  
+    #
+    # Left mouse press
+    # 
+    def press_left_mouse_button
+      @robot ||= Robot.new
+      @robot.mousePress(InputEvent::BUTTON1_MASK)
+    end
+  
+    #
+    # Right mouse press
+    # 
+    def press_right_mouse_button
+      @robot ||= Robot.new
+      @robot.mousePress(InputEvent::BUTTON2_MASK)
+    end
+  
+    #
+    # Left mouse release
+    # 
+    def release_left_mouse_button
+      @robot ||= Robot.new
+      @robot.mouseRelease(InputEvent::BUTTON1_MASK)
+    end
+  
+    #
+    # Right mouse release
+    # 
+    def release_right_mouse_button
+      @robot ||= Robot.new
+      @robot.mouseRelease(InputEvent::BUTTON2_MASK)
+    end
+  
+    #
+    # Left mouse click
+    # 
+    def click_left_mouse_button
+      @robot ||= Robot.new
+      press_left_mouse_button
+      release_left_mouse_button
+    end
+  
+    #
+    # Right mouse click
+    # 
+    def click_right_mouse_button
+      @robot ||= Robot.new
+      press_right_mouse_button
+      release_right_mouse_button
+    end
+    
+    #
+    # Press a key on a given HTML element
+    #
+    # @param [String] loc id, css or xpath query to identify an HTML element
+    # @param [String] the letter to be pressed, or an ASCII code in the format "ascii=65" (the letter 'a')
+    #
+    #def press_keys_at_location(loc, keys)
+    #  @browser.element(parse_location(loc)).focus
+    #  
+    #  @robot ||= Robot.new
+    #  key_codes = parse_key_code(key)
+    #  @robot.keyPress(key_code)
+    #  @robot.keyRelease(key_code)
+    #end
+    
+    #
+    # Press a key (literally press and release).
+    #
+    # If you want to press a key on a given HTML element, you should use the
+    # Press Key keyword, or use the Focus keyword before Press Key Native.
+    #
+    # @param [String] the letter to be pressed, or an ASCII code in the format "ascii=65" (the letter 'a')
+    #
+    #def press_keys(keys)
+    #  @robot ||= Robot.new
+    #  key_code = parse_key_code(key)
+    #  @robot.keyPress(key_code)
+    #  @robot.keyRelease(key_code)
+    #end
+  
+    #
+    # Drag and drop with the mouse
+    # 
+    # This is at the operating system level. Consider using WebDriver's
+    # facilities for drag and drop if you need drag-and-drop within a web page.
+    #
+    # @param [String] start_x x-axis coordinate of initial mouse press (as string because arg comes from Robot Framework)
+    # @param [String] start_y y-axis coordinate of iniital mouse press (as string because arg comes from Robot Framework)
+    # @param [String] finish_x x-axis coordinate of final mouse release (as string because arg comes from Robot Framework)
+    # @param [String] finish_y y-axis coordinate of final mouse release (as string because arg comes from Robot Framework)
+    # 
+    def drag_and_drop(start_x, start_y, finish_x, finish_y)
+      @robot ||= Robot.new
+      move_mouse_to_position(start_x.to_i, start_y.to_i)
+      press_left_mouse_button
+      move_mouse_to_position(finish_x.to_i, finish_y.to_i)
+      release_left_mouse_button
+    end
+    
+    #
+    # Take a screenshot of the entire screen
+    #
+    # @param [String] path the path (including file name) to which to save the screenshot image
+    #
+    def capture_screenshot(path = nil)
+      t = Toolkit.getDefaultToolkit
+      s = t.getScreenSize
+      rect = Rectangle.new(0, 0, s.width, s.height);
+      
+      @robot ||= Robot.new
+      image = @robot.createScreenCapture(rect)
+      if path.nil?
+        path = Time.now.to_i.to_s + '_screenshot.png'
+      end
+      file = java.io.File.new(path)
+      ImageIO.write(image, 'png', file)
+    end
+    
+  end
+  
+end