Selenium

Someone who knows this better than I do will need to verify / clarify. My understanding is that elements are given references when the page is loaded. On loading a new page you are building all new references, even if it looks like the same link on each page.

You are storing a reference to that element and then asking it to go ahead and pull the href attribute from it. It works the first time, as the element still exists. Once the new page has loaded it no longer exists. The request to pull the attribute fails.

If all you care about are the hrefs there's a shorter, more Ruby way of doing it.

array = []

browser.as(:class => 'foo').each { |link|
  array << link.href
}

array.each { |link| 
  browser.goto link
}

By cramming the links into the array we don't have to worry about stale references.

You need to add that inside your setup method:

def setup
  caps = Selenium::WebDriver::Remote::Capabilities.internet_explorer
  caps[:name] = name()
end

In the process of finding a solution for this, I think I might have found a bug in Capybara (v1.1.2).

I managed to get around this problem using the following approach, instead of using the click from capybara (which would not allow me to capture an exception), I started using the click method from selenium-webdriver.

It seems that when Firefox triggers this alertbox, a string with the message

Although this page is encrypted, the information you have entered is to be sent over an unencrypted connection and could easily be read by a third party

is returned as a result of object.native.click, otherwise the string

ok

is returned.

# Define the click method in ruby and call it when you're executing a 'click'

  # Public: Click the object.
  #
  # object - Capybara::Node::Element object to click.
  def click object
    return_string = object.native.click
    check_firefox_alertbox if return_string == "ok"
  end

  def check_firefox_alertbox
    if @current_browser == :firefox 
     @session.driver.browser.switch_to.alert.accept
    end
  rescue Exception => e
    puts e
  end

I got this working under Rails2 by doing the following (but Rails3 shouldn't be too different):

add the following lines to the top of your config/environments/development.rb:

require 'simplecov'

# clean the existing coverage directory before writing the new results.
Dir.foreach("coverage") do |file|
  next if [".",".."].include?(file)
  FileUtils.rm_rf(File.join("coverage",file), :verbose=>true)
end

SimpleCov.start 'rails' do
  add_filter "/vendor/"
end

Now, go and add a handy controller method to one of your controllers (I added it to an admin controller so I know it won't be accidentally called, but anything will do since you are guarding it for development only use):

class Admin::DebugController < ApplicationController

  if RAILS_ENV=="development"
    # see config/environments/development.rb
    def coverage
      SimpleCov.result.format!
      render :text => "Wrote results. STOP AND RESTART THE SERVER TO BEGIN A NEW COVERAGE RUN!!"
    end
  end

end

Now, start your rails server normally and let your external test suite run against it (or your manual integration QE tester ;)

When you are finished running through your integration tests, hit the url you setup in the admin controller, e.g.

http://localhost:3000/admin/debug/coverage

NOTE: this url only works/exists in development!

Voila! The coverage report will be written out to coverage/** in your rails directory. You can view it by loading coverage/index.html in your browser.

Justification

While the normal usage of SimpleCov is meant for unit and functional testing, adding the ability to evaluate external integration tests gives QE testers valuable feedback about what their testing strategies actually test within the target rails application.

This may be a trivial distinction for the majority of Rails applications, however it is useful when the application operates as a "pass-thru" for a large amount of data from other applications that is dynamically mixed into the application models (for example, a dashboard or console app). In these kinds of apps, rails testers may think they are testing permutations of the app, when in fact they are testing permutations of the underlying data (e.g. a network cluster). In this situation, code coverage gives an additional level of visibility into what is being tested.

This would help you

 p @driver.find_elements(xpath: "(.//*)[contains(@id, '-panel')]").select{|element|element.attribute("id").end_with?"-panel"}

If you want to iterate and wanted to do perform some action on each element, then you can do

@driver.find_elements(xpath: "(.//*)[contains(@id, '-panel')]").select{|element|element.attribute("id").end_with?"-panel"}.each do |i|
  puts i.displayed?  # Or whatever operation you want to perform
end

If you want to check whether all the element with id which consist of -panel is displayed

p @driver.find_elements(xpath: "(.//*)[contains(@id, '-panel')]")
    .select{|element|element.attribute("id").end_with?"-panel"}
    .map{|element| element.displayed?}
    .all?

Take a look at Bundler.

You could maintain a list of your required gems in a Gemfile, then run bundle install on each machine before the build starts. This would install all of the gems in the Gemfile (and you could lock gems to a particular version by also including the Gemfile.lock file).

Yes, you are likely going to have issues. You can have multiple scripts read from an Excel sheet but when you add writing to Excel, two scripts cannot write to Excel at the same time.

There are several options.

1. ThomasSevestre is on the right track, I think. I would suggest that you set up a centralized database that all the 40 systems can access and have the script write to the db. I think that is the best solution. It doesn't have to be SQL Server, it could be MySQL or any other db that you can set up locally.

2. You can write a local log (text, CSV, etc.) and then when the script is done, you can merge all the different logs together. It's a little more of a manual process but it shouldn't be that bad as long as you write a script to do the merging. If you can't or don't want to deal with a database, this is probably your best option.

3. Another solution is to retry the write to Excel. As long as you have some gaps between the potential write, it might be alright. I don't think I would recommend this approach but you could try it and see how it goes. If your script runs very quickly, you might get a lot of delays as the scripts wait for each other to finish writing.

I don't have enough reputation to comment on jacksparrow007's answer, but in Ruby Selenium, his suggestion could be coded as:

profile = Selenium::WebDriver::Firefox::Profile.new
profile['browser.cache.disk.enable'] = false
profile['browser.cache.memory.enable'] = false
profile['browser.cache.offline.enable'] = false
profile['network.http.use-cache'] = false
Selenium::WebDriver.for :firefox, :profile => profile

It's common notion that when people use selenium,they tend to use driver variable, but when people use WATIR they use browser, so use browser instead of driver.

And to answer your question, you can use the following code to set up your zoom level.

browser=Watir::Browser.new :chrome
browser.execute_script("document.body.style.zoom='75%'")