AXElements 0.6.0beta2 → 0.7.5

data/test/helper.rb

@@ -1,119 +1,33 @@
-require 'rubygems'
-
-require 'ax_elements'
-require 'stringio'
-
-# Accessibility.log.level = Logger::DEBUG
+framework 'Cocoa'
 
 # We want to launch the test app and make sure it responds to
 # accessibility queries, but that is difficult, so we just sleep
-APP_BUNDLE_URL = NSURL.URLWithString File.expand_path './test/fixture/Release/AXElementsTester.app'
+APP_BUNDLE_URL = NSURL.fileURLWithPath File.expand_path './test/fixture/Release/AXElementsTester.app'
+APP_BUNDLE_IDENTIFIER = 'com.marketcircle.AXElementsTester'
 
-error = Pointer.new :id
+error    = Pointer.new :id
 TEST_APP = NSWorkspace.sharedWorkspace.launchApplicationAtURL APP_BUNDLE_URL,
                                                      options: NSWorkspaceLaunchAsync,
                                                configuration: {},
                                                        error: error
-if error[0]
-  $stderr.puts 'You need to build AND run the fixture app before running tests'
-  $stderr.puts 'Run `rake fixture`'
+if TEST_APP.nil?
+  $stderr.puts 'You need to build AND run the fixture app once before running tests'
+  $stderr.puts 'Run `rake run_fixture` to initalize the fixture'
   exit 3
 else
-  sleep 3 # I haven't yet figured out a good way of knowing exactly
-          # when the app is ready
+  sleep 2 # Instead of using high level features of AXElements that we are
+          # testing, I think it is just safer to sleep
   # Make sure the test app is closed when testing finishes
   at_exit do TEST_APP.terminate end
 end
 
 
-gem     'minitest'
-require 'minitest/autorun'
-
-# preprocessor powers, assemble!
-if ENV['BENCH']
-  require 'minitest/benchmark'
-else
-  require'minitest/pride'
-end
+require 'test/runner'
 
 
 class MiniTest::Unit::TestCase
-  # You may need this to help track down an issue if a test is crashing MacRuby
-  # def self.test_order
-  #   :alpha
-  # end
-
-  def assert_instance_of_boolean value
-    message = "Expected #{value.inspect} to be a boolean"
-    assert value.is_a?(TrueClass) || value.is_a?(FalseClass), message
-  end
-
-  def self.bench_range
-    bench_exp 10, 10_000
-  end
-end
-
-##
-# A mix in module to allow capture of logs
-module LoggingCapture
-  def setup
-    super
-    @log_output = StringIO.new
-    Accessibility.log = Logger.new @log_output
-  end
-end
-
-module AXHelpers
-  def pid_for name
-    NSWorkspace.sharedWorkspace.runningApplications.find do |app|
-      app.bundleIdentifier == name
-    end.processIdentifier
-  end
-
-  # returns raw attribute
-  def attribute_for element, attr
-    ptr = Pointer.new :id
-    AXUIElementCopyAttributeValue(element, attr, ptr)
-    ptr[0]
-  end
-
-  def children_for element
-    attribute_for element, KAXChildrenAttribute
-  end
-
-  def value_for element
-    attribute_for element, KAXValueAttribute
-  end
-
-  def action_for element, action
-    AXUIElementPerformAction(element, action)
-  end
-
-  # remember to wrap structs in an AXValueRef
-  def set_attribute_for element, attr, value
-    AXUIElementSetAttributeValue(element, attr, value)
-  end
-end
-
-class TestAX < MiniTest::Unit::TestCase
-  include AXHelpers
-  extend AXHelpers
-
-  APP_BUNDLE_IDENTIFIER = 'com.marketcircle.AXElementsTester'
+  # needs to be defined in the class, there is a TOPLEVEL::PID
   PID = pid_for APP_BUNDLE_IDENTIFIER
   REF = AXUIElementCreateApplication(PID)
-
-  # execute the block with full logging turned on
-  def with_logging level = Logger::DEBUG
-    original_level = Accessibility.log.level
-    Accessibility.log.level = level
-    yield
-    Accessibility.log.level = original_level
-  end
 end
 
-##
-# Just pretend that you didnt' see this hack
-class AX::Element
-  attr_reader :ref
-end

data/test/integration/accessibility/test_core.rb

@@ -0,0 +1,18 @@
+require 'test/integration/helper'
+
+class TestAccessibilityCore < MiniTest::Unit::TestCase
+
+  # this assumes that radar://10040865 is not fixed
+  # once it is fixed, this case becomes less of an
+  # issue anyways
+  def test_nil_children_returns_empty_array
+    app  = app_with_name 'AXElementsTester'
+    menu = app.menu_bar_item(title: 'Help')
+    press menu
+
+    assert_empty menu.search_field.children
+  ensure
+    cancel menu if menu
+  end
+
+end

data/test/integration/accessibility/test_debug.rb

@@ -0,0 +1,44 @@
+require 'test/integration/helper'
+
+class TestAccessibilityDebug < MiniTest::Unit::TestCase
+
+  def app
+    @app ||= AX::Application.new PID
+  end
+
+  def test_path_returns_correct_elements_in_correct_order
+    list = Accessibility::Debug.path(app.window.close_button)
+    assert_equal 3, list.size
+    assert_instance_of AX::CloseButton,    list.first
+    assert_instance_of AX::StandardWindow, list.second
+    assert_instance_of AX::Application,    list.third
+  end
+
+  def test_dump_works_for_nested_tab_groups
+    element = app.window.tab_group
+    output  = Accessibility::Debug.subtree_for element
+
+    expected = [
+                ['AX::TabGroup',    0],
+                ['AX::RadioButton', 1], ['AX::RadioButton', 1], ['AX::TabGroup', 1],
+                ['AX::RadioButton', 2], ['AX::RadioButton', 2], ['AX::TabGroup', 2],
+                ['AX::RadioButton', 3], ['AX::RadioButton', 3], ['AX::TabGroup', 3],
+                ['AX::RadioButton', 4], ['AX::RadioButton', 4],
+                ['AX::Group',       4],
+                ['AX::TextField',   5], ['AX::StaticText',  6],
+                ['AX::TextField' ,  5], ['AX::StaticText',  6]
+               ]
+
+    refute_empty output
+    output = output.split("\n")
+
+    until output.empty?
+      line           = output.shift
+      klass, indents = expected.shift
+      assert_equal indents, line.match(/^\t*/).to_a.first.length, line
+      line.strip!
+      assert_match /^\#<#{klass}/, line
+    end
+  end
+
+end

data/test/integration/accessibility/test_dsl.rb

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+require 'test/integration/helper'
+
+class TestAccessibilityDSL < MiniTest::Unit::TestCase
+
+  # LSP FTW
+  class DSL
+    include Accessibility::DSL
+  end
+
+  def dsl
+    @dsl ||= DSL.new
+  end
+
+  def app
+    @@app ||= AX::Application.new REF
+  end
+
+  def text_area
+    @@text_area ||= app.main_window.text_area
+  end
+
+  def pref_window
+    app.children.find { |x|
+      x.attributes.include?(:title) && x.title == 'Preferences'
+    }
+  end
+
+  def spelling_window
+    app.children.find { |x|
+      x.attributes.include?(:title) && x.title.match(/^Spelling/)
+    }
+  end
+
+  def try_typing string, expected = nil
+    expected = string unless expected
+    text_area.set :focused, true
+    dsl.type string
+    assert_equal expected, text_area.value
+  ensure # reset for next test
+    dsl.type "\\COMMAND+a \b"
+  end
+
+  def test_dsl_is_mixed_into_toplevel
+    assert_includes Object.new.class.ancestors, Accessibility::DSL
+  end
+
+  def test_application_with_bundle_id
+    assert_equal app, dsl.app_with_bundle_identifier(APP_BUNDLE_IDENTIFIER)
+    assert_equal app, dsl.app_with_bundle_id(APP_BUNDLE_IDENTIFIER)
+    assert_equal app, dsl.launch(APP_BUNDLE_IDENTIFIER)
+  end
+
+  def test_application_with_name
+    assert_equal app, dsl.app_with_name('AXElementsTester')
+  end
+
+  def test_application_with_pid
+    assert_equal app, dsl.app_with_pid(PID)
+  end
+
+  def test_typing_human_string
+    try_typing "A sentence, with punctuation and num8ers. LOL!\tA 'quoted' string--then some @#*$."
+  end
+
+  def test_typing_backspaces
+    try_typing "The cake is a lie!\b\b\b\bgift!", 'The cake is a gift!'
+  end
+
+  def test_typing_hotkeys
+    try_typing ", world!\\CONTROL+a Hello", 'Hello, world!'
+    try_typing "MacRuby\\OPTION+2",         'MacRuby™'
+  end
+
+  def test_typing_command_keys
+    try_typing "Hai.\\<- \\<- \b", "Hi."
+  end
+
+  def test_typing_ruby_escapes
+    try_typing "First.\nSecond."
+  end
+
+  def test_select_menu_item_string
+    assert_nil pref_window
+    dsl.select_menu_item app, app.title, 'Preferences…'
+    window = dsl.wait_for :window, parent: app, title: 'Preferences'
+    refute_nil window
+  ensure
+    window.close_button.perform :press if window
+  end
+
+  def test_select_menu_item_regexp
+    assert_nil spelling_window
+    dsl.select_menu_item app, /Edit/, /Spelling/, /show spelling/i
+    window = dsl.wait_for :floating_window, parent: app
+    refute_nil window
+  ensure
+    window.close_button.perform :press if window
+  end
+
+  def test_select_menu_item_raises_if_cannot_find_item
+    assert_raises Accessibility::SearchFailure do
+      dsl.select_menu_item app, 'File', 'NonExistantMenuItem'
+    end
+    # @todo verify that menu is closed
+  end
+
+  def test_select_menu_item_provides_proper_debug_info
+    e = assert_raises Accessibility::SearchFailure do
+      dsl.select_menu_item app, 'Format', 'Front'
+    end
+    assert_match /MenuItem/, e.message
+  end
+
+  def test_wait_for_obeys_timeout_option
+    # loop sleeps for 0.2, so we have to wait at least that long
+    start = Time.now
+    dsl.wait_for :strawberry_rhubarb, parent: AX::DOCK, timeout: 0.2
+    assert_in_delta Time.now, start, 0.3
+  end
+
+  def test_wait_for_parent_only_looks_at_children
+    result = dsl.wait_for :trash_dock_item, parent: AX::DOCK, timeout: 0.5
+    assert_nil result
+
+    result = dsl.wait_for :trash_dock_item, parent: AX::DOCK.list
+    assert_equal AX::DOCK.list.trash_dock_item, result
+
+    result = dsl.wait_for :button, parent: app.main_window, title: 'Yes'
+    assert_equal 'Yes', result.title
+  end
+
+  def test_wait_for_ancestor_searches
+    result = dsl.wait_for :trash_dock_item, ancestor: AX::DOCK
+    assert_equal AX::DOCK.list.trash_dock_item, result
+
+    result = dsl.wait_for :nothing, ancestor: AX::DOCK, timeout: 0.5
+    assert_nil result
+
+    result = dsl.wait_for :text_field, ancestor: app.main_window, value: 'AXIsNyan'
+    assert_equal 'AXIsNyan', result.value
+  end
+
+  def test_system_wide
+    assert_instance_of AX::SystemWide, dsl.system_wide
+  end
+
+  def test_element_under_mouse
+    [
+      app.main_window.close_button,
+      app.main_window.value_indicator
+    ].each do |element|
+      dsl.move_mouse_to element
+      assert_equal element, dsl.element_under_mouse
+    end
+  end
+
+  def test_element_at_point_for_app
+    [
+      app.main_window.minimize_button,
+      app.main_window.increment_arrow
+    ].each do |element|
+      assert_equal element, dsl.element_at_point(element, for: app)
+    end
+  end
+
+  # @todo We aren't being very thorough here
+  def test_element_at_point
+    [
+      app.main_window.minimize_button,
+      app.main_window.increment_arrow
+    ].each do |element|
+      assert_equal element, dsl.element_at_point(element)
+    end
+  end
+
+  def test_show_about_window
+    dialog = dsl.show_about_window_for app
+    assert_instance_of AX::Dialog, dialog
+    assert_equal 'AXElementsTester icon', dialog.image.description
+  ensure
+    dialog.close_button.perform :press if dialog
+  end
+
+  def test_show_prefs_for_app
+    prefs = dsl.show_preferences_window_for app
+    assert_kind_of AX::Window, prefs
+    assert_equal 'Preferences', prefs.title
+  ensure
+    prefs.close_button.perform :press if prefs
+  end
+
+  def test_scroll_to
+    table = app.main_window.table
+    ['AXIsNyan', 'AXSubrole'].each do |attr|
+      text = table.text_field(value: attr)
+      dsl.scroll_to text
+      assert NSContainsRect(table.bounds, text.bounds)
+    end
+  end
+
+  def test_scroll_menu_to
+    pop_up = app.main_window.pop_up_button
+
+    pop_up.perform :press
+    expected = pop_up.menu_item(title: '49')
+    dsl.scroll_menu_to expected
+    assert_equal expected, element_under_mouse
+    dsl.click
+    assert_equal '49', pop_up.value
+
+    pop_up.perform :press
+    expected = pop_up.menu_item(title: 'Togusa')
+    dsl.scroll_menu_to expected
+    assert_equal expected, element_under_mouse
+    dsl.click
+    assert_equal 'Togusa', pop_up.value
+
+  ensure
+    unless pop_up.children.empty?
+      pop_up.menu_item.perform :cancel
+    end if pop_up
+  end
+
+end

data/test/integration/accessibility/test_enumerators.rb

@@ -0,0 +1,122 @@
+require 'test/integration/helper'
+
+class TestAccessibilityEnumeratorsBreadthFirst < MiniTest::Unit::TestCase
+
+  def app
+    @@app ||= AX::Application.new REF
+  end
+
+  def test_each_iterates_in_correct_order
+    tab_group = app.main_window.children.find { |x| x.class == AX::TabGroup }
+    enum      = Accessibility::Enumerators::BreadthFirst.new(tab_group)
+    actual    = enum.map &:class
+    expected  = [
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::Group,
+                 AX::TextField,   AX::TextField,
+                 AX::StaticText,  AX::StaticText
+                ]
+    assert_equal expected, actual
+  end
+
+  def test_first_element_is_first_child # not the root
+    enum = Accessibility::Enumerators::BreadthFirst.new app
+    def enum.first
+      each { |x| return x }
+    end
+    assert_instance_of AX::StandardWindow, enum.first
+  end
+
+  # this was a big performance issue, so we should make sure it
+  # doesn't happen again
+  def test_find_returns_immediately_after_finding
+    tree  = Accessibility::Enumerators::BreadthFirst.new app
+    cache = []
+    tree.find do |element|
+      cache << element.class
+      element.class == AX::StandardWindow
+    end
+    assert_equal 1, cache.size
+  end
+
+  def bench_each
+    skip 'TODO'
+  end
+
+  def bench_find
+    skip 'TODO'
+  end
+
+end
+
+
+class TestAccessibilityEnumeratorsDepthFirst < MiniTest::Unit::TestCase
+  include Accessibility::Core
+
+  def app
+    @@app ||= AX::Application.new REF
+  end
+
+  def test_each_iterates_in_correct_order
+    tab_group = app.main_window.children.find { |x| x.class == AX::TabGroup }
+    enum      = Accessibility::Enumerators::DepthFirst.new tab_group
+    actual    = enum.map &:class
+    expected  = [
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::Group,
+                 AX::TextField, AX::StaticText,
+                 AX::TextField, AX::StaticText
+                ]
+    assert_equal expected, actual
+  end
+
+  # since we have a different implementation, we should also verify order here...
+  def test_each_with_level_in_correct_order
+    tab_group = app.main_window.children.find { |x| x.class == AX::TabGroup }
+    enum      = Accessibility::Enumerators::DepthFirst.new tab_group
+    actual    = []
+    enum.each_with_level do |x,_| actual << x.class end
+    expected  = [
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::TabGroup,
+                 AX::RadioButton, AX::RadioButton, AX::Group,
+                 AX::TextField, AX::StaticText,
+                 AX::TextField, AX::StaticText
+                ]
+    assert_equal expected, actual
+  end
+
+  def test_each_with_level_has_correct_height
+    enum   = Accessibility::Enumerators::DepthFirst.new app.main_window
+    actual = []
+    enum.each_with_level do |element, level|
+      actual << [element.class, level]
+    end
+
+    assert_includes actual, [AX::Slider,         1]
+    assert_includes actual, [AX::CloseButton,    1]
+    assert_includes actual, [AX::ZoomButton,     1]
+    assert_includes actual, [AX::MinimizeButton, 1]
+    assert_includes actual, [AX::SearchField,    1]
+    assert_includes actual, [AX::CheckBox,       1]
+    assert_includes actual, [AX::WebArea,        2]
+    assert_includes actual, [AX::Table,          2]
+    assert_includes actual, [AX::ScrollBar,      2]
+    assert_includes actual, [AX::SortButton,     4]
+  end
+
+  def bench_each
+    skip 'TODO'
+  end
+
+  def bench_each_with_level
+    skip 'TODO'
+  end
+
+end
+

data/test/integration/accessibility/test_errors.rb

@@ -0,0 +1,38 @@
+require 'test/integration/helper'
+
+class TestAccessibilityErrors < MiniTest::Unit::TestCase
+
+  def test_search_failure_shows_arguments
+    e = Accessibility::SearchFailure.new(AX::DOCK, :list, {herp: :derp})
+    def e.backtrace; []; end
+    assert_match /Could not find `List\(herp: :derp\)`/, e.message
+    assert_match /as a child of AX::Application/, e.message
+    assert_match /Element Path:\n\t\#<AX::Application/, e.message
+
+    e = Accessibility::SearchFailure.new(AX::DOCK, :list, {})
+    def e.backtrace; []; end
+    assert_match /Could not find `List`/, e.message
+
+    e = Accessibility::SearchFailure.new(AX::DOCK, :list, nil)
+    def e.backtrace; []; end
+    assert_match /Could not find `List`/, e.message
+  end
+
+  def test_search_failure_shows_element_path
+    l = AX::DOCK.children.first
+    e = Accessibility::SearchFailure.new(l, :trash_dock_item, nil)
+    def e.backtrace; []; end
+    assert_match /AX::Application/, e.message
+    assert_match /AX::List/, e.message
+  end
+
+  def test_search_failure_includes_subtree_in_debug_mode
+    assert Accessibility::Debug.on?, 'Someone turned debugging off'
+    l = AX::DOCK.children.first
+    e = Accessibility::SearchFailure.new(l, :trash_dock_item, nil)
+    def e.backtrace; []; end
+    assert_match /Subtree:/, e.message
+    assert_match subtree_for(l), e.message
+  end
+
+end

data/test/integration/accessibility/test_notifications.rb

@@ -0,0 +1,22 @@
+class TestAccessibilityNotifications < MiniTest::Unit::TestCase
+
+  def test_custom_notifications
+  end
+
+
+  def test_standard_notifications
+  end
+
+
+  def test_notifications_from_the_app
+  end
+
+
+  def test_notification_filtering
+    # I can reject based on block return value
+  end
+
+  def test_notification_callbacks_get_correct_arguments
+  end
+
+end