AXElements 1.0.0.alpha11 → 1.0.0.beta

data/lib/minitest/ax_elements.rb

@@ -1,180 +0,0 @@
-require 'ax/element'
-require 'accessibility/qualifier'
-require 'accessibility/dsl'
-
-##
-# AXElements assertions for MiniTest.
-# [Learn more about minitest.](https://github.com/seattlerb/minitest)
-class MiniTest::Assertions
-
-  ##
-  # Test that an element has a specific child. For example, test
-  # that a table has a row with certain contents. You can pass any
-  # filters that you normally would during a search, including a block.
-  #
-  # @example
-  #
-  #   assert_has_child table, :row, static_text: { value: 'Mark' }
-  #
-  # @param parent [AX::Element]
-  # @param kind [#to_s]
-  # @param filters [Hash]
-  # @yield Optional block used for filtering
-  # @return [AX::Element]
-  def assert_has_child parent, kind, filters = {}, &block
-    msg = message {
-      child = ax_search_id kind, filters, block
-      "Expected #{parent.inspect} to have #{child} as a child"
-    }
-    result = ax_check_children parent, kind, filters, block
-    refute result.blank?, msg
-    result
-  end
-
-  ##
-  # Test that an element has a specifc descendent. For example, test
-  # that a window contains a specific label. You can pass any filters
-  # that you normally would during a search, including a block.
-  #
-  # @example
-  #
-  #   assert_has_descendent window, :static_text, value: /Cake/
-  #
-  # @param ancestor [AX::Element]
-  # @param kind [#to_s]
-  # @param filters [Hash]
-  # @yield Optional block used for filtering
-  # @return [AX::Element]
-  def assert_has_descendent ancestor, kind, filters = {}, &block
-    msg = message {
-      descendent = ax_search_id kind, filters, block
-      "Expected #{ancestor.inspect} to have #{descendent} as a descendent"
-    }
-    result = ax_check_descendent ancestor, kind, filters, block
-    refute result.blank?, msg
-    result
-  end
-  alias_method :assert_has_descendant, :assert_has_descendent
-
-  ##
-  # Test that an element will have a child/descendent soon. This method
-  # will block until the element is found or a timeout occurs.
-  #
-  # This is a minitest front end to using {DSL#wait_for}, so any
-  # parameters you would normally pass to that method will work here.
-  # This also means that you must include either a `parent` key or an
-  # `ancestor` key as one of the filters.
-  #
-  # @param kind [#to_s]
-  # @param filters [Hash]
-  # @yield An optional block to be used in the search qualifier
-  def assert_shortly_has kind, filters = {}, &block
-    # need to know if parent/ancestor now because wait_for eats some keys
-    (ancest = filters[:ancestor]) || (parent = filters[:parent])
-    msg = message {
-      descend = ax_search_id kind, filters, block
-      if ancest
-        "Expected #{ancest.inspect} to have descendent #{descend} before a timeout occurred"
-      else
-        "Expected #{parent.inspect} to have child #{descend} before a timeout occurred"
-      end
-    }
-    result = wait_for kind, filters, &block
-    refute result.blank?, msg
-    result
-  end
-
-  ##
-  # Test that an element _does not_ have a specific child. For example,
-  # test that a row is no longer in a table. You can pass any filters
-  # that you normally would during a search, including a block.
-  #
-  # @example
-  #
-  #   refute_has_child table, :row, id: 'MyRow'
-  #
-  # @param parent [AX::Element]
-  # @param kind [#to_s]
-  # @param filters [Hash]
-  # @yield An optional block to be used in the search qualifier
-  # @return [nil]
-  def refute_has_child parent, kind, filters = {}, &block
-    result = ax_check_children parent, kind, filters, block
-    msg    = message {
-      "Expected #{parent.inspect} NOT to have #{result} as a child"
-    }
-    assert result.blank?, msg
-    result
-  end
-
-  ##
-  # Test that an element _does not_ have a specific descendent. For
-  # example, test that a window does not contain a spinning progress
-  # indicator anymore.
-  #
-  # @example
-  #
-  #  refute_has_descendent window, :busy_indicator
-  #
-  # @param ancestor [AX::Element]
-  # @param kind [#to_s]
-  # @param filters [Hash]
-  # @yield An optional block to be used in the search qualifier
-  # @return [nil,Array()]
-  def refute_has_descendent ancestor, kind, filters = {}, &block
-    result = ax_check_descendent ancestor, kind, filters, block
-    msg    = message {
-      "Expected #{ancestor.inspect} NOT to have #{result} as a descendent"
-    }
-    assert result.blank?, msg
-    result
-  end
-  alias_method :refute_has_descendant, :refute_has_descendent
-
-  ##
-  # @todo Does having this assertion make sense? I've only added it
-  #       for the time being because OCD demands it.
-  #
-  # Test that an element will NOT have a child/descendent soon. This
-  # method will block until the element is found or a timeout occurs.
-  #
-  # This is a minitest front end to using {DSL#wait_for}, so any
-  # parameters you would normally pass to that method will work here.
-  # This also means that you must include either a `parent` key or an
-  # `ancestor` key as one of the filters.
-  #
-  # @param kind [#to_s]
-  # @param filters [Hash]
-  # @yield An optional block to be used in the search qualifier
-  # @return [nil]
-  def refute_shortly_has kind, filters = {}, &block
-    result = wait_for kind, filters, &block
-    msg = message {
-      if ancest = filters[:ancestor]
-        "Expected #{ancest.inspect} NOT to have #{result.inspect} as a descendent"
-      else
-        parent = filters[:parent]
-        "Expected #{parent.inspect} NOT to have #{result.inspect} as a child"
-      end
-    }
-    assert result.blank?, msg
-    result
-  end
-
-
-  private
-
-  def ax_search_id kind, filters, block
-    Accessibility::Qualifier.new(kind, filters, &block).describe
-  end
-
-  def ax_check_children parent, kind, filters, block
-    q = Accessibility::Qualifier.new(kind, filters, &block)
-    parent.children.find { |x| q.qualifies? x }
-  end
-
-  def ax_check_descendent ancestor, kind, filters, block
-    ancestor.search(kind, filters, &block)
-  end
-
-end

data/lib/rspec/expectations/ax_elements.rb

@@ -1,234 +0,0 @@
-require 'accessibility/dsl'
-require 'accessibility/qualifier'
-require 'ax/element'
-
-module Accessibility
-
-  ##
-  # @abstract
-  #
-  # Base class for RSpec matchers used with AXElements.
-  class AbstractMatcher
-
-    # @return [#to_s]
-    attr_reader :kind
-
-    # @return [Hash{Symbol=>Object}]
-    attr_reader :filters
-
-    # @return [Proc]
-    attr_reader :block
-
-    # @param kind [#to_s]
-    # @param filters [Hash]
-    # @yield Optional block used for search filtering
-    def initialize kind, filters, &block
-      @kind, @filters, @block = kind, filters, block
-    end
-
-    # @param element [AX::Element]
-    def does_not_match? element
-      !matches?(element)
-    end
-
-
-    private
-
-    # @return [Accessibility::Qualifier]
-    def qualifier
-      @qualifier ||= Accessibility::Qualifier.new(kind, filters, &block)
-    end
-  end
-
-  ##
-  # Custom matcher for RSpec to check if an element has the specified
-  # child element.
-  class HasChildMatcher < AbstractMatcher
-    # @param parent [AX::Element]
-    def matches? parent
-      @parent = parent
-      @result = parent.children.find { |x| qualifier.qualifies? x }
-      !@result.blank?
-    end
-
-    # @return [String]
-    def failure_message_for_should
-      "Expected #@parent to have child #{qualifier.describe}"
-    end
-
-    # @return [String]
-    def failure_message_for_should_not
-      "Expected #@parent to NOT have child #@result"
-    end
-
-    # @return [String]
-    def description
-    "should have a child that matches #{qualifier.describe}"
-    end
-  end
-
-  ##
-  # Custom matcher for RSpec to check if an element has the specified
-  # descendent element.
-  class HasDescendentMatcher < AbstractMatcher
-    # @param ancestor [AX::Element]
-    def matches? ancestor
-      @ancestor = ancestor
-      @result   = ancestor.search(kind, filters, &block)
-      !@result.blank?
-    end
-
-    # @return [String]
-    def failure_message_for_should
-      "Expected #@ancestor to have descendent #{qualifier.describe}"
-    end
-
-    # @return [String]
-    def failure_message_for_should_not
-      "Expected #@ancestor to NOT have descendent #@result"
-    end
-
-    # @return [String]
-    def description
-      "should have a descendent matching #{qualifier.describe}"
-    end
-  end
-
-  ##
-  # Custom matcher for RSpec to check if an element has the specified
-  # child element within a grace period. Used for testing things
-  # after an asynchronous action is performed.
-  class HasChildShortlyMatcher < AbstractMatcher
-    include DSL
-
-    # @param parent [AX::Element]
-    def matches? parent
-      @filters[:parent] = @parent = parent
-      @result = wait_for kind, filters, &block
-      !@result.blank?
-    end
-
-    # @return [String]
-    def failure_message_for_should
-      "Expected #@parent to have child #{qualifier.describe} before a timeout occurred"
-    end
-
-    # @return [String]
-    def failure_message_for_should_not
-      "Expected #@parent to NOT have child #@result before a timeout occurred"
-    end
-
-    # @return [String]
-    def description
-      "should have a child that matches #{qualifier.describe} before a timeout occurs"
-    end
-  end
-
-  ##
-  # Custom matcher for RSpec to check if an element has the specified
-  # descendent element within a grace period. Used for testing things
-  # after an asynchronous action is performed.
-  class HasDescendentShortlyMatcher < AbstractMatcher
-    include DSL
-
-    # @param ancestor [AX::Element]
-    def matches? ancestor
-      @filters[:ancestor] = @ancestor = ancestor
-      @result = wait_for kind, filters, &block
-      !@result.blank?
-    end
-
-    # @return [String]
-    def failure_message_for_should
-      "Expected #@ancestor to have descendent #{qualifier.describe} before a timeout occurred"
-    end
-
-    # @return [String]
-    def failure_message_for_should_not
-      "Expected #@ancestor to NOT have descendent #@result before a timeout occurred"
-    end
-
-    # @return [String]
-    def description
-      "should have a descendent matching #{qualifier.describe} before a timeout occurs"
-    end
-  end
-end
-
-
-##
-# Assert that the receiving element has the specified child element. You
-# can use any filters you would normally use in a search, including
-# a block.
-#
-# @example
-#
-#   window.toolbar.should have_child(:search_field)
-#   table.should have_child(:row, static_text: { value: /42/ })
-#
-#   search_field.should_not have_child(:busy_indicator)
-#
-# @param kind [#to_s]
-# @param filters [Hash]
-# @yield An optional block to be used as part of the search qualifier
-def have_child kind, filters = {}, &block
-  Accessibility::HasChildMatcher.new kind, filters, &block
-end
-
-##
-# Assert that the given element has the specified descendent. You can
-# pass any parameters you normally would use during a search,
-# including a block.
-#
-# @example
-#
-#   app.main_window.should have_descendent(:button, title: 'Press Me')
-#
-#   row.should_not have_descendent(:check_box)
-#
-# @param kind [#to_s]
-# @param filters [Hash]
-# @yield An optional block to be used as part of the search qualifier
-def have_descendent kind, filters = {}, &block
-  Accessibility::HasDescendentMatcher.new kind, filters, &block
-end
-alias :have_descendant :have_descendent
-
-##
-# Assert that the given element has the specified child soon. This
-# method will block until the child is found or a timeout occurs. You
-# can pass any parameters you normally would use during a search,
-# including a block.
-#
-# @example
-#
-#   app.main_window.should shortly_have_child(:row, static_text: { value: 'Cake' })
-#
-#   row.should_not shortly_have_child(:check_box)
-#
-# @param kind [#to_s]
-# @param filters [Hash]
-# @yield An optional block to be used as part of the search qualifier
-def shortly_have_child kind, filters = {}, &block
-  Accessibility::HasChildShortlyMatcher.new(kind, filters, &block)
-end
-
-##
-# Assert that the given element has the specified descendent soon. This
-# method will block until the descendent is found or a timeout occurs.
-# You can pass any parameters you normally would use during a search,
-# including a block.
-#
-# @example
-#
-#   app.main_window.should shortly_have_child(:row, static_text: { value: 'Cake' })
-#
-#   row.should_not shortly_have_child(:check_box)
-#
-# @param kind [#to_s]
-# @param filters [Hash]
-# @yield An optional block to be used as part of the search qualifier
-def shortly_have_descendent kind, filters = {}, &block
-  Accessibility::HasDescendentShortlyMatcher.new kind, filters, &block
-end
-alias :shortly_have_descendant :shortly_have_descendent

data/test/integration/accessibility/test_core.rb

@@ -1,18 +0,0 @@
-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/minitest/test_ax_elements.rb

@@ -1,89 +0,0 @@
-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