locator 0.0.6 → 0.0.7

data/test/locator/dom/nokogiri_test.rb

@@ -1,42 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'nokogiri'
-
-class NokogiriTest < Test::Unit::TestCase
-  include Locator
-
-  # test "Element takes a Nokogiri dom" do
-  #   dom = Nokogiri::HTML::Document.parse('<a href="#">the link</a>')
-  #   assert Element.new.locate(dom, 'the link')
-  # end
-
-  test "Element takes a Nokogiri page adapter" do
-    dom = Locator::Dom::Nokogiri::Page.new('<a href="#">the link</a>')
-    assert Element.new.locate(dom, 'the link')
-  end
-
-  # test "Nokogiri and Umlauts" do
-  #   encoded = '<p>&ouml;</p>'
-  #   unencoded = '<p>ö</p>'
-  #
-  #   # this is ok
-  #   fragment = Nokogiri::HTML.fragment(encoded)
-  #   assert_equal encoded, fragment.to_s
-  #
-  #   # this seems weird ... wtf experiences ahead
-  #   fragment = Nokogiri::HTML.fragment(unencoded)
-  #   assert_equal encoded, fragment.to_s
-  #
-  #   options =
-  #     Nokogiri::XML::ParseOptions::RECOVER |
-  #     Nokogiri::XML::ParseOptions::NOERROR |
-  #     Nokogiri::XML::ParseOptions::NOWARNING
-  #
-  #   # this is ok
-  #   node = Nokogiri::HTML.parse(encoded, nil, nil, options)
-  #   assert_equal encoded, node.xpath('//p').first.to_s
-  #
-  #   # this is ok
-  #   node = Nokogiri::HTML.parse(unencoded, nil, 'utf-8', options)
-  #   assert_equal unencoded, node.xpath('//p').first.to_s
-  # end
-end

data/test/locator/element/button_test.rb

@@ -1,31 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
-
-class ElementButtonTest < Test::Unit::TestCase
-  Button = Locator::Element::Button
-
-  test "finds a button" do
-    html = '<button></button>'
-    assert_equal 'button', Button.new.locate(html).name
-  end
-
-  test "finds a submit input" do
-    html = '<input type="submit">'
-    assert_equal 'input', Button.new.locate(html).name
-  end
-
-  test "finds a button input" do
-    html = '<input type="button">'
-    assert_equal 'input', Button.new.locate(html).name
-  end
-
-  test "finds an image input" do
-    html = '<input type="image">'
-    assert_equal 'input', Button.new.locate(html).name
-  end
-
-  test "does not find a checkbox input" do
-    html = '<input type="checkbox">'
-    assert_nil Button.new.locate(html)
-  end
-end

data/test/locator/element/field_test.rb

@@ -1,71 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
-
-class ElementFieldTest < Test::Unit::TestCase
-  Field = Locator::Element::Field
-
-  test "finds a textarea" do
-    html = '<textarea></textarea>'
-    assert_equal 'textarea', Field.new.locate(html).name
-  end
-  
-  test "finds a text input" do
-    html = '<input type="text">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-  
-  test "finds a password input" do
-    html = '<input type="password">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-  
-  test "finds an email input" do
-    html = '<input type="email">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-  
-  test "finds a url input" do
-    html = '<input type="url">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-  
-  test "finds a search input" do
-    html = '<input type="search">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-  
-  test "finds a tel input" do
-    html = '<input type="tel">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-  
-  test "finds a color input" do
-    html = '<input type="color">'
-    assert_equal 'input', Field.new.locate(html).name
-  end
-
-  test "finds a text input by name" do
-    html = '<input type="text" name="foo">'
-    assert_equal 'input', Field.new.locate(html, 'foo').name
-  end
-
-  test "finds a text input by class attribute" do
-    html = '<input type="text" class="foo">'
-    assert_equal 'input', Field.new.locate(html, :class => 'foo').name
-  end
-
-  test "finds an input by label content" do
-    html = '<label for="bar">foo</label><input type="text" id="bar">'
-    assert_equal 'input', Field.new.locate(html, 'foo').name
-  end
-
-  test "finds an input by label content and input class" do
-    html = '<label for="bar">foo</label><input type="text" id="bar" class="baz">'
-    assert_equal 'input', Field.new.locate(html, 'foo', :class => 'baz').name
-  end
-
-  test "does not find a checkbox input" do
-    html = '<input type="checkbox">'
-    assert_nil Field.new.locate(html)
-  end
-end

data/test/locator/element/form_test.rb

@@ -1,36 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
-
-class ElementFormTest < Test::Unit::TestCase
-  Form = Locator::Element::Form
-
-  test "finds a form" do
-    html = '<form></form>'
-    assert_equal 'form', Form.new.locate(html).name
-  end
-
-  test "finds a form by id" do
-    html = '<form id="foo"></form>'
-    assert_equal 'form', Form.new.locate(html, 'foo').name
-  end
-
-  test "finds a form by name" do
-    html = '<form name="foo"></form>'
-    assert_equal 'form', Form.new.locate(html, 'foo').name
-  end
-
-  test "finds a form by class" do
-    html = '<form class="foo"></form>'
-    assert_equal 'form', Form.new.locate(html, :class => 'foo').name
-  end
-
-  test "does not find a form when id does not match" do
-    html = '<form id="bar"></form>'
-    assert_nil Form.new.locate(html, :class => 'foo')
-  end
-
-  test "does not find a form when class does not match" do
-    html = '<form class="bar"></form>'
-    assert_nil Form.new.locate(html, :class => 'foo')
-  end
-end

data/test/locator/element/hidden_field_test.rb

@@ -1,36 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
-
-class ElementHiddenFieldTest < Test::Unit::TestCase
-  HiddenField = Locator::Element::HiddenField
-
-  test "finds a hidden input" do
-    html = '<input type="hidden" />'
-    assert_equal 'input', HiddenField.new.locate(html).name
-  end
-
-  test "finds a hidden input by id" do
-    html = '<input type="hidden" id="foo" />'
-    assert_equal 'input', HiddenField.new.locate(html, 'foo').name
-  end
-
-  test "finds a hidden input by name" do
-    html = '<input type="hidden" name="foo" />'
-    assert_equal 'input', HiddenField.new.locate(html, 'foo').name
-  end
-
-  test "finds a hidden input by class" do
-    html = '<input type="hidden" class="foo" />'
-    assert_equal 'input', HiddenField.new.locate(html, :class => 'foo').name
-  end
-
-  test "does not find a hidden input when id does not match" do
-    html = '<input type="hidden" id="bar" />'
-    assert_nil HiddenField.new.locate(html, :class => 'foo')
-  end
-
-  test "does not find a hidden input when class does not match" do
-    html = '<input type="hidden" class="bar" />'
-    assert_nil HiddenField.new.locate(html, :class => 'foo')
-  end
-end

data/test/locator/element/label_test.rb

@@ -1,30 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class ElementLabelTest < Test::Unit::TestCase
-  Label = Locator::Element::Label
-
-  test "finds a label" do
-    html = '<label></label>'
-    assert_equal 'label', Label.new.locate(html).name
-  end
-
-  test "finds a label by id" do
-    html = '<label id="foo"></label>'
-    assert_equal 'label', Label.new.locate(html, 'foo').name
-  end
-
-  test "finds a label by class" do
-    html = '<label class="foo"></label>'
-    assert_equal 'label', Label.new.locate(html, :class => 'foo').name
-  end
-
-  test "does not find a label when id does not match" do
-    html = '<label id="bar"></label>'
-    assert_nil Label.new.locate(html, :class => 'foo')
-  end
-
-  test "does not find a label when class does not match" do
-    html = '<label class="bar"></label>'
-    assert_nil Label.new.locate(html, :class => 'foo')
-  end
-end

data/test/locator/element/link_test.rb

@@ -1,36 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class LocatorElementLinkTest < Test::Unit::TestCase
-  Link = Locator::Element::Link
-
-  test "finds a link" do
-    html = '<a class="foo"></a><a href="" class="bar"></a>'
-    assert_equal 'bar', Link.new.locate(html).attribute('class')
-  end
-
-  test "finds a link by id" do
-    html = '<a href="" id="foo"></a><a href="" id="bar"></a>'
-    assert_equal 'bar', Link.new.locate(html, :id => 'bar').attribute('id')
-  end
-
-  test "finds a link by class" do
-    html = '<a href="" class="foo"></a><a href="" class="bar"></a>'
-    assert_equal 'bar', Link.new.locate(html, :class => 'bar').attribute('class')
-  end
-
-  test "finds a link by content" do
-    html = '<a href="">foo</a><a href="">bar</a>'
-    assert_equal 'bar', Link.new.locate(html, 'bar').content
-  end
-
-  test "does not find an anchor" do
-    html = 
-    assert_nil Link.new.locate('<a name="">foo</a>')
-  end
-
-  test "finds a link with a href starting with a slash" do
-    html = '<a href="/foo/bar" class="foo"></a><a href="" class="bar"></a>'
-    assert_equal '/foo/bar', Link.new.locate(html, :href => '/foo/bar').attribute('href')
-  end
-end
-

data/test/locator/element/select_option_test.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
-
-class ElementSelectOptionOptionTest < Test::Unit::TestCase
-  SelectOption = Locator::Element::SelectOption
-
-  test "finds an option" do
-    html = '<option></option>'
-    assert_equal 'option', SelectOption.new.locate(html).name
-  end
-
-  test "finds an option by id" do
-    html = '<option id="foo"></option>'
-    assert_equal 'option', SelectOption.new.locate(html, 'foo').name
-  end
-
-  test "finds an option by value" do
-    html = '<option value="foo"></option>'
-    assert_equal 'option', SelectOption.new.locate(html, 'foo').name
-  end
-
-  test "finds an option by content" do
-    html = '<option>foo</option>'
-    assert_equal 'option', SelectOption.new.locate(html, 'foo').name
-  end
-
-  test "finds an option by class attribute" do
-    html = '<option class="foo"></option>'
-    assert_equal 'option', SelectOption.new.locate(html, :class => 'foo').name
-  end
-
-  test "does not find an option when id does not match" do
-    html = '<option id="bar"></option>'
-    assert_nil SelectOption.new.locate(html, :class => 'foo')
-  end
-
-  test "does not find an option when class does not match" do
-    html = '<option class="bar"></option>'
-    assert_nil SelectOption.new.locate(html, :class => 'foo')
-  end
-end

data/test/locator/element/select_test.rb

@@ -1,30 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-class ElementSelectTest < Test::Unit::TestCase
-  Select = Locator::Element::Select
-
-  test "finds a select" do
-    html = '<select id="foo" class="foo"></select><select id="bar" class="bar"></select>'
-    assert_equal 'select', Select.new.locate(html).name
-  end
-
-  test "finds a select by id" do
-    html = '<select id="foo"></select>'
-    assert_equal 'select', Select.new.locate(html, 'foo').name
-  end
-
-  test "finds a select by class" do
-    html = '<select class="foo"></select>'
-    assert_equal 'select', Select.new.locate(html, :class => 'foo').name
-  end
-
-  test "does not find a select when id does not match" do
-    html = '<select id="bar"></select>'
-    assert_nil Select.new.locate(html, :class => 'foo')
-  end
-
-  test "does not find a select when class does not match" do
-    html = '<select class="bar"></select>'
-    assert_nil Select.new.locate(html, :class => 'foo')
-  end
-end

data/test/locator/element/text_area_test.rb

@@ -1,31 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
-
-class ElementTextAreaTest < Test::Unit::TestCase
-  TextArea = Locator::Element::TextArea
-
-  test "finds a textarea" do
-    html = '<textarea></textarea>'
-    assert_equal 'textarea', TextArea.new.locate(html).name
-  end
-
-  test "finds a textarea by id" do
-    html = '<textarea id="foo"></textarea>'
-    assert_equal 'textarea', TextArea.new.locate(html, 'foo').name
-  end
-
-  test "finds a textarea by class" do
-    html = '<textarea class="foo"></textarea>'
-    assert_equal 'textarea', TextArea.new.locate(html, :class => 'foo').name
-  end
-
-  test "does not find a textarea when id does not match" do
-    html = '<textarea id="bar"></textarea>'
-    assert_nil TextArea.new.locate(html, :class => 'foo')
-  end
-
-  test "does not find a textarea when class does not match" do
-    html = '<textarea class="bar"></textarea>'
-    assert_nil TextArea.new.locate(html, :class => 'foo')
-  end
-end

data/test/locator/element_test.rb

@@ -1,136 +0,0 @@
-# encoding: utf-8
-require File.expand_path('../../test_helper', __FILE__)
-
-class LocatorElementTest < Test::Unit::TestCase
-  include Locator
-
-  # xpath
-
-  test "xpath without further arguments given" do
-    assert_equal './/*', Element.new.xpath
-  end
-
-  test "xpath of an element with a node name" do
-    xpath = Element.new(:div).xpath
-    assert_equal './/div', xpath
-  end
-
-  test "xpath of an element with attributes" do
-    xpath = Element.new(nil, :type => 'type', :class => 'class').xpath
-    assert_equal ".//*[@type=\"type\"][contains(concat(' ', @class, ' '), concat(' ', \"class\", ' '))]", xpath
-  end
-
-  test "xpath of an element with node name and attributes" do
-    xpath = Element.new(:div, :type => 'type', :class => 'class').xpath
-    assert_equal ".//div[@type=\"type\"][contains(concat(' ', @class, ' '), concat(' ', \"class\", ' '))]", xpath
-  end
-
-  test "xpath of an element with multiple node name and attributes" do
-    xpath = Element.new([:div, :p], :type => 'type').xpath
-    assert_equal ".//div[@type=\"type\"] | .//p[@type=\"type\"]", xpath
-  end
-
-  test "xpath merges given attributes with element attributes" do
-    xpath = Element.new(:div, :foo => 'foo').xpath(:bar => 'bar')
-    assert xpath.include?(".//div")
-    assert xpath.include?("[@foo=\"foo\"]") # humpf, unsorted hash
-    assert xpath.include?("[@bar=\"bar\"]")
-  end
-
-  test "xpath with given xpath and attributes" do
-    xpath = Element.new.xpath('.//div', :foo => 'foo')
-    assert_equal ".//div[@foo=\"foo\"]", xpath
-  end
-
-  # all
-
-  test "all selects all elements when given no attributes" do
-    html = '<a class="foo"></a><p class="bar"></p>'
-    elements = Element.new.all(html)
-    assert_equal %w(html body a p), elements.map { |element| element.name }
-  end
-
-  test "all selects all nodes with given node name" do
-    html = '<a class="foo"></a><p class="bar"></p>'
-    elements = Element.new('a').all(html)
-    assert_equal %w(a), elements.map { |element| element.name }
-  end
-
-  test "all selects all nodes with attribute given to initialize" do
-    html = '<a class="foo"></a><p class="bar"></p>'
-    elements = Element.new(:class => 'foo').all(html)
-    assert_equal %w(a), elements.map { |element| element.name }
-  end
-
-  test "all selects all nodes with attribute given to all" do
-    html = '<a class="foo"></a><p class="bar"></p>'
-    elements = Element.new.all(html, :class => 'foo')
-    assert_equal %w(a), elements.map { |element| element.name }
-  end
-
-  # locate
-
-  test "locate selects an element based on the length of the matching value" do
-    html = %(
-      <a href="#">the link with extra text</a>
-      <a href="http://www.some-very-long-url.com">the link ...</a>
-    )
-    element = Element.new.locate(html, 'the link')
-    assert_equal 'the link ...', element.content
-  end
-
-  test "locate selects an element containing whitespace" do
-    html = %(
-      <a href="#">
-        the
-        link
-      </a>
-    )
-    assert Element.new.locate(html, 'the link')
-  end
-
-  test "locate selects an element containing extra tags" do
-    html = '<a href="#">the <span>link</span></a>'
-    assert Element.new.locate(html, 'the link')
-  end
-
-  test "locate selects an element containing extra text (1)" do
-    html = '<a href="#">the link &raquo;</label>'
-    assert Element.new.locate(html, 'the link')
-  end
-
-  test "locate selects an element containing extra text (2)" do
-    html = '<a href="#">(the link)</label>'
-    assert Element.new.locate(html, 'the link')
-  end
-
-  test "does not find a link when id does not match" do
-    html = '<a href="" id="bar"></a>'
-    assert_nil Element.new.locate(html, :id => 'foo')
-  end
-
-  test "does not find a link when class does not match" do
-    html = '<a href="" class="bar"></a>'
-    assert_nil Element.new.locate(html, :class => 'foo')
-  end
-
-  test "locate using an xpath" do
-    html = '<a class="foo" href="#"></a><a class="bar" href="#"></a>'
-    assert_equal 'bar', Element::Link.new.locate(html, :xpath => '//a[@class="bar"]').attribute('class')
-  end
-
-  test "locate using a css selector" do
-    html = '<a class="foo" href="#"></a><a class="bar" href="#"></a>'
-    assert_equal 'bar', Element::Link.new.locate(html, :css => '.bar').attribute('class')
-  end
-
-  test "locate selects an element containing an umlaut" do
-    html = '<a href="#">the lünk</a>'
-    assert Element.new.locate(html, 'the lünk')
-  end
-
-  test "locate selects an element with an attribute containing an umlaut" do
-    html = '<input type="text" value="München" />'
-    assert Element.new.locate(html, :value => 'München')
-  end
-end