How to use require_file method of Selenium.WebDriver.Support Package

Lets look on the definition of Private Browsing here: https://support.apple.com/kb/PH19216?locale=en_US

When you use Private Browsing windows, Safari doesn’t save your browsing history, and it asks websites you visit not to track you.

and here:http://en.wikipedia.org/wiki/Privacy_mode

Privacy mode or "private browsing" or "incognito mode"[1] is a privacy feature in some web browsers to disable browsing history and the web cache. This allows a person to browse the Web without storing local data that could be retrieved at a later date. Privacy mode will also disable the storage of data in cookies and Flash cookies. This privacy protection is only on the local computing device as it is still possible to identify frequented websites by associating the IP address at the web server.

So this means that Selenium is equivalent to turning on Private Browsing. Every time you start any driver via Selenium it creates a brand new anonymous profile, you are actually browsing privately. (if you do not use already created profile of safari)

BUT! If you still think that you need to run safari in incognito mode, you can use the following hack:

you can automate the process of enabling the Private Browsing option with AppleScript. Like so.

1. First, launch the Universal Access system preference and enable the Enable Access for Assistive Devices option.

2. Launch Script Editor (within the AppleScript folder inside the Applications folder) and enter the following script:

tell application "Safari"
  activate
end tell

tell application "System Events"
  tell process "Safari"
      tell menu bar 1
          tell menu bar item "Safari"
              tell menu "Safari"
                  click menu item "Private Browsing"
              end tell
          end tell
      end tell
  end tell
end tell

Info from here: http://www.macworld.com/article/1139714/enableprivatebrowsing.html

Similar to type method I need to focus the Ferrum::Node instance before clicking it.

- browser.at_css('input[name=searchButton]').click
+ browser.at_css('input[name=searchButton]').focus.click

You don't indicate what browser and version of the browser you're using (for instance FF 59 has recently made a change that makes handling unload modals more difficultg to deal with) nor any other versions of the test gems you're using, so it's tough to say whether or not your current issue would be fixed by upgrading (it may). However you can work around this issue in the tests where you know an unload modal will appear by adding

accept_confirm do
  visit("about:blank") # or any page in your app that doesn't have an unload modal ( / for instance )
end

to the end of those specific tests. That could be implemented in after block triggered by metadata on the feature if you want to keep your actual test code clean. To implement it via metadata you'd change your RSpec configure block to something like

RSpec.configure do |config|
  config.before(:each) do
    config.include Capybara::DSL
  end

  config.after(:each, clear_unload_modal: true) do
    accept_confirm do # may need to be Capybara.current_session.accept_confirm depending on your includes
      visit("/") # may need to be Capybara.current_session.visit
    end
  end

  config.after(:each) do
    Capybara.reset_sessions!
  end
end

and then tag each test that needs it with :clear_unload_modal

scenario "blah blah", :clear_unload_modal do
  ....
end

There are two competing definitions of "screenshot" when dealing with WebDriver. The first is the definition used by the open-source project, where a screenshot is defined to be an image of the entire DOM of the loaded page. In this case, both the IE driver and the Firefox driver are doing the correct thing as defined by the project since 2010. The Chrome implementation of WebDriver is incorrect in returning an image of only the visible view port.

The W3C WebDriver specification, on the other hand, defines screenshots to be of the current view port only. This is at odds with the current open-source project's driver implementations (IE and Firefox), and can be expected to change in the future. Once the specification has attained "Candidate Recommendation" status, those drivers are likely to be updated.

As an aside, it should be noted that the IE driver in no way uses a "scroll-and-stitch" method to create its screenshots. It does resize the browser window large enough to display the entire DOM, as calculated at the moment the screenshot is requested, and take an image of that. However, please note that there are issues with IE 10 and 11 in producing these full-DOM screenshots depending on the bit-ness of your operating system and of the IEDriverServer executable you're using.

At present, you'll need to use a tool external to WebDriver to obtain view-port-only screenshots for IE and Firefox.

While discussing this problem in the comments, I wrote some C# code to demonstrate how we wait for clickable in C#

new WebDriverWait(Driver, TimeSpan.FromSeconds(5)).Until(ExpectedConditions.ElementToBeClickable(By.Name("btnK"))).Click();

In the process of writing the C# code I posted, I think I see what the issue is. When you start typing in the search box, a dropdown appears that contains the suggested searches. This covers the "Google Search" button that you are trying to click... BUT another "Google Search" button appears at the bottom of the dropdown itself. You should print a count of the (:name, "btnK") element(s)... I'm assuming it will print 2 (if a proper wait is added). From there, you just need to click the one that is on top.

Another option would be to send a \r\n at the end of your search string and avoid this whole issue... or you could just navigate to the final search URL and save even more headaches and time.

Added note from barlop

To clarify, this has nothing to do with the suggestions popup showing(and having to get rid of the popup).. and nothing to do with having a wait (Since I was working with IRB, I was naturally waiting). And I'd already clicked outside or hit escape to get rid of the popup. The issue was, and Jeff's answer alerted me to this - Even after the popup is gone, there are still two buttons with that btnK name. So, using find_elements rather than find_element, and running .click on the second one works! (Also, using find_elements(plural) for the name attribute makes sense, since as noted in an answer herehttps://stackoverflow.com/questions/5518458/does-a-name-attribute-have-to-be-unique-in-a-html-document. the name attribute is not unique / not a unique identifier.

This is quite a big question really! There are so many different approaches to the page object model - I'll try to give you an example that sorta fits with the code that you posted. It won't cover 100% what you need, but should give you an idea of the sort of thing you can do.

Firstly, you need to abstract your browser stuff. You want tests themselves to be build of page object calls and no direct calls to the browser itself. This means that you can change the stuff behind the scenes without having to edit your tests.

#
# The web browser.
#
module Browser
  #
  # Starts the browser.
  #
  # @return [Void]
  def self.start
    @browser ||= Selenium::WebDriver.for :chrome
  end

  #
  # Closes the browser.
  #
  # @return [Void]
  def self.close
    @browser.quit
  end

  private

  #
  # A catch all method to pass WebDriver requests through to our browser object.
  #
  # @return [Void]
  def self.method_missing(method, *arguments)
    @browser.send(method, *arguments)
  end
end

This provides us with a basic way of talking to the browser. We can start and stop it, and also run Selenium WebDriver methods through this module.

Next a basic page object module:

# Basic page object module. You will expand upon this a lot.
#
module PageObject
  #
  # Creates a class method that will return the selector and reference
  # of an element
  #
  # @param name [Symbol] name of the method
  # @param params [Hash<String>] element selector (key) and reference (value)
  def element(name, params)
    send(:define_method, name) do
      params
    end
  end

  #
  # Types into specified element.
  #
  # @param element [Hash] the element selector and reference
  # @param text [String] the text to type
  def type(element, text)
    Browser.find_element(element).send_keys text
  end

  #
  # Clicks on the specified element.
  #
  # @param element [Hash] the element selector and reference
  # @return [Void]
  def click(element)
    Browser.find_element(element).click
  end
end

Next an example page object. I've used your example of the login page.

#
# Page object representing a log in page. This is the bit that will contain all
# methods related to specific pages.
#
class LogInPage
  include PageObject

  element :email_field, id: 'email'
  element :password_field, id: 'password'
  element :submit_button, css: '.button.primary'

  #
  # Logs in using the specified user credentials.
  #
  # @param email [String] the users email address
  # @param password [String] the users password
  # @return [Void]
  def log_in_with!(email, password)
    type email_field, text: email
    type password_field, text: password
    click submit_button
    # Some approaches will return another page object at this point.
    # You can do this if you want, but personally I think it leads to confusing
    # tests.
  end

  #
  # Checks if a user is logged in.
  #
  # @return [Boolean]
  def user_logged_in?
    # This should return true or false depending on if a user is logged in.
    # Login page may not be the correct place for this, but it'll do for this
    # example.
  end
end

Your test might look something like:

describe 'Merchantcentric' do
  context 'User Login' do
    before :all do
      Browser.start
      Browser.get 'https://meffff.com/session/new'
      # Ideally all this browser creation stuff would be abstracted
      # out of your tests and into something else (spec_helper maybe?)
      @page = LogInPage.new
    end

    after :all do
      Browser.close
    end

    it 'success' do
      # I purposely left out your csv stuff - you should probably
      # have that separate to your tests also. I am assuming that
      # user and pass will be coming from somewhere.
      @page.log_in_with! user, pass
      assert(@page.user_logged_in?, 'User was not logged in successfully')
    end
  end
end

These would all obviously be inside different files! I've run out of lunch break time now, so if you have any questions let me know, I'm always available to chat about this stuff! Also apologies if some of this stuff doesn't work... I wrote it without testing but it should be ok(ish)!

Also, you shouldn't need to check for element presence before you interact with them. If the element isn't there, the test should fail anyway with a Selenium exception.

What made you settle on Rspec for your functional browser tests btw? Did you explore other options such as Cucumber?

Update

In regard to your comment:

In the example you've given, you could create a new method in your PageObject class called element_exists? and create a method inside your LogInPage class (for example) called deals_present?. You'd use this method in your assertion.

Your element_exists? method would be simple:

#
# Checks if an element exists, returning true or false.
#
# @params params [Hash] the selector and reference for the element
# @return [Boolean]
def element_exists?(params)
  Browser.find_elements(params).any?
end

Your ‘deals_present’ method could look something like:

#
# Checks if the deals element is present on the page.
#
# @return [Boolean]
def deals_present?
  element_exists? deals_navigation
end

You’d obviously need to create the deals_navigation page element using the ‘element’ method described in my post.

I notice that you want to have a wait.until before you check for the deals element. Again, you’ll want to abstract this out into your PageObject class and then perhaps call it inside your deals_present? method. I’ll let you work this one out, but let me know if you have too much trouble with it.

Your test assertion with all this done would look something like:

expect(!@page.deals_present?)

This will fail if the deals element is displayed. The benefit of doing it this way is you're removing the majority of the logic from the tests themselves which means if the logic changes, you just need to update it in a single place rather than all the tests that use it.

The only way to solve these issues is to debug the error received. To debug, we can add screenshots at different places in the scenario to identify the cause of the failure. If this is failing as page not completely loaded, then to solve this issue, is to increase the default wait time to open the particular page or to locate an element. Once the page loads or element is located, set the default time to its original value.

Example: 1. You can add screen shot in you scenario:

Scenario: Click on Sign In Link
Given Joe opens "www.yahoo.com" page
When Joe takes screenshot with file name "ScreenShot1"
When Joe clicks "Sign In" link

The second line "When Joe takes screenshot with file name "ScreenShot1" can be used to take the screen shot

And(/^(\S*) takes screenshot with file name "([^"]*)"$/) do |user, file_name|
  takes_screenshot_with_file_name(file_name, "ScreenShot")
end

def takes_screenshot_with_file_name(file_name, message)
  page.save_screenshot("../../target/#{file_name}.png", :full => true)
end

2. Default wait time can be increased in below mentioned way:

The second line "And Joe waits for "Sign In" link" can be used to increase the default wait time

Scenario: Click on Sign In Link
Given Joe opens "www.yahoo.com" page
And Joe waits for "Sign In" link
When Joe clicks "Sign In" link

And(/^Joe waits for "([^"]*)" link$/) do |linkName|
  Capybara.default_wait_time = 120
  page.should have_content(linkName)
  Capybara.default_wait_time = DEFAULT_WAIT_TIME
end

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.

So, in this particular example, you could do

@driver.find_elements(:xpath, "//div[@class='currency_dropdown']/div[@id='scroll-innerBox-1']/div[not(@style='display: none;')]").size

This should return 1 when USD is typed into the search field.

Edit: I recommend getting ChroPath for your preferred browser (FF or Chrome). It helps significantly when testing xpath.