Selenium 1.0.9 → 1.1.11

data/lib/selenium.rb

@@ -3,10 +3,13 @@ $:.unshift File.join(File.dirname(__FILE__), 'selenium')
 require 'openqa/selenium'
 
 require 'selenium_server'
+require 'web_page'
 require 'server'
-require 'directory_listing_page'
 
+require 'html_element'
 require 'button'
 require 'link'
 require 'locator'
 require 'text_field'
+
+

data/lib/selenium/auto_it.rb

@@ -0,0 +1,6 @@
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'win32ole'
+require 'auto_it_driver'
+require 'auto_it_window'
+require 'file_upload'

data/lib/selenium/auto_it_driver.rb

@@ -0,0 +1,45 @@
+module Selenium
+class AutoIt
+  @@autoit = nil
+
+  def self.load
+    begin
+      @@autoit = load_instance
+    rescue WIN32OLERuntimeError
+      registerAutoItDll
+      @@autoit = load_instance
+    end
+    @@autoit
+  end
+
+  def self.load_instance
+    @@autoit = WIN32OLE.new('AutoItX3.Control') unless @@autoit
+    @@autoit
+  end
+
+  def self.reset
+    if @@autoit
+      @@autoit.ole_free
+      @@autoit =nil
+      system("regsvr32.exe /s /u #{dll}")
+    end
+  end
+
+  def self.registerAutoItDll
+    system("regsvr32.exe /s #{dll}")
+  end
+
+  def self.dll
+    File.join(File.dirname(__FILE__), 'autoit', 'AutoItX3.dll')
+  end
+
+  def initialize
+    @autoit = AutoIt.load
+  end
+
+  def on_window_active(title, text = nil)
+    @autoit.WinWaitActive(title, text, 30)
+    yield @@autoit
+  end
+end
+end

data/lib/selenium/auto_it_window.rb

@@ -0,0 +1,86 @@
+$:.unshift File.join(File.dirname(__FILE__))
+
+require 'auto_it'
+
+class AutoItWindow
+  def initialize(autoit, title, text=nil)
+    @autoit = autoit
+    @title = title
+    @text = text
+  end
+
+  def self.wait_for(autoit, title, text = nil)
+    window = self.new(autoit, title, text)
+    window.wait_for_appear
+    window
+  end
+
+  def self.on_activation(autoit, title, text = nil)
+    window = wait_for(autoit, title, text)
+    yield window
+  end
+
+  def wait_for_activation
+    @autoit.WinWaitActive(@title, @text, 30)
+  end
+
+  def wait_for_appear
+    @autoit.WinWait(@title, @text, 30)
+  end
+
+  def activate
+    @autoit.WinActivate(@title, @text)
+  end
+
+  def active?
+    1 == @autoit.WinActive(@title, @text)
+  end
+
+  def state
+    AutoItWindowState.new(@autoit.WinGetState(@title, @text))
+  end
+
+  def send_keys(keys)
+    activate_if_needed
+    @autoit.Send(keys)
+  end
+
+  def close
+    @autoit.WinClose(@title)
+  end
+
+  def activate_if_needed
+    winstate = state
+    activate unless winstate.active?
+  end
+end
+
+class AutoItWindowState
+  def initialize(state)
+    @state = state
+  end
+
+  def exists?
+    @state & 1 > 0
+  end
+
+  def visible?
+    @state & 2 > 0
+  end
+
+  def enabled?
+    @state & 4 > 0
+  end
+
+  def active?
+    @state & 8 > 0
+  end
+
+  def minimized?
+    @state & 16 > 0
+  end
+
+  def maxmized?
+    @state & 32 > 0
+  end
+end

data/lib/selenium/autoit/README

@@ -0,0 +1 @@
+All the files in this foler are from the "AutoIt" project (http://www.autoitscript.com/autoit3/), under autoit3 license

data/lib/selenium/button.rb

@@ -1,19 +1,7 @@
 module Selenium
-class Button
-  attr_reader :browser
-  
-  def initialize(browser, locator)
-    @browser = browser
-    @locator = locator
+  class Button < HtmlElement
+    def initialize(webpage, locator)
+      super(webpage, locator)
+    end
   end
-  
-  def click
-    browser.click(@locator)
-  end
-  
-  def click_wait
-    click
-    browser.wait_for_page_to_load()
-  end
-end
 end

data/lib/selenium/file_upload.rb

@@ -0,0 +1,16 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'auto_it_window'
+
+module Selenium
+  class FileUpload
+    def initialize(webpage, locator)
+      @webpage = webpage
+      @locator = locator
+    end
+
+    def enter(file)
+      @webpage.upload(@locator, file)
+    end
+  end
+end

data/lib/selenium/html_element.rb

@@ -1,4 +1,30 @@
 module Selenium
   class HtmlElement
+    attr_reader :webpage, :locator
+    def initialize(webpage, locator)
+      webpage = WebPage.new(webpage) if webpage.is_a? SeleniumDriver
+      @webpage = webpage
+      @locator = locator
+    end
+
+    def browser
+      webpage.browser
+    end
+
+    def present?
+      webpage.browser.is_element_present @locator
+    end
+
+    # click the element
+    def click
+      @webpage.click(@locator)
+    end
+
+    # click the element and wait for page to load
+    # TODO: wait on block instead if givven
+    def click_wait
+      @webpage.click_wait(@locator)
+    end
+
   end
 end

data/lib/selenium/link.rb

@@ -1,32 +1,22 @@
 module Selenium
 
   # Link class that models the behavior of a link
-  class Link
-    attr_reader :browser
-
+  class Link < HtmlElement
     def Link::by_id(browser, id, target = nil)
-      Link.new(browser, "id=#{id}", target)
+      Link.new(WebPage.new(browser), "id=#{id}", target)
     end
 
     def Link::by_text(browser, text, target = nil)
-      Link.new(browser, "link=#{text}", target)
+      Link.new(WebPage.new(browser), "link=#{text}", target)
     end
 
-    def initialize(browser, locator, target = nil)
-      @browser = browser
-      @locator = locator
+    def initialize(webpage, locator, target = nil)
+      super(webpage, locator)
       @target = target
     end
 
-    # click the link
-    def click
-      @browser.click(@locator)
-    end
-
-    # click the link and wait for page to load
-    def click_wait
-      click
-      @browser.wait_for_page_to_load(30000)
+    def with_target(target)
+      Link.new(webpage, locator, target.new(webpage.browser))
     end
 
     # click the link, wait for the page to load, and asserts the target that
@@ -34,7 +24,7 @@ module Selenium
     def go
       raise "target page not defined for link #{@locator}" unless @target
       click_wait
-      @target.assert_page
+      @target.ensure_present
       @target
     end
   end

data/lib/selenium/selenium_server.rb

@@ -2,54 +2,83 @@ require 'net/http'
 
 module Selenium
 
-# Selenium server driver that provides API to start/stop server and check if 
-# server is running.
-# NOTE: The start does not return until the server shuts down.
-class SeleniumServer
-  def SeleniumServer::run(argv)
-    jar_file = SeleniumServer.jar_file
-    command = "java -jar #{jar_file} #{argv.join(' ')}"
-    puts command
-    system(command)
-  end
-  
-  private
-  def SeleniumServer::jar_file
-    File.join(File.dirname(__FILE__), 'openqa', 'selenium-server.jar.txt')
-  end
-  
-  public
-  attr_reader :port_number
+  # Selenium server driver that provides API to start/stop server and check if
+  # server is running.
+  # NOTE: The start does not return until the server shuts down.
+  class SeleniumServer
 
-  # Initialize the server driver with an opitonal port number (default to 4444)
-  def initialize(port_number = 4444)
-    @port_number = port_number
-  end
-  
-  # Starts the Selenium server.  This does not return until the server is shutdown.
-  def start(*argv)
-    SeleniumServer.run(['-port', port_number.to_s] + argv)
-  end
-  
-  # Stops the Selenium server
-  def stop
-    Net::HTTP.get('localhost', '/selenium-server/driver/?cmd=shutDown', @port_number)
-  end
-  
-  # Check if the Selenium is running by sending a test_complete command with invalid session ID
-  def running?
-    url = URI.parse("http://localhost:#{@port_number}/selenium-server/driver/?cmd=testComplete&sessionId=smoketest")
-    request = Net::HTTP::Get.new(url.path)
-    begin
-      res = Net::HTTP.start(url.host, url.port) {|http|
+    def SeleniumServer::run(argv, vmparameter='')
+      jar_file = SeleniumServer.jar_file
+      if (argv[0] == '-stop')
+        server = SeleniumServer.new(argv[1])
+        puts "stopping server on port #{server.port_number}"
+        server.stop
+      elsif argv[0] == '-check'
+        server = SeleniumServer.new(argv[1])
+        if (server.running?)
+          puts "server running on #{server.port_number}"
+        else
+          puts "server not running on #{server.port_number}"
+        end
+      else
+        command = "java #{vmparameter} -jar #{jar_file} #{argv.join(' ')}"
+        puts command
+        system(command)
+      end
+    end
+
+    private
+    def SeleniumServer::jar_file
+      File.join(File.dirname(__FILE__), 'openqa', 'selenium-server.jar.txt')
+    end
+
+    public
+    attr_reader :port_number, :request_timeout
+    attr_accessor :print_log
+
+    # Initialize the server driver with an opitonal port number (default to 4444)
+    def initialize(port_number_to_use = 4444)
+      port_number_to_use = 4444 unless port_number_to_use
+      @port_number = port_number_to_use
+      @request_timeout = 30
+      @print_log = false
+    end
+
+    def port_number
+      @port_number
+    end
+
+    # Starts the Selenium server.  This does not return until the server is shutdown.
+    def start(*argv)
+      logging_option = ''
+      logging_option = '-Dorg.apache.commons.logging.Log=org.apache.commons.logging.impl.SimpleLog -Dorg.apache.commons.logging.simplelog.defaultlog=warn' unless @print_log
+      SeleniumServer.run(['-port', port_number.to_s, '-timeout', request_timeout.to_s] + argv, logging_option)
+    end
+
+    # Stops the Selenium server
+    def stop
+      Net::HTTP.get('localhost', '/selenium-server/driver/?cmd=shutDown', @port_number)
+    end
+
+    # Check if the Selenium is running by sending a test_complete command with invalid session ID
+    def running?
+      begin
+        ping
+      rescue Errno::EBADF, Errno::ECONNREFUSED => e
+        return false
+      end
+      return true
+    end
+
+    # ping the server to see if it is running, raises error if not
+    # returns the ping status
+    def ping
+      url = URI.parse("http://localhost:#{@port_number}/selenium-server/driver/?cmd=testComplete&sessionId=smoketest")
+      request = Net::HTTP::Get.new(url.path)
+      Net::HTTP.start(url.host, url.port) {|http|
         http.read_timeout=5
         http.request(request)
       }
-      puts "response: #{res}"
-    rescue Errno::EBADF, Errno::ECONNREFUSED => e
-      return false
     end
-    return true      
   end
-end
 end

data/lib/selenium/server.rb

@@ -1,3 +1,5 @@
+require 'uri'
+
 module Selenium
 # The class that can manages the server driver classes.
 # This class is originally copied from the BuildMaster project.
@@ -28,13 +30,33 @@ class Server
     @status = 'stopped'
   end
 
+  def print_log=(value)
+    @server.print_log = value
+  end
+
   # Starts the server, returns when the server is up and running
   def start(*argv)
+    puts "starting selenium server..."
     starting_server(*argv)
     wait_for_condition {@server.running?}
+    puts "started selenium server"
     @status = 'started'
   end
 
+  def driver(browser_start_command, browser_url)
+    SeleniumDriver.new('localhost', @server.port_number, browser_start_command, browser_url, @server.request_timeout * 1000)
+  end
+
+  def open(browser_start_command, browser_url)
+    url = URI.parse(browser_url)
+    browser = driver(browser_start_command, URI::Generic::new(url.scheme, url.userinfo, url.host, url.port, nil, nil, nil, nil, nil))
+    browser.start
+    browser.open(url.request_uri)
+    page = WebPage.new(browser)
+    page.wait_for_load
+    page
+  end
+
   # Starts the server, does not return until the server shuts down
   def run(*argv)
     @server.start(*argv)
@@ -42,8 +64,10 @@ class Server
 
   # Stops the server, returns when the server is no longer running
   def stop
+    puts "stopping selenium server..."
     stopping_server
     wait_for_condition {not @server.running?}
+    puts "stopped selenium server."
     @status = 'stopped'
   end
 

data/lib/selenium/server_manager.rb

@@ -1,3 +1,5 @@
+
+
 module Selenium
 
 require 'server'

data/lib/selenium/text_field.rb

@@ -1,18 +1,17 @@
 module Selenium
-class TextField
+class TextField < HtmlElement
   attr_reader :browser
   
-  def initialize(browser, locator)
-    @browser = browser
-    @locator = locator
+  def initialize(webpage, locator)
+    super(webpage, locator)
   end
   
-  def type(value)
-    @browser.type(@locator, value)
+  def enter(value)
+    @webpage.enter(@locator, value)
   end
   
   def value
-    @browser.get_value(@locator)
+    @webpage.value(@locator)
   end
 end
 end

data/lib/selenium/version

@@ -1 +1 @@
-1.0.9
+1.1.11

data/lib/selenium/web_page.rb

@@ -1,18 +1,125 @@
 $:.unshift File.dirname(__FILE__)
 
+require 'timeout'
+
 module Selenium
   # Class that models a web page with a title
   class WebPage
-    attr_reader :title
+    attr_reader :browser
+    attr_accessor :timeout, :interval_millis
 
-    def initialize(browser, expected_title)
+    def initialize(browser, expected_title = nil)
       @browser = browser
       @expected_title = expected_title
+      @timeout = 60
+      @interval_millis = 100
     end
 
     def title
+      raise 'nil as browser' unless @browser
       @browser.get_title
     end
+
+    def present?
+      title == @expected_title
+    end
+
+    def ensure_present
+      title.should == @expected_title
+    end
+
+    def html
+      @browser.get_html_source
+    end
+
+    def wait_for_load
+      @browser.wait_for_page_to_load
+    end
+
+    def wait_until(message, &block)
+      Timeout::timeout(timeout, "Timeout waiting for : #{message}") do
+        while(not yield message)
+          sleep interval_millis / 1000.0
+        end
+      end
+    end
+
+    def link(how, what=nil)
+      if (how == :text)
+        locator = "link=#{what}"
+      elsif (how == :href)
+        locator = "xpath=//a[@href='#{what}']"
+      else
+        locator = element_locator(how, what)
+      end
+      Link.new(self, locator)
+    end
+
+    def text_field(how, what=nil)
+      TextField.new(self, element_locator(how, what))
+    end
+
+    def button(how, what=nil)
+      Button.new(self, element_locator(how, what))
+    end
+
+    def element_locator(how, what=nil)
+      locator = how
+      if (not what.nil?)
+        if (how == :xpath or how == :name or how == :id)
+          locator = "#{how}=#{what}"
+        else
+          raise "couldn't understand how to build locator using #{how} with #{what}"
+        end
+      end
+    end
+
+    def file_upload(how, what)
+      FileUpload.new(self, element_locator(how, what))
+    end
+
+    def open(url)
+      @browser.open(url)
+    end
+
+    def close
+      @browser.stop
+    end
+
+    def click(locator)
+      @browser.click(locator)
+    end
+
+    def click_wait(locator)
+      click(locator)
+      wait_for_load
+    end
+
+    # enter the text to the element found by locator
+    def enter(locator, text)
+      @browser.type(locator, text)
+    end
+
+    def value(locator)
+      @browser.get_value(locator)
+    end
+
+    def upload(locator, file)
+#      @browser.attach_file(locator, file)
+      @browser.click(locator)
+      require 'auto_it'
+      autoit = AutoIt.load
+      window = AutoItWindow.wait_for(autoit, 'File Upload')
+      puts window
+    end
+
+    def capture_page(file)
+      @browser.capture_entire_page_screenshot(file)
+    end
+
+    def capture_screen(file)
+      @browser.capture_screenshot(file)
+    end
 	
   end
 end

data/spec/selenium/examples/selenium_ruby/directory_listing_page.rb

@@ -0,0 +1,9 @@
+$:.unshift File.dirname(__FILE__)
+
+module Selenium
+  class DirectoryListingPage < WebPage
+    def initialize(browser)
+      super(browser, 'Index of /')
+    end
+  end
+end

data/spec/selenium/{home_page.rb → examples/selenium_ruby/home_page.rb}

@@ -2,10 +2,6 @@ $:.unshift File.dirname(__FILE__)
 require 'menu'
 require 'selenium_ruby_page'
 
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib', 'selenium')
-
-require 'link'
-
 module Selenium
 class HomePage < SeleniumRubyPage
 

data/spec/selenium/examples/selenium_ruby/menu.rb

@@ -0,0 +1,29 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'home_page'
+require 'directory_listing_page'
+require 'license_page'
+
+module Selenium
+  class Menu
+    attr_reader :webpage
+    def initialize(webpage)
+      @webpage = webpage
+    end
+
+    def home_link
+      # todo there should be a way to alter this instance so that the click returns the directory listing page
+      webpage.link(:id, 'home').with_target(DirectoryListingPage)
+    end
+
+    #MENU START
+    def download_link
+      webpage.link(:text, 'Download')
+    end
+
+    def license_link
+      webpage.link(:text, 'License').with_target(LicensePage)
+    end
+#MENU END
+  end
+end

data/spec/selenium/{selenium_ruby_page.rb → examples/selenium_ruby/selenium_ruby_page.rb}

@@ -1,9 +1,6 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib', 'selenium')
-
-require 'web_page'
-
 $:.unshift File.dirname(__FILE__)
 
+#require '../../../../lib/selenium'
 require 'menu'
 
 module Selenium
@@ -14,12 +11,8 @@ module Selenium
       super(browser, expected_title)
     end
 
-    def assert_page
-      title.should == @expected_title
-    end
-
     def menu
-      Menu.new(@browser)
+      Menu.new(self)
     end
   end
 end

data/spec/selenium/manual_tc_file_upload.rb

@@ -0,0 +1,53 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..')
+
+require 'lib/selenium/auto_it'
+require 'lib/selenium'
+require 'spec'
+
+module Selenium
+  describe FileUpload do
+    before(:all) do
+      @server = Server.on_port(4440)
+#      @server.print_log = true
+      @server.start
+    end
+
+    after(:all) do
+      @server.stop
+    end
+
+    before do
+#      @page = @server.open('*iexplore', 'http://www.rubyforge.org/projects/selenium')
+      @page = @server.open('*chrome D:\Program Files\Mozilla Firefox2\firefox.exe', 'http://www.rubyforge.org/projects/selenium')
+    end
+
+    after do
+      file = File.join(File.dirname(__FILE__), 'screenshot.png')
+      puts "image at #{file}"
+      @page.capture_screen(file)
+      @page.close
+    end
+
+    # this requires the user to manually enter the login information on rubyforge, and can only be run by selenium admin
+    it 'should handle firefox' do
+      login_link = @page.link(:text, 'Log In')
+      autoit = AutoIt.load
+      login_link.click if login_link.present?
+      AutoItWindow.wait_for(autoit, 'Website Certified by an Unknown Authority').send_keys(' ')
+      @page.wait_for_load
+      @page.wait_until('manual login for test') do |message|
+        puts message
+        not login_link.present?
+      end
+      @page.wait_for_load
+      selenium_project_link = @page.link(:text, 'Selenium')
+      selenium_project_link.should be_present
+      selenium_project_link.click_wait
+      @page.link(:text, 'Files').click_wait
+      @page.link(:href, '/frs/admin/?group_id=2789').click_wait
+      @page.link(:xpath, "//a[@href='qrs.php?package_id=3298&group_id=2789']").click_wait
+      @page.file_upload(:name, 'userfile').enter("file:///#{__FILE__}")
+#      @page.file_upload('userfile').enter("file:///#{__FILE__}")
+    end
+  end
+end

data/spec/selenium/tc_auto_it.rb

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..')
+
+require 'lib/selenium/auto_it'
+require 'spec'
+
+module Selenium
+  describe AutoIt do
+    it 'should control notepad' do
+      autoit = AutoIt.load
+      autoit.Run('Notepad.exe')
+      autoit.WinWaitActive('Untitled - Notepad')
+      autoit.Send('some text')
+      autoit.WinClose('Untitled - Notepad')
+      autoit.WinWaitActive('Notepad', 'Do you want to save')
+      autoit.Send('!n')
+    end
+  end
+end

data/spec/selenium/tc_auto_it_window.rb

@@ -0,0 +1,19 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', '..')
+
+require 'lib/selenium/auto_it'
+require 'spec'
+
+module Selenium
+  describe AutoItWindow do
+    it 'should control notepad' do
+      autoit = AutoIt.load
+      autoit.Run('Notepad.exe')
+      window = AutoItWindow.new(autoit, 'Untitled - Notepad')
+      window.wait_for_activation
+      window.send_keys('some text')
+      window.close
+      confirm = AutoItWindow.wait_for(autoit, 'Notepad', 'Do you want to save')
+      confirm.send_keys('!n')
+    end
+  end
+end

data/spec/selenium/tc_basic_operation.rb

@@ -3,39 +3,35 @@ require 'spec'
 $:.unshift File.join(File.dirname(__FILE__), '..', '..')
 
 require 'lib/selenium'
-require 'spec/selenium/home_page'
-require 'spec/selenium/download_page'
+require 'spec/selenium/examples/selenium_ruby/home_page'
+require 'spec/selenium/examples/selenium_ruby/download_page'
 
 module Selenium
 describe 'basic operation with selenium' do
-  
   before do
     port = 4567
     @server = Selenium::Server.on_port(port)
     @server.start
-    @browser = Selenium::SeleniumDriver.new("localhost", port, "*iexplore", "http://localhost:2000", 10000)
-    @browser.start
-    @browser.open('http://localhost:2000/index.html')
+    @webpage = @server.open("*iexplore", 'http://localhost:2000/index.html')
+    @browser = @webpage.browser
   end
 
   after do
-    @browser.stop
+    @webpage.close
     @server.stop
   end
   
   it 'should click through menus' do
-=begin comment
 #TEST START
     page = HomePage.new(@browser)
     page.menu.download_link.click_wait
     page = DownloadPage.new(@browser)
-    page.assert_page
+    page.should be_present
     page = page.menu.home_link.go
-    page.link_to_entry('index.txt').click_wait
+    page.link(:text, 'index.txt').click_wait
     page = HomePage.new(@browser)
     page.menu.license_link.go
 #TEST END
-=end comment
   end
 end
 end

data/spec/selenium/tc_domain_example.rb

@@ -1,55 +1,54 @@
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..', '..')
 
 require 'spec'
-require 'selenium'
+require 'lib/selenium'
 
 #START GOOGLEHOME
-class GoogleHomPage
-  include Selenium::Locator
-  attr_reader :browser
-
-  def GoogleHomPage::open(sel)
-    sel.open("http://www.google.com/webhp")
-    GoogleHomPage.new(sel)
-  end
-
+class GoogleHomPage < Selenium::WebPage
   def initialize(browser)
-    @browser = browser
-    end
+    super(browser, 'Google')
+  end
 
   def title
     browser.get_title
   end
 
   def search_field
-    Selenium::TextField.new(browser, by_name('q'))
+    text_field(:name, 'q')
   end
 
   def search_button
-    Selenium::Button.new(browser, by_name('btnG'))
+    button(:name, 'btnG')
   end
 
 end
 #END GOOGLEHOME
 
 context 'Test goole search' do
-  before do
+  before(:all) do
     port = 4567
     @server = Selenium::Server.on_port(port)
     @server.start
-    @sel = Selenium::SeleniumDriver.new("localhost", port, "*chrome", "http://www.google.com", 15000)
-    @sel.start
   end
 
-  after do
-    @sel.stop
+  before(:each) do
+    @webpage = @server.open('*chrome D:\Program Files\Mozilla Firefox2\firefox.exe', 'http://www.google.com/webhp')
+  end
+
+  after(:each) do
+    @webpage.close if @webpage
+  end
+
+  after(:all) do
+    puts "stopping server"
     @server.stop
   end
 
 #START DOMAIN
   specify'searh hello world with google using docmain based script' do
-    page = GoogleHomPage.open(@sel)
-    page.search_field.type('hello world')
+    page = GoogleHomPage.new(@webpage.browser)
+    page.should be_present
+    page.search_field.enter('hello world')
     page.search_button.click_wait
     page.title.should == 'hello world - Google Search'
     page.search_field.value.should == 'hello world'

data/spec/selenium/tc_interaction_example.rb

@@ -7,23 +7,23 @@ require 'selenium'
 context 'Test goole search' do
   before do
     port = 4567
-    @server = Selenium::Server.on_port(4567)
+    @server = Selenium::Server.on_port(port)
     @server.start
-    @sel = Selenium::SeleniumDriver.new("localhost", port, "*chrome", "http://www.google.com", 15000)
-    @sel.start
+    @page = @server.open('*chrome D:\Program Files\Mozilla Firefox2\firefox.exe', 'http://www.google.com')
   end
 
   after do
-    @sel.stop
+    @page.close
     @server.stop
   end
 
   specify'searh hello world with google using interaction based script' do
-    @sel.open("http://www.google.com")
-    @sel.type("q", "hello world")
-    @sel.click("btnG")
-    @sel.wait_for_page_to_load("5000")
-    @sel.get_title.should == 'hello world - Google Search'
+    @page.open("/")
+    @page.title.should == 'Google'
+    @page.enter("q", "hello world")
+    @page.click("btnG")
+    @page.wait_for_load
+    @page.title.should == 'hello world - Google Search'
   end
 
 end

data/spec/selenium/tc_web_page.rb

@@ -0,0 +1,19 @@
+require 'spec'
+
+$:.unshift File.join(File.dirname(__FILE__), '..', '..')
+
+require 'lib/selenium'
+
+module Selenium
+  describe WebPage do
+    it 'should create link based on text' do
+      webpage = WebPage.new('browser')
+      webpage.link(:text, 'text').locator.should == 'link=text'
+    end
+
+    it 'should create link based on href' do
+      webpage = WebPage.new('browser')
+      webpage.link(:href, 'a.html').locator.should == "xpath=//a[@href='a.html']"
+    end
+  end
+end

metadata

@@ -1,38 +1,37 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: Selenium
 version: !ruby/object:Gem::Version 
-  version: 1.0.9
-date: 2008-05-18 00:00:00 -07:00
-summary: A project that wraps selenium API into object-oriented testing style and packages it into a RubyGem.
-require_paths: 
-- lib
-email: selenium@gmail.com
-homepage: http://selenium.rubyforge.org/
-rubyforge_project: selenium
-description: 
-autorequire: selenium
-default_executable: selenium
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 1.1.11
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Shane Duan
+autorequire: selenium
+bindir: bin
+cert_chain: []
+
+date: 2008-07-12 00:00:00 -07:00
+default_executable: selenium
+dependencies: []
+
+description: 
+email: selenium-ruby@googlegroups.com
+executables: 
+- selenium
+extensions: []
+
+extra_rdoc_files: 
+- README
 files: 
 - bin/selenium
 - lib/selenium
+- lib/selenium/autoit
+- lib/selenium/autoit/AutoItX3.dll
+- lib/selenium/autoit/README
+- lib/selenium/auto_it.rb
+- lib/selenium/auto_it_driver.rb
+- lib/selenium/auto_it_window.rb
 - lib/selenium/button.rb
-- lib/selenium/directory_listing_page.rb
+- lib/selenium/file_upload.rb
 - lib/selenium/html_element.rb
 - lib/selenium/link.rb
 - lib/selenium/locator.rb
@@ -50,29 +49,50 @@ files:
 - lib/selenium/web_page.rb
 - lib/selenium.rb
 - spec/selenium
-- spec/selenium/download_page.rb
-- spec/selenium/home_page.rb
-- spec/selenium/license_page.rb
+- spec/selenium/examples
+- spec/selenium/examples/selenium_ruby
+- spec/selenium/examples/selenium_ruby/directory_listing_page.rb
+- spec/selenium/examples/selenium_ruby/download_page.rb
+- spec/selenium/examples/selenium_ruby/home_page.rb
+- spec/selenium/examples/selenium_ruby/license_page.rb
+- spec/selenium/examples/selenium_ruby/menu.rb
+- spec/selenium/examples/selenium_ruby/selenium_ruby_page.rb
+- spec/selenium/manual_tc_file_upload.rb
 - spec/selenium/manual_tc_timout.rb
-- spec/selenium/menu.rb
-- spec/selenium/selenium_ruby_page.rb
+- spec/selenium/tc_auto_it.rb
+- spec/selenium/tc_auto_it_window.rb
 - spec/selenium/tc_basic_operation.rb
 - spec/selenium/tc_domain_example.rb
 - spec/selenium/tc_interaction_example.rb
 - spec/selenium/tc_server.rb
+- spec/selenium/tc_web_page.rb
 - spec/ts_selenium.rb
 - README
-test_files: []
-
+has_rdoc: true
+homepage: http://selenium.rubyforge.org/
+post_install_message: 
 rdoc_options: []
 
-extra_rdoc_files: 
-- README
-executables: 
-- selenium
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: selenium
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A project that wraps selenium API into object-oriented testing style and packages it into a RubyGem.
+test_files: []
 

data/lib/selenium/directory_listing_page.rb

@@ -1,20 +0,0 @@
-$:.unshift File.dirname(__FILE__)
-require 'link'
-
-module Selenium
-class DirectoryListingPage
-  attr_reader :browser
-  
-  def initialize(browser)
-    @browser = browser
-  end
-  
-  def link_to_entry(text)
-    Link.new(browser, "link=#{text}")
-  end
-
-  def assert_page
-    @browser.get_title.should == 'Index of /'
-  end
-end
-end

data/spec/selenium/menu.rb

@@ -1,31 +0,0 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'home_page'
-
-$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'lib', 'selenium')
-
-require 'directory_listing_page'
-require 'license_page'
-
-module Selenium
-  class Menu
-    attr_reader :browser
-    def initialize(browser)
-      @browser = browser
-    end
-  def home_link
-    # todo there should be a way to alter this instance so that the click returns the directory listing page
-    Link.by_id(browser, 'home', DirectoryListingPage.new(@browser))
-  end
-  
-#MENU START
-  def download_link
-    Link.by_text(browser, 'Download')
-  end
-  
-  def license_link
-    Link.by_text(browser, 'License', LicensePage.new(@browser))
-  end
-#MENU END
-end
-end