locator 0.0.6 → 0.0.7

data/test/locator/matcher/have_content_test.rb

@@ -1,29 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class LocatorMatcherHaveContentTest < Test::Unit::TestCase
-  include Locator::Matcher
-  
-  def setup
-    @html = '<p><a class="foo">The link</a></p>'
-  end
-  
-  test 'target matches a given text' do
-    assert contain('The link').matches?(@html)
-  end
-
-  test 'target does not match a given text' do
-    assert !contain('No link').matches?(@html)
-  end
-  
-  test 'target matches a given regex' do
-    assert contain(/The\slink/).matches?(@html)
-  end
-
-  test 'target does not match a given regex' do
-    assert !contain(/No\slink/).matches?(@html)
-  end
-  
-  test 'treats newslines as spaces' do
-    assert contain('Some text').matches?("<p>Some\ntext</p>")
-  end
-end

data/test/locator/matcher/have_tag_test.rb

@@ -1,161 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class LocatorMatcherHaveTagTest < Test::Unit::TestCase
-  include Locator::Matcher
-
-  def setup
-    @html = '<p><a class="foo">The link</a></p>'
-  end
-
-  # given a selector
-
-  test 'target matches a given selector' do
-    assert have_tag('The link').matches?(@html)
-  end
-
-  test 'target does not match a given selector' do
-    assert !have_tag('No link').matches?(@html)
-  end
-
-  # given an xpath
-
-  test 'target matches a given xpath' do
-    assert have_tag(:xpath => '//p/a[@class="foo"]').matches?(@html)
-  end
-
-  test 'target does not match a given xpath' do
-    assert !have_tag(:xpath => '//p/a[@id="foo"]').matches?(@html)
-  end
-
-  # given a css selector
-
-  test 'target matches a given css' do
-    assert have_tag(:css => 'p a.foo').matches?(@html)
-  end
-
-  test 'target does not match a given css' do
-    assert !have_tag(:css => 'p a#foo').matches?(@html)
-  end
-
-  # given a selector and xpath
-
-  test 'target matches a given selector and xpath' do
-    assert have_tag('The link', :xpath => '//p/a').matches?(@html)
-  end
-
-  test 'target does not match a given (wrong) selector and xpath' do
-    assert !have_tag('No link', :xpath => '//p/a').matches?(@html)
-  end
-
-  test 'target does not match a given selector and (wrong) xpath' do
-    assert !have_tag('The link', :xpath => '//p/div').matches?(@html)
-  end
-
-  # given a selector and css selector
-
-  test 'target matches a given selector and css selector' do
-    assert have_tag('The link', :css => 'p a').matches?(@html)
-  end
-
-  test 'target does not match a given (wrong) selector and css selector' do
-    assert !have_tag('No link', :css => 'p a').matches?(@html)
-  end
-
-  test 'target does not match a given selector and (wrong) css selector' do
-    assert !have_tag('The link', :css => 'p div').matches?(@html)
-  end
-
-  # given an xpath and attributes
-
-  test 'target matches a given xpath and attributes' do
-    assert have_tag(:xpath => '//p/a', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given (wrong) xpath and attributes' do
-    assert !have_tag(:xpath => '//p/div', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given xpath and (wrong) attributes' do
-    assert !have_tag(:xpath => '//p/a', :id => 'foo').matches?(@html)
-  end
-
-  # given selector, xpath and attributes
-
-  test 'target matches a given selector, xpath and attributes' do
-    assert have_tag('The link', :xpath => '//p/a', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given (wrong) selector, xpath and attributes' do
-    assert !have_tag('The link', :xpath => '//p/div', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given selector, (wrong) xpath and attributes' do
-    assert !have_tag('No link', :xpath => '//p/a', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given selector, xpath and (wrong) attributes' do
-    assert !have_tag('The link', :xpath => '//p/a', :class => 'bar').matches?(@html)
-  end
-
-  # given a selector, css selector and attributes
-
-  test 'target matches a given selector, css selector and attributes' do
-    assert have_tag('The link', :css => 'p a', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given (wrong) selector, css selector and attributes' do
-    assert !have_tag('The link', :css => 'p div', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given selector, (wrong) css selector and attributes' do
-    assert !have_tag('No link', :css => 'p a', :class => 'foo').matches?(@html)
-  end
-
-  test 'target does not match a given selector, css selector and (wrong) attributes' do
-    assert !have_tag('The link', :css => 'p a', :class => 'bar').matches?(@html)
-  end
-
-  # using a block
-
-  # test 'given block selects from matched elements (block yields true)' do
-  #   assert have_tag(:xpath => '//p') { true }.matches?(@html)
-  # end
-  #
-  # test 'given block selects from matched elements (block yields false)' do
-  #   assert !have_tag(:xpath => '//p') { false }.matches?(@html)
-  # end
-
-  test 'can use have_path in the given block' do
-    assert have_tag(:xpath => '//p') { assert have_tag(:xpath => '//a').matches?(nil); true }.matches?(@html)
-  end
-
-  test 'uses a relative path when called in a block' do
-    assert have_tag(:xpath => '//p') { assert have_tag(:xpath => '//a').matches?(nil); true }.matches?(@html)
-  end
-
-  test 'does not match parent tags called in a block' do
-    assert have_tag(:xpath => '//a') { assert !have_tag(:xpath => '//p').matches?(nil); true }.matches?(@html)
-  end
-
-  # counting matches
-
-  test 'target contains the given number of elements' do
-    assert have_tag(:xpath => '//p/a', :count => 1).matches?(@html)
-  end
-
-  test 'target does not contain the given number of elements' do
-    assert !have_tag(:xpath => '//p/a', :count => 2).matches?(@html)
-  end
-
-  test 'target contains the given number of elements when used with a block' do
-    assert have_tag(:xpath => '//p/a', :count => 1) { |element| element.name == 'a' }.matches?(@html)
-  end
-
-  test 'target does not contain the given number of elements when used with a block (too few elements)' do
-    assert !have_tag(:xpath => '//p/a', :count => 2) { |element| element.name == 'a' }.matches?(@html)
-  end
-
-  test 'target does not contain the given number of elements when used with a block (block does not match)' do
-    assert !have_tag(:xpath => '//p/a', :count => 1) { |element| element.name == 'div' }.matches?(@html)
-  end
-end

data/test/locator/xpath_test.rb

@@ -1,45 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'locator/xpath'
-
-class XpathTest < Test::Unit::TestCase
-  Xpath = Locator::Xpath
-
-  def setup
-    Locator::Boolean::Or.operator, Locator::Boolean::And.operator = ' | ', ''
-  end
-
-  test "simple xpath" do
-    path = Xpath.new('input').to_s
-    assert_equal ".//input", path
-  end
-
-  test "xpath with alternate nodenames" do
-    path = Xpath.new(['input', 'button']).to_s
-    assert_equal ".//input | .//button", path
-  end
-
-  test "xpath with attributes" do
-    path = Xpath.new(['input', 'button'], :type => 'text', :id => 'foo')
-    assert_equal %(.//input[@type="text"][@id="foo"] | .//button[@type="text"][@id="foo"]), path.to_s
-  end
-
-  test "xpath with alternate nodenames and attributes" do
-    path = Xpath.new(['input', 'button']).to_s
-    assert_equal ".//input | .//button", path
-  end
-  
-  test "attribute equals to one of multiple values" do
-    path = Xpath.new('input', :type => [:text, :password]).to_s
-    assert_equal %(.//input[@type="text" or @type="password"]), path
-  end
-  
-  test "one of multiple attributes equals to value" do
-    path = Xpath.new('input', [:id, :name] => 'foo').to_s
-    assert_equal %(.//input[@id="foo" or @name="foo"]), path
-  end
-  
-  test "one of multiple attributes equals to one of multiple values" do
-    path = Xpath.new('input', [:id, :name] => ['foo', 'bar']).to_s
-    assert_equal %(.//input[@id="foo" or @id="bar" or @name="foo" or @name="bar"]), path
-  end
-end

data/test/locator_test.rb

@@ -1,132 +0,0 @@
-# encoding: utf-8
-require File.expand_path('../test_helper', __FILE__)
-
-class LocatorTest < Test::Unit::TestCase
-  include Locator
-
-  # test "returns the element if given an element" do
-  #   html = '<p></p>'
-  #   element = locate(html, :p)
-  #   assert_equal element, locate(html, element)
-  # end
-
-  test "looks up a locator/element class by type" do
-    assert_equal Locator::Element::Field, Locator[:field]
-  end
-
-  test "generates an xpath for type and given args" do
-    xpath = xpath(:form, :id => 'bar')
-    assert_equal './/form[@id="bar"]', xpath
-  end
-
-  # locate
-
-  test "locates the first element by node name" do
-    html = '<html><body><form id="foo"></form><form id="bar"></form></body></html>'
-    element = locate(html, :form)
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "locates the first element by xpath" do
-    html = '<html><body><form id="foo"></form><form id="bar"></form></body></html>'
-    element = locate(html, :xpath => '//form')
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  # within
-
-  test "within scopes to a locator" do
-    html = '<form></form><div id="bar"><form id="foo"></form></div>'
-    element = within(html, :div, :id => 'bar') { locate(:form) }
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "within scopes to a css selector" do
-    html = '<form></form><div id="bar"><form id="foo"></form></div>'
-    element = within(html, '#bar') { locate(:form) }
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "within scopes to an xpath" do
-    html = '<form></form><div id="bar"><form id="foo"></form></div>'
-    element = within(html, '//div[@id="bar"]') { locate(:form) }
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "nested within blocks" do
-    html = '<form></form><div><form><p id="foo"><p></form></div>'
-    element = within(html, :div) { within(:form) { locate(:p) } }
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "locates scopes to :within option (css selector)" do
-    html = '<form></form><div><form id="foo"></form></div>'
-    element = locate(html, :form, :within => 'div')
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "locates scopes to :within option (xpath)" do
-    html = '<form></form><div><form id="foo"></form></div>'
-    element = locate(html, :form, :within => '//div')
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "within/locate with module included" do
-    html = '<form></form><div><form id="foo"></form></div>'
-    element = within(html, :div) { locate(:form) }
-    assert_equal 'foo', element.attribute('id')
-  end
-
-  test "locate when given a block scopes the block to the located element" do
-    html = '<p id="foo"><p><form></form><div><form><p id="bar"><p></form></div>'
-    element = locate(html, :div) { locate(:form) { locate(:p) } }
-    assert_equal 'bar', element.attribute('id')
-  end
-
-  test "locate does not yield the block when no element was found (would otherwise locate in global scope)" do
-    html = '<form></form><div><form><p id="foo"><p></form></div>'
-    assert_nil locate(html, :div) { locate(html, :form, :class => 'bar')  { locate(html, :p) } }
-  end
-
-  # locate with umlauts
-
-  test "locates an element by encoded selector from html containing an encoded umlaut" do
-    html = '<span>Berlin</span><span>M&uuml;nchen</span>'
-    assert_equal 'München', locate(html, 'M&uuml;nchen').content
-  end
-
-  test "locates an element by encoded selector from html containing an non-encoded umlaut" do
-    html = '<span>Berlin</span><span>München</span>'
-    assert_equal 'München', locate(html, 'M&uuml;nchen').content
-  end
-
-  test "locates an element by non-encoded selector from html containing an encoded umlaut" do
-    html = '<span>Berlin</span><span>M&uuml;nchen</span>'
-    assert_equal 'München', locate(html, 'München').content
-  end
-
-  test "locates an element by non-encoded selector from html containing a non-encoded umlaut" do
-    html = '<span>Berlin</span><span>München</span>'
-    assert_equal 'München', locate(html, 'München').content
-  end
-
-  test "locates an element by encoded attribute from html containing an encoded umlaut" do
-    html = '<input type="text" value="M&uuml;nchen">'
-    assert_equal 'München', locate(html, :value => 'M&uuml;nchen').value
-  end
-
-  test "locates an element by encoded attribute from html containing an non-encoded umlaut" do
-    html = '<input type="text" value="München">'
-    assert_equal 'München', locate(html, :value => 'M&uuml;nchen').value
-  end
-
-  test "locates an element by non-encoded attribute from html containing an encoded umlaut" do
-    html = '<input type="text" value="M&uuml;nchen">'
-    assert_equal 'München', locate(html, :value => 'München').value
-  end
-
-  test "locates an element by non-encoded attribute from html containing a non-encoded umlaut" do
-    html = '<input type="text" value="München">'
-    assert_equal 'München', locate(html, :value => 'München').value
-  end
-end

data/test/test_helper.rb

@@ -1,31 +0,0 @@
-$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
-
-require 'test/unit'
-require 'locator'
-
-module TestMethod
-  def self.included(base)
-    base.class_eval do
-      def self.test(name, &block)
-        test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
-        defined = instance_method(test_name) rescue false
-        raise "#{test_name} is already defined in #{self}" if defined
-        if block_given?
-          define_method(test_name, &block)
-        else
-          define_method(test_name) do
-            flunk "No implementation provided for #{name}"
-          end
-        end
-      end
-    end
-  end
-end
-
-class Module
-  include TestMethod
-end
-
-class Test::Unit::TestCase
-  include TestMethod
-end

data/test/webrat.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-require File.expand_path('../test_helper', __FILE__)
-require 'action_pack'
-require 'webrat'
-require 'rack/test'
-
-Webrat.configure do |config|
-  config.mode = :rack
-end
-
-class WebratBehaviorTest < Test::Unit::TestCase
-  include Webrat::Methods
-  
-  def last_response
-    @last_response ||= Rack::Response.new
-  end
-
-  def with_html(html)
-    last_response.body = html
-  end
-
-  test "foo" do
-    with_html '<span>München</span>'
-    field = field_by_xpath(".//span")
-    p field.element.to_s
-  end
-end