locator 0.0.1 → 0.0.2

data/test/locator/element/button_test.rb

@@ -5,22 +5,27 @@ class ElementButtonTest < Test::Unit::TestCase
   Button = Locator::Element::Button
 
   test "finds a button" do
-    assert_locate '<button></button>', Button.new.xpath
+    html = '<button></button>'
+    assert_equal 'button', Button.new.locate(html).tag_name
   end
 
   test "finds a submit input" do
-    assert_locate '<input type="submit">', Button.new.xpath
+    html = '<input type="submit">'
+    assert_equal 'input', Button.new.locate(html).tag_name
   end
 
   test "finds a button input" do
-    assert_locate '<input type="button">', Button.new.xpath
+    html = '<input type="button">'
+    assert_equal 'input', Button.new.locate(html).tag_name
   end
 
   test "finds an image input" do
-    assert_locate '<input type="image">', Button.new.xpath
+    html = '<input type="image">'
+    assert_equal 'input', Button.new.locate(html).tag_name
   end
 
   test "does not find a checkbox input" do
-    assert_no_locate '<input type="checkbox">', Button.new.xpath
+    html = '<input type="checkbox">'
+    assert_nil Button.new.locate(html)
   end
 end

data/test/locator/element/field_test.rb

@@ -5,56 +5,67 @@ class ElementFieldTest < Test::Unit::TestCase
   Field = Locator::Element::Field
 
   test "finds a textarea" do
-    assert_locate '<textarea></textarea>', Field.new.xpath
+    html = '<textarea></textarea>'
+    assert_equal 'textarea', Field.new.locate(html).tag_name
   end
   
   test "finds a text input" do
-    assert_locate '<input type="text">', Field.new.xpath
+    html = '<input type="text">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
   
   test "finds a password input" do
-    assert_locate '<input type="password">', Field.new.xpath
+    html = '<input type="password">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
   
   test "finds an email input" do
-    assert_locate '<input type="email">', Field.new.xpath
+    html = '<input type="email">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
   
   test "finds a url input" do
-    assert_locate '<input type="url">', Field.new.xpath
+    html = '<input type="url">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
   
   test "finds a search input" do
-    assert_locate '<input type="search">', Field.new.xpath
+    html = '<input type="search">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
   
   test "finds a tel input" do
-    assert_locate '<input type="tel">', Field.new.xpath
+    html = '<input type="tel">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
   
   test "finds a color input" do
-    assert_locate '<input type="color">', Field.new.xpath
+    html = '<input type="color">'
+    assert_equal 'input', Field.new.locate(html).tag_name
   end
 
   test "finds a text input by name" do
-    assert_locate '<input type="text" name="foo">', Field.new.xpath('foo')
+    html = '<input type="text" name="foo">'
+    assert_equal 'input', Field.new.locate(html, 'foo').tag_name
   end
 
   test "finds a text input by class attribute" do
-    assert_locate '<input type="text" class="foo">', Field.new.xpath(:class => 'foo')
+    html = '<input type="text" class="foo">'
+    assert_equal 'input', Field.new.locate(html, :class => 'foo').tag_name
   end
 
   test "finds an input by label content" do
     html = '<label for="bar">foo</label><input type="text" id="bar">'
-    assert_locate html, Field.new.xpath('foo'), '<input type="text" id="bar">'
+    assert_equal 'input', Field.new.locate(html, 'foo').tag_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_locate html, Field.new.xpath('foo', :class => 'baz'), '<input type="text" id="bar" class="baz">'
+    assert_equal 'input', Field.new.locate(html, 'foo', :class => 'baz').tag_name
   end
 
   test "does not find a checkbox input" do
-    assert_no_locate '<input type="checkbox">', Field.new.xpath
+    html = '<input type="checkbox">'
+    assert_nil Field.new.locate(html)
   end
 end

data/test/locator/element/form_test.rb

@@ -5,26 +5,32 @@ class ElementFormTest < Test::Unit::TestCase
   Form = Locator::Element::Form
 
   test "finds a form" do
-    assert_locate '<form></form>', Form.new.xpath
+    html = '<form></form>'
+    assert_equal 'form', Form.new.locate(html).tag_name
   end
 
   test "finds a form by id" do
-    assert_locate '<form id="foo"></form>', Form.new.xpath('foo')
+    html = '<form id="foo"></form>'
+    assert_equal 'form', Form.new.locate(html, 'foo').tag_name
   end
 
   test "finds a form by name" do
-    assert_locate '<form name="foo"></form>', Form.new.xpath('foo')
+    html = '<form name="foo"></form>'
+    assert_equal 'form', Form.new.locate(html, 'foo').tag_name
   end
 
   test "finds a form by class" do
-    assert_locate '<form class="foo"></form>', Form.new.xpath(:class => 'foo')
+    html = '<form class="foo"></form>'
+    assert_equal 'form', Form.new.locate(html, :class => 'foo').tag_name
   end
 
   test "does not find a form when id does not match" do
-    assert_no_locate '<form id="bar"></form>', Form.new.xpath(:class => 'foo')
+    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
-    assert_no_locate '<form class="bar"></form>', Form.new.xpath(:class => 'foo')
+    html = '<form class="bar"></form>'
+    assert_nil Form.new.locate(html, :class => 'foo')
   end
 end

data/test/locator/element/label_test.rb

@@ -1,26 +1,30 @@
 require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
 
 class ElementLabelTest < Test::Unit::TestCase
   Label = Locator::Element::Label
 
   test "finds a label" do
-    assert_locate '<label></label>', Label.new.xpath
+    html = '<label></label>'
+    assert_equal 'label', Label.new.locate(html).tag_name
   end
 
   test "finds a label by id" do
-    assert_locate '<label id="foo"></label>', Label.new.xpath('foo')
+    html = '<label id="foo"></label>'
+    assert_equal 'label', Label.new.locate(html, 'foo').tag_name
   end
 
   test "finds a label by class" do
-    assert_locate '<label class="foo"></label>', Label.new.xpath(:class => 'foo')
+    html = '<label class="foo"></label>'
+    assert_equal 'label', Label.new.locate(html, :class => 'foo').tag_name
   end
 
   test "does not find a label when id does not match" do
-    assert_no_locate '<label id="bar"></label>', Label.new.xpath(:class => 'foo')
+    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
-    assert_no_locate '<label class="bar"></label>', Label.new.xpath(:class => 'foo')
+    html = '<label class="bar"></label>'
+    assert_nil Label.new.locate(html, :class => 'foo')
   end
 end

data/test/locator/element/link_test.rb

@@ -1,34 +1,36 @@
 require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
 
-class ElementLinkTest < Test::Unit::TestCase
+class LocatorElementLinkTest < Test::Unit::TestCase
   Link = Locator::Element::Link
 
   test "finds a link" do
-    assert_locate '<a href=""></a>', Link.new.xpath
+    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
-    assert_locate '<a href="" id="foo"></a>', Link.new.xpath('foo')
+    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
-    assert_locate '<a href="" class="foo"></a>', Link.new.xpath(:class => 'foo')
+    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 an link by content" do
-    assert_locate '<a href="">foo</a>', Link.new.xpath('foo')
+  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
-    assert_no_locate '<a name=""></a>', Link.new.xpath
+    html = 
+    assert_nil Link.new.locate('<a name="">foo</a>')
   end
 
-  test "does not find a link when id does not match" do
-    assert_no_locate '<a href="" id="bar"></a>', Link.new.xpath(:class => 'foo')
-  end
-
-  test "does not find a link when class does not match" do
-    assert_no_locate '<a href="" class="bar"></a>', Link.new.xpath(:class => 'foo')
+  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

@@ -5,30 +5,37 @@ class ElementSelectOptionOptionTest < Test::Unit::TestCase
   SelectOption = Locator::Element::SelectOption
 
   test "finds an option" do
-    assert_locate '<option></option>', SelectOption.new.xpath
+    html = '<option></option>'
+    assert_equal 'option', SelectOption.new.locate(html).tag_name
   end
 
   test "finds an option by id" do
-    assert_locate '<option id="foo"></option>', SelectOption.new.xpath('foo')
+    html = '<option id="foo"></option>'
+    assert_equal 'option', SelectOption.new.locate(html, 'foo').tag_name
   end
 
   test "finds an option by value" do
-    assert_locate '<option value="foo"></option>', SelectOption.new.xpath('foo')
+    html = '<option value="foo"></option>'
+    assert_equal 'option', SelectOption.new.locate(html, 'foo').tag_name
   end
 
   test "finds an option by content" do
-    assert_locate '<option>foo</option>', SelectOption.new.xpath('foo')
+    html = '<option>foo</option>'
+    assert_equal 'option', SelectOption.new.locate(html, 'foo').tag_name
   end
 
   test "finds an option by class attribute" do
-    assert_locate '<option class="foo"></option>', SelectOption.new.xpath(:class => 'foo')
+    html = '<option class="foo"></option>'
+    assert_equal 'option', SelectOption.new.locate(html, :class => 'foo').tag_name
   end
 
   test "does not find an option when id does not match" do
-    assert_no_locate '<option id="bar"></option>', SelectOption.new.xpath(:class => 'foo')
+    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
-    assert_no_locate '<option class="bar"></option>', SelectOption.new.xpath(:class => 'foo')
+    html = '<option class="bar"></option>'
+    assert_nil SelectOption.new.locate(html, :class => 'foo')
   end
 end

data/test/locator/element/select_test.rb

@@ -1,26 +1,30 @@
 require File.expand_path('../../../test_helper', __FILE__)
-require 'locator/element'
 
 class ElementSelectTest < Test::Unit::TestCase
   Select = Locator::Element::Select
 
   test "finds a select" do
-    assert_locate '<select></select>', Select.new.xpath
+    html = '<select id="foo" class="foo"></select><select id="bar" class="bar"></select>'
+    assert_equal 'select', Select.new.locate(html).tag_name
   end
 
   test "finds a select by id" do
-    assert_locate '<select id="foo"></select>', Select.new.xpath('foo')
+    html = '<select id="foo"></select>'
+    assert_equal 'select', Select.new.locate(html, 'foo').tag_name
   end
 
   test "finds a select by class" do
-    assert_locate '<select class="foo"></select>', Select.new.xpath(:class => 'foo')
+    html = '<select class="foo"></select>'
+    assert_equal 'select', Select.new.locate(html, :class => 'foo').tag_name
   end
 
   test "does not find a select when id does not match" do
-    assert_no_locate '<select id="bar"></select>', Select.new.xpath(:class => 'foo')
+    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
-    assert_no_locate '<select class="bar"></select>', Select.new.xpath(:class => 'foo')
+    html = '<select class="bar"></select>'
+    assert_nil Select.new.locate(html, :class => 'foo')
   end
 end

data/test/locator/element/text_area_test.rb

@@ -5,22 +5,27 @@ class ElementTextAreaTest < Test::Unit::TestCase
   TextArea = Locator::Element::TextArea
 
   test "finds a textarea" do
-    assert_locate '<textarea></textarea>', TextArea.new.xpath
+    html = '<textarea></textarea>'
+    assert_equal 'textarea', TextArea.new.locate(html).tag_name
   end
 
   test "finds a textarea by id" do
-    assert_locate '<textarea id="foo"></textarea>', TextArea.new.xpath('foo')
+    html = '<textarea id="foo"></textarea>'
+    assert_equal 'textarea', TextArea.new.locate(html, 'foo').tag_name
   end
 
   test "finds a textarea by class" do
-    assert_locate '<textarea class="foo"></textarea>', TextArea.new.xpath(:class => 'foo')
+    html = '<textarea class="foo"></textarea>'
+    assert_equal 'textarea', TextArea.new.locate(html, :class => 'foo').tag_name
   end
 
   test "does not find a textarea when id does not match" do
-    assert_no_locate '<textarea id="bar"></textarea>', TextArea.new.xpath(:class => 'foo')
+    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
-    assert_no_locate '<textarea class="bar"></textarea>', TextArea.new.xpath(:class => 'foo')
+    html = '<textarea class="bar"></textarea>'
+    assert_nil TextArea.new.locate(html, :class => 'foo')
   end
 end

data/test/locator/element_test.rb

@@ -1,40 +1,98 @@
 require File.expand_path('../../test_helper', __FILE__)
-require 'locator/element'
 
-class ElementTest < Test::Unit::TestCase
-  def xpath(*args)
-    Locator::Element.new('foo', [:id, :content]).xpath(*args)
+class LocatorElementTest < Test::Unit::TestCase
+  include Locator
+  
+  # xpath
+  
+  test "xpath without further arguments given" do
+    assert_equal './/*', Element.new.xpath
   end
-
-  test "no selector given => finds all element" do
-    assert_locate '<foo></foo><foo></foo>', xpath, ['<foo></foo>', '<foo></foo>']
+  
+  test "xpath with a node name" do
+    xpath = Element.new(:div).xpath
+    assert_equal './/div', xpath
+  end
+  
+  test "xpath with attributes" do
+    xpath = Element.new(nil, nil, :type => 'type', :class => 'class').xpath
+    assert_equal ".//*[@type=\"type\"][contains(concat(' ', @class, ' '), concat(' ', \"class\", ' '))]", xpath
+  end
+  
+  test "xpath with node name and attributes" do
+    xpath = Element.new(:div, nil, :type => 'type', :class => 'class').xpath
+    assert_equal ".//div[@type=\"type\"][contains(concat(' ', @class, ' '), concat(' ', \"class\", ' '))]", 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.tag_name }
   end
   
-  test "given selector equals content => finds the element" do
-    assert_locate '<foo>foo</foo>', xpath('foo')
+  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.tag_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(nil, nil, :class => 'foo').all(html)
+    assert_equal %w(a), elements.map { |element| element.tag_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.tag_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 "given selector contained in content => finds the element" do
-    assert_locate '<foo>foo!</foo>', xpath('foo')
+  test "locate selects an element containing whitespace" do
+    html = %(
+      <a href="#">
+        the
+        link
+      </a>
+    )
+    assert Element.new.locate(html, 'the link')
   end
   
-  test "given selector equals id => finds the element" do
-    assert_locate '<foo id="foo"></foo>', xpath('foo')
+  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 "given selector contained in id => does not find the element" do
-    assert_no_locate '<foo id="foobar"></foo>', xpath('foo')
+  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 "given attribute equals attribute => finds the element" do
-    assert_locate '<foo class="foo">a</foo>', xpath(:class => 'foo')
+  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 "given attribute contained in attribute => does not find the element" do
-    assert_no_locate '<foo class="foo-bar">a</foo>', xpath(:class => 'foo')
+  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 "selector + attributes => finds the element" do
-    assert_locate '<foo class="foo" title="bar">bar</foo>', xpath('bar', :class => 'foo', :title => 'bar')
+  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
 end

data/test/locator/xpath_test.rb

@@ -27,11 +27,6 @@ class XpathTest < Test::Unit::TestCase
     path = Xpath.new(['input', 'button']).to_s
     assert_equal ".//input | .//button", path
   end
-
-  test "xpath or xpath" do
-    path = Xpath.new('input', :type => 'text').or!(Xpath.new('textarea')).to_s
-    assert_equal %(.//input[@type="text"] | .//textarea), path
-  end
   
   test "attribute equals to one of multiple values" do
     path = Xpath.new('input', :type => [:text, :password]).to_s

data/test/locator_test.rb

@@ -1,31 +1,81 @@
 require File.expand_path('../test_helper', __FILE__)
-require 'locator/element'
 
 class LocatorTest < Test::Unit::TestCase
+  include Locator
+
+  test "returns the element if given an element" do
+    html = '<p></p>'
+    element = Locator.locate(html, :p)
+    assert_equal element, Locator.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
-    path = Locator.xpath(:form, 'foo', :class => 'bar')
-    assert_equal './/form[@class="bar"][@id="foo" or @name="foo"]', path
+    xpath = Locator.xpath(:form, :id => 'bar')
+    assert_equal './/form[@id="bar"]', xpath
   end
 
   test "locates an element from html" do
-    html = '<html><body><h1></h1><form class="bar"></form></body></html>'
-    element = Locator.new(html).locate(:form, :class => 'bar')
-    assert_equal '<form class="bar"></form>', element.to_s
+    html = '<html><body><p></p><form class="bar"></form></body></html>'
+    element = Locator.locate(html, :form)
+    assert_equal 'form', element.tag_name
+  end
+
+  # within
+
+  test "within scopes to a locator" do
+    html = '<form></form><div id="bar"><form id="foo"></form></div>'
+    element = Locator.within(:div, :id => 'bar') { |scope| scope.locate(html, :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 = Locator.within('#bar') { |scope| scope.locate(html, :form) }
+    assert_equal 'foo', element.attribute('id')
   end
 
   test "within scopes to an xpath" do
-    html = '<form id="foo"></form><div id="bar"><form></form></div>'
-    element = Locator.new(html).within(:xpath => '//div[@id="bar"]') { locate(:form) }
-    assert_equal '<form></form>', element.to_s
+    html = '<form></form><div id="bar"><form id="foo"></form></div>'
+    element = Locator.within('//div[@id="bar"]') { |scope| scope.locate(html, :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 = Locator.within(:div) { |scope| scope.within(:form) { |scope| scope.locate(html, :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 = Locator.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 = Locator.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(:div) { locate(html, :form) }
+    assert_equal 'foo', element.attribute('id')
+  end
+
+  test "locate when given a block scopes the block to the located element" do
+    html = '<form></form><div><form><p id="foo"><p></form></div>'
+    element = locate(html, :div) { locate(html, :form)  { locate(html, :p) } }
+    assert_equal 'foo', element.attribute('id')
   end
 
-  test "locates scopes to :within option" do
-    html = '<form id="foo"></form><div id="bar"><form></form></div>'
-    element = Locator.new(html).locate(:form, :within => '//div[@id="bar"]')
-    assert_equal '<form></form>', element.to_s
+  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
 end

data/test/test_helper.rb

@@ -29,18 +29,4 @@ end
 
 class Test::Unit::TestCase
   include TestMethod
-
-  def dom(html)
-    Locator::Dom.page(html)
-  end
-  
-  def assert_locate(html, path, elements = nil)
-    expected = Array(elements || html)
-    result   = dom(html).elements_by_xpath(path).map(&:to_s)
-    assert_equal expected, result
-  end
-  
-  def assert_no_locate(html, path)
-    assert_locate(html, path, [])
-  end
 end