qa_robusta 0.1.3

data/common/monkey_patches/table.rb

@@ -0,0 +1,363 @@
+module Watir
+
+  # This class is used for dealing with tables.
+  # Normally a user would not need to create this object as it is returned by the Watir::Container#table method
+  #
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class Table < Element
+    include Container
+    
+    # Returns the table object containing the element
+    #   * container  - an instance of an IE object
+    #   * anElement  - a Watir object (TextField, Button, etc.)
+    def Table.create_from_element(container, element)
+      element.locate if defined?(element.locate)
+      o = element.ole_object.parentElement
+      o = o.parentElement until o.tagName == 'TABLE'
+      new container, :ole_object, o 
+    end
+    
+    # Returns an initialized instance of a table object
+    #   * container      - the container
+    #   * how         - symbol - how we access the table
+    #   * what         - what we use to access the table - id, name index etc
+    def initialize(container, how, what)
+      set_container container
+      @how = how
+      @what = what
+      super nil
+    end
+    
+    def locate
+      if @how == :xpath
+        @o = @container.element_by_xpath(@what)
+      elsif @how == :ole_object
+        @o = @what
+      else
+        @o = @container.locate_tagged_element('TABLE', @how, @what)
+      end
+    end
+    
+    # override the highlight method, as if the tables rows are set to have a background color,
+    # this will override the table background color, and the normal flash method won't work
+    def highlight(set_or_clear)
+      if set_or_clear == :set
+        begin
+          @original_border = @o.border.to_i
+          if @o.border.to_i==1
+            @o.border = 2
+          else
+            @o.border = 1
+          end
+        rescue
+          @original_border = nil
+        end
+      else
+        begin
+          @o.border= @original_border unless @original_border == nil
+          @original_border = nil
+        rescue
+          # we could be here for a number of reasons...
+        ensure
+          @original_border = nil
+        end
+      end
+      super
+    end
+    
+    # this method is used to populate the properties in the to_s method
+    def table_string_creator
+      n = []
+      n << "rows:".ljust(TO_S_SIZE) + self.row_count.to_s
+      n << "cols:".ljust(TO_S_SIZE) + self.column_count.to_s
+      return n
+    end
+    private :table_string_creator
+    
+    # returns the properties of the object in a string
+    # raises an ObjectNotFound exception if the object cannot be found
+    def to_s
+      assert_exists
+      r = string_creator
+      r += table_string_creator
+      return r.join("\n")
+    end
+    
+    # iterates through the rows in the table. Yields a TableRow object
+    def each
+      assert_exists
+      0.upto(@o.getElementsByTagName("TR").length) do |i| 
+        yield TableRow.new(@container, :ole_object, _row(i))
+      end
+    end
+    
+    # Returns a row in the table
+    #   * index         - the index of the row
+    def [](index)
+      assert_exists
+      return TableRow.new(@container, :ole_object, _row(index))
+    end
+    
+    # Returns the number of rows inside the table, including rows in nested tables.
+    def row_count
+      assert_exists
+      #return table_body.children.length
+      return @o.getElementsByTagName("TR").length
+    end
+
+    # Returns the number of rows in the table, not including rows in nested tables.    
+    def row_count_excluding_nested_tables
+      assert_exists
+      return @o.rows.length
+    end    
+    
+    # This method returns the number of columns in a row of the table.
+    # Raises an UnknownObjectException if the table doesn't exist.
+    #   * index         - the index of the row
+    def column_count(index=0)
+      assert_exists
+      _row(index).cells.length
+    end
+    
+    # This method returns the table as a 2 dimensional array. 
+    # Don't expect too much if there are nested tables, colspan etc.
+    # Raises an UnknownObjectException if the table doesn't exist.
+    # http://www.w3.org/TR/html4/struct/tables.html
+    def to_a
+      assert_exists
+      y = []
+      table_rows = @o.getElementsByTagName("TR")
+      for row in table_rows
+        x = []
+        for td in row.getElementsbyTagName("TD")
+          x << td.innerText.strip
+        end
+        y << x
+      end
+      return y
+    end
+    
+    def table_body(index=1)
+      return @o.getElementsByTagName('TBODY')[index]
+    end
+    private :table_body
+    
+    # returns a watir object
+    def body(how, what)
+      return TableBody.new(@container, how, what, self)
+    end
+    
+    # returns a watir object
+    def bodies
+      assert_exists
+      return TableBodies.new(@container, @o)
+    end
+    
+    # returns an ole object
+    def _row(index)
+      return @o.invoke("rows")[(index - 1).to_s]
+    end
+    private :_row
+    
+    # Returns an array containing all the text values in the specified column
+    # Raises an UnknownCellException if the specified column does not exist in every
+    # Raises an UnknownObjectException if the table doesn't exist.
+    # row of the table
+    #   * columnnumber  - column index to extract values from
+    def column_values(columnnumber)
+      return (1..row_count).collect {|i| self[i][columnnumber].text}
+    end
+    
+    # Returns an array containing all the text values in the specified row
+    # Raises an UnknownObjectException if the table doesn't exist.
+    #   * rownumber  - row index to extract values from
+    def row_values(rownumber)
+      return (1..column_count(rownumber)).collect {|i| self[rownumber][i].text}
+    end
+    
+  end
+  
+  # this class is a collection of the table body objects that exist in the table
+  # it wouldnt normally be created by a user, but gets returned by the bodies method of the Table object
+  # many of the methods available to this object are inherited from the Element class
+  #
+  class TableBodies < Element
+    def initialize(container, parent_table)
+      set_container container
+      @o = parent_table     # in this case, @o is the parent table
+    end
+    
+    # returns the number of TableBodies that exist in the table
+    def length
+      assert_exists
+      return @o.tBodies.length
+    end
+    
+    # returns the n'th Body as a Watir TableBody object
+    def []n
+      assert_exists
+      return TableBody.new(@container, :ole_object, ole_table_body_at_index(n))
+    end
+    
+    # returns an ole table body
+    def ole_table_body_at_index(n)
+      return @o.tBodies[(n-1).to_s]
+    end
+    
+    # iterates through each of the TableBodies in the Table. Yields a TableBody object
+    def each
+      1.upto(@o.tBodies.length) do |i| 
+        yield TableBody.new(@container, :ole_object, ole_table_body_at_index(i))
+      end
+    end
+    
+  end
+  
+  # this class is a table body
+  class TableBody < Element
+    def locate
+      @o = nil
+      if @how == :ole_object
+        @o = @what     # in this case, @o is the table body
+      elsif @how == :index
+        @o = @parent_table.bodies.ole_table_body_at_index(@what)
+      end
+      @rows = []
+      if @o
+        @o.rows.each do |oo|
+          @rows << TableRow.new(@container, :ole_object, oo)
+        end
+      end
+    end
+    
+    def initialize(container, how, what, parent_table=nil)
+      set_container container
+      @how = how
+      @what = what
+      @parent_table = parent_table
+      super nil
+    end
+    
+    # returns the specified row as a TableRow object
+    def [](n)
+      assert_exists
+      return @rows[n - 1]
+    end
+    
+    # iterates through all the rows in the table body
+    def each
+      locate
+      0.upto(@rows.length - 1) { |i| yield @rows[i] }
+    end
+    
+    # returns the number of rows in this table body.
+    def length
+      return @rows.length
+    end
+  end
+    
+  class TableRow < Element
+    
+    def locate
+      @o = nil
+      if @how == :ole_object
+        @o = @what
+      elsif @how == :xpath
+        @o = @container.element_by_xpath(@what)
+      else
+        @o = @container.locate_tagged_element("TR", @how, @what)
+      end
+      if @o # cant call the assert_exists here, as an exists? method call will fail
+        @cells = []
+        @o.cells.each do |oo|
+          @cells << TableCell.new(@container, :ole_object, oo)
+        end
+      end
+    end
+    
+    # Returns an initialized instance of a table row
+    #   * o  - the object contained in the row
+    #   * container  - an instance of an IE object
+    #   * how          - symbol - how we access the row
+    #   * what         - what we use to access the row - id, index etc. If how is :ole_object then what is a Internet Explorer Raw Row
+    def initialize(container, how, what)
+      set_container container
+      @how = how
+      @what = what
+      super nil
+    end
+    
+    # this method iterates through each of the cells in the row. Yields a TableCell object
+    def each
+      locate
+      0.upto(@cells.length) { |i| yield @cells[i] }
+    end
+    
+    # Returns an element from the row as a TableCell object
+    def [](index)
+      assert_exists
+      if @cells.length < index
+        raise UnknownCellException, "Unable to locate a cell at index #{index}" 
+      end
+      return @cells[(index)]
+    end
+    
+    # defaults all missing methods to the array of elements, to be able to
+    # use the row as an array
+    #        def method_missing(aSymbol, *args)
+    #            return @o.send(aSymbol, *args)
+    #        end
+    def column_count
+      locate
+      @cells.length
+    end
+  end
+  
+  # this class is a table cell - when called via the Table object
+  class TableCell < Element
+    include Watir::Exception
+    include Container
+    
+    def locate
+      if @how == :xpath
+        @o = @container.element_by_xpath(@what)
+      elsif @how == :ole_object
+        @o = @what
+      else
+        @o = @container.locate_tagged_element("TD", @how, @what)
+      end
+    end
+    
+    # Returns an initialized instance of a table cell
+    #   * container  - an  IE object
+    #   * how        - symbol - how we access the cell
+    #   * what       - what we use to access the cell - id, name index etc
+    def initialize(container, how, what)
+      set_container container
+      @how = how
+      @what = what
+      super nil
+    end
+    
+    def ole_inner_elements
+      locate
+      return @o.all
+    end
+    private :ole_inner_elements
+    
+    def document
+      locate
+      return @o
+    end
+    
+    alias to_s text
+    
+    def colspan
+      locate
+      @o.colSpan
+    end
+    
+  end
+  
+end

data/common/monkey_patches/telnet.rb

@@ -0,0 +1,420 @@
+require 'rubygems'
+require 'net/ssh'
+ 
+module Net
+module SSH
+
+  # == Net::SSH::Telnet
+  #
+  # Provides a simple send/expect interface with an API almost
+  # identical to Net::Telnet. Please see Net::Telnet for main documentation.
+  # Only the differences are documented here.
+  
+  class Telnet
+
+    CR   = "\015"
+    LF   = "\012"
+    EOL  = CR + LF
+    VERSION = '0.0.1'
+
+    # Wrapper to emulate the behaviour of Net::Telnet "Proxy" option, where
+    # the user passes in an already-open socket
+
+    class TinyFactory
+      def initialize(sock)
+        @sock = sock
+      end
+      def open(host, port)
+        s = @sock
+        @sock = nil
+        s
+      end
+    end
+
+    # Creates a new Net::SSH::Telnet object.
+    #
+    # The API is similar to Net::Telnet, although you will need to pass in
+    # either an existing Net::SSH::Session object or a Username and Password,
+    # as shown below.
+    #
+    # Note that unlike Net::Telnet there is no preprocess method automatically
+    # setting up options related to proper character translations, so if your 
+    # remote ptty is configured differently than the typical linux one you may 
+    # need to pass in a different terminator or call 'stty' remotely to set it 
+    # into an expected mode. This is better explained by the author of perl's 
+    # Net::SSH::Expect here:
+    #
+    # http://search.cpan.org/~bnegrao/Net-SSH-Expect-1.04/lib/Net/SSH/Expect.pod
+    # #IMPORTANT_NOTES_ABOUT_DEALING_WITH_SSH_AND_PSEUDO-TERMINALS
+    #
+    # though for most installs the default LF should be fine. See example 5
+    # below.
+    #
+    # A new option is added to correct a misfeature of Net::Telnet. If you
+    # pass "FailEOF" => true, then if the remote end disconnects while you
+    # are still waiting for your match pattern then an EOFError is raised.
+    # Otherwise, it reverts to the same behaviour as Net::Telnet, which is
+    # just to return whatever data was sent so far, or nil if no data was
+    # returned so far. (This is a poor design because you can't tell whether
+    # the expected pattern was successfully matched or the remote end
+    # disconnected unexpectedly, unless you perform a second match on the
+    # return string). See
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/11373
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/11380
+    #
+    # Example 1 - pass existing Net::SSH::Session object
+    #
+    #   ssh = Net::SSH.start("127.0.0.1",
+    #         :username=>"test123",
+    #         :password=>"pass456"
+    #   )
+    #   s = Net::SSH::Telnet.new(
+    #         "Dump_log" => "/dev/stdout",
+    #         "Session" => ssh
+    #   )
+    #   puts "Logged in"
+    #   p s.cmd("echo hello")
+    #
+    # This is the most flexible way as it allows you to set up the SSH
+    # session using whatever authentication system you like. When done this
+    # way, calling Net::SSH::Telnet.new multiple times will create
+    # multiple channels, and #close will only close one channel.
+    #
+    # In all later examples, calling #close will close the entire
+    # Net::SSH::Session object (and therefore drop the TCP connection)
+    #
+    # Example 2 - pass host, username and password
+    #
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Host" => "127.0.0.1",
+    #           "Username" => "test123",
+    #           "Password" => "pass456"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("echo hello")
+    #
+    # Example 3 - pass open IO object, username and password (this is really
+    # just for compatibility with Net::Telnet Proxy feature)
+    #
+    #   require 'socket'
+    #   sock = TCPSocket.open("127.0.0.1",22)
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Proxy" => sock,
+    #           "Username" => "test123",
+    #           "Password" => "pass456"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("echo hello")
+    #
+    # Example 4 - pass a connection factory, host, username and password;
+    # Net::SSH will call #open(host,port) on this object. Included just
+    # because it was easy :-)
+    #
+    #   require 'socket'
+    #   s = Net::SSH::Telnet.new(
+    #           "Dump_log" => "/dev/stdout",
+    #           "Factory" => TCPSocket,
+    #           "Host" => "127.0.0.1",
+    #           "Username" => "test123",
+    #           "Password" => "pass456"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("echo hello")
+    #
+    # Example 5 - connection to a SAN device running a customized NetBSD with
+    # different ptty defaults, it doesn't convert LF -> CR+LF (see the man
+    # page for 'stty') and uses a custom prompt
+    #
+    #   s = Net::SSH::Telnet.new(
+    #           "Host" => "192.168.1.1",
+    #           "Username" => "test123",
+    #           "Password" => "pass456",
+    #           "Prompt" => %r{^\S+>\s.*$},
+    #           "Terminator" => "\r"
+    #   )
+    #   puts "Logged in"
+    #   puts s.cmd("show alerts")
+
+    def initialize(options, &blk) # :yield: mesg
+      @options = options
+      @options["Host"]       = "localhost"   unless @options.has_key?("Host")
+      @options["Port"]       = 22            unless @options.has_key?("Port")
+      @options["Prompt"]     = /[$%#>] \z/n  unless @options.has_key?("Prompt")
+      @options["Timeout"]    = 10            unless @options.has_key?("Timeout")
+      @options["Waittime"]   = 0             unless @options.has_key?("Waittime")
+      @options["Terminator"] = LF            unless @options.has_key?("Terminator")
+
+      unless @options.has_key?("Binmode")
+        @options["Binmode"]    = false
+      else
+        unless (true == @options["Binmode"] or false == @options["Binmode"])
+          raise ArgumentError, "Binmode option must be true or false"
+        end
+      end
+
+      if @options.has_key?("Output_log")
+        @log = File.open(@options["Output_log"], 'a+')
+        @log.sync = true
+        @log.binmode
+      end
+
+      if @options.has_key?("Dump_log")
+        @dumplog = File.open(@options["Dump_log"], 'a+')
+        @dumplog.sync = true
+        @dumplog.binmode
+        def @dumplog.log_dump(dir, x)  # :nodoc:
+          len = x.length
+          addr = 0
+          offset = 0
+          while 0 < len
+            if len < 16
+              line = x[offset, len]
+            else
+              line = x[offset, 16]
+            end
+            hexvals = line.unpack('H*')[0]
+            hexvals += ' ' * (32 - hexvals.length)
+            hexvals = format("%s %s %s %s  " * 4, *hexvals.unpack('a2' * 16))
+            line = line.gsub(/[\000-\037\177-\377]/n, '.')
+            printf "%s 0x%5.5x: %s%s\n", dir, addr, hexvals, line
+            addr += 16
+            offset += 16
+            len -= 16
+          end
+          print "\n"
+        end
+      end
+
+      if @options.has_key?("Session")
+        @ssh = @options["Session"]
+        @close_all = false
+      elsif @options.has_key?("Proxy")
+        @ssh = Net::SSH.start(nil, nil,
+                :host_name => @options["Host"],  # ignored
+                :port => @options["Port"],       # ignored
+                :user => @options["Username"],
+                :password => @options["Password"],
+                :timeout => @options["Timeout"],
+                :proxy => TinyFactory.new(@options["Proxy"])
+        )
+        @close_all = true
+      else
+        message = "Trying " + @options["Host"] + "...\n"
+        yield(message) if block_given?
+        @log.write(message) if @options.has_key?("Output_log")
+        @dumplog.log_dump('#', message) if @options.has_key?("Dump_log")
+
+        begin
+          @ssh = Net::SSH.start(nil, nil,
+                :host_name => @options["Host"],
+                :port => @options["Port"],
+                :user => @options["Username"],
+                :password => @options["Password"],
+                :timeout => @options["Timeout"],
+                :proxy => @options["Factory"]
+          )
+          @close_all = true
+        rescue TimeoutError
+          raise TimeoutError, "timed out while opening a connection to the host"
+        rescue
+          @log.write($ERROR_INFO.to_s + "\n") if @options.has_key?("Output_log")
+          @dumplog.log_dump('#', $ERROR_INFO.to_s + "\n") if @options.has_key?("Dump_log")
+          raise
+        end
+
+        message = "Connected to " + @options["Host"] + ".\n"
+        yield(message) if block_given?
+        @log.write(message) if @options.has_key?("Output_log")
+        @dumplog.log_dump('#', message) if @options.has_key?("Dump_log")
+      end
+
+      @buf = ""
+      @eof = false
+      @channel = nil
+      @ssh.open_channel do |channel|
+        channel.request_pty { |ch,success|
+          if success == false
+            raise "Failed to open ssh pty"
+          end
+        }
+        channel.send_channel_request("shell") { |ch, success|
+          if success
+            @channel = ch
+            waitfor(@options['Prompt'], &blk)
+            return
+          else
+            raise "Failed to open ssh shell"
+          end
+        }
+        channel.on_data { |ch,data| @buf << data }
+        channel.on_extended_data { |ch,type,data| @buf << data if type == 1 }
+        channel.on_close { @eof = true }
+      end
+      @ssh.loop
+    end # initialize
+
+    # Close the ssh channel, and also the entire ssh session if we
+    # opened it.
+
+    def close
+      @channel.close if @channel
+      @channel = nil
+      @ssh.close if @close_all and @ssh
+    end
+        
+    # The ssh session and channel we are using.
+    attr_reader :ssh, :channel
+
+    # Turn newline conversion on (+mode+ == false) or off (+mode+ == true),
+    # or return the current value (+mode+ is not specified).
+    def binmode(mode = nil)
+      case mode
+      when nil
+        @options["Binmode"]
+      when true, false
+        @options["Binmode"] = mode
+      else
+        raise ArgumentError, "argument must be true or false"
+      end
+    end
+
+    # Turn newline conversion on (false) or off (true).
+    def binmode=(mode)
+      if (true == mode or false == mode)
+        @options["Binmode"] = mode
+      else
+        raise ArgumentError, "argument must be true or false"
+      end
+    end
+
+    # Read data from the host until a certain sequence is matched.
+
+    def waitfor(options) # :yield: recvdata
+      time_out = @options["Timeout"]
+      waittime = @options["Waittime"]
+      fail_eof = @options["FailEOF"]
+
+      if options.kind_of?(Hash)
+        prompt   = if options.has_key?("Match")
+                     options["Match"]
+                   elsif options.has_key?("Prompt")
+                     options["Prompt"]
+                   elsif options.has_key?("String")
+                     Regexp.new( Regexp.quote(options["String"]) )
+                   end
+        time_out = options["Timeout"]  if options.has_key?("Timeout")
+        waittime = options["Waittime"] if options.has_key?("Waittime")
+        fail_eof = options["FailEOF"]  if options.has_key?("FailEOF")
+      else
+        prompt = options
+      end
+
+      if time_out == false
+        time_out = nil
+      end
+      line = ''
+      buf = ''
+      rest = ''
+      sock = @ssh.transport.socket
+      init_time = Time.now.tv_sec
+      until prompt === line and ((@eof and @buf == "") or not IO::select([sock], nil, nil, waittime))
+        while @buf == "" and !@eof
+          # timeout is covered by net-ssh
+          @channel.connection.process(0.1)
+#          if waittime.to_i > 0
+#            exec_time = Time.now.tv_sec - init_time
+#            raise Timeout::Error if exec_time > waittime
+#          end 
+        end
+        if @buf != ""
+#          if waittime.to_i > 0
+#            exec_time = Time.now.tv_sec - init_time
+#            raise Timeout::Error if exec_time > waittime
+#          end 
+
+          c = @buf; @buf = ""
+          @dumplog.log_dump('<', c) if @options.has_key?("Dump_log")
+          buf = c
+          buf.gsub!(/#{EOL}/no, "\n") unless @options["Binmode"]
+          rest = ''
+          @log.print(buf) if @options.has_key?("Output_log")
+          line += buf
+          yield buf if block_given?
+        elsif @eof # End of file reached
+          break if prompt === line
+          raise EOFError if fail_eof
+          if line == ''
+            line = nil
+            yield nil if block_given?
+          end
+          break
+        end
+      end
+      line
+    end
+
+    # Write +string+ to the host.
+    #
+    # Does not perform any conversions on +string+.  Will log +string+ to the
+    # dumplog, if the Dump_log option is set.
+    def write(string)
+      @dumplog.log_dump('>', string) if @options.has_key?("Dump_log")
+      @channel.send_data string
+    end
+
+    # Sends a string to the host.
+    #
+    # This does _not_ automatically append a newline to the string.  Embedded
+    # newlines may be converted depending upon the values of binmode or
+    # terminator.
+    def print(string)
+      terminator = @options["Terminator"]
+
+      if @options["Binmode"]
+        self.write(string)
+      else
+        self.write(string.gsub(/\n/n, terminator))
+      end
+    end
+
+    # Sends a string to the host.
+    #
+    # Same as #print(), but appends a newline to the string.
+    def puts(string)
+      self.print(string + "\n")
+    end
+
+    # Send a command to the host.
+    #
+    # More exactly, sends a string to the host, and reads in all received
+    # data until is sees the prompt or other matched sequence.
+    #
+    # The command or other string will have the newline sequence appended
+    # to it.
+
+    def cmd(options) # :yield: recvdata
+      match    = @options["Prompt"]
+      time_out = @options["Timeout"]
+
+      if options.kind_of?(Hash)
+        string   = options["String"]
+        match    = options["Match"]   if options.has_key?("Match")
+        time_out = options["Timeout"] if options.has_key?("Timeout")
+        waittime = options["Waittime"] if options.has_key?("Waittime")
+      else
+        string = options
+      end
+
+      self.puts(string)
+      if block_given?
+        waitfor({"Prompt" => match, "Timeout" => time_out, "Waittime" => waittime}){|c| yield c }
+      else
+        waitfor({"Prompt" => match, "Timeout" => time_out, "Waittime" => waittime})
+      end
+    end
+
+  end  # class Telnet
+end  # module SSH
+end  # module Net