lapis_lazuli 0.6.1

data/lib/lapis_lazuli/generators/cucumber/template/features/step_definitions/interaction_steps.rb

@@ -0,0 +1,20 @@
+################################################################################
+# Copyright <%= config[:year] %> spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version <%= config[:lapis_lazuli][:version] %>
+# Author: "<%= config[:user] %>" <<%= config[:email] %>>
+
+Given(/^I navigate to (.*) in (.*)$/) do |site,language|
+  config_name = "#{site.downcase}.#{language.downcase}"
+  if has_env?(config_name)
+    url = env(config_name)
+    browser.goto url
+  else
+    error(:env => config_name)
+  end
+end
+
+Given(/^I search for "(.*?)"$/) do |query|
+  searchbox = browser.find(:text_field => {:name => "q"})
+  searchbox.clear rescue log.debug "Could not clear searchbox"
+  searchbox.send_keys(query)
+end

data/lib/lapis_lazuli/generators/cucumber/template/features/step_definitions/validation_steps.rb

@@ -0,0 +1,21 @@
+################################################################################
+# Copyright <%= config[:year] %> spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version <%= config[:lapis_lazuli][:version] %>
+# Author: "<%= config[:user] %>" <<%= config[:email] %>>
+
+Then(/I see "([^"]*)" on the page/) do |string|
+  # Note: The following is *really* slow, as it'll apply the regex to all
+  #       elements in the page, one after the other. Of course, if any element
+  #       includes the regex, all its parent elements also will, so you have
+  #       tons of matches to process.
+  #
+  # browser.wait(:text => /#{string}/i)
+
+  #       Instead, you will want to search only the root element for some
+  #       text, e.g.
+  #
+  # browser.wait(:html => {:text => /#{string}/i})
+
+  #       There's a shortcut for that in find/wait:
+  browser.wait(:html => /#{string}/i)
+end

data/lib/lapis_lazuli/generators/cucumber/template/features/support/env.rb

@@ -0,0 +1,12 @@
+################################################################################
+# Copyright <%= config[:year] %> spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version <%= config[:lapis_lazuli][:version] %>
+# Author: "<%= config[:user] %>" <<%= config[:email] %>>
+require 'lapis_lazuli'
+require 'lapis_lazuli/cucumber'
+
+LapisLazuli::WorldModule::Config.config_file = "config/config.yml"
+World(LapisLazuli)
+
+# Transition function from old codebase to new
+load 'features/support/transition.rb'

data/lib/lapis_lazuli/generators/cucumber/template/features/support/transition.rb

@@ -0,0 +1,12 @@
+##
+# All function in this file SHOULD not be used.
+# There only included for backwards compatibility
+#
+
+##
+# Creating a link for easy debugging afterwards
+def create_link(name, url)
+  log.info("[DEPRECATED] [feature/support/transition.rb] create_link")
+  #Lets just send the url without the parameters to prevent html display problems
+  "<a href='#{url}' target='_blank'>#{name}</a>"
+end

data/lib/lapis_lazuli/generators/cucumber.rb

@@ -0,0 +1,128 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require 'lapis_lazuli/version'
+
+require 'thor/group'
+
+module LapisLazuli
+  module Generators
+
+    PROJECT_PATHS = [
+      'config',
+      'features',
+      File.join('features', 'step_definitions'),
+      File.join('features', 'support'),
+      'log',
+      'results',
+      'screenshots',
+    ]
+
+
+    ALLOWED_HIDDEN = [
+      '.gitignore'
+    ]
+
+
+
+    class Cucumber < Thor::Group
+      include Thor::Actions
+
+      argument :path, :type => :string
+
+      # Bug in Thor: this seems to need to be in place both here, and in the CLI
+      # class - here to actually work, and in the CLI class to be shown in the help.
+      class_option :branch, :aliases => "-b", :type => :string, :default => nil
+
+
+
+      def create_directory_structure
+        empty_directory(path)
+        PROJECT_PATHS.each do |p|
+          empty_directory(File.join(path, p))
+        end
+      end
+
+
+
+      def copy_template
+        opts = {
+          :year => Time.now.year,
+          :user => Cucumber.get_username(self),
+          :email => Cucumber.get_email(self),
+          :lapis_lazuli => {
+            :version => LapisLazuli::VERSION,
+            :dependency => '"' + LapisLazuli::VERSION + '"',
+          },
+          :project => {
+            :name => File.basename(path),
+          },
+        }
+
+        # If a branch was specified on the CLI, we have to update the dependency
+        # string.
+        if options.has_key?("branch")
+          opts[:lapis_lazuli][:dependency] = ":github => 'spriteCloud/lapis-lazuli', :branch => '#{options["branch"]}'"
+        end
+
+        require 'facets/string/lchomp'
+        require 'find'
+        Find.find(Cucumber.source_root) do |name|
+          # Skip the source root itself
+          next if name == Cucumber.source_root
+
+          # Find the relative path and file name component
+          relative = name.lchomp(Cucumber.source_root + File::SEPARATOR)
+          filename = File.basename(relative)
+
+          # Ignore hidden files UNLESS they're listed in the allowed hidden
+          # files.
+          if filename.start_with?('.')
+            next if not ALLOWED_HIDDEN.include?(filename)
+          end
+
+          # Create directories as empty directories, and treat every file as 
+          # a template.
+          if File.directory?(name)
+            empty_directory(File.join(path, relative))
+          else
+            template(relative, File.join(path, relative), opts)
+          end
+        end
+      end
+
+
+
+      def self.source_root
+        File.join(File.dirname(__FILE__), "cucumber", "template")
+      end
+
+
+
+      def self.run_helper(cuke, command, default)
+        begin
+          cuke.run(command, {:capture => true}).strip || default
+        rescue
+          default
+        end
+      end
+
+
+
+      def self.get_username(cuke)
+        run_helper(cuke, 'git config --get user.name', 'spriteCloud B.V.')
+      end
+
+
+
+      def self.get_email(cuke)
+        run_helper(cuke, 'git config --get user.email', 'info@spritecloud.com')
+      end
+    end
+  end
+end

data/lib/lapis_lazuli/generic/xpath.rb

@@ -0,0 +1,49 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+module LapisLazuli
+module GenericModule
+
+  ##
+  # Helper functions for XPath composition
+  module XPath
+
+
+    ##
+    # Return an xpath contains clause for e.g. checking wether an element's
+    # class attribute node contains a string. The optional third parameter
+    # determines how substrings are separated in the attribute node; the
+    # default is space for matching class names.
+    # Note that enclosing [ and ] are not included in the return value; this
+    # lets you more easily use and()/or()/not() operators.
+    def xp_contains(node, needle, separator = ' ')
+      contains = "contains(concat('#{separator}', normalize-space(#{node}), '#{separator}'), '#{separator}#{needle}#{separator}')"
+      return contains
+    end
+
+    ##
+    # Constructs xpath and clause
+    def xp_and(first, second)
+      return "(#{first} and #{second})"
+    end
+
+    ##
+    # Constructs xpath or clause
+    def xp_or(first, second)
+      return "(#{first} or #{second})"
+    end
+
+    ##
+    # Constructs xpath or clause
+    def xp_not(expr)
+      return "not(#{expr})"
+    end
+
+
+  end # module XPath
+end # module GenericModule
+end # module LapisLazuli

data/lib/lapis_lazuli/options.rb

@@ -0,0 +1,28 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+module LapisLazuli
+  ##
+  # Configuration options and their default values
+  CONFIG_OPTIONS = {
+    "close_browser_after" => ["feature", "Close the browser after every scenario, feature, etc. Possible values are 'feature', 'scenario', 'end' and 'never'."],
+    "error_strings" => [nil, "List of strings that indicate errors when detected on a web page."],
+    "default_env" => [nil, "Indicates which environment specific configuration to load when no test environment is provided explicitly."],
+    "test_env" => [nil, "Indicates which environment specific configuration to load in this test run."],
+    "browser" => ['firefox', "Indicates the browser in which to run tests. Possible values are 'firefox', 'chrome', 'safari', 'ie', 'ios'."],
+    "email_domain" => ["google.com", "The domain name used when generating email addresses. See the `placeholders` command for more information."],
+    "screenshot_on_failure" => [true, "Toggle whether failed scenarios should result in a screenshot being taken automatically."],
+    "screenshot_dir" => [".#{File::SEPARATOR}screenshots", "Location prefix for the screenshot path."],
+    "screenshot_scheme" => ["old", "Naming scheme for screenshots. Possible values are 'old' and 'new'. This option will be deprecated in the near future, and only the new scheme will be supported."],
+    "breakpoint_on_error" => [false, "If the error() function is used to create errors, should the debugger be started?"],
+    "step_pause_time" => [0, "(Deprecated) Number of seconds to wait after each cucumber step is executed."],
+    "log_dir" => [".#{File::SEPARATOR}logs", "Location for log files; they'll be named like the configuration file but with the '.log' extension."],
+    "log_file" => [nil, "Location of log file; overrides 'log_dir'."],
+    "log_level" => ['DEBUG', "Log level; see ruby Logger class for details."],
+    "storage_dir" => [".#{File::SEPARATOR}storage", "Location prefix where to output test information file with the '.json' extension."]
+  }
+end # module LapisLazuli

data/lib/lapis_lazuli/placeholders.rb

@@ -0,0 +1,36 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+#
+module LapisLazuli
+  ##
+  # Placeholders and their meanings.
+  # The first value is a string to be eval'd to determine the value the
+  # placeholder is to be replaced with.
+  # The second value describes the meaning.
+  PLACEHOLDERS = {
+    :timestamp => ['time[:timestamp]', 'The local time at which the test run started.'],
+    :iso_timestamp => ['time[:iso_timestamp]', 'The UTC time at which the test run started.'],
+    :iso_short => ['time[:iso_short]', 'A shorter version of the UTC time above.'],
+    :epoch => ['time[:epoch]', 'An integer representation of the local time above, relative to the epoch.'],
+    :email => ['"test_#{uuid}@#{email_domain}"', 'A unique email for the test run (contains the UUID).'],
+    :uuid => ['uuid', 'A UUID for the test run.'],
+    :scenario_id => ['scenario.id', 'A unique identifier for the current scenario based on the title, in filesystem safe form.'],
+    :scenario_timestamp => ['scenario.time[:timestamp]', 'Same as timestamp, but relative to the start of the scenario.'],
+    :scenario_iso_timestamp => ['scenario.time[:iso_timestamp]', 'Same as iso_timestamp, but relative to the start of the scenario.'],
+    :scenario_iso_short => ['scenario.time[:iso_short]', 'Same as iso_short, but relative to the start of the scenario.'],
+    :scenario_epoch => ['scenario.time[:epoch]', 'Same as epoch, but relative to the start of the scenario.'],
+    :scenario_email => ['"test_#{uuid}_scenario_#{scenario.uuid}@#{email_domain}"', 'Same as email, but contains the test run UUID and the scenario UUID.'],
+    :scenario_uuid => ['scenario.uuid', 'A UUID for the scenario.'],
+    :random => ['rand(9999)', 'A random integer <10,000.'],
+    :random_small => ['rand(99)', 'A random integer <100.'],
+    :random_lange => ['rand(999999)', 'A random integer <1,000,000.'],
+    :random_uuid => ['random_uuid', 'A random UUID.'],
+    :random_email => ['"test_#{uuid}_random_#{random_uuid}@#{email_domain}"', 'Same as email, but contains the test run and the random UUID.'],
+    :versions => ['LapisLazuli.software_versions.nil? ? "" : JSON.generate(LapisLazuli.software_versions)', 'A JSON serialized string of software versions found in e.g. the AfterConfiguration hook.']
+  }
+end # module LapisLazuli

data/lib/lapis_lazuli/proxy.rb

@@ -0,0 +1,179 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+
+require 'socket'
+require 'timeout'
+require "lapis_lazuli/api"
+
+module LapisLazuli
+  ##
+  # Proxy class to map to sc-proxy
+  class Proxy
+    attr_reader :is_scproxy, :api, :ip, :scproxy_port, :port
+
+    ##
+    # Create a new LL Proxy
+    # What is the ip/port of the master?
+    def initialize(ip, port, scproxy=true)
+      # Save the information
+      @ip = ip
+      @is_scproxy = scproxy
+      if scproxy
+        @scproxy_port = port
+      else
+        @port = port
+      end
+      # We should have a master
+      if !is_port_open?(ip, port)
+        raise "Proxy not online"
+      end
+      if @is_scproxy
+        # Create an API connection to the master
+        @api = API.new()
+      end
+    end
+
+    def has_session?()
+      return !@port.nil? && is_port_open?(@ip, @port);
+    end
+
+    ##
+    # Creates a new session with the proxy
+    def create()
+      # Do we already have a connection?
+      if @is_scproxy and self.has_session?
+        # Close it before starting a new one
+        self.close()
+      end
+      # Create a new
+      if @is_scproxy and @api
+        # Let the master create a new proxy
+        response = self.proxy_new :master => true
+        # Did we get on?
+        if response["status"] == true
+          @port = response["result"]["port"]
+        else
+          # Show the error
+          raise response["message"]
+        end
+      end
+
+      if @port.nil?
+        raise "Coult not create a new proxy"
+      end
+
+      return @port
+    end
+
+    ##
+    # Close the session with the proxy
+    def close()
+      # If we don't have one we don't do anything
+      return if !@is_scproxy or !self.has_session?
+
+      # Send the call to the master
+      response = self.proxy_close :port => @port, :master => true
+
+      # Did we close it?
+      if response["status"] == true
+        # Clear our session
+        @port = nil
+      else
+        # Show an error
+        raise response["message"]
+      end
+    end
+
+    ##
+    # Check if a TCP port is open on a host
+    def is_port_open?(ip, port)
+      begin
+        # Timeout is important
+        Timeout::timeout(1) do
+          begin
+            # Create the socket and close it
+            s = TCPSocket.new(ip, port)
+            s.close
+            return true
+          # If it fails the port is closed
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          end
+        end
+      rescue Timeout::Error
+      end
+
+      # Sorry port is closed
+      return false
+    end
+
+    ##
+    # Map any missing method to the API object
+    #
+    # Example
+    # proxy.har_get
+    # proxy.proxy_close :port => 10002
+    def method_missing(meth, *args, &block)
+      # Only for spritecloud proxies
+      if !@is_scproxy
+        raise "Incorrect method: #{meth}"
+      end
+
+      # We should have no arguments or a Hash
+      if args.length > 1 or (args.length == 1 and not args[0].is_a? Hash)
+        raise "Incorrect arguments: #{args}"
+      end
+      settings = args[0] || {}
+
+      # A custom block or arguments?
+      block = block_given? ? block : Proc.new do |req|
+        if args.length == 1
+          settings.each do |key,value|
+            req.params[key.to_s] = value.to_s
+          end
+        end
+      end
+
+      # Pick the master proxy or the proxy for this session
+      @api.set_conn("http://#{@ip}:#{(settings.has_key? :master) ? @scproxy_port : @port}/")
+
+      # Call the API
+      response = @api.get("/#{meth.to_s.gsub("_","/")}", nil, &block)
+      # Only return the body if we could parse the JSOn
+      if response.body.is_a? Hash
+        return response.body
+      else
+        # Got a serious issue here, label as code 500
+        return {
+          "code" => 500,
+          "status" => false,
+          "message" => "Incorrect response from proxy",
+          "result" => response
+        }
+      end
+    end
+
+    ##
+    # During the end of the test run all data should be added to the storage
+    def destroy(world)
+      begin
+        # Is it a spriteCloud proxy?
+        if @is_scproxy
+          # Request HAR data
+          response = self.har_get
+          if response["status"] == true
+            # Add it to the storage
+            world.storage.set("har", response["result"])
+          end
+        end
+        self.close
+      rescue StandardError => err
+        world.log.debug("Failed to close the proxy: #{err}")
+      end
+    end
+  end
+end

data/lib/lapis_lazuli/runtime.rb

@@ -0,0 +1,88 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+require 'singleton'
+
+module LapisLazuli
+
+  ##
+  # Simple singleton class (that therefore lives for the duration of the test's
+  # run time for managing objects whose lifetime should also be this long.
+  class Runtime
+    include Singleton
+
+    def initialize
+      @objects = {}
+    end
+
+    def has?(name)
+      return @objects.has_key? name
+    end
+
+    def set(world, name, object, destructor = nil)
+      if @objects.has_key? name
+        Runtime.destroy(world, name, destructor)
+      end
+
+      # Register a finalizer, so we can clean up the proxy again
+      ObjectSpace.define_finalizer(self, Runtime.destroy(world, name, destructor))
+
+      @objects[name] = object
+    end
+
+    def set_if(world, name, destructor = nil, &block)
+      if @objects.has_key? name
+        return @objects[name]
+      end
+
+      obj = block.call
+
+      set(world, name, obj, destructor)
+
+      return obj
+    end
+
+    def get(name)
+      return @objects[name]
+    end
+
+
+  private
+    def self.destroy(world, name, destructor)
+      Proc.new do
+        # If a destructor is given, call that.
+        if not destructor.nil?
+          return destructor.call(world)
+        end
+
+        # Next, try a has_foo?/foo.destroy combination
+        if world.respond_to? "has_#{name}?" and world.respond_to? name
+          if world.send("has_#{name}?")
+            return world.send(name).destroy(world)
+          end
+          return false
+        end
+
+        # If it only responds to a destroy function, then we can just
+        # call that.
+        if world.respond_to? name
+          return world.send(name).destroy(world)
+        end
+
+        # If all else fails, we have to log an error. We can't rely
+        # on log existing in world, though...
+        message = "No destructor available for #{name}."
+        if world.respond_to? :log
+          world.log.info(message)
+        else
+          puts message
+        end
+      end
+    end
+
+  end # class Runtime
+end

data/lib/lapis_lazuli/scenario.rb

@@ -0,0 +1,88 @@
+#
+# LapisLazuli
+# https://github.com/spriteCloud/lapis-lazuli
+#
+# Copyright (c) 2013-2014 spriteCloud B.V. and other LapisLazuli contributors.
+# All rights reserved.
+#
+require "securerandom"
+require "lapis_lazuli/storage"
+require "lapis_lazuli/ast"
+
+module LapisLazuli
+  ##
+  # Stores the Cucumber scenario
+  # Includes timing, running state and a name
+  class Scenario
+    include LapisLazuli::Ast
+
+    attr_reader :id, :time, :uuid, :data, :storage, :error
+    attr_accessor :running, :check_browser_errors
+
+    def initialize
+      @uuid = SecureRandom.hex
+      @storage = Storage.new
+      @running = false
+      @name = "start_of_test_run"
+      self.update_timestamp
+    end
+
+    ##
+    # Update the scenario with a new one
+    def update(scenario)
+      @uuid = SecureRandom.hex
+      # Reset the fail attribute
+      @check_browser_errors = true
+      # The original scenario from cucumber
+      @data = scenario
+      # A name without special characters.
+      @id = clean(scenario_id(scenario))
+      self.update_timestamp
+    end
+
+    def update_timestamp
+      now = Time.now
+      # The current time
+      @time = {
+        :timestamp => now.strftime('%y%m%d_%H%M%S'),
+        :iso_timestamp => now.utc.strftime("%FT%TZ"),
+        :iso_short => now.utc.strftime("%y%m%dT%H%M%SZ"),
+        :epoch => now.to_i.to_s
+      }
+    end
+
+    def tags
+      if !@data.nil?
+        return @data.source_tag_names
+      end
+    end
+
+    def scope(cleaned = false)
+      scope = nil
+      if @data.respond_to? :backtrace_line
+        scope = @data.backtrace_line
+      elsif @data.respond_to? :file_colon_line
+        scope = @data.file_colon_line
+      end
+
+      if scope.nil?
+        return nil
+      elsif cleaned
+        return clean [scope]
+      else
+        return scope
+      end
+    end
+
+    private
+
+    def clean(strings)
+      result = []
+      strings.each do |string|
+        clean_string = string.gsub(/[^\w\.\-]/, ' ').strip.squeeze(' ').gsub(" ","_")
+        result.push(clean_string)
+      end
+      return result.join("-").squeeze("-")
+    end
+  end
+end