lapis_lazuli 0.6.1

data/lib/lapis_lazuli/browser/wait.rb

@@ -0,0 +1,158 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2015 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require 'test/unit/assertions'
+require 'lapis_lazuli/argparse'
+
+module LapisLazuli
+module BrowserModule
+
+  ##
+  # Wait functionality for Browser
+  module Wait
+    include LapisLazuli::ArgParse
+
+    ##
+    # Same arguments as for the find functions, but a few more options are valid:
+    #
+    # :timeout    - specifies the timeout to wait for, defaulting to 10 seconds
+    # :condition  - specifies the condition to wait for, either of :while or
+    #               :until. The default is :until.
+    # :screenshot - boolean flag determining whether a screenshot should be made
+    #               if the function produces an error. The default is false.
+    def multi_wait_all(*args)
+      return internal_wait(:multi_find_all, *args)
+    end
+
+    def wait_all(*args)
+      return internal_wait(:find_all, *args)
+    end
+
+    def multi_wait(*args)
+      return internal_wait(:multi_find, *args)
+    end
+
+    def wait(*args)
+      return internal_wait(:find, *args)
+    end
+
+  private
+
+    ##
+    # Internal wait function; public functions differ only in which of the find
+    # functions they use.
+    def internal_wait(find_func, *args)
+      options = parse_wait_options(*args)
+
+      # Extract our own options
+      timeout = options[:timeout]
+      options.delete(:timeout)
+
+      retries = options[:stale_retries] + 1 # Add first attempt!
+      options.delete(:stale_retries)
+
+      condition = options[:condition]
+      options.delete(:condition)
+
+      # The easiest way to deal with find's new :throw policy is to set it to
+      # false.
+      options[:throw] = false
+
+      # pp "got options: #{options}"
+
+      # The proc we're waiting for invokes the find_func
+      results = []
+      has_single = false
+      find_proc = lambda { |dummy|
+        res = false
+        err = nil
+        retries.times do
+          begin
+            opts = Marshal.load(Marshal.dump(options))
+            results = send(find_func.to_sym, opts)
+            if results.respond_to? :length
+              res = (results.length > 0)
+            else
+              has_single = true
+              results = [results]
+              res = !!results[0]
+            end
+            break # don't need to retry
+          rescue Selenium::WebDriver::Error::StaleElementReferenceError => e
+            err = e
+          end
+          # Retry
+        end
+
+        # Raise the error if the retries didn't suffice
+        if not err.nil? and not res
+          raise err, "Tried #{retries} times, but got: #{err.message}", err.backtrace
+        end
+
+        # Return the results!
+        res
+      }
+
+      # Call the appropriate condition function.
+      err = nil
+      begin
+        res = Watir::Wait.send(condition, timeout, &find_proc)
+      rescue Watir::Wait::TimeoutError => e
+        @world.log.debug("Caught timeout: #{e}")
+        err = e
+      end
+
+      # Filter out any nil results
+      filter_results = results.select {|i| not i.nil?}
+      # Error handling
+      if not err.nil? and filter_results.empty?
+        options[:exception] = err
+        @world.error(options)
+      end
+
+      # Set if the underlying find function returns single results
+      if has_single
+        return results[0]
+      end
+      return results
+    end
+
+
+
+    ##
+    # Parses wait options, using parse_args
+    def parse_wait_options(*args)
+      options = {
+        :timeout => 10,
+        :stale_retries => 3,
+        :condition => :until,
+        :screenshot => false,
+      }
+      options = ERROR_OPTIONS.merge options
+      options = parse_args(options, :selectors, *args)
+
+      # Validate options
+      options[:timeout] = options[:timeout].to_i
+      options[:screenshot] = !!options[:screenshot]
+
+      options[:condition] = options[:condition].to_sym
+      assert [:while, :until].include?(options[:condition]), ":condition must be one of :while, :until"
+
+      # For all selectors that don't have the filter_by set, default it to
+      # present?
+      options[:selectors].each do |sel|
+        if not sel.has_key? :filter_by
+          sel[:filter_by] = :present?
+        end
+      end
+
+      return options
+    end
+  end # module Wait
+end # module BrowserModule
+end # module LapisLazuli

data/lib/lapis_lazuli/browser.rb

@@ -0,0 +1,246 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2015 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require 'selenium-webdriver'
+require 'watir-webdriver'
+require "watir-webdriver/extensions/alerts"
+require 'test/unit/assertions'
+
+require "lapis_lazuli/ast"
+
+# Modules
+require "lapis_lazuli/browser/error"
+require 'lapis_lazuli/browser/find'
+require "lapis_lazuli/browser/wait"
+require "lapis_lazuli/browser/screenshots"
+require "lapis_lazuli/browser/interaction"
+require 'lapis_lazuli/generic/xpath'
+
+module LapisLazuli
+  ##
+  # Extension to the Watir browser
+  #
+  # This class handles initialization, for the most part. BrowserModules
+  # included here can rely on @world being set to the current cucumber world
+  # object, and for some WorldModules to exist in it (see assertions in
+  # constructor).
+  class Browser
+    include Test::Unit::Assertions
+
+    include LapisLazuli::Ast
+
+    include LapisLazuli::BrowserModule::Error
+    include LapisLazuli::BrowserModule::Find
+    include LapisLazuli::BrowserModule::Wait
+    include LapisLazuli::BrowserModule::Screenshots
+    include LapisLazuli::BrowserModule::Interaction
+    include LapisLazuli::GenericModule::XPath
+
+    @world
+    @browser
+    @cached_browser_wanted
+    @cached_optional_data
+
+    @browser_name
+    attr_reader :browser_name
+
+    def initialize(world, *args)
+      # The class only works with some modules loaded; they're loaded by the
+      # Browser module, but we can't be sure that's been used.
+      assert world.respond_to?(:config), "Need to include LapisLazuli::WorldModule::Config in your cucumber world."
+      assert world.respond_to?(:log), "Need to include LapisLazuli::WorldModule::Logging in your cucumber world."
+      assert world.respond_to?(:error), "Need to include LapisLazuli::WorldModule::Error in your cucumber world."
+      assert world.respond_to?(:has_proxy?), "Need to include LapisLazuli::WorldModule::Proxy in your cucumber world."
+
+      @world = world
+
+      # Create a new browser with optional arguments
+      @browser = self.init(*args)
+    end
+
+    ##
+    # The main browser window for testing
+    def init(browser_wanted=(no_browser_wanted=true;nil), optional_data=(no_optional_data=true;nil))
+      # Store the optional data so on restart of the browser it still has the
+      # correct configuration
+      if no_optional_data and optional_data.nil? and @cached_optional_data
+        optional_data = @cached_optional_data
+      elsif optional_data.nil?
+        optional_data = {}
+      else
+        # Duplicate the data as Webdriver modifies it
+        @cached_optional_data = optional_data.dup
+      end
+
+      # Do the same caching stuff for the browser
+      if no_browser_wanted and browser_wanted.nil? and @cached_browser_wanted
+        browser_wanted = @cached_browser_wanted
+      else
+        @cached_browser_wanted = browser_wanted
+      end
+
+      # Create the browser
+      self.create(browser_wanted, optional_data)
+    end
+
+    ##
+    # Create a new browser depending on settings
+    # Always cached the supplied arguments
+    def create(browser_wanted=nil, optional_data=nil)
+      # No browser? Does the config have a browser? Default to firefox
+      if browser_wanted.nil?
+        browser_wanted = @world.env_or_config('browser', 'firefox')
+      end
+
+      # Select the correct browser
+      case browser_wanted.to_s.downcase
+        when 'chrome'
+          # Check Platform running script
+          browser = :chrome
+        when 'safari'
+          browser = :safari
+        when 'ie'
+          require 'rbconfig'
+          if (RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/)
+            browser = :ie
+          else
+            @world.error("You can't run IE tests on non-Windows machine")
+          end
+        when 'ios'
+          if RUBY_PLATFORM.downcase.include?("darwin")
+            browser = :iphone
+          else
+            @world.error("You can't run IOS tests on non-mac machine")
+          end
+        else
+          browser = :firefox
+      end
+
+      args = [browser]
+      @browser_name = browser.to_s
+      if not optional_data.nil? and not optional_data.empty?
+        @world.log.debug("Got optional data: #{optional_data}")
+        args.push(optional_data)
+      elsif @world.has_proxy?
+        # Create a session if needed
+        if !@world.proxy.has_session?
+          @world.proxy.create()
+        end
+
+        proxy_url = "#{@world.proxy.ip}:#{@world.proxy.port}"
+        if browser == :firefox
+          @world.log.debug("Configuring Firefox proxy: #{proxy_url}")
+          profile = Selenium::WebDriver::Firefox::Profile.new
+          profile.proxy = Selenium::WebDriver::Proxy.new :http => proxy_url, :ssl => proxy_url
+          args.push({:profile => profile})
+        end
+      end
+
+      browser_instance = Watir::Browser.new(*args)
+      return browser_instance
+    end
+
+    ##
+    # Return if the browser is open
+    def is_open?
+      return !@browser.nil?
+    end
+
+    ##
+    # Start the browser if it's not yet open.
+    def start
+      if @browser.nil?
+        @browser = self.init
+      end
+    end
+
+    ##
+    # Close and create a new browser
+    def restart
+      @world.log.debug "Restarting browser"
+      @browser.close
+      self.start
+    end
+
+    ##
+    # Closes the browser and updates LL so that it will open a new one if needed
+    def close(reason = nil)
+      if not @browser.nil?
+        if not reason.nil?
+          reason = " after #{reason}"
+        else
+          reason = ""
+        end
+
+        @world.log.debug "Closing browser#{reason}: #{@browser}"
+        @browser.close
+        @browser = nil
+      end
+    end
+
+    ##
+    # Same as close
+    def quit
+      self.close
+    end
+
+    ##
+    # Close after scenario will close the browser depending on the close_browser_after
+    # configuration
+    #
+    # Valid config options: feature, scenario, end, never
+    # Default: feature
+    def close_after_scenario(scenario)
+      # Determine the config
+      close_browser_after = @world.env_or_config("close_browser_after")
+
+      case close_browser_after
+      when "scenario"
+        # We always close it
+        self.close close_browser_after
+      when "never"
+        # Do nothing: party time, excellent!
+      when "end"
+        # Also ignored here - this is handled  in World.browser_destroy
+      else
+        if is_last_scenario?(scenario)
+          # Close it
+          self.close close_browser_after
+        end
+      end
+    end
+
+    ##
+    # Map any missing method to the browser object
+    # Example
+    # ll.browser.goto "http://www.spritecloud.com"
+    def respond_to?(meth)
+      if !@browser.nil? and @browser.respond_to? meth
+        return true
+      end
+      return super
+    end
+
+    def method_missing(meth, *args, &block)
+      if !@browser.nil? and @browser.respond_to? meth
+        return @browser.send(meth.to_s, *args, &block)
+      end
+      return super
+    end
+
+    def destroy(world)
+      if "end" == world.env_or_config("close_browser_after")
+        begin
+          self.close "end"
+        rescue
+          world.log.debug("Failed to close the browser, probably chrome")
+        end
+      end
+    end
+  end
+end

data/lib/lapis_lazuli/cli.rb

@@ -0,0 +1,110 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+require 'thor'
+
+require 'lapis_lazuli/generators/cucumber'
+require 'lapis_lazuli/options'
+require 'lapis_lazuli/placeholders'
+
+module LapisLazuli
+  class CLI < Thor
+    class_option :verbose, :aliases => "-v", :type => :boolean, :default => false, :desc => "Be verbose."
+
+    long_desc <<-LONGDESC
+      Creates/updates a cucumber test script directory pre-seeded with common
+      step definitions, environment and configuratin support, and all the bells
+      and whistles of a proper spriteCloud test setup.
+
+      The default behaviour is to reference the release gem of the Lapis Lazuli
+      version you are using as a dependency of the created/updated project.
+
+      By specifying a github branch, you will instead use that branch of Lapis
+      Lazuli as a dependency.
+    LONGDESC
+
+    option :branch, :aliases => "-b", :type => :string, :default => nil, :desc => "Specify the github branch of Lapis Lazuli a created/updated project is to use."
+    register(LapisLazuli::Generators::Cucumber, "create", "create PROJECT", "Creates a cucumber project with some common step definitions.")
+    register(LapisLazuli::Generators::Cucumber, "update", "update PROJECT", "Updates a project. Alias for 'create'.")
+
+
+    desc "config", "Describe how LapisLazuli configuration works."
+    def config 
+      STDOUT.write <<-INTRO
+LapisLazuli searches for configuration files in the `config' subdirectory of
+the current working directory, taking the stated test environment into
+consideration.
+
+Example:
+  ENV['TEST_ENV'] = 'production'
+  load_config("config/config.yml")
+
+Will try to load the following files, in order:
+  - config/config-production.yml
+  - config/config-debug.yml
+  - config/config-test.yml
+  - config/config-local.yml
+  - config/config.yml
+
+The first configuration file in the list that is found will be loaded, and its
+contents become available via the configuraiton functions.
+
+Supported configuration formats and file name extensions are:
+  .yml  - YAML file
+  .json - JSON file
+
+In addition to environment-specific configuration files, LapisLazuli supports
+the concept of test environments within a single file, where environments are
+just top-level keys, e.g.:
+
+  production:
+    - config for the production environment
+
+  development:
+    - config for the development environment
+
+The configuration files can contain any configuration options, but a few are
+interpreted by LapisLazuli. Note that instead of specifying these supported
+options in the configuraiton file, you may also provide them in the environment
+(convert option name to upper case). Environment variables override the
+configuration file contents.
+
+INTRO
+      STDOUT.flush
+
+      LapisLazuli::CONFIG_OPTIONS.each do |option, value|
+        printf "%22s\n", option
+
+        display_default = value[0]
+        if display_default.nil?
+          display_default = "No default."
+        else
+          display_default = "Defaults to '#{display_default}'."
+        end
+        printf "                 #{display_default}\n"
+        printf "                 #{value[1]}\n\n"
+
+      end
+    end
+
+
+
+    desc "placeholders", "Display placeholders managed by WorldModule::Variable."
+    def placeholders
+      STDOUT.write <<-INTRO
+The following are placeholders to use with WorldModule::Variable's functions
+as managed by this version of LapisLazuli.
+
+INTRO
+      STDOUT.flush
+
+      LapisLazuli::PLACEHOLDERS.each do |option, value|
+        printf "%22s - %s\n", option, value[1]
+      end
+    end
+  end
+end

data/lib/lapis_lazuli/cucumber.rb

@@ -0,0 +1,25 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+Before do |scenario|
+  if respond_to? :before_scenario_hook
+    before_scenario_hook(scenario)
+  end
+end
+
+After do |scenario|
+  if respond_to? :after_scenario_hook
+    after_scenario_hook(scenario)
+  end
+end
+
+# Can be used for debug purposes
+AfterStep('@pause') do |scenario|
+  print "Press Return to continue"
+  STDIN.getc
+end

data/lib/lapis_lazuli/generators/cucumber/template/.gitignore

@@ -0,0 +1,6 @@
+# Editor files
+.*.sw*
+
+# Directories created by LapisLazuli
+logs
+screenshots

data/lib/lapis_lazuli/generators/cucumber/template/Gemfile

@@ -0,0 +1,37 @@
+source 'http://rubygems.org'
+
+
+# Add following two lines to your ~/.gemrc or /etc/gemrc:
+# install: --no-rdoc --no-ri
+# update:  --no-rdoc --no-ri
+
+# Install helper libraries
+gem 'rspec'
+gem 'gherkin'
+gem 'xml-simple'
+gem 'mechanize'
+
+# Debuggers
+platforms :ruby_18, :ruby_19 do
+  gem 'debugger'
+end
+platforms :ruby_20, :ruby_21 do
+  gem 'byebug'
+  gem 'rb-readline'
+end
+
+# Windows specific
+platforms :mswin, :mingw do
+  gem 'win32console'
+  gem 'term-ansicolor'
+end
+
+
+# Install all the webdriver gems and cucumber
+gem 'watir-webdriver'
+gem 'watir-webdriver-performance'
+gem 'watir-scroll'
+gem 'cucumber'
+
+# LapisLazul itself
+gem 'lapis_lazuli', <%= config[:lapis_lazuli][:dependency] %>

data/lib/lapis_lazuli/generators/cucumber/template/README.md

@@ -0,0 +1,27 @@
+# Tests for <%= config[:project][:name] %>
+
+Author: "<%= config[:user] %>" <<%= config[:email] %>>
+
+# Setup
+
+## General
+
+- Make sure you have ruby 1.9 or later installed.
+- Make sure you have firefox and/or chrome installed
+- Install the bundler gem:
+
+    $ gem install bundler
+
+- Install all of the required gems defined in the gemfile:
+
+    $ bundle install
+
+- Run cucumber or regressinator through bundler:
+
+    $ bundle exec cucumber
+    $ bundle exec regressinator legacy cucumber
+
+# Contributing
+
+If you create new utility functions and want to contribute them to the Lapis
+Lazuli project, see https://github.com/spriteCloud/lapis-lazuli

data/lib/lapis_lazuli/generators/cucumber/template/config/config.yml

@@ -0,0 +1,29 @@
+################################################################################
+# Copyright <%= config[:year] %> spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version <%= config[:lapis_lazuli][:version] %>
+# Author: "<%= config[:user] %>" <<%= config[:email] %>>
+#
+# Config file for the test automation
+# When a config_local.yml exists, that will then be loaded instead of this default config file
+
+################################################################################
+# Set the global variables
+default_env: production              # defines the environment
+
+################################################################################
+# List of error strings. Step will fail if one of these strings is detected.
+error_strings:
+  [
+    "Server Error",
+    "Error: Page Not Found"
+  ]
+
+################################################################################
+# Environment specific variables
+test:
+
+uat:
+
+production:
+  google:
+      english: http://www.google.com/ncr

data/lib/lapis_lazuli/generators/cucumber/template/config/cucumber.yml

@@ -0,0 +1,34 @@
+################################################################################
+# Copyright <%= config[:year] %> spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version <%= config[:lapis_lazuli][:version] %>
+# Author: "<%= config[:user] %>" <<%= config[:email] %>>
+#
+# Ask developer of testsuite to add profiles where desired.
+# This file defines predefined profiles that can be used.
+# Example > Cucumber -t @homepage -p default -p localhost
+
+<%% timestamp = Time.now.strftime("%Y%m%d_%H%M") %>
+
+################################################################################
+# Type of testrun
+default: -f pretty -x
+debug: -f pretty BREAKPOINT_ON_FAILURE=1
+html_report: -f pretty -f html --out=results/<%%=timestamp%>_report.html
+junit_report: -f pretty -f junit --out=results
+
+################################################################################
+# Supported browsers (default = firefox)
+ff: BROWSER=firefox
+firefox: BROWSER=firefox
+chrome: BROWSER=chrome
+ie: BROWSER=ie
+safari: BROWSER=safari
+
+
+################################################################################
+# Listed environments (default is set in config.yml)
+t: TEST_ENV=test -t @t,@test
+test: TEST_ENV=test -t @t,@test
+
+p: TEST_ENV=production -t @p,@prod
+production: TEST_ENV=production -t @p,@prod

data/lib/lapis_lazuli/generators/cucumber/template/features/example.feature

@@ -0,0 +1,11 @@
+@example @p
+Feature: Example Feature
+  When I want to learn how to make test cases
+  As a user of the test automation tool
+  I want to run and adjust the tests below
+
+  @example01
+  Scenario: example01 - Google Search
+    Given I navigate to Google in english
+    And I search for "spriteCloud"
+    Then I see "www.spriteCloud.com" on the page