AXElements 0.9.0 → 1.0.0.alpha

data/rakelib/gem.rake

@@ -4,24 +4,15 @@ ax_elements = Gem::Specification.load('AXElements.gemspec')
 Gem::PackageTask.new(ax_elements) { }
 
 desc 'Build and install gem (not including deps)'
-task :install => [:gem, :setup] do
+task :install => :gem do
   require 'rubygems/installer'
   Gem::Installer.new("pkg/#{ax_elements.file_name}").install
 end
 
-desc 'Install dependencies for running AXElements'
-task :setup do
-  require 'rubygems/dependency_installer'
-  ax_elements.runtime_dependencies.each do |dep|
-    puts "Installing #{dep.name} (#{dep.requirement})"
-    Gem::DependencyInstaller.new.install(dep.name, dep.requirement)
-  end
-end
-
 desc 'Install dependencies for development'
-task :setup_dev => :setup do
+task :setup_dev do
   require 'rubygems/dependency_installer'
-  (ax_elements.runtime_dependencies + ax_elements.development_dependencies).each do |dep|
+  ax_elements.development_dependencies.each do |dep|
     puts "Installing #{dep.name} (#{dep.requirement})"
     Gem::DependencyInstaller.new.install(dep.name, dep.requirement)
   end

data/rakelib/test.rake

@@ -23,6 +23,12 @@ task :clobber => :clobber_fixture
 
 require 'rake/testtask'
 namespace :test do
+  Rake::TestTask.new(:core) do |t|
+    t.libs   << '.'
+    t.pattern = 'test/test_core.rb'
+  end
+  task :core => [:ext, :fixture]
+
   Rake::TestTask.new(:sanity) do |t|
     t.libs   << '.'
     t.pattern = "test/sanity/**/test_*.rb"
@@ -41,4 +47,13 @@ namespace :test do
     t.pattern = "test/sanity/accessibility/test_string.rb"
   end
   task :string => :ext
+
+  desc 'Run tests under CRuby (where applicable)'
+  task :cruby do
+    if ENV['RUBY_VERSION'] # using rvm
+      puts sh 'rvm 1.9.3 do rake test:string'
+    else
+      sh 'rake test:string'
+    end
+  end
 end

data/test/helper.rb

@@ -1,18 +1,28 @@
-require 'rubygems'
-require 'accessibility/core'
-framework 'Cocoa' if on_macruby?
+framework 'Cocoa'
 
 # We want to launch the test app and make sure it responds to
 # accessibility queries, but that is difficult to know at what
 # point it will start to respond, so we just sleep
-APP_BUNDLE_PATH       = 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'
 
-`open #{APP_BUNDLE_PATH}`
-sleep 3
-
-at_exit do
-  `killall AXElementsTester`
+error    = Pointer.new :id
+TEST_APP = NSWorkspace.sharedWorkspace.launchApplicationAtURL APP_BUNDLE_URL,
+                                                     options: NSWorkspaceLaunchAsync,
+                                               configuration: {},
+                                                       error: error
+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 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
+    puts STATS.to_s
+  end
 end
 
 
@@ -22,5 +32,5 @@ require 'test/runner'
 class MiniTest::Unit::TestCase
   # needs to be defined in the class, there is a TOPLEVEL::PID
   PID = pid_for APP_BUNDLE_IDENTIFIER
-  REF = Accessibility::Element.application_for PID
+  REF = AXUIElementCreateApplication(PID)
 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_dsl.rb

@@ -166,8 +166,7 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
 
   def test_wait_for_invalidation_of_element
     app.main_window.button(title: 'Yes').perform(:press)
-    Thread.new do
-      sleep 1
+    Dispatch::Queue.new("herp").after(1) do
       app.main_window.button(title: 'No').perform(:press)
     end
 
@@ -176,8 +175,7 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
 
   def test_wait_for_invalidation_of_wait_for
     app.main_window.button(title: 'Yes').perform(:press)
-    Thread.new do
-      sleep 1
+    Dispatch::Queue.new("herp").after(1) do
       app.main_window.button(title: 'No').perform(:press)
     end
 
@@ -201,33 +199,48 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
     app.main_window.set :position, orig_window_position if orig_window_position
   end
 
-  def test_right_click_with_block
-    area = app.main_window.web_area
-
-    got_called = false
-    dsl.right_click area do
-      got_called = true
-    end
-    assert got_called
-  ensure
-    dsl.click area
-  end
-
-  def test_triple_click
-    dummy_text = 'Lorem ipsum dolor.' * 15
-    text_area.set :value, dummy_text
-    dsl.triple_click text_area
-    assert_equal dummy_text, text_area.selected_text
-  ensure
-    app.main_window.text_area.set :value, ''
-  end
-
   def test_highlight
     highlighter = dsl.highlight app.main_window, colour: NSColor.blueColor
     assert_kind_of Accessibility::Highlighter, highlighter
-    assert_equal   NSColor.blueColor,          highlighter.color
+    assert_equal   NSColor.blueColor,          highlighter.backgroundColor
     highlighter.stop
-    refute highlighter.visible?
+
+    def highlight_test
+      @got_called = true
+    end
+    highlighter = dsl.highlight app.main_window, color: NSColor.greenColor, timeout: 0.1
+    NSNotificationCenter.defaultCenter.addObserver self,
+                                         selector: 'highlight_test',
+                                             name: NSWindowWillCloseNotification,
+                                           object: highlighter
+    sleep 0.1
+    assert @got_called
+  end
+
+  def test_dump_works_for_nested_tab_groups
+    output = dsl.subtree_for app.window.tab_group
+
+    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
 
   def test_screenshot
@@ -331,15 +344,4 @@ class TestAccessibilityDSL < MiniTest::Unit::TestCase
     pop_up.menu_item.perform :cancel unless pop_up.children.empty?
   end
 
-  def test_contextual_menu
-    Mouse.move_to app.window.web_area
-    menu = nil
-    dsl.right_click do
-      menu = dsl.contextual_menu
-    end
-    refute_nil menu, 'did not find the contextual menu'
-    refute_nil menu.item(title: 'Reload')
-    menu.perform :cancel
-  end
-
 end

data/test/integration/accessibility/test_enumerators.rb

@@ -49,6 +49,7 @@ end
 
 
 class TestAccessibilityEnumeratorsDepthFirst < MiniTest::Unit::TestCase
+  include Accessibility::Element
 
   def app
     @@app ||= AX::Application.new REF

data/test/integration/accessibility/test_graph.rb

@@ -4,7 +4,6 @@ require 'accessibility/graph'
 class TestAccessibilityGraph < MiniTest::Unit::TestCase
 
   def test_generate
-    skip 'graphs are broken right now'
     p = Accessibility::Graph.new(app.main_window).generate_png!
     assert File.exists? p
     assert_match /^PNG image/, `file --brief #{p}`

data/test/integration/accessibility/test_qualifier.rb

@@ -72,14 +72,14 @@ class TestAccessibilityQualifier < MiniTest::Unit::TestCase
 
   def test_qualifies_based_on_param_attribute_value
     e = app.attribute(:main_window).attribute(:title_ui_element)
-    q = qualifier(:StaticText, [:string_for_range, 0..1] => 'AX' )
+    q = qualifier(:StaticText, [:string_for_range, CFRange.new(0,2)] => 'AX' )
     assert q.qualifies? e
     refute q.qualifies? list
   end
 
   def test_qualifies_based_on_param_attribute_regexp_match
     e = app.attribute(:main_window).attribute(:title_ui_element)
-    q = qualifier(:StaticText, [:string_for_range, 0..1] => /AX/ )
+    q = qualifier(:StaticText, [:string_for_range, CFRange.new(0,2)] => /AX/ )
     assert q.qualifies? e
     refute q.qualifies? items.sample
   end

data/test/integration/ax/test_application.rb

@@ -13,13 +13,6 @@ class TestAXApplication < MiniTest::Unit::TestCase
     assert_equal app, AX::Application.new(running_app)
   end
 
-  def test_initialize_causing_app_to_launch
-    app = AX::Application.new('com.apple.Grab')
-    assert_kind_of AX::Application, app
-  ensure
-    app.terminate if app
-  end
-
   def test_can_set_focus_and_blur_app # lol, blur
     assert app.set :focused, false
     refute app.active?
@@ -32,7 +25,7 @@ class TestAXApplication < MiniTest::Unit::TestCase
     assert app.attribute :focused?
 
   ensure
-    running_app.activateWithOptions NSRunningApplication::NSApplicationActivateIgnoringOtherApps
+    running_app.activateWithOptions NSApplicationActivateIgnoringOtherApps
   end
 
   def test_can_hide_and_unhide_app
@@ -49,7 +42,7 @@ class TestAXApplication < MiniTest::Unit::TestCase
     refute app.hidden?
 
   ensure
-    running_app.activateWithOptions NSRunningApplication::NSApplicationActivateIgnoringOtherApps
+    running_app.activateWithOptions NSApplicationActivateIgnoringOtherApps
   end
 
   def test_set_calls_super

data/test/integration/ax/test_element.rb

@@ -10,13 +10,6 @@ class TestAXElement < MiniTest::Unit::TestCase
     assert_equal app.window.close_button, list.first
   end
 
-  def test_parameterized_attribute_normalizes_ranges
-    text = app.main_window.static_text
-    expected = text.value
-    actual   = text.parameterized_attribute :string_for_range, 0..-1
-    assert_equal expected, actual
-  end
-
   def test_search_singular_returns_array
     result = app.search(:window)
     assert_kind_of AX::Window, result
@@ -50,13 +43,6 @@ class TestAXElement < MiniTest::Unit::TestCase
     box.set :value, '' if box
   end
 
-  def test_parameterized_attribute_through_method_missing
-    field = app.window.static_text
-    expected = field.parameterized_attribute :string_for_range, 0..2
-    actual   = field.string_for_range 0..2
-    assert_equal expected, actual
-  end
-
   def test_invalid
     refute app.invalid?
 
@@ -66,30 +52,4 @@ class TestAXElement < MiniTest::Unit::TestCase
     assert bye.invalid?
   end
 
-  def test_dump_works_for_nested_tab_groups
-    output = app.window.tab_group.inspect_subtree
-
-    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/minitest/test_ax_elements.rb

@@ -0,0 +1,89 @@
+require 'test/integration/helper'
+require 'minitest/ax_elements'
+
+class TestMiniTestAssertions < MiniTest::Unit::TestCase
+
+  def test_assert_has_child
+    expected = app.window
+
+    assert_equal expected, assert_has_child(app, :window)
+    assert_equal expected, assert_has_child(app, :window, title: 'AXElementsTester')
+
+    assert_has_child(app, :window) { |_| @got_called = true }
+    assert @got_called
+  end
+
+  def test_assert_has_child_raises_in_failure_cases
+    e = assert_raises(MiniTest::Assertion) { assert_has_child app, :button }
+    assert_match /to have Button as a child/, e.message
+
+    e = assert_raises(MiniTest::Assertion) { assert_has_child app, :button, title: "Press" }
+    assert_match %r{to have Button\(title: "Press"\) as a child}, e.message
+  end
+
+  def test_assert_has_descendent
+    expected = app.main_window.check_box
+
+    assert_equal expected, assert_has_descendent(app,:check_box)
+    assert_equal expected, assert_has_descendent(app,:check_box, title: /Box/)
+
+    assert_has_descendent(app, :check_box) { |_| @got_called = true }
+    assert @got_called
+  end
+
+  def test_assert_has_descendent_raises_in_failure_cases
+    e = assert_raises(MiniTest::Assertion) {
+      assert_has_descendent(app.main_window.slider, :window, title: /Cake/)
+    }
+    assert_match /to have Window\(title: \/Cake\/\) as a descendent/, e.message
+  end
+
+  def test_assert_shortly_has
+    assert_equal app.window, assert_shortly_has(:window, parent: app)
+    assert_equal app.check_box, assert_shortly_has(:check_box, ancestor: app)
+
+    assert_shortly_has(:window, parent: app) { @got_called = true }
+    assert @got_called
+  end
+
+  def test_assert_shortly_has_raises_in_failure_cases
+    e = assert_raises(MiniTest::Assertion) { assert_shortly_has(:button, parent: app, timeout: 0) }
+    assert_match /to have child Button before a timeout occurred/, e.message
+
+    e = assert_raises(MiniTest::Assertion) { assert_shortly_has(:table, ancestor: app.menu_bar_item, timeout: 0) }
+    assert_match /to have descendent Table before a timeout occurred/, e.message
+  end
+
+  def test_refute_has_child
+    assert_nil refute_has_child(app, :button)
+    assert_nil refute_has_child(app, :window, title: 'Herp Derp')
+
+    result = refute_has_child(app, :window) { |x| x.title == 'Herp Derp' }
+    assert_nil result
+  end
+
+  def test_refute_has_child_raises_in_failure_cases
+    e = assert_raises(MiniTest::Assertion) { refute_has_child app, :window }
+    assert_match /NOT to have #{Regexp.escape(app.window.inspect)} as a child/, e.message
+  end
+
+  def test_refute_has_descendent
+    slider = app.main_window.slider
+
+    assert_nil refute_has_descendent(slider, :window)
+    assert_nil refute_has_descendent(slider, :element, title: 'Rhubarb')
+
+    result = refute_has_descendent slider, :element do |x|
+      @got_called = true
+      x.attributes.include?(:title) && x.title == 'Rhubarb'
+    end
+    assert_nil result
+    assert @got_called
+  end
+
+  def test_refute_has_descendent_raises_in_failure_cases
+    e = assert_raises(MiniTest::Assertion) { refute_has_descendent app, :window }
+    assert_match /#{Regexp.escape(app.window.inspect)} as a descendent/, e.message
+  end
+
+end

data/test/integration/rspec/expectations/test_ax_elements.rb

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+require 'test/integration/helper'
+require 'rspec/expectations/ax_elements'
+
+class TestRSpecMatchers < MiniTest::Unit::TestCase
+
+
+  def test_have_child_should_failure_message
+    e = app.main_window.slider
+    m = have_child(:window)
+
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have child Window", m.failure_message_for_should
+  end
+
+  def test_have_child_should_not_failure_message
+    e = app.window
+    m = have_child(:window)
+
+    refute m.does_not_match?(app)
+    assert_equal "Expected #{app.inspect} to NOT have child #{e.inspect}", m.failure_message_for_should_not
+  end
+
+  def test_have_child_description
+    m = have_child(:window) { }
+    assert_equal 'should have a child that matches Window[✔]', m.description
+  end
+
+
+
+  def test_have_descendent_should_failure_message
+    m = have_descendent(:button)
+    e = app.main_window.slider
+
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have descendent Button", m.failure_message_for_should
+  end
+
+  def test_have_descendent_should_not_failure_message
+    m = have_descendant(:window)
+    e = app.window
+
+    refute m.does_not_match?(app)
+    assert_equal "Expected #{app.inspect} to NOT have descendent #{e.inspect}", m.failure_message_for_should_not
+  end
+
+  def test_have_descendent_description
+    m = have_descendent(:button)
+    assert_equal 'should have a descendent matching Button', m.description
+  end
+
+
+
+  def test_shortly_have_child_should_failure_message
+    m = shortly_have_child(:button, timeout: 0) { }
+    e = app.main_window.slider
+
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have child Button[✔] before a timeout occurred",
+      m.failure_message_for_should
+  end
+
+  def test_shortly_have_child_should_not_failure_message
+    m = shortly_have_child(:window)
+    e = app
+
+    refute m.does_not_match?(e)
+    assert_equal "Expected #{e.inspect} to NOT have child #{e.window.inspect} before a timeout occurred",
+      m.failure_message_for_should_not
+  end
+
+  def test_shortly_have_child_description
+    m = shortly_have_child(:button)
+    assert_equal 'should have a child that matches Button before a timeout occurs', m.description
+  end
+
+
+
+  def test_shortly_have_descendent_should_failure_message
+    m = shortly_have_descendent(:button, timeout: 0)
+    e = app.main_window.slider
+
+    refute m.matches?(e)
+    assert_equal "Expected #{e.inspect} to have descendent Button before a timeout occurred",
+      m.failure_message_for_should
+  end
+
+  def test_shortly_have_descendent_should_not_failure_message
+    m = shortly_have_descendent(:window)
+    e = app
+
+    refute m.does_not_match?(e)
+    assert_equal "Expected #{e.inspect} to NOT have descendent #{e.window.inspect} before a timeout occurred",
+      m.failure_message_for_should_not
+  end
+
+  def test_shortly_have_descendent_description
+    m = shortly_have_descendent(:button)
+    assert_equal 'should have a descendent matching Button before a timeout occurs', m.description
+  end
+
+end